meta-ads-mcp 0.3.7__py3-none-any.whl → 0.3.8__py3-none-any.whl

meta_ads_mcp/__init__.py

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

meta_ads_mcp/core/http_auth_integration.py

@@ -0,0 +1,248 @@
+"""
+FastMCP HTTP Authentication Integration for Meta Ads MCP
+
+This module provides direct integration with FastMCP to inject authentication
+from HTTP headers into the tool execution context.
+"""
+
+import asyncio
+import contextvars
+from typing import Optional
+from .utils import logger
+import json
+
+# Use context variables instead of thread-local storage for better async support
+_auth_token: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar('auth_token', default=None)
+
+class FastMCPAuthIntegration:
+    """Direct integration with FastMCP for HTTP authentication"""
+    
+    @staticmethod
+    def set_auth_token(token: str) -> None:
+        """Set authentication token for the current context
+        
+        Args:
+            token: Access token to use for this request
+        """
+        _auth_token.set(token)
+    
+    @staticmethod
+    def get_auth_token() -> Optional[str]:
+        """Get authentication token for the current context
+        
+        Returns:
+            Access token if set, None otherwise
+        """
+        return _auth_token.get(None)
+    
+    @staticmethod
+    def clear_auth_token() -> None:
+        """Clear authentication token for the current context"""
+        _auth_token.set(None)
+    
+    @staticmethod
+    def extract_token_from_headers(headers: dict) -> Optional[str]:
+        """Extract token from HTTP headers
+        
+        Args:
+            headers: HTTP request headers
+            
+        Returns:
+            Token if found, None otherwise
+        """
+        # Check for Bearer token in Authorization header (primary method)
+        auth_header = headers.get('Authorization') or headers.get('authorization')
+        if auth_header and auth_header.lower().startswith('bearer '):
+            token = auth_header[7:].strip()
+            logger.debug("Found Bearer token in Authorization header")
+            return token
+        
+        # Check for direct Meta access token
+        meta_token = headers.get('X-META-ACCESS-TOKEN') or headers.get('x-meta-access-token')
+        if meta_token:
+            return meta_token
+        
+        # Check for Pipeboard token (legacy support, to be removed)
+        pipeboard_token = headers.get('X-PIPEBOARD-API-TOKEN') or headers.get('x-pipeboard-api-token')
+        if pipeboard_token:
+            logger.debug("Found Pipeboard token in legacy headers")
+            return pipeboard_token
+        
+        return None
+
+def patch_fastmcp_server(mcp_server):
+    """Patch FastMCP server to inject authentication from HTTP headers
+    
+    Args:
+        mcp_server: FastMCP server instance to patch
+    """
+    logger.info("Patching FastMCP server for HTTP authentication")
+    
+    # Store the original run method
+    original_run = mcp_server.run
+    
+    def patched_run(transport="stdio", **kwargs):
+        """Enhanced run method that sets up HTTP auth integration"""
+        logger.debug(f"Starting FastMCP with transport: {transport}")
+        
+        if transport == "streamable-http":
+            logger.debug("Setting up HTTP authentication for streamable-http transport")
+            setup_http_auth_patching()
+        
+        # Call the original run method
+        return original_run(transport=transport, **kwargs)
+    
+    # Replace the run method
+    mcp_server.run = patched_run
+    logger.info("FastMCP server patching complete")
+
+def setup_http_auth_patching():
+    """Setup HTTP authentication patching for auth system"""
+    logger.info("Setting up HTTP authentication patching")
+    
+    # Import and patch the auth system
+    from . import auth
+    from . import api
+    from . import authentication
+    
+    # Store the original function
+    original_get_current_access_token = auth.get_current_access_token
+    
+    async def get_current_access_token_with_http_support() -> Optional[str]:
+        """Enhanced get_current_access_token that checks HTTP context first"""
+        
+        # Check for context-scoped token first
+        context_token = FastMCPAuthIntegration.get_auth_token()
+        if context_token:
+            return context_token
+        
+        # Fall back to original implementation
+        return await original_get_current_access_token()
+    
+    # Replace the function in all modules that imported it
+    auth.get_current_access_token = get_current_access_token_with_http_support
+    api.get_current_access_token = get_current_access_token_with_http_support
+    authentication.get_current_access_token = get_current_access_token_with_http_support
+    
+    logger.info("Auth system patching complete - patched in auth, api, and authentication modules")
+
+# Global instance for easy access
+fastmcp_auth = FastMCPAuthIntegration()
+
+# Forward declaration of setup_starlette_middleware
+def setup_starlette_middleware(app):
+    pass
+
+def setup_fastmcp_http_auth(mcp_server):
+    """Setup HTTP authentication integration with FastMCP
+    
+    Args:
+        mcp_server: FastMCP server instance to configure
+    """
+    logger.info("Setting up FastMCP HTTP authentication integration")
+    
+    # 1. Patch FastMCP's run method to ensure our get_current_access_token patch is applied
+    # This remains crucial for the token to be picked up by tool calls.
+    patch_fastmcp_server(mcp_server) # This patches mcp_server.run
+    
+    # 2. Patch the methods that provide the Starlette app instance
+    # This ensures our middleware is added to the app Uvicorn will actually serve.
+
+    app_provider_methods = []
+    if mcp_server.settings.json_response:
+        if hasattr(mcp_server, "streamable_http_app") and callable(mcp_server.streamable_http_app):
+            app_provider_methods.append("streamable_http_app")
+        else:
+            logger.warning("mcp_server.streamable_http_app not found or not callable, cannot patch for JSON responses.")
+    else: # SSE
+        if hasattr(mcp_server, "sse_app") and callable(mcp_server.sse_app):
+            app_provider_methods.append("sse_app")
+        else:
+            logger.warning("mcp_server.sse_app not found or not callable, cannot patch for SSE responses.")
+
+    if not app_provider_methods:
+        logger.error("No suitable app provider method (streamable_http_app or sse_app) found on mcp_server. Cannot add HTTP Auth middleware.")
+        # Fallback or error handling might be needed here if this is critical
+    
+    for method_name in app_provider_methods:
+        original_app_provider_method = getattr(mcp_server, method_name)
+        
+        def new_patched_app_provider_method(*args, **kwargs):
+            # Call the original method to get/create the Starlette app
+            app = original_app_provider_method(*args, **kwargs)
+            if app:
+                logger.debug(f"Original {method_name} returned app: {type(app)}. Adding AuthInjectionMiddleware.")
+                # Now, add our middleware to this specific app instance
+                setup_starlette_middleware(app) 
+            else:
+                logger.error(f"Original {method_name} returned None or a non-app object.")
+            return app
+            
+        setattr(mcp_server, method_name, new_patched_app_provider_method)
+        logger.debug(f"Patched mcp_server.{method_name} to inject AuthInjectionMiddleware.")
+
+    # The old setup_request_middleware call is no longer needed here,
+    # as middleware addition is now handled by patching the app provider methods.
+    # try:
+    #     setup_request_middleware(mcp_server) 
+    # except Exception as e:
+    #     logger.warning(f"Could not setup request middleware: {e}")
+
+    logger.info("FastMCP HTTP authentication integration setup attempt complete.")
+
+# Remove the old setup_request_middleware function as its logic is integrated above
+# def setup_request_middleware(mcp_server): ... (delete this function)
+
+# --- AuthInjectionMiddleware definition ---
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+import json # Ensure json is imported if not already at the top
+
+class AuthInjectionMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        logger.debug(f"HTTP Auth Middleware: Processing request to {request.url.path}")
+        logger.debug(f"HTTP Auth Middleware: Request headers: {list(request.headers.keys())}")
+        
+        token = FastMCPAuthIntegration.extract_token_from_headers(dict(request.headers))
+        
+        if token:
+            logger.debug(f"HTTP Auth Middleware: Extracted token: {token[:10]}...")
+            logger.debug("Injecting auth token into request context")
+            FastMCPAuthIntegration.set_auth_token(token)
+        else:
+            logger.warning("HTTP Auth Middleware: No authentication token found in headers")
+        
+        try:
+            response = await call_next(request)
+            return response
+        finally:
+            if token: # Clear only if a token was set for this request
+                FastMCPAuthIntegration.clear_auth_token()
+
+def setup_starlette_middleware(app):
+    """Add AuthInjectionMiddleware to the Starlette app if not already present.
+    
+    Args:
+        app: Starlette app instance
+    """
+    if not app:
+        logger.error("Cannot setup Starlette middleware, app is None.")
+        return
+
+    # Check if our specific middleware class is already in the stack
+    already_added = False
+    # Starlette's app.middleware is a list of Middleware objects.
+    # app.user_middleware contains middleware added by app.add_middleware()
+    for middleware_item in app.user_middleware:
+        if middleware_item.cls == AuthInjectionMiddleware:
+            already_added = True
+            break
+            
+    if not already_added:
+        try:
+            app.add_middleware(AuthInjectionMiddleware)
+            logger.info("AuthInjectionMiddleware added to Starlette app successfully.")
+        except Exception as e:
+            logger.error(f"Failed to add AuthInjectionMiddleware to Starlette app: {e}", exc_info=True)
+    else:
+        logger.debug("AuthInjectionMiddleware already present in Starlette app's middleware stack.") 

meta_ads_mcp/core/server.py

@@ -5,6 +5,8 @@ import argparse
 import os
 import sys
 import webbrowser
+import json
+from typing import Dict, Any, Optional
 from .auth import login as login_auth
 from .resources import list_resources, get_resource
 from .utils import logger
@@ -19,6 +21,173 @@ mcp_server.resource(uri="meta-ads://resources")(list_resources)
 mcp_server.resource(uri="meta-ads://images/{resource_id}")(get_resource)
 
 
+class StreamableHTTPHandler:
+    """Handles stateless Streamable HTTP requests for Meta Ads MCP"""
+    
+    def __init__(self):
+        """Initialize handler with no session storage - all auth per request"""
+        logger.debug("StreamableHTTPHandler initialized for stateless operation")
+        
+    def handle_request(self, request_headers: Dict[str, str], request_body: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle individual request with authentication
+        
+        Args:
+            request_headers: HTTP request headers
+            request_body: JSON-RPC request body
+            
+        Returns:
+            JSON response with auth status and any tool results
+        """
+        try:
+            # Extract authentication configuration from headers
+            auth_config = self.get_auth_config_from_headers(request_headers)
+            logger.debug(f"Auth method detected: {auth_config['auth_method']}")
+            
+            # Handle based on auth method
+            if auth_config['auth_method'] == 'bearer':
+                return self.handle_bearer_request(auth_config, request_body)
+            elif auth_config['auth_method'] == 'custom_meta_app':
+                return self.handle_custom_app_request(auth_config, request_body)
+            else:
+                return self.handle_unauthenticated_request(request_body)
+                
+        except Exception as e:
+            logger.error(f"Error handling request: {e}")
+            return {
+                'jsonrpc': '2.0',
+                'error': {
+                    'code': -32603,
+                    'message': 'Internal error',
+                    'data': str(e)
+                },
+                'id': request_body.get('id')
+            }
+    
+    def get_auth_config_from_headers(self, request_headers: Dict[str, str]) -> Dict[str, Any]:
+        """Extract authentication configuration from HTTP headers
+        
+        Args:
+            request_headers: HTTP request headers
+            
+        Returns:
+            Dictionary with auth method and relevant credentials
+        """
+        # Security validation - only allow safe headers
+        ALLOWED_VIA_HEADERS = {
+            'pipeboard_api_token': True,   # ✅ Primary method - simple and secure
+            'meta_app_id': True,           # ✅ Fallback only - triggers OAuth complexity
+            'meta_app_secret': False,      # ❌ Server environment only
+            'meta_access_token': False,    # ❌ Use proper auth flows instead
+        }
+        
+        # PRIMARY: Check for Bearer token in Authorization header (handles 90%+ of cases)
+        auth_header = request_headers.get('Authorization') or request_headers.get('authorization')
+        if auth_header and auth_header.lower().startswith('bearer '):
+            token = auth_header[7:].strip()
+            logger.info("Bearer authentication detected (primary path)")
+            return {
+                'auth_method': 'bearer',
+                'bearer_token': token,
+                'requires_oauth': False  # Simple token-based auth
+            }
+        
+        # FALLBACK: Custom Meta app (minority of users)
+        meta_app_id = request_headers.get('X-META-APP-ID') or request_headers.get('x-meta-app-id')
+        if meta_app_id:
+            logger.debug("Custom Meta app authentication detected (fallback path)")
+            return {
+                'auth_method': 'custom_meta_app',
+                'meta_app_id': meta_app_id,
+                'requires_oauth': True  # Complex OAuth flow required
+            }
+        
+        # No authentication provided
+        logger.warning("No authentication method detected in headers")
+        return {
+            'auth_method': 'none',
+            'requires_oauth': False
+        }
+    
+    def handle_bearer_request(self, auth_config: Dict[str, Any], request_body: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle request with Bearer token (primary path)
+        
+        Args:
+            auth_config: Authentication configuration from headers
+            request_body: JSON-RPC request body
+            
+        Returns:
+            JSON response ready for tool execution
+        """
+        logger.debug("Processing Bearer authenticated request")
+        token = auth_config['bearer_token']
+        
+        # Token is ready to use immediately for API calls
+        # TODO: In next phases, this will execute the actual tool call
+        return {
+            'jsonrpc': '2.0',
+            'result': {
+                'status': 'ready',
+                'auth_method': 'bearer',
+                'message': 'Authentication successful with Bearer token',
+                'token_source': 'bearer_header'
+            },
+            'id': request_body.get('id')
+        }
+    
+    def handle_custom_app_request(self, auth_config: Dict[str, Any], request_body: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle request with custom Meta app (fallback path)
+        
+        Args:
+            auth_config: Authentication configuration from headers
+            request_body: JSON-RPC request body
+            
+        Returns:
+            JSON response indicating OAuth flow is required
+        """
+        logger.debug("Processing custom Meta app request (OAuth required)")
+        
+        # This may require OAuth flow initiation
+        # Each request is independent - no session state
+        return {
+            'jsonrpc': '2.0',
+            'result': {
+                'status': 'oauth_required',
+                'auth_method': 'custom_meta_app',
+                'meta_app_id': auth_config['meta_app_id'],
+                'message': 'OAuth flow required for custom Meta app authentication',
+                'next_steps': 'Use get_login_link tool to initiate OAuth flow'
+            },
+            'id': request_body.get('id')
+        }
+    
+    def handle_unauthenticated_request(self, request_body: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle request with no authentication
+        
+        Args:
+            request_body: JSON-RPC request body
+            
+        Returns:
+            JSON error response requesting authentication
+        """
+        logger.warning("Unauthenticated request received")
+        
+        return {
+            'jsonrpc': '2.0',
+            'error': {
+                'code': -32600,
+                'message': 'Authentication required',
+                'data': {
+                    'supported_methods': [
+                        'Authorization: Bearer <token> (recommended)',
+                        'X-META-APP-ID: Custom Meta app OAuth (advanced users)'
+                    ],
+                    'documentation': 'https://github.com/pipeboard-co/meta-ads-mcp'
+                }
+            },
+            'id': request_body.get('id')
+        }
+
+
 def login_cli():
     """
     Command-line function to authenticate with Meta
@@ -34,17 +203,37 @@ def main():
     """Main entry point for the package"""
     # Log startup information
     logger.info("Meta Ads MCP server starting")
-    logger.info(f"Python version: {sys.version}")
-    logger.info(f"Args: {sys.argv}")
+    logger.debug(f"Python version: {sys.version}")
+    logger.debug(f"Args: {sys.argv}")
     
     # Initialize argument parser
-    parser = argparse.ArgumentParser(description="Meta Ads MCP Server")
+    parser = argparse.ArgumentParser(
+        description="Meta Ads MCP Server - Model Context Protocol server for Meta Ads API",
+        epilog="For more information, see https://github.com/pipeboard-co/meta-ads-mcp"
+    )
     parser.add_argument("--login", action="store_true", help="Authenticate with Meta and store the token")
     parser.add_argument("--app-id", type=str, help="Meta App ID (Client ID) for authentication")
     parser.add_argument("--version", action="store_true", help="Show the version of the package")
     
+    # Transport configuration arguments
+    parser.add_argument("--transport", type=str, choices=["stdio", "streamable-http"], 
+                       default="stdio", 
+                       help="Transport method: 'stdio' for MCP clients (default), 'streamable-http' for HTTP API access")
+    parser.add_argument("--port", type=int, default=8080, 
+                       help="Port for Streamable HTTP transport (default: 8080, only used with --transport streamable-http)")
+    parser.add_argument("--host", type=str, default="localhost", 
+                       help="Host for Streamable HTTP transport (default: localhost, only used with --transport streamable-http)")
+    parser.add_argument("--sse-response", action="store_true", 
+                       help="Use SSE response format instead of JSON (default: JSON, only used with --transport streamable-http)")
+    
     args = parser.parse_args()
-    logger.info(f"Parsed args: login={args.login}, app_id={args.app_id}, version={args.version}")
+    logger.debug(f"Parsed args: login={args.login}, app_id={args.app_id}, version={args.version}")
+    logger.debug(f"Transport args: transport={args.transport}, port={args.port}, host={args.host}, sse_response={args.sse_response}")
+    
+    # Validate CLI argument combinations
+    if args.transport == "stdio" and (args.port != 8080 or args.host != "localhost" or args.sse_response):
+        logger.warning("HTTP transport arguments (--port, --host, --sse-response) are ignored when using stdio transport")
+        print("Warning: HTTP transport arguments are ignored when using stdio transport")
     
     # Update app ID if provided as environment variable or command line arg
     from .auth import auth_manager, meta_config
@@ -52,7 +241,7 @@ def main():
     # Check environment variable first (early init)
     env_app_id = os.environ.get("META_APP_ID")
     if env_app_id:
-        logger.info(f"Found META_APP_ID in environment: {env_app_id}")
+        logger.debug(f"Found META_APP_ID in environment: {env_app_id}")
     else:
         logger.warning("META_APP_ID not found in environment variables")
     
@@ -124,6 +313,69 @@ def main():
                 logger.error(f"Error initiating browser-based authentication: {e}")
                 print(f"Error: Could not start authentication: {e}")
     
-    # Initialize and run the server
-    logger.info("Starting MCP server with stdio transport")
-    mcp_server.run(transport='stdio') 
+    # Transport-specific server initialization and startup
+    if args.transport == "streamable-http":
+        logger.info(f"Starting MCP server with Streamable HTTP transport on {args.host}:{args.port}")
+        logger.info("Mode: Stateless (no session persistence)")
+        logger.info(f"Response format: {'SSE' if args.sse_response else 'JSON'}")
+        logger.info("Primary auth method: Bearer Token (recommended)")
+        logger.info("Fallback auth method: Custom Meta App OAuth (complex setup)")
+        
+        print(f"Starting Meta Ads MCP server with Streamable HTTP transport")
+        print(f"Server will listen on {args.host}:{args.port}")
+        print(f"Response format: {'SSE' if args.sse_response else 'JSON'}")
+        print("Primary authentication: Bearer Token (via Authorization: Bearer <token> header)")
+        print("Fallback authentication: Custom Meta App OAuth (via X-META-APP-ID header)")
+        
+        # Configure the existing server with streamable HTTP settings
+        mcp_server.settings.host = args.host
+        mcp_server.settings.port = args.port
+        mcp_server.settings.stateless_http = True
+        mcp_server.settings.json_response = not args.sse_response
+        
+        # Import all tool modules to ensure they are registered
+        logger.info("Ensuring all tools are registered for HTTP transport")
+        from . import accounts, campaigns, adsets, ads, insights, authentication
+        from . import ads_library, budget_schedules
+        
+        # ✅ NEW: Setup HTTP authentication middleware
+        logger.info("Setting up HTTP authentication middleware")
+        try:
+            from .http_auth_integration import setup_fastmcp_http_auth
+            
+            # Setup the FastMCP HTTP auth integration
+            setup_fastmcp_http_auth(mcp_server)
+            logger.info("FastMCP HTTP authentication integration setup successful")
+            print("✅ FastMCP HTTP authentication integration enabled")
+            print("   - Bearer tokens via Authorization: Bearer <token> header")
+            print("   - Direct Meta tokens via X-META-ACCESS-TOKEN header")
+            
+        except Exception as e:
+            logger.error(f"Failed to setup FastMCP HTTP authentication integration: {e}")
+            print(f"⚠️  FastMCP HTTP authentication integration setup failed: {e}")
+            print("   Server will still start but may not support header-based auth")
+        
+        # Log final server configuration
+        logger.info(f"FastMCP server configured with:")
+        logger.info(f"  - Host: {mcp_server.settings.host}")
+        logger.info(f"  - Port: {mcp_server.settings.port}")
+        logger.info(f"  - Stateless HTTP: {mcp_server.settings.stateless_http}")
+        logger.info(f"  - JSON Response: {mcp_server.settings.json_response}")
+        logger.info(f"  - Streamable HTTP Path: {mcp_server.settings.streamable_http_path}")
+        
+        # Start the FastMCP server with Streamable HTTP transport
+        try:
+            logger.info("Starting FastMCP server with Streamable HTTP transport")
+            print(f"✅ Server configured successfully")
+            print(f"   URL: http://{args.host}:{args.port}{mcp_server.settings.streamable_http_path}/")
+            print(f"   Mode: {'Stateless' if mcp_server.settings.stateless_http else 'Stateful'}")
+            print(f"   Format: {'JSON' if mcp_server.settings.json_response else 'SSE'}")
+            mcp_server.run(transport="streamable-http")
+        except Exception as e:
+            logger.error(f"Error starting Streamable HTTP server: {e}")
+            print(f"Error: Failed to start Streamable HTTP server: {e}")
+            return 1
+    else:
+        # Default stdio transport
+        logger.info("Starting MCP server with stdio transport")
+        mcp_server.run(transport='stdio') 

{meta_ads_mcp-0.3.7.dist-info → meta_ads_mcp-0.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-ads-mcp
-Version: 0.3.7
+Version: 0.3.8
 Summary: Model Calling Protocol (MCP) plugin for interacting with Meta Ads API
 Project-URL: Homepage, https://github.com/nictuku/meta-ads-mcp
 Project-URL: Bug Tracker, https://github.com/nictuku/meta-ads-mcp/issues
@@ -13,7 +13,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.26.0
-Requires-Dist: mcp[cli]>=1.6.0
+Requires-Dist: mcp[cli]>=1.9.0
 Requires-Dist: pathlib>=1.0.1
 Requires-Dist: pillow>=10.0.0
 Requires-Dist: python-dateutil>=2.8.2
@@ -27,10 +27,14 @@ A [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server for in
 
 > **DISCLAIMER:** This is an unofficial third-party tool and is not associated with, endorsed by, or affiliated with Meta in any way. This project is maintained independently and uses Meta's public APIs according to their terms of service. Meta, Facebook, Instagram, and other Meta brand names are trademarks of their respective owners.
 
-**Screenshot**: Using an LLM to understand your ad performance:
+[![Meta Ads MCP Server Demo](https://github.com/user-attachments/assets/3e605cee-d289-414b-814c-6299e7f3383e)](https://github.com/user-attachments/assets/3e605cee-d289-414b-814c-6299e7f3383e)
 
-![Meta Ads MCP in action: Visualize ad performance metrics and creative details directly in Claude or your favorite MCP client, with rich insights about campaign reach, engagement, and costs](./images/meta-ads-example.png)
 
+## Community & Support
+
+- [Discord](https://discord.gg/hNxpJcqM52). Join the community.
+- [Email Support](info@pipeboard.co). Email us for support.
+  
 ## Quick Start
 
 1. Sign-up to [Pipeboard](https://pipeboard.co) to authenticate with Meta (alternatively, you can setup your own [custom meta app](CUSTOM_META_APP.md))
@@ -157,6 +161,10 @@ Add this to your `claude_desktop_config.json` to integrate with Claude or `~/.cu
 }
 ```
 
+## Transports
+
+Meta Ads MCP uses **stdio transport** by default, which works with MCP clients like Claude Desktop and Cursor. For web applications and direct HTTP API access, see [STREAMABLE_HTTP_SETUP.md](STREAMABLE_HTTP_SETUP.md) for streamable HTTP transport configuration.
+
 ### Available MCP Tools
 
 1. `mcp_meta_ads_get_ad_accounts`

{meta_ads_mcp-0.3.7.dist-info → meta_ads_mcp-0.3.8.dist-info}/RECORD

@@ -1,6 +1,5 @@
-meta_ads_mcp/__init__.py,sha256=2862NGwFr1iQ3EIKCJEc_uFo5L6stIhTjOH8fkFy4Gg,1236
+meta_ads_mcp/__init__.py,sha256=k6KFlGKu2RuY7N8tuThfUV551Qe0giWO1lQSNinT-V0,1236
 meta_ads_mcp/__main__.py,sha256=XaQt3iXftG_7f0Zu7Wop9SeFgrD2WBn0EQOaPMc27d8,207
-meta_ads_mcp/api.py,sha256=DJQCzPiguObgdHg0s9Nz9rQLLuaONB-oYQcUfNUKg2A,84546
 meta_ads_mcp/core/__init__.py,sha256=NvRA_socbKPEXFXIYdso5jBHb8cEEpF_2Mwhe3Obguw,1105
 meta_ads_mcp/core/accounts.py,sha256=Nmp7lPxO9wmq25jWV7_H0LIqnEbBhpCVBlLGW2HUaq0,2277
 meta_ads_mcp/core/ads.py,sha256=b_81GlGHIM4jISvuDZmHNyc6uW7uD3ovX68ezBci9MM,29747
@@ -12,13 +11,14 @@ meta_ads_mcp/core/authentication.py,sha256=PFqmN7ujtNsJCEDutDzs81peGWFJ8_0YLYI3-
 meta_ads_mcp/core/budget_schedules.py,sha256=UxseExsvKAiPwfDCY9aycT4kys4xqeNytyq-yyDOxrs,2901
 meta_ads_mcp/core/callback_server.py,sha256=AUymElaVwHqFyqB2wgqf6A68KsqwtKoYmY-7JZZt8Ks,43286
 meta_ads_mcp/core/campaigns.py,sha256=Fd477GsD1Gx08Ve0uXUCvr4fC-xQCeVHPBwRVaeRQKk,10965
+meta_ads_mcp/core/http_auth_integration.py,sha256=ZJHuxK1Kwtr9gvwfC5HZOLH5MW-HnDDKqJc4xuG5yVE,10060
 meta_ads_mcp/core/insights.py,sha256=XAm4uu83gWp84PEGqAJ3GFIqlvg7prh6MdD71JfvBCo,18072
 meta_ads_mcp/core/pipeboard_auth.py,sha256=VvbxEB8ZOhnMccLU7HI1HgaPWHCl5NGrzZCm-zzHze4,22798
 meta_ads_mcp/core/resources.py,sha256=-zIIfZulpo76vcKv6jhAlQq91cR2SZ3cjYZt3ek3x0w,1236
-meta_ads_mcp/core/server.py,sha256=5WofyJZGzeDhbGzLXPhQjT0XnZwo0syeK8TM_XnJo4Q,5507
+meta_ads_mcp/core/server.py,sha256=PmoJBuMi1PbUvF-IWxFb7uaO_yiEdMH4KcFnFiNhwk0,17574
 meta_ads_mcp/core/utils.py,sha256=DsizDYuJnWUpkbShV1y5Qe8t47Qf59aPZ6O9v0hzdkY,6705
-meta_ads_mcp-0.3.7.dist-info/METADATA,sha256=QJDzaqVO24H-vuPnptWEgsXph_BhPYasxwRSxAVucUk,16579
-meta_ads_mcp-0.3.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-meta_ads_mcp-0.3.7.dist-info/entry_points.txt,sha256=Dv2RkoBjRJBqj6CyhwqGIiwPCD-SCL1-7B9-zmVRuv0,57
-meta_ads_mcp-0.3.7.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-meta_ads_mcp-0.3.7.dist-info/RECORD,,
+meta_ads_mcp-0.3.8.dist-info/METADATA,sha256=dqvQ1zpwldGTqpkcCH9uicMOOkM9C2lziTdlNAnjW0g,16913
+meta_ads_mcp-0.3.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+meta_ads_mcp-0.3.8.dist-info/entry_points.txt,sha256=Dv2RkoBjRJBqj6CyhwqGIiwPCD-SCL1-7B9-zmVRuv0,57
+meta_ads_mcp-0.3.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+meta_ads_mcp-0.3.8.dist-info/RECORD,,