MCP and A2A Compatibility

// Example of integrating Mage with an MCP server
// Using direct API calls instead of an SDK

// Set up an MCP server that can process payments via Mage
async function setupMCPPaymentProcessor(apiKey) {
  // Register payment capabilities with MCP server
  const paymentService = {
    name: "payment_service",
    description: "Process payments via Mage API",
    methods: {
      // Define payment method that MCP can call
      "process_payment": async (sender, receiver, amount, currency = "USDC") => {
        // Call Mage API to register a payment
        const response = await fetch('https://api.magebank.ai/payments/register', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'x-api-key': apiKey
          },
          body: JSON.stringify({
            senderagentid: sender,
            receiveragentid: receiver,
            paymentdetails: {
              amount: amount,
              currency: currency,
              method: "CRYPTO_ADDRESS"
            },
            name: `Payment from ${sender} to ${receiver}`,
            type: "EXTERNAL"
          })
        });
        
        return await response.json();
      }
    }
  };
  
  // Return the payment service for MCP server registration
  return paymentService;
}

# Example of integrating Mage with an MCP server in Python
# Using direct API calls with the requests library

import requests
import json

def setup_mcp_payment_processor(api_key):
    """
    Set up an MCP server that can process payments via Mage
    
    Args:
        api_key (str): Your Mage API key
        
    Returns:
        dict: Payment service definition for MCP server registration
    """
    
    # Define the payment service for MCP integration
    payment_service = {
        "name": "payment_service",
        "description": "Process payments via Mage API",
        "methods": {
            "process_payment": lambda sender, receiver, amount, currency="USDC": process_payment(
                api_key, sender, receiver, amount, currency
            )
        }
    }
    
    return payment_service

def process_payment(api_key, sender, receiver, amount, currency="USDC"):
    """
    Process a payment between agents using the Mage API
    
    Args:
        api_key (str): Your Mage API key
        sender (str): ID of the sender agent
        receiver (str): ID of the receiver agent
        amount (float): Payment amount
        currency (str, optional): Currency code. Defaults to "USDC".
        
    Returns:
        dict: Result of the payment operation
    """
    
    # Call Mage API to register a payment
    response = requests.post(
        'https://api.magebank.ai/payments/register',
        headers={
            'Content-Type': 'application/json',
            'x-api-key': api_key
        },
        json={
            'senderagentid': sender,
            'receiveragentid': receiver,
            'paymentdetails': {
                'amount': amount,
                'currency': currency,
                'method': "CRYPTO_ADDRESS"
            },
            'name': f"Payment from {sender} to {receiver}",
            'type': "EXTERNAL"
        }
    )
    
    # Return the API response
    return response.json()

// Example of integrating Mage with Google's A2A framework
// This example shows how a financial agent could advertise payment capabilities via A2A

// Define an A2A Agent Card with Mage payment capabilities
const agentCard = {
  "name": "Mage Payment Agent",
  "description": "Agent for processing payments and financial transactions",
  "version": "1.0.0",
  "skills": [
    {
      "name": "process_payment",
      "description": "Process a payment between agents or external accounts",
      "parameters": {
        "type": "object",
        "properties": {
          "sender": { "type": "string", "description": "Sender agent ID" },
          "receiver": { "type": "string", "description": "Receiver agent ID or wallet address" },
          "amount": { "type": "number", "description": "Payment amount" },
          "currency": { "type": "string", "description": "Currency code (default: USDC)" }
        },
        "required": ["sender", "receiver", "amount"]
      }
    },
    {
      "name": "check_balance",
      "description": "Check available balance for an agent",
      "parameters": {
        "type": "object",
        "properties": {
          "agentId": { "type": "string", "description": "Agent ID to check balance for" }
        },
        "required": ["agentId"]
      }
    }
  ],
  "supportedModes": ["text", "structured"],
  "authentication": {
    "required": true,
    "type": "apiKey"
  }
};

// Handle incoming A2A task requests
async function handleA2ATask(task, apiKey) {
  if (task.skill === "process_payment") {
    const params = task.parameters;
    
    // Call Mage API to process payment
    const response = await fetch('https://api.magebank.ai/payments/register', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': apiKey
      },
      body: JSON.stringify({
        senderagentid: params.sender,
        receiveragentid: params.receiver,
        paymentdetails: {
          amount: params.amount,
          currency: params.currency || "USDC",
          method: "CRYPTO_ADDRESS"
        },
        name: `A2A Payment: ${params.sender} to ${params.receiver}`,
        type: "EXTERNAL"
      })
    });
    
    const result = await response.json();
    return {
      status: "completed",
      result: {
        success: result.status !== "error",
        paymentId: result.id,
        message: result.message || result.error
      }
    };
  }
  
  if (task.skill === "check_balance") {
    // Call Mage API to get agent balance
    const response = await fetch(`https://api.magebank.ai/agentsWith/${task.parameters.agentId}`, {
      headers: {
        'x-api-key': apiKey
      }
    });
    
    const agent = await response.json();
    return {
      status: "completed",
      result: {
        agentId: agent.id,
        balance: agent.balance,
        currency: agent.currency
      }
    };
  }
  
  return {
    status: "failed",
    error: "Unsupported skill requested"
  };
}

# Example of integrating Mage with Google's A2A framework in Python
# This example shows how a financial agent could advertise payment capabilities via A2A

import requests
import json

# Define an A2A Agent Card with Mage payment capabilities
agent_card = {
    "name": "Mage Payment Agent",
    "description": "Agent for processing payments and financial transactions",
    "version": "1.0.0",
    "skills": [
        {
            "name": "process_payment",
            "description": "Process a payment between agents or external accounts",
            "parameters": {
                "type": "object",
                "properties": {
                    "sender": {"type": "string", "description": "Sender agent ID"},
                    "receiver": {"type": "string", "description": "Receiver agent ID or wallet address"},
                    "amount": {"type": "number", "description": "Payment amount"},
                    "currency": {"type": "string", "description": "Currency code (default: USDC)"}
                },
                "required": ["sender", "receiver", "amount"]
            }
        },
        {
            "name": "check_balance",
            "description": "Check available balance for an agent",
            "parameters": {
                "type": "object",
                "properties": {
                    "agentId": {"type": "string", "description": "Agent ID to check balance for"}
                },
                "required": ["agentId"]
            }
        }
    ],
    "supportedModes": ["text", "structured"],
    "authentication": {
        "required": True,
        "type": "apiKey"
    }
}

def handle_a2a_task(task, api_key):
    """
    Handle incoming A2A task requests
    
    Args:
        task (dict): Task request from A2A framework
        api_key (str): Your Mage API key
        
    Returns:
        dict: Task response for A2A framework
    """
    
    if task["skill"] == "process_payment":
        params = task["parameters"]
        
        # Call Mage API to process payment
        response = requests.post(
            'https://api.magebank.ai/payments/register',
            headers={
                'Content-Type': 'application/json',
                'x-api-key': api_key
            },
            json={
                'senderagentid': params["sender"],
                'receiveragentid': params["receiver"],
                'paymentdetails': {
                    'amount': params["amount"],
                    'currency': params.get("currency", "USDC"),
                    'method': "CRYPTO_ADDRESS"
                },
                'name': f"A2A Payment: {params['sender']} to {params['receiver']}",
                'type': "EXTERNAL"
            }
        )
        
        result = response.json()
        return {
            "status": "completed",
            "result": {
                "success": result.get("status") != "error",
                "paymentId": result.get("id"),
                "message": result.get("message") or result.get("error", "")
            }
        }
    
    elif task["skill"] == "check_balance":
        # Call Mage API to get agent balance
        response = requests.get(
            f"https://api.magebank.ai/agentsWith/{task['parameters']['agentId']}",
            headers={'x-api-key': api_key}
        )
        
        agent = response.json()
        return {
            "status": "completed",
            "result": {
                "agentId": agent.get("id"),
                "balance": agent.get("balance"),
                "currency": agent.get("currency")
            }
        }
    
    return {
        "status": "failed",
        "error": "Unsupported skill requested"
    }