traia-iatp 0.1.2__py3-none-any.whl → 0.1.67__py3-none-any.whl

traia_iatp/mcp/d402_mcp_tool_adapter.py

@@ -0,0 +1,526 @@
+#!/usr/bin/env python
+"""
+D402 MCP Tool Adapter
+
+A simple adapter for using d402-enabled MCP servers with CrewAI.
+This adapter avoids the complexity of persistent SSE connections and background tasks.
+
+Instead, it:
+1. Lists available tools from the MCP server
+2. Creates CrewAI BaseTool wrappers for each MCP tool
+3. Each tool uses httpx with d402 payment hooks for requests
+4. No persistent connections - simple request/response pattern
+
+This is more reliable than MCPServerAdapter for d402 payment scenarios.
+"""
+
+import json
+import logging
+from typing import Any, Dict, List, Optional, Type
+from pydantic import BaseModel, Field, create_model
+from crewai.tools import BaseTool
+import httpx
+
+from traia_iatp.d402.clients.httpx import d402HttpxClient
+
+logger = logging.getLogger(__name__)
+
+
+def json_schema_to_pydantic_model(json_schema: Dict[str, Any], model_name: str = "ToolInput") -> type[BaseModel]:
+    """
+    Convert JSON schema to Pydantic BaseModel for CrewAI args_schema.
+    
+    CrewAI BaseTool expects args_schema to be a Pydantic BaseModel, not a Dict.
+    Without this conversion, CrewAI cannot properly extract and validate tool arguments,
+    causing arguments to be lost (empty dict sent to MCP server).
+    
+    Args:
+        json_schema: JSON schema dictionary (OpenAPI format)
+        model_name: Name for the generated Pydantic model
+        
+    Returns:
+        Pydantic BaseModel class
+    """
+    if not json_schema or "properties" not in json_schema:
+        # Return empty model if no schema
+        return create_model(model_name, __base__=BaseModel)
+    
+    properties = json_schema.get("properties", {})
+    required = json_schema.get("required", [])
+    
+    # Map JSON schema types to Python types
+    type_mapping = {
+        "string": str,
+        "integer": int,
+        "number": float,
+        "boolean": bool,
+        "array": list,
+        "object": dict,
+    }
+    
+    # Build field definitions
+    field_definitions = {}
+    for prop_name, prop_schema in properties.items():
+        prop_type = prop_schema.get("type", "string")
+        python_type = type_mapping.get(prop_type, str)
+        
+        # Get description for Field
+        description = prop_schema.get("description", "")
+        
+        # Check if required
+        is_required = prop_name in required
+        
+        # Create Field with description
+        if is_required:
+            field_definitions[prop_name] = (python_type, Field(description=description))
+        else:
+            # Optional field with default
+            default_value = prop_schema.get("default", None)
+            field_definitions[prop_name] = (Optional[python_type], Field(default=default_value, description=description))
+    
+    # Create Pydantic model
+    if field_definitions:
+        return create_model(model_name, **field_definitions)
+    else:
+        return create_model(model_name, __base__=BaseModel)
+
+
+class D402MCPTool(BaseTool):
+    """
+    CrewAI tool wrapper for a single MCP tool with d402 payment support.
+    
+    Each instance represents one MCP tool and handles d402 payments automatically.
+    """
+    
+    name: str = "mcp_tool"
+    description: str = "MCP tool with d402 payment"
+    mcp_server_url: str = ""  # Full MCP server URL (will be cleaned of trailing slash)
+    mcp_tool_name: str = ""
+    mcp_session_id: str = ""
+    d402_operator_account: Optional[Any] = None  # Operator account (EOA) for signing
+    d402_wallet_address: Optional[str] = None  # IATPWallet contract address
+    input_schema: Dict[str, Any] = Field(default_factory=dict)
+    
+    class Config:
+        arbitrary_types_allowed = True
+    
+    def __init__(self, **data):
+        """Initialize with custom data."""
+        super().__init__(**data)
+        # Ensure args_schema is preserved if provided
+        # BaseTool.__init__ might not preserve it properly, so set it explicitly
+        if "args_schema" in data and data["args_schema"] is not None:
+            self.args_schema = data["args_schema"]
+    
+    def _set_args_schema(self):
+        """
+        Override to prevent BaseTool from overriding our args_schema.
+        
+        If args_schema is already set (from input_schema conversion), keep it.
+        Otherwise, let BaseTool infer it from _run signature.
+        """
+        # Only set args_schema if it's not already set (i.e., still the placeholder)
+        from crewai.tools.base_tool import BaseTool as BaseToolClass
+        if self.args_schema == BaseToolClass._ArgsSchemaPlaceholder:
+            # Call parent to infer from _run signature
+            super()._set_args_schema()
+        # Otherwise, keep our custom args_schema from input_schema conversion
+    
+    def _run(self, **kwargs) -> Dict[str, Any]:
+        """
+        Synchronous wrapper that runs async _arun.
+        
+        This method receives arguments from CrewAI. If kwargs is empty, it means
+        CrewAI didn't extract arguments properly from the LLM's tool call.
+        
+        IMPORTANT: This method signature must match what CrewAI expects.
+        CrewAI will call this with keyword arguments based on args_schema.
+        """
+        # Debug: Log what arguments we received
+        if not kwargs:
+            logger.error(f"❌ D402MCPTool._run called with EMPTY kwargs for {self.name}")
+            logger.error(f"   This means CrewAI/LLM didn't provide arguments!")
+            logger.error(f"   args_schema: {self.args_schema}")
+            if hasattr(self.args_schema, 'model_fields'):
+                required_fields = [name for name, field in self.args_schema.model_fields.items() 
+                                 if field.is_required()]
+                logger.error(f"   Required fields: {required_fields}")
+                logger.error(f"   All fields: {list(self.args_schema.model_fields.keys())}")
+            logger.error(f"   Tool description: {self.description[:200]}...")
+            # Don't fail here - let the MCP server validate and return proper error
+        else:
+            logger.info(f"✅ D402MCPTool._run called with kwargs: {kwargs}")
+        
+        import asyncio
+        try:
+            # Run the async method in a new event loop
+            return asyncio.run(self._arun(**kwargs))
+        except RuntimeError:
+            # If we're already in an event loop, use run_until_complete
+            loop = asyncio.get_event_loop()
+            return loop.run_until_complete(self._arun(**kwargs))
+    
+    async def _arun(self, **kwargs) -> Dict[str, Any]:
+        """
+        Execute the MCP tool with d402 payment support.
+        
+        This method:
+        1. Creates d402HttpxClient with built-in payment handling
+        2. Makes MCP tools/call request
+        3. d402 hooks automatically handle any 402 responses
+        4. Returns the result
+        """
+        
+        # Remove trailing slash to avoid redirects
+        mcp_url = self.mcp_server_url.rstrip('/')
+        
+        # Create d402HttpxClient with built-in payment hooks
+        # This ensures the hooks have a reference to the client for retries
+        async with d402HttpxClient(
+            operator_account=self.d402_operator_account,
+            wallet_address=self.d402_wallet_address,
+            timeout=60.0,
+            http2=False  # Disable HTTP/2 for compatibility
+        ) as client:
+            
+            # Create MCP tools/call request
+            # kwargs contains the actual arguments from CrewAI (e.g., {"q": "test"})
+            mcp_request = {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "tools/call",
+                "params": {
+                    "name": self.mcp_tool_name,
+                    "arguments": kwargs  # Pass arguments directly from CrewAI
+                }
+            }
+            
+            try:
+                # Make request - d402 hooks will handle any 402 responses automatically
+                response = await client.post(
+                    mcp_url,  # Use full URL without trailing slash
+                    json=mcp_request,
+                    headers={
+                        "Content-Type": "application/json",
+                        "Accept": "application/json, text/event-stream",
+                        "mcp-session-id": self.mcp_session_id
+                    },
+                    follow_redirects=False  # Don't follow redirects - causes issues
+                )
+                
+                # Read response content
+                content = await response.aread()
+                content_str = content.decode() if content else ""
+                
+                # Parse SSE format if present
+                if "data:" in content_str:
+                    sse_lines = content_str.strip().split('\n')
+                    for line in sse_lines:
+                        if line.startswith("data:"):
+                            content_str = line[5:].strip()
+                            break
+                
+                # Parse JSON response
+                response_data = json.loads(content_str)
+                
+                # Extract result
+                if "result" in response_data:
+                    result = response_data["result"]
+                    # Return structured content if available, otherwise full result
+                    if isinstance(result, dict) and "structuredContent" in result:
+                        return result["structuredContent"].get("result", result)
+                    return result
+                elif "error" in response_data:
+                    return {"error": response_data["error"]}
+                else:
+                    return response_data
+                    
+            except Exception as e:
+                logger.error(f"Error calling MCP tool {self.mcp_tool_name}: {e}")
+                return {"error": str(e)}
+
+
+class D402MCPToolAdapter:
+    """
+    Adapter for using d402-enabled MCP servers with CrewAI.
+    
+    This adapter is simpler and more reliable than MCPServerAdapter for d402:
+    - No persistent SSE connections
+    - No background tasks
+    - Direct request/response with d402 hooks
+    
+    Usage:
+        ```python
+        from eth_account import Account
+        from traia_iatp.mcp import D402MCPToolAdapter
+        
+        account = Account.from_key("0x...")
+        adapter = D402MCPToolAdapter(
+            url="http://localhost:8000/mcp",
+            account=account
+        )
+        
+        with adapter as tools:
+            agent = Agent(
+                role="Analyst",
+                goal="Analyze data",
+                tools=tools
+            )
+        ```
+    """
+    
+    def __init__(
+        self,
+        url: str,
+        account: Any,  # Operator account (EOA) for signing
+        wallet_address: str = None,  # IATPWallet contract address
+        max_value: Optional[int] = None
+    ):
+        """
+        Initialize the d402 MCP adapter.
+        
+        Args:
+            url: MCP server URL (e.g., "http://localhost:8000/mcp")
+            account: Operator account (EOA) with private key for signing payments
+            wallet_address: IATPWallet contract address (if None, uses account.address for testing)
+            max_value: Optional maximum payment value in base units
+        """
+        self.url = url
+        self.account = account  # Operator EOA
+        self.wallet_address = wallet_address or account.address  # IATPWallet or EOA for testing
+        self.max_value = max_value
+        self.tools: List[BaseTool] = []
+        self.session_id: Optional[str] = None
+    
+    async def _initialize_session(self) -> str:
+        """Initialize MCP session and return session ID."""
+        # Remove trailing slash to avoid redirects
+        mcp_url = self.url.rstrip('/')
+        
+        async with httpx.AsyncClient(timeout=30.0, http2=False) as client:
+            init_request = {
+                "jsonrpc": "2.0",
+                "id": "init",
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {},
+                    "clientInfo": {"name": "d402-crewai-client", "version": "1.0"}
+                }
+            }
+            
+            response = await client.post(
+                mcp_url,  # Use full URL without trailing slash
+                json=init_request,
+                headers={
+                    "Content-Type": "application/json",
+                    "Accept": "application/json, text/event-stream"
+                },
+                follow_redirects=False  # Don't follow redirects - causes issues
+            )
+            
+            session_id = response.headers.get("mcp-session-id")
+            if not session_id:
+                raise RuntimeError("Failed to establish MCP session")
+            
+            return session_id
+    
+    async def _list_tools(self) -> List[Dict[str, Any]]:
+        """List available tools from the MCP server."""
+        # Remove trailing slash to avoid redirects
+        mcp_url = self.url.rstrip('/')
+        
+        async with httpx.AsyncClient(timeout=30.0, http2=False) as client:
+            mcp_request = {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "tools/list",
+                "params": {}
+            }
+            
+            response = await client.post(
+                mcp_url,  # Use full URL without trailing slash
+                json=mcp_request,
+                headers={
+                    "Content-Type": "application/json",
+                    "Accept": "application/json, text/event-stream",
+                    "mcp-session-id": self.session_id
+                },
+                follow_redirects=False  # Don't follow redirects - causes issues
+            )
+            
+            # Read response content (SSE format)
+            content = await response.aread()
+            content_str = content.decode() if content else ""
+            
+            # Parse SSE format if present
+            if "data:" in content_str:
+                sse_lines = content_str.strip().split('\n')
+                for line in sse_lines:
+                    if line.startswith("data:"):
+                        content_str = line[5:].strip()
+                        break
+            
+            response_data = json.loads(content_str)
+            
+            if "result" in response_data and "tools" in response_data["result"]:
+                return response_data["result"]["tools"]
+            return []
+    
+    def __enter__(self) -> List[BaseTool]:
+        """
+        Enter context manager - set up session and create tool wrappers.
+        
+        Returns:
+            List of CrewAI BaseTool objects for each MCP tool
+        """
+        import asyncio
+        
+        logger.info("="*80)
+        logger.info("🚀 D402MCPToolAdapter.__enter__() starting...")
+        logger.info("="*80)
+        
+        # Handle nested event loop scenario (e.g., when CrewAI already has an event loop running)
+        logger.info("🔍 Step 1: Checking for existing event loop...")
+        try:
+            # Try to get existing event loop
+            loop = asyncio.get_running_loop()
+            logger.info(f"   ✅ Found existing event loop: {loop}")
+            # We have a running loop - use nest_asyncio to allow nested asyncio.run()
+            logger.info("   Attempting to apply nest_asyncio...")
+            try:
+                import nest_asyncio
+                logger.info("   nest_asyncio imported successfully")
+                nest_asyncio.apply()
+                logger.info("   📡 Applied nest_asyncio for nested event loop support")
+            except ImportError as e:
+                logger.warning(f"   ⚠️  nest_asyncio not available: {e}")
+                logger.warning("   This WILL cause hanging with nested event loops")
+        except RuntimeError as e:
+            # No event loop running - asyncio.run() will work fine
+            logger.info(f"   ✅ No existing event loop detected (RuntimeError: {e})")
+            logger.info("   asyncio.run() will work without nest_asyncio")
+        
+        # Initialize session
+        logger.info("")
+        logger.info("🔍 Step 2: Initializing MCP session...")
+        logger.info(f"   URL: {self.url}")
+        logger.info("   About to call: asyncio.run(self._initialize_session())")
+        try:
+            self.session_id = asyncio.run(self._initialize_session())
+            logger.info(f"   ✅ Session established: {self.session_id}")
+        except Exception as e:
+            logger.error(f"   ❌ Session initialization failed: {e}")
+            raise
+        
+        # List available tools
+        logger.info("")
+        logger.info("🔍 Step 3: Listing available tools...")
+        logger.info("   About to call: asyncio.run(self._list_tools())")
+        try:
+            mcp_tools = asyncio.run(self._list_tools())
+            logger.info(f"   ✅ Found {len(mcp_tools)} tools")
+        except Exception as e:
+            logger.error(f"   ❌ Tool listing failed: {e}")
+            raise
+        
+        logger.info("")
+        logger.info("🔍 Step 4: Creating CrewAI tool wrappers...")
+        logger.info(f"   Creating wrappers for {len(mcp_tools)} tools...")
+        
+        # Create CrewAI tool wrappers for each MCP tool
+        self.tools = []
+        for mcp_tool in mcp_tools:
+            tool_name = mcp_tool.get("name", "unknown")
+            tool_description = mcp_tool.get("description", f"MCP tool: {tool_name}")
+            input_schema = mcp_tool.get("inputSchema", {})
+            
+            # Convert JSON schema to Pydantic model for CrewAI args_schema
+            # This is critical: CrewAI BaseTool expects args_schema to be a Pydantic BaseModel,
+            # not a Dict. Without this conversion, CrewAI cannot properly extract arguments,
+            # causing arguments to be lost (empty dict sent to MCP server).
+            model_name = f"{tool_name}Input"
+            args_schema = json_schema_to_pydantic_model(input_schema, model_name)
+            
+            # Create tool instance with all necessary data
+            tool_instance = D402MCPTool(
+                name=tool_name,
+                description=tool_description,
+                mcp_server_url=self.url,
+                mcp_tool_name=tool_name,
+                mcp_session_id=self.session_id,
+                d402_operator_account=self.account,  # Operator EOA for signing
+                d402_wallet_address=self.wallet_address,  # IATPWallet contract (or EOA for testing)
+                input_schema=input_schema,  # Keep for reference, but args_schema is what CrewAI uses
+                args_schema=args_schema  # Set the Pydantic model for CrewAI argument extraction
+            )
+            # Note: args_schema is preserved by __init__ override, no need to set again
+            # BaseTool will automatically enhance the description with argument info
+            
+            self.tools.append(tool_instance)
+        
+        logger.info(f"✅ Created {len(self.tools)} CrewAI tool wrappers")
+        return self.tools
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit context manager - cleanup."""
+        logger.info("🔌 Closing D402MCPToolAdapter")
+        return False
+
+
+def create_d402_mcp_adapter(
+    url: str,
+    account: Any,  # Operator account (EOA) for signing
+    wallet_address: str = None,  # IATPWallet contract address
+    max_value: Optional[int] = None
+) -> D402MCPToolAdapter:
+    """
+    Create a d402 MCP adapter for CrewAI.
+    
+    Args:
+        url: MCP server URL
+        account: Operator account (EOA) for signing payments
+        wallet_address: IATPWallet contract address (if None, uses account.address for testing)
+        max_value: Optional maximum payment value in base units
+        
+    Returns:
+        D402MCPToolAdapter instance
+        
+    Example:
+        ```python
+        from eth_account import Account
+        from traia_iatp.mcp import create_d402_mcp_adapter
+        
+        # For testing (uses mock wallet address)
+        operator_account = Account.from_key("0x...")
+        mock_wallet = "0x70997970C51812dc3A010C7d01b50e0d17dc79C8"  # Different from operator
+        adapter = create_d402_mcp_adapter(
+            url="http://localhost:8000/mcp",
+            account=operator_account,
+            wallet_address=mock_wallet,
+            max_value=1_000_000  # $1.00 in USDC
+        )
+        
+        # For production (with deployed IATPWallet contract)
+        operator_account = Account.from_key("0x...")  # Operator EOA
+        wallet_address = "0x..."  # Deployed IATPWallet contract
+        adapter = create_d402_mcp_adapter(
+            url="http://localhost:8000/mcp",
+            account=operator_account,
+            wallet_address=wallet_address,
+            max_value=1_000_000
+        )
+        
+        with adapter as tools:
+            agent = Agent(
+                role="Analyst",
+                goal="Analyze data",
+                tools=tools
+            )
+        ```
+    """
+    return D402MCPToolAdapter(url, account, wallet_address, max_value)
+
+
+__all__ = ["D402MCPTool", "D402MCPToolAdapter", "create_d402_mcp_adapter"]
+

traia_iatp/mcp/mcp_agent_template.py

@@ -82,8 +82,9 @@ from pathlib import Path
 from crewai import Agent, Task, Crew, Process, LLM
 from crewai_tools import MCPServerAdapter
 
-# Import our custom adapter for API key support
-from .traia_mcp_adapter import create_mcp_adapter, create_mcp_adapter_with_auth
+# Import our custom adapters for API key and d402 payment support
+from .traia_mcp_adapter import create_mcp_adapter, create_mcp_adapter_with_auth, create_mcp_adapter_with_x402
+from .d402_mcp_tool_adapter import create_d402_mcp_adapter
 
 
 logger = logging.getLogger(__name__)
@@ -152,7 +153,9 @@ class MCPAgentBuilder:
         verbose: bool = True,
         allow_delegation: bool = False,
         llm: LLM = None,
-        tools_subset: List[str] = None
+        tools_subset: List[str] = None,
+        memory: bool = False,
+        max_iter: int = 25
     ) -> Agent:
         """
         Create a CrewAI agent for use with MCP tools.
@@ -165,6 +168,8 @@ class MCPAgentBuilder:
             allow_delegation: Whether to allow the agent to delegate tasks
             llm: The LLM instance to use (defaults to gpt-4.1 with temperature 0.7)
             tools_subset: Optional list of specific tool names to include (if None, all tools are included)
+            memory: Whether to enable memory for learning and context retention
+            max_iter: Maximum number of iterations for tool execution
             
         Returns:
             CrewAI Agent configured for MCP tools
@@ -181,7 +186,9 @@ class MCPAgentBuilder:
             backstory=backstory,
             verbose=verbose,
             allow_delegation=allow_delegation,
-            llm=llm
+            llm=llm,
+            memory=memory,  # Enable memory for context retention
+            max_iter=max_iter  # Allow sufficient iterations to execute tools
         )
         
         # Store the tools_subset in the class dictionary
@@ -245,15 +252,21 @@ def run_with_mcp_tools(
     verbose: bool = True,
     inputs: Optional[Dict[str, Any]] = None,
     skip_health_check: bool = False,
-    api_key: Optional[str] = None
+    api_key: Optional[str] = None,
+    d402_account: Optional[Any] = None,
+    d402_wallet_address: Optional[str] = None,
+    d402_max_value: Optional[int] = None,
+    d402_max_value_token: Optional[str] = None,
+    d402_max_value_network: Optional[str] = None
 ) -> Any:
     """
     Run tasks with agents that have access to MCP server tools.
     
-    NOTE ON AUTHENTICATION:
-    This function automatically detects if the MCP server requires authentication
-    based on the server's metadata. If authentication is required, you must provide
-    your API key using the api_key parameter.
+    NOTE ON AUTHENTICATION AND PAYMENT:
+    This function supports three modes of operation:
+    1. Authenticated mode: Provide api_key if server requires authentication
+    2. Payment mode: Provide d402_account (CLIENT's account) for servers using HTTP 402 payment protocol
+    3. Standard mode: No authentication or payment required
     
     Args:
         tasks: List of tasks to run
@@ -264,6 +277,23 @@ def run_with_mcp_tools(
         inputs: Optional inputs for the crew
         skip_health_check: Skip server health check
         api_key: Optional API key for authenticated MCP servers
+        d402_account: CLIENT's operator account (EOA) with private key for signing payments.
+                      This is the account that signs transactions on behalf of the wallet.
+        d402_wallet_address: CLIENT's IATPWallet contract address (holds funds).
+                            If None, uses d402_account.address (for testing only).
+                            In production, this must be the deployed IATPWallet contract address.
+        d402_max_value: Optional safety limit for maximum payment amount per request in base units.
+                       This is a global safety check that prevents paying more than intended.
+                       Typically, each MCP server uses one primary token, so this limit applies
+                       to all endpoints using that token. Set it based on your most expensive
+                       expected payment in the token's base units (e.g., for USDC with 6 decimals,
+                       $1.00 = 1_000_000 base units).
+                       If None, no limit is enforced (not recommended for production).
+        d402_max_value_token: Optional token address (e.g., "0x036CbD53842c5426634e7929541eC2318f3dCF7e" for USDC)
+                             or token symbol (e.g., "USDC") that this max_value relates to.
+                             Used for documentation/clarity - the actual validation is numeric only.
+        d402_max_value_network: Optional network name (e.g., "base-sepolia", "sepolia") that this
+                                max_value relates to. Used for documentation/clarity.
         
     Returns:
         Result from the crew execution
@@ -280,8 +310,40 @@ def run_with_mcp_tools(
     requires_api_key = mcp_server.metadata.get("requires_api_key", False)
     api_key_header = mcp_server.metadata.get("api_key_header", "Authorization")
     
-    # Create appropriate adapter
-    if requires_api_key:
+    # Determine connection mode: d402 payment takes precedence over auth
+    if d402_account:
+        # Payment mode: use new D402MCPToolAdapter (simpler, no background tasks)
+        # d402_account is the CLIENT's operator account for signing payments
+        # d402_wallet_address is the CLIENT's IATPWallet contract (if None, uses operator address for testing)
+        try:
+            adapter = create_d402_mcp_adapter(
+                url=mcp_server.url,
+                account=d402_account,
+                wallet_address=d402_wallet_address,
+                max_value=d402_max_value
+            )
+            max_value_info = ""
+            if d402_max_value is not None:
+                max_value_info = f" (max: {d402_max_value}"
+                if d402_max_value_token:
+                    max_value_info += f" {d402_max_value_token}"
+                if d402_max_value_network:
+                    max_value_info += f" on {d402_max_value_network}"
+                max_value_info += ")"
+            
+            wallet_info = d402_wallet_address or d402_account.address
+            print(f"\n💳 Using d402 payment protocol:")
+            print(f"   Operator account: {d402_account.address} (signs payments)")
+            print(f"   Wallet address: {wallet_info} ({'IATPWallet' if d402_wallet_address else 'EOA for testing'})")
+            if max_value_info:
+                print(f"   Max value: {max_value_info}")
+            print(f"   Using D402MCPToolAdapter (simple request/response, no background tasks)")
+        except ImportError as e:
+            print(f"\n❌ Error: d402 payment hooks not available")
+            print("Ensure traia_iatp.d402 is installed")
+            sys.exit(1)
+    elif requires_api_key:
+        # Authenticated mode: use API key
         if not api_key:
             print(f"\n⚠️  WARNING: MCP server '{mcp_server.name}' requires authentication")
             print(f"Expected header: {api_key_header}")
@@ -289,6 +351,8 @@ def run_with_mcp_tools(
             print("\nTo provide authentication:")
             print("Pass your API key using the 'api_key' parameter")
             print("Example: run_with_mcp_tools(tasks, mcp_server, api_key='YOUR_API_KEY')")
+            print("\nAlternatively, use d402 payment protocol:")
+            print("Example: run_with_mcp_tools(tasks, mcp_server, d402_account=client_account)")
             sys.exit(1)
         
         # Use the provided API key directly (user provides raw key without Bearer prefix)
@@ -300,7 +364,7 @@ def run_with_mcp_tools(
         )
         print(f"\n🔐 Using authenticated connection (header: {api_key_header})")
     else:
-        # No authentication required
+        # Standard mode: no authentication or payment required
         adapter = create_mcp_adapter(url=mcp_server.url)
         print("\n🔓 Using standard connection (no authentication)")
     
@@ -335,7 +399,8 @@ def run_with_mcp_tools(
                 agents=agents,
                 tasks=tasks,
                 verbose=verbose,
-                process=process
+                process=process,
+                tracing=True if os.getenv("AGENTOPS_API_KEY") else False,
             )
             
             # Kickoff the crew with inputs