traia-iatp 0.1.29__py3-none-any.whl

traia_iatp/d402/types.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import Any, Optional, Union, Dict, Literal, List
+from typing_extensions import (
+    TypedDict,
+)  # use `typing_extensions.TypedDict` instead of `typing.TypedDict` on Python < 3.12
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic.alias_generators import to_camel
+
+from .networks import SupportedNetworks
+
+
+# Add HTTP request structure types
+class HTTPVerbs(str, Enum):
+    GET = "GET"
+    POST = "POST"
+    PUT = "PUT"
+    DELETE = "DELETE"
+    PATCH = "PATCH"
+    OPTIONS = "OPTIONS"
+    HEAD = "HEAD"
+
+
+class HTTPInputSchema(BaseModel):
+    """Schema for HTTP request input, excluding spec and method which are handled by the middleware"""
+
+    query_params: Optional[Dict[str, str]] = None
+    body_type: Optional[
+        Literal["json", "form-data", "multipart-form-data", "text", "binary"]
+    ] = None
+    body_fields: Optional[Dict[str, Any]] = None
+    header_fields: Optional[Dict[str, Any]] = None
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+
+class HTTPRequestStructure(HTTPInputSchema):
+    """Complete HTTP request structure including protocol type and method"""
+
+    type: Literal["http"]
+    method: HTTPVerbs
+
+
+# For now we only support HTTP, but could add MCP and OpenAPI later
+RequestStructure = HTTPRequestStructure
+
+
+class TokenAmount(BaseModel):
+    """Represents an amount of tokens in atomic units with asset information"""
+
+    amount: str
+    asset: TokenAsset
+
+    @field_validator("amount")
+    def validate_amount(cls, v):
+        try:
+            int(v)
+        except ValueError:
+            raise ValueError("amount must be an integer encoded as a string")
+        return v
+
+
+class TokenAsset(BaseModel):
+    """Represents token asset information including EIP-712 domain data and network"""
+
+    address: str
+    decimals: int
+    eip712: EIP712Domain
+    network: Optional[str] = None  # Blockchain network (e.g., "sepolia", "base-sepolia")
+
+    @field_validator("decimals")
+    def validate_decimals(cls, v):
+        if v < 0 or v > 255:
+            raise ValueError("decimals must be between 0 and 255")
+        return v
+
+
+class EIP712Domain(BaseModel):
+    """EIP-712 domain information for token signing"""
+
+    name: str
+    version: str
+
+
+# Price can be either Money (USD string) or TokenAmount
+Money = Union[str, int]  # e.g., "$0.01", 0.01, "0.001"
+Price = Union[Money, TokenAmount]
+
+
+class PaymentRequirements(BaseModel):
+    scheme: str
+    network: SupportedNetworks
+    max_amount_required: str
+    resource: str
+    description: str
+    mime_type: str
+    output_schema: Optional[Any] = None
+    pay_to: str
+    max_timeout_seconds: int
+    asset: str
+    extra: Optional[dict[str, Any]] = None
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    @field_validator("max_amount_required")
+    def validate_max_amount_required(cls, v):
+        try:
+            int(v)
+        except ValueError:
+            raise ValueError(
+                "max_amount_required must be an integer encoded as a string"
+            )
+        return v
+
+
+# Returned by a server as json alongside a 402 response code
+class d402PaymentRequiredResponse(BaseModel):
+    d402_version: int
+    accepts: list[PaymentRequirements]
+    error: str
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+
+class PullFundsAuthorization(BaseModel):
+    """
+    Authorization data for payment header (wire format).
+    
+    This structure is sent in the payment header and includes fields for:
+    - EIP-712 signature: wallet, provider, token, amount, deadline, requestPath
+    - Transport metadata: valid_after, valid_before (for payment window)
+    
+    Note: Only some fields are signed (see IATPWallet.sol PULL_FUNDS_FOR_SETTLEMENT_TYPEHASH)
+    """
+    from_: str = Field(alias="from")  # Consumer's IATPWallet address
+    to: str  # Provider's IATPWallet address
+    value: str  # Payment amount
+    valid_after: str = Field(alias="validAfter")  # Not in signature (transport only)
+    valid_before: str = Field(alias="validBefore")  # Maps to 'deadline' in signature
+    request_path: str = Field(alias="requestPath")  # API path (signed)
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    @field_validator("value")
+    def validate_value(cls, v):
+        try:
+            int(v)
+        except ValueError:
+            raise ValueError("value must be an integer encoded as a string")
+        return v
+
+
+class ExactPaymentPayload(BaseModel):
+    """Payment payload with PullFundsForSettlement signature."""
+    signature: str
+    authorization: PullFundsAuthorization
+
+
+class VerifyResponse(BaseModel):
+    is_valid: bool = Field(alias="isValid")
+    invalid_reason: Optional[str] = Field(None, alias="invalidReason")
+    payer: Optional[str]
+    payment_uuid: Optional[str] = Field(None, alias="paymentUuid")  # Unique payment identifier from facilitator
+    facilitator_fee_percent: Optional[int] = Field(250, alias="facilitatorFeePercent")  # Fee percent from facilitator (default 2.5% = 250 basis points)
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+
+class SettleResponse(BaseModel):
+    success: bool
+    error_reason: Optional[str] = None
+    transaction: Optional[str] = None
+    network: Optional[str] = None
+    payer: Optional[str] = None
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+
+# Union of payloads for each scheme
+SchemePayloads = ExactPaymentPayload
+
+
+class PaymentPayload(BaseModel):
+    d402_version: int
+    scheme: str
+    network: str
+    payload: SchemePayloads
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+
+class D402Headers(BaseModel):
+    x_payment: str
+
+
+class UnsupportedSchemeException(Exception):
+    pass
+
+
+class PaywallConfig(TypedDict, total=False):
+    """Configuration for paywall UI customization"""
+
+    cdp_client_key: str
+    app_name: str
+    app_logo: str
+    session_token_endpoint: str
+
+
+class DiscoveredResource(BaseModel):
+    """A discovery resource represents a discoverable resource in the D402 ecosystem."""
+
+    resource: str
+    type: str = Field(..., pattern="^http$")  # Currently only supports 'http'
+    d402_version: int = Field(..., alias="d402Version")
+    accepts: List["PaymentRequirements"]
+    last_updated: datetime = Field(
+        ...,
+        alias="lastUpdated",
+        description="ISO 8601 formatted datetime string with UTC timezone (e.g. 2025-08-09T01:07:04.005Z)",
+    )
+    metadata: Optional[dict] = None
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+
+class ListDiscoveryResourcesRequest(BaseModel):
+    """Request parameters for listing discovery resources."""
+
+    type: Optional[str] = None
+    limit: Optional[int] = None
+    offset: Optional[int] = None
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+
+class DiscoveryResourcesPagination(BaseModel):
+    """Pagination information for discovery resources responses."""
+
+    limit: int
+    offset: int
+    total: int
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+
+class ListDiscoveryResourcesResponse(BaseModel):
+    """Response from the discovery resources endpoint."""
+
+    d402_version: int = Field(..., alias="d402Version")
+    items: List[DiscoveredResource]
+    pagination: DiscoveryResourcesPagination
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )

traia_iatp/mcp/__init__.py

@@ -0,0 +1,18 @@
+"""MCP (Model Context Protocol) integration module."""
+
+from .client import MCPClient
+from .mcp_agent_template import MCPServerConfig, MCPAgentBuilder, run_with_mcp_tools, MCPServerInfo
+from .traia_mcp_adapter import TraiaMCPAdapter, create_mcp_adapter
+from .d402_mcp_tool_adapter import D402MCPToolAdapter, create_d402_mcp_adapter
+
+__all__ = [
+    "MCPClient",
+    "MCPServerConfig",
+    "MCPAgentBuilder",
+    "run_with_mcp_tools",
+    "MCPServerInfo",
+    "TraiaMCPAdapter",
+    "create_mcp_adapter",
+    "D402MCPToolAdapter",
+    "create_d402_mcp_adapter",
+]

traia_iatp/mcp/client.py

@@ -0,0 +1,201 @@
+"""MCP client wrapper for connecting to MCP servers with streamable-http support."""
+
+import asyncio
+import logging
+from typing import Any, Dict, Optional, List, AsyncIterator
+import httpx
+import json
+
+from ..core.models import MCPServer, MCPServerType
+
+logger = logging.getLogger(__name__)
+
+
+class MCPClient:
+    """Wrapper for MCP client connections with streamable-http support."""
+    
+    def __init__(self, mcp_server: MCPServer):
+        self.mcp_server = mcp_server
+        self._available_tools: List[Dict[str, Any]] = []
+        self._http_client: Optional[httpx.AsyncClient] = None
+        self._connected = False
+    
+    async def connect(self) -> None:
+        """Connect to the MCP server using streamable-http."""
+        try:
+            if self.mcp_server.server_type != MCPServerType.STREAMABLE_HTTP:
+                raise ValueError(f"Only streamable-http is supported, got: {self.mcp_server.server_type}")
+                
+            await self._connect_streamable_http()
+                
+        except Exception as e:
+            logger.error(f"Failed to connect to MCP server {self.mcp_server.name}: {e}")
+            raise
+    
+    async def _connect_streamable_http(self) -> None:
+        """Connect using streamable-http for real-time updates."""
+        url = str(self.mcp_server.url)
+        
+        logger.info(f"Connecting to MCP server {self.mcp_server.name} via streamable-http at {url}")
+        
+        # Initialize HTTP client for persistent connection
+        self._http_client = httpx.AsyncClient(
+            timeout=httpx.Timeout(30.0, connect=10.0),
+            limits=httpx.Limits(max_keepalive_connections=5, max_connections=10),
+            http2=True  # Enable HTTP/2 for better streaming support
+        )
+        
+        # Test connection and get available tools
+        try:
+            response = await self._http_client.get(f"{url}/tools")
+            response.raise_for_status()
+            tools_data = response.json()
+            self._available_tools = tools_data.get("tools", [])
+            self._connected = True
+            logger.info(f"Connected to {self.mcp_server.name}, found {len(self._available_tools)} tools")
+            
+            # Update capabilities in the MCP server model
+            self.mcp_server.capabilities = [tool["name"] for tool in self._available_tools]
+        except Exception as e:
+            await self._http_client.aclose()
+            self._http_client = None
+            raise RuntimeError(f"Failed to connect to MCP server: {e}")
+    
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Any:
+        """Call a tool on the MCP server."""
+        if not self._connected or not self._http_client:
+            # Reconnect if needed
+            await self.connect()
+            
+        # Find the tool
+        tool = next((t for t in self._available_tools if t["name"] == tool_name), None)
+        if not tool:
+            raise ValueError(f"Tool {tool_name} not found")
+            
+        # Call the tool
+        url = str(self.mcp_server.url).rstrip('/') + '/call'
+        
+        response = await self._http_client.post(
+            url,
+            json={"name": tool_name, "input": arguments}
+        )
+        response.raise_for_status()
+        return response.json()
+    
+    async def call_tool_streaming(self, tool_name: str, arguments: Dict[str, Any]) -> AsyncIterator[Any]:
+        """Call a tool with streaming response support."""
+        if not self._connected:
+            await self.connect()
+        
+        # Stream the tool call response
+        async for chunk in self._stream_tool_call(tool_name, arguments):
+            yield chunk
+    
+    async def _stream_tool_call(self, tool_name: str, arguments: Dict[str, Any]) -> AsyncIterator[Any]:
+        """Stream a tool call response for streamable-http connections."""
+        if not self._http_client:
+            raise RuntimeError("HTTP client not initialized")
+        
+        url = str(self.mcp_server.url).rstrip('/') + '/call'
+        
+        # Make streaming request
+        async with self._http_client.stream(
+            "POST",
+            url,
+            json={"name": tool_name, "input": arguments},
+            headers={"Accept": "text/event-stream"}
+        ) as response:
+            async for line in response.aiter_lines():
+                if line.startswith("data: "):
+                    data = line[6:]  # Remove "data: " prefix
+                    if data:
+                        try:
+                            yield json.loads(data)
+                        except json.JSONDecodeError:
+                            logger.warning(f"Failed to parse streaming data: {data}")
+    
+    async def list_tools(self) -> List[Dict[str, Any]]:
+        """List available tools."""
+        if not self._connected:
+            await self.connect()
+            
+        return self._available_tools
+    
+    async def disconnect(self) -> None:
+        """Disconnect from the MCP server."""
+        self._connected = False
+        self._available_tools = []
+        
+        if self._http_client:
+            await self._http_client.aclose()
+            self._http_client = None
+    
+    async def health_check(self) -> bool:
+        """Check if the MCP server connection is healthy."""
+        try:
+            if not self._connected or not self._http_client:
+                return False
+                
+            # Try to ping the server
+            response = await self._http_client.get(f"{self.mcp_server.url}/health")
+            return response.status_code == 200
+        except Exception as e:
+            logger.warning(f"Health check failed for {self.mcp_server.name}: {e}")
+            return False
+    
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self.connect()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.disconnect()
+
+
+class MCPToolWrapper:
+    """Wrapper to expose MCP tools as CrewAI-compatible tools with connection pooling."""
+    
+    # Class-level connection pool
+    _connection_pool: Dict[str, MCPClient] = {}
+    _pool_lock = asyncio.Lock()
+    
+    def __init__(self, mcp_server: MCPServer, tool_name: str, tool_description: str):
+        self.mcp_server = mcp_server
+        self.tool_name = tool_name
+        self.description = tool_description
+        self.name = tool_name
+    
+    @classmethod
+    async def get_or_create_client(cls, mcp_server: MCPServer) -> MCPClient:
+        """Get or create a client from the connection pool."""
+        server_key = f"{mcp_server.name}:{mcp_server.url}"
+        
+        async with cls._pool_lock:
+            if server_key not in cls._connection_pool:
+                # Create new client
+                client = MCPClient(mcp_server)
+                await client.connect()
+                cls._connection_pool[server_key] = client
+            else:
+                # Check if existing client is healthy
+                client = cls._connection_pool[server_key]
+                if not await client.health_check():
+                    # Reconnect if unhealthy
+                    await client.disconnect()
+                    await client.connect()
+            
+            return cls._connection_pool[server_key]
+    
+    async def __call__(self, **kwargs) -> Any:
+        """Execute the MCP tool using pooled connection."""
+        client = await self.get_or_create_client(self.mcp_server)
+        return await client.call_tool(self.tool_name, kwargs)
+    
+    @classmethod
+    async def cleanup_pool(cls):
+        """Clean up all connections in the pool."""
+        async with cls._pool_lock:
+            for client in cls._connection_pool.values():
+                await client.disconnect()
+            cls._connection_pool.clear()