AP2 Protocol

from intra import PaymentClient

payment = PaymentClient()

# Create payment intent
intent = payment.create_intent(
    amount=29.99,
    currency="USD",
    description="Premium subscription",
    metadata={
        "agent_id": "subscription-agent",
        "user_id": "user_123"
    }
)

# Request user consent
consent = payment.request_consent(
    intent_id=intent.id,
    user_id="user_123"
)

# Process payment after consent
if consent.approved:
    result = payment.process(intent.id)
    print(f"Payment successful: {result.receipt_url}")

{
  "consentId": "consent_abc123",
  "type": "payment",
  "status": "pending",
  "details": {
    "action": "Purchase subscription",
    "amount": 29.99,
    "currency": "USD",
    "recipient": "Intra Platform",
    "description": "Monthly Premium subscription"
  },
  "requestedBy": {
    "agentId": "subscription-agent",
    "agentName": "Subscription Manager"
  },
  "expiresAt": "2025-09-30T14:30:00Z"
}

from intra import DeploymentClient

deploy = DeploymentClient()

# Deploy agent with billing
deployment = deploy.create(
    agent_id="data-analyzer",
    instance_type="standard",
    billing_plan="pay_as_you_go",
    cost_limits={
        "daily_max": 50.00,
        "monthly_max": 1000.00
    }
)

# Monitor usage and costs
usage = deploy.get_usage(deployment.id)
print(f"Current cost: ${usage.current_cost}")
print(f"Estimated monthly: ${usage.estimated_monthly}")

# Get detailed billing
billing = deploy.get_billing(
    deployment.id,
    period="current_month"
)

from intra import EcommerceAgent, PaymentClient

agent = EcommerceAgent()
payment = PaymentClient()

@agent.on_task
async def purchase_product(product_id: str, quantity: int):
    # Calculate total
    product = get_product(product_id)
    total = product.price * quantity
    
    # Request user consent
    consent = await payment.request_consent(
        amount=total,
        description=f"Purchase {quantity}x {product.name}",
        details={
            "product_id": product_id,
            "quantity": quantity,
            "unit_price": product.price
        }
    )
    
    if consent.approved:
        # Process payment
        result = await payment.process(consent.id)
        
        # Fulfill order
        order = create_order(product_id, quantity, result.transaction_id)
        
        return {
            "status": "success",
            "order_id": order.id,
            "receipt_url": result.receipt_url
        }
    else:
        return {
            "status": "declined",
            "reason": "User did not approve payment"
        }

@agent.on_task
async def manage_subscription(action: str, plan: str):
    if action == "upgrade":
        # Calculate price difference
        current = get_current_plan()
        new_plan = get_plan(plan)
        prorated = calculate_proration(current, new_plan)
        
        # Request consent for upgrade
        consent = await payment.request_consent(
            amount=prorated,
            description=f"Upgrade to {plan} plan",
            recurring={
                "frequency": "monthly",
                "amount": new_plan.price
            }
        )
        
        if consent.approved:
            # Process upgrade
            result = upgrade_subscription(plan, consent.id)
            return {"status": "upgraded", "plan": plan}
    
    elif action == "cancel":
        # No payment needed for cancellation
        result = cancel_subscription()
        return {"status": "cancelled"}

from intra import DeploymentClient, UsageTracker

deploy = DeploymentClient()
tracker = UsageTracker()

# Deploy agent with usage tracking
deployment = deploy.create(
    agent_id="ml-trainer",
    resources={
        "cpu": "8 cores",
        "memory": "32GB",
        "gpu": "NVIDIA A100"
    },
    billing={
        "model": "pay_as_you_go",
        "rates": {
            "compute": 0.50,  # per hour
            "storage": 0.10,  # per GB/month
            "egress": 0.01    # per GB
        }
    }
)

# Track usage
@deployment.on_usage
async def track_usage(metrics):
    cost = tracker.calculate_cost(
        compute_hours=metrics.compute_hours,
        storage_gb=metrics.storage_gb,
        egress_gb=metrics.egress_gb
    )
    
    # Alert if approaching limit
    if cost.daily > deployment.cost_limits.daily_max * 0.9:
        await notify_user("Approaching daily cost limit")
    
    return cost

from intra import PaymentError

try:
    result = payment.process(intent.id)
except PaymentError as e:
    if e.code == "insufficient_funds":
        # Handle insufficient funds
        await notify_user("Payment failed: Insufficient funds")
    elif e.code == "consent_expired":
        # Re-request consent
        new_consent = await payment.request_consent(...)
    elif e.code == "fraud_detected":
        # Fraud detected, escalate
        await escalate_to_human_review(intent.id)
    else:
        # Generic error handling
        await log_error(e)