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

traia_iatp/d402/common.py

@@ -0,0 +1,114 @@
+from decimal import Decimal
+from typing import List, Optional
+
+from .chains import (
+    get_chain_id,
+    get_token_decimals,
+    get_token_name,
+    get_token_version,
+    get_default_token_address,
+)
+from .types import Price, TokenAmount, PaymentRequirements, PaymentPayload
+
+
+def parse_money(amount: str | int, address: str, network: str) -> int:
+    """Parse money string or int into int
+
+    Params:
+        amount: str | int - if int, should be the full amount including token specific decimals
+    """
+    if isinstance(amount, str):
+        if amount.startswith("$"):
+            amount = amount[1:]
+        decimal_amount = Decimal(amount)
+
+        chain_id = get_chain_id(network)
+        decimals = get_token_decimals(chain_id, address)
+        decimal_amount = decimal_amount * Decimal(10**decimals)
+        return int(decimal_amount)
+    return amount
+
+
+def process_price_to_atomic_amount(
+    price: Price, network: str
+) -> tuple[str, str, dict[str, str]]:
+    """Process a Price into atomic amount, asset address, and EIP-712 domain info
+
+    Args:
+        price: Either Money (USD string/int) or TokenAmount
+        network: Network identifier
+
+    Returns:
+        Tuple of (max_amount_required, asset_address, eip712_domain)
+
+    Raises:
+        ValueError: If price format is invalid
+    """
+    if isinstance(price, (str, int)):
+        # Money type - convert USD to USDC atomic units
+        try:
+            if isinstance(price, str) and price.startswith("$"):
+                price = price[1:]
+            amount = Decimal(str(price))
+
+            # Get USDC address for the network
+            chain_id = get_chain_id(network)
+            asset_address = get_usdc_address(chain_id)
+            decimals = get_token_decimals(chain_id, asset_address)
+
+            # Convert to atomic units
+            atomic_amount = int(amount * Decimal(10**decimals))
+
+            # Get EIP-712 domain info
+            eip712_domain = {
+                "name": get_token_name(chain_id, asset_address),
+                "version": get_token_version(chain_id, asset_address),
+            }
+
+            return str(atomic_amount), asset_address, eip712_domain
+
+        except (ValueError, KeyError) as e:
+            raise ValueError(f"Invalid price format: {price}. Error: {e}")
+
+    elif isinstance(price, TokenAmount):
+        # TokenAmount type - already in atomic units with asset info
+        return (
+            price.amount,
+            price.asset.address,
+            {
+                "name": price.asset.eip712.name,
+                "version": price.asset.eip712.version,
+            },
+        )
+
+    else:
+        raise ValueError(f"Invalid price type: {type(price)}")
+
+
+def get_usdc_address(chain_id: int | str) -> str:
+    """Get the USDC contract address for a given chain ID"""
+    chain_id_str = str(chain_id)  # Convert to string for consistency
+    return get_default_token_address(chain_id_str, "usdc")
+
+
+def find_matching_payment_requirements(
+    payment_requirements: List[PaymentRequirements],
+    payment: PaymentPayload,
+) -> Optional[PaymentRequirements]:
+    """
+    Finds the matching payment requirements for the given payment.
+
+    Args:
+        payment_requirements: The payment requirements to search through
+        payment: The payment to match against
+
+    Returns:
+        The matching payment requirements or None if no match is found
+    """
+    for req in payment_requirements:
+        if req.scheme == payment.scheme and req.network == payment.network:
+            return req
+    return None
+
+
+d402_VERSION = 1

traia_iatp/d402/encoding.py

@@ -0,0 +1,28 @@
+import base64
+from typing import Union
+
+
+def safe_base64_encode(data: Union[str, bytes]) -> str:
+    """Safely encode string or bytes to base64 string.
+
+    Args:
+        data: String or bytes to encode
+
+    Returns:
+        Base64 encoded string
+    """
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+    return base64.b64encode(data).decode("utf-8")
+
+
+def safe_base64_decode(data: str) -> str:
+    """Safely decode base64 string to bytes and then to utf-8 string.
+
+    Args:
+        data: Base64 encoded string
+
+    Returns:
+        Decoded utf-8 string
+    """
+    return base64.b64decode(data).decode("utf-8")

traia_iatp/d402/examples/client_example.py

@@ -0,0 +1,197 @@
+"""Example: Client agent making payments to utility agents."""
+
+import os
+import asyncio
+from traia_iatp.client import create_d402_a2a_client
+
+
+async def example_simple_payment():
+    """Example 1: Simple payment to a utility agent."""
+    print("=" * 60)
+    print("Example 1: Simple Payment")
+    print("=" * 60)
+    
+    # Create client with payment support
+    client = create_d402_a2a_client(
+        agent_endpoint="https://sentiment-agent.traia.io",
+        payment_private_key=os.getenv("CLIENT_PRIVATE_KEY"),
+        max_payment_usd=5.0  # Maximum $5 per request
+    )
+    
+    # Send message - automatically handles payment if required
+    try:
+        response = await client.send_message_with_payment(
+            "Analyze sentiment: 'Tech stocks rally on strong earnings'"
+        )
+        print(f"Response: {response}")
+    except ValueError as e:
+        print(f"Payment error: {e}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+async def example_crewai_integration():
+    """Example 2: Using paid agents in CrewAI."""
+    print("\n" + "=" * 60)
+    print("Example 2: CrewAI Integration with Paid Agents")
+    print("=" * 60)
+    
+    from crewai import Agent, Task, Crew
+    from traia_iatp.client.crewai_a2a_tools import A2AToolkit
+    from traia_iatp.registry.iatp_search_api import find_utility_agent
+    
+    # Find the utility agent
+    agent_info = find_utility_agent(agent_id="finbert-sentiment-agent")
+    
+    if not agent_info:
+        print("Agent not found in registry")
+        return
+    
+    print(f"Found agent: {agent_info.name}")
+    print(f"D402 Enabled: {agent_info.d402_enabled}")
+    
+    # Create tool with payment support
+    sentiment_tool = A2AToolkit.create_tool_from_endpoint(
+        endpoint=agent_info.base_url,
+        name=agent_info.name,
+        description=agent_info.description,
+        # Payment configuration
+        payment_private_key=os.getenv("CLIENT_PRIVATE_KEY"),
+        max_payment_usd=1.0
+    )
+    
+    # Create CrewAI agent
+    analyst = Agent(
+        role="Financial Sentiment Analyst",
+        goal="Analyze sentiment of financial news",
+        backstory="Expert financial analyst with access to AI sentiment tools",
+        tools=[sentiment_tool],
+        verbose=True
+    )
+    
+    # Create task
+    task = Task(
+        description="Analyze sentiment of: 'Federal Reserve signals rate cuts ahead'",
+        expected_output="Sentiment analysis with confidence scores",
+        agent=analyst
+    )
+    
+    # Run crew
+    crew = Crew(agents=[analyst], tasks=[task])
+    result = crew.kickoff()
+    
+    print(f"\nResult: {result}")
+
+
+async def example_multiple_agents():
+    """Example 3: Using multiple paid utility agents."""
+    print("\n" + "=" * 60)
+    print("Example 3: Multiple Paid Agents")
+    print("=" * 60)
+    
+    from traia_iatp.registry.iatp_search_api import search_utility_agents
+    from traia_iatp.client import create_d402_a2a_client
+    
+    # Search for sentiment analysis agents
+    agents = search_utility_agents(
+        query="sentiment analysis",
+        limit=5
+    )
+    
+    print(f"Found {len(agents)} sentiment analysis agents")
+    
+    # Filter for paid agents
+    paid_agents = [a for a in agents if a.d402_enabled]
+    print(f"Found {len(paid_agents)} paid agents")
+    
+    # Create clients for each paid agent
+    for agent_info in paid_agents[:2]:  # Try first 2
+        print(f"\n--- Testing {agent_info.name} ---")
+        
+        client = create_d402_a2a_client(
+            agent_endpoint=agent_info.base_url,
+            payment_private_key=os.getenv("CLIENT_PRIVATE_KEY"),
+            max_payment_usd=1.0
+        )
+        
+        try:
+            response = await client.send_message_with_payment(
+                "Analyze: 'Stock market reaches all-time high'"
+            )
+            print(f"Response: {response}")
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+async def example_payment_limits():
+    """Example 4: Payment limits and error handling."""
+    print("\n" + "=" * 60)
+    print("Example 4: Payment Limits and Error Handling")
+    print("=" * 60)
+    
+    # Create client with very low payment limit
+    client = create_d402_a2a_client(
+        agent_endpoint="https://expensive-agent.traia.io",
+        payment_private_key=os.getenv("CLIENT_PRIVATE_KEY"),
+        max_payment_usd=0.001  # Only allow $0.001
+    )
+    
+    try:
+        response = await client.send_message_with_payment("test")
+        print(f"Response: {response}")
+    except ValueError as e:
+        print(f"Payment rejected: {e}")
+        print("Solution: Increase max_payment_usd or choose a cheaper agent")
+
+
+async def example_check_agent_pricing():
+    """Example 5: Check agent pricing before calling."""
+    print("\n" + "=" * 60)
+    print("Example 5: Check Pricing Before Calling")
+    print("=" * 60)
+    
+    from traia_iatp.registry.iatp_search_api import find_utility_agent
+    
+    # Find agent and check pricing
+    agent_info = find_utility_agent(agent_id="finbert-sentiment-agent")
+    
+    if agent_info and agent_info.d402_enabled:
+        payment_info = agent_info.d402_payment_info
+        
+        print(f"Agent: {agent_info.name}")
+        print(f"D402 Enabled: {agent_info.d402_enabled}")
+        
+        if payment_info:
+            default_price = payment_info.get("defaultPrice", {})
+            print(f"Default Price: ${default_price.get('usdAmount', 'N/A')} USD")
+            print(f"Network: {default_price.get('network', 'N/A')}")
+            print(f"Asset: {default_price.get('asset', 'N/A')}")
+            
+            skill_prices = payment_info.get("skillPrices", {})
+            if skill_prices:
+                print("\nSkill-specific pricing:")
+                for skill_id, price in skill_prices.items():
+                    print(f"  {skill_id}: ${price.get('usdAmount', 'N/A')} USD")
+
+
+async def main():
+    """Run all examples."""
+    # Example 1: Simple payment
+    await example_simple_payment()
+    
+    # Example 2: CrewAI integration
+    await example_crewai_integration()
+    
+    # Example 3: Multiple agents
+    await example_multiple_agents()
+    
+    # Example 4: Payment limits
+    await example_payment_limits()
+    
+    # Example 5: Check pricing
+    await example_check_agent_pricing()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+

traia_iatp/d402/examples/server_example.py

@@ -0,0 +1,171 @@
+"""Example: Utility agent with d402 payment support."""
+
+import os
+import asyncio
+from fastapi import FastAPI, Request
+import uvicorn
+
+from traia_iatp.d402 import (
+    D402Config,
+    D402ServicePrice,
+    require_iatp_payment,
+    add_d402_info_to_agent_card
+)
+
+# Initialize FastAPI app
+app = FastAPI(title="Paid Sentiment Analysis Agent")
+
+# Configure d402 payments
+d402_config = D402Config(
+    enabled=True,
+    # This would be the deployed utility agent contract address
+    pay_to_address=os.getenv("UTILITY_AGENT_CONTRACT_ADDRESS", "0x1234567890123456789012345678901234567890"),
+    
+    # Default pricing: $0.01 per request
+    default_price=D402ServicePrice(
+        usd_amount="0.01",
+        network="base-mainnet",
+        asset_address="0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",  # USDC on Base
+        max_timeout_seconds=300
+    ),
+    
+    # Custom pricing per skill
+    skill_prices={
+        "sentiment_analysis": D402ServicePrice(
+            usd_amount="0.01",
+            network="base-mainnet",
+            asset_address="0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+            max_timeout_seconds=300
+        ),
+        "entity_extraction": D402ServicePrice(
+            usd_amount="0.02",
+            network="base-mainnet",
+            asset_address="0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+            max_timeout_seconds=300
+        )
+    },
+    
+    # Facilitator configuration
+    facilitator_url=os.getenv("FACILITATOR_URL", "https://api.traia.io/d402/facilitator"),
+    facilitator_api_key=os.getenv("TRAIA_RELAYER_API_KEY"),
+    
+    # Service description for payment UI
+    service_description="AI-powered financial sentiment analysis using FinBERT models",
+    
+    # Protect all paths by default
+    protected_paths=["*"]
+)
+
+
+# Add d402 middleware
+@app.middleware("http")
+async def payment_middleware(request: Request, call_next):
+    """Middleware that requires payment for all requests."""
+    middleware = require_iatp_payment(d402_config)
+    return await middleware(request, call_next)
+
+
+# Agent card endpoint (standard A2A protocol)
+@app.get("/.well-known/agent.json")
+async def agent_card():
+    """Return agent card with d402 payment information."""
+    card = {
+        "name": "sentiment_analysis_agent",
+        "description": "AI-powered financial sentiment analysis",
+        "version": "1.0.0",
+        "capabilities": {
+            "streaming": False,
+            "pushNotifications": False,
+            "stateTransitionHistory": False
+        },
+        "skills": [
+            {
+                "id": "sentiment_analysis",
+                "name": "Sentiment Analysis",
+                "description": "Analyze sentiment of financial text",
+                "examples": [
+                    "Analyze: 'Tech stocks rally on strong earnings'",
+                    "What is the sentiment of: 'Markets tumble amid recession fears'"
+                ]
+            }
+        ]
+    }
+    
+    # Add d402 payment information
+    card = await add_d402_info_to_agent_card(card, d402_config)
+    return card
+
+
+# Protected endpoint - requires payment
+@app.post("/analyze")
+async def analyze_sentiment(request: Request):
+    """Analyze sentiment of text. Requires payment."""
+    data = await request.json()
+    text = data.get("text", "")
+    
+    # Simulate sentiment analysis
+    # In real implementation, this would call a model
+    result = {
+        "text": text,
+        "sentiment": "positive",
+        "confidence": 0.87,
+        "scores": {
+            "positive": 0.87,
+            "neutral": 0.08,
+            "negative": 0.05
+        }
+    }
+    
+    return result
+
+
+# Another protected endpoint
+@app.post("/extract-entities")
+async def extract_entities(request: Request):
+    """Extract entities from text. Requires payment (higher price)."""
+    data = await request.json()
+    text = data.get("text", "")
+    
+    # Simulate entity extraction
+    result = {
+        "text": text,
+        "entities": [
+            {"text": "Apple", "type": "ORGANIZATION", "confidence": 0.95},
+            {"text": "Tim Cook", "type": "PERSON", "confidence": 0.92}
+        ]
+    }
+    
+    return result
+
+
+# Health check endpoint (not protected)
+@app.get("/health")
+async def health():
+    """Health check endpoint - no payment required."""
+    # This endpoint bypasses payment because we can add specific path exclusions
+    return {"status": "healthy"}
+
+
+def main():
+    """Run the server."""
+    print("Starting Paid Sentiment Analysis Agent")
+    print(f"D402 Enabled: {d402_config.enabled}")
+    print(f"Pay-to Address: {d402_config.pay_to_address}")
+    print(f"Default Price: ${d402_config.default_price.usd_amount} USD")
+    print(f"Facilitator: {d402_config.facilitator_url}")
+    print()
+    print("Protected endpoints:")
+    print("  POST /analyze - $0.01 per request")
+    print("  POST /extract-entities - $0.02 per request")
+    print()
+    print("Free endpoints:")
+    print("  GET /health")
+    print("  GET /.well-known/agent.json")
+    print()
+    
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    main()
+