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

traia_iatp/__init__.py

@@ -1,13 +1,76 @@
-"""Traia IATP - Inter Agent Transfer Protocol package."""
+"""Traia IATP - Inter Agent Transfer Protocol package with lazy loading for performance."""
 
-from .core.models import UtilityAgent, MCPServer, AgentCard
-from .server.iatp_server_agent_generator import IATPServerAgentGenerator
-from .registry.mongodb_registry import UtilityAgentRegistry, MCPServerRegistry
-from .registry.iatp_search_api import find_utility_agent
-from .client.a2a_client import UtilityAgencyTool, create_utility_agency_tools
-from .utils.docker_utils import LocalDockerRunner, run_generated_agent_locally, use_run_local_docker_script
+from typing import TYPE_CHECKING
 
-__version__ = "0.1.0"
+# Read version dynamically from pyproject.toml to avoid version mismatches
+def _get_version():
+    """Read version from pyproject.toml."""
+    try:
+        import tomli
+        from pathlib import Path
+        pyproject_path = Path(__file__).parent.parent.parent / "pyproject.toml"
+        with open(pyproject_path, "rb") as f:
+            pyproject = tomli.load(f)
+        return pyproject["project"]["version"]
+    except Exception:
+        # Fallback for installed packages where pyproject.toml isn't available
+        return "0.1.47"
+
+__version__ = _get_version()
+
+# Type hints for IDEs and type checkers (not loaded at runtime)
+if TYPE_CHECKING:
+    from .core.models import UtilityAgent, MCPServer, AgentCard
+    from .server.iatp_server_agent_generator import IATPServerAgentGenerator
+    from .registry.mongodb_registry import UtilityAgentRegistry, MCPServerRegistry
+    from .registry.iatp_search_api import find_utility_agent
+    from .client.a2a_client import UtilityAgencyTool, create_utility_agency_tools
+    from .utils.docker_utils import LocalDockerRunner, run_generated_agent_locally, use_run_local_docker_script
+    from .d402 import (
+        D402Config,
+        D402PaymentInfo,
+        D402ServicePrice,
+        PaymentScheme,
+        D402IATPClient,
+        IATPSettlementFacilitator,
+        require_payment,
+    )
+    from .client.d402_a2a_client import D402A2AClient, create_d402_a2a_client
+
+# Lazy imports - these will only load when accessed
+_LAZY_IMPORTS = {
+    # Core models (lightweight)
+    "UtilityAgent": ".core.models",
+    "MCPServer": ".core.models",
+    "AgentCard": ".core.models",
+    # Server components
+    "IATPServerAgentGenerator": ".server.iatp_server_agent_generator",
+    # Registry (lightweight, no CrewAI dependency)
+    "UtilityAgentRegistry": ".registry.mongodb_registry",
+    "MCPServerRegistry": ".registry.mongodb_registry",
+    "find_utility_agent": ".registry.iatp_search_api",
+    # Client (HEAVY - imports CrewAI)
+    "UtilityAgencyTool": ".client.a2a_client",
+    "create_utility_agency_tools": ".client.a2a_client",
+    # Docker utilities
+    "LocalDockerRunner": ".utils.docker_utils",
+    "run_generated_agent_locally": ".utils.docker_utils",
+    "use_run_local_docker_script": ".utils.docker_utils",
+    # D402 payment integration (HEAVY - imports CrewAI indirectly)
+    "D402A2AClient": ".client.d402_a2a_client",
+    "create_d402_a2a_client": ".client.d402_a2a_client",
+}
+
+# D402 imports need special handling as they come from a submodule
+_D402_IMPORTS = [
+    "D402Config",
+    "D402PaymentInfo",
+    "D402ServicePrice",
+    "PaymentScheme",
+    "D402IATPClient",
+    "IATPSettlementFacilitator",
+    "require_payment",
+]
 
 __all__ = [
     # Core models
@@ -27,4 +90,38 @@ __all__ = [
     "LocalDockerRunner",
     "run_generated_agent_locally",
     "use_run_local_docker_script",
+    # D402 payment integration
+    "D402Config",
+    "D402PaymentInfo",
+    "D402ServicePrice",
+    "PaymentScheme",
+    "D402IATPClient",
+    "IATPSettlementFacilitator",
+    "require_payment",
+    "D402A2AClient",
+    "create_d402_a2a_client",
 ]
+
+
+def __getattr__(name: str):
+    """Lazy import mechanism to load modules only when accessed."""
+    # Handle regular lazy imports
+    if name in _LAZY_IMPORTS:
+        from importlib import import_module
+        module_path = _LAZY_IMPORTS[name]
+        module = import_module(module_path, package=__package__)
+        attr = getattr(module, name)
+        # Cache the imported attribute
+        globals()[name] = attr
+        return attr
+    
+    # Handle D402 imports
+    if name in _D402_IMPORTS:
+        from importlib import import_module
+        d402_module = import_module(".d402", package=__package__)
+        attr = getattr(d402_module, name)
+        # Cache the imported attribute
+        globals()[name] = attr
+        return attr
+    
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

traia_iatp/cli/main.py

@@ -16,6 +16,7 @@ from ..registry.mongodb_registry import UtilityAgentRegistry, MCPServerRegistry
 from ..utils.docker_utils import use_run_local_docker_script, LocalDockerRunner
 from ..client.a2a_client import create_utility_agency_tools
 from ..mcp.mcp_agent_template import MCPServerConfig
+from ..contracts.wallet_creator import create_iatp_wallet
 
 app = typer.Typer(
     name="iatp",
@@ -24,6 +25,89 @@ app = typer.Typer(
 console = Console()
 
 
+@app.command(name="create-iatp-wallet")
+def create_wallet_cli(
+    owner_key: str = typer.Option(..., "--owner-key", help="Owner's private key (REQUIRED INPUT)"),
+    operator_address: Optional[str] = typer.Option(None, "--operator-address", help="Operator address (or use --create-operator)"),
+    create_operator: bool = typer.Option(False, "--create-operator", help="Generate new operator keypair"),
+    wallet_name: str = typer.Option("", "--wallet-name", help="Name for the wallet"),
+    wallet_type: str = typer.Option("MCP_SERVER", "--wallet-type", help="Type: CLIENT, HUMAN, MCP_SERVER, WEB_SERVER, AGENT"),
+    wallet_description: str = typer.Option("", "--wallet-description", help="Description of the wallet/service"),
+    network: str = typer.Option("sepolia", "--network", help="Network (sepolia, base-mainnet)"),
+    rpc_url: Optional[str] = typer.Option(None, "--rpc-url", help="Custom RPC URL"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Save wallet info to JSON file")
+):
+    """Create a new IATPWallet contract.
+    
+    The owner creates the wallet themselves (no maintainer key needed).
+    
+    Examples:
+    
+      # Create wallet and generate operator (recommended)
+      traia-iatp create-iatp-wallet --owner-key 0x... --create-operator --wallet-name "My Server"
+      
+      # Create wallet with existing operator
+      traia-iatp create-iatp-wallet --owner-key 0x... --operator-address 0x... --wallet-type AGENT
+    """
+    try:
+        console.print("\n🔧 Creating IATPWallet...\n", style="bold")
+        
+        result = create_iatp_wallet(
+            owner_private_key=owner_key,
+            operator_address=operator_address,
+            create_operator=create_operator,
+            wallet_name=wallet_name,
+            wallet_type=wallet_type,
+            wallet_description=wallet_description,
+            network=network,
+            rpc_url=rpc_url,
+            maintainer_private_key=None  # Regular developers don't have maintainer key
+        )
+        
+        # Display results
+        console.print("\n" + "="*80, style="green")
+        console.print("✅ IATPWallet Created Successfully!", style="bold green")
+        console.print("="*80 + "\n", style="green")
+        
+        # Create table for results
+        table = Table(title="Wallet Information", show_header=False)
+        table.add_column("Field", style="cyan")
+        table.add_column("Value", style="white")
+        
+        table.add_row("Wallet Address", result['wallet_address'])
+        table.add_row("Owner", result['owner_address'])
+        table.add_row("Operator", result['operator_address'])
+        table.add_row("Network", result['network'])
+        table.add_row("Transaction", result['transaction_hash'])
+        
+        if 'operator_private_key' in result:
+            table.add_row("Operator Private Key", result['operator_private_key'])
+        
+        console.print(table)
+        
+        # Save to file if requested
+        if output:
+            with open(output, 'w') as f:
+                json.dump(result, f, indent=2)
+            console.print(f"\n💾 Wallet info saved to: {output}", style="green")
+        
+        # Show next steps
+        console.print("\n📝 Next Steps:", style="bold")
+        console.print("1. Save your credentials securely (especially operator private key)")
+        console.print("2. Fund the wallet with USDC for payments")
+        console.print("3. Set environment variables:")
+        console.print(f"   export IATP_WALLET_ADDRESS={result['wallet_address']}")
+        if 'operator_private_key' in result:
+            console.print(f"   export OPERATOR_PRIVATE_KEY={result['operator_private_key']}")
+        console.print("4. Start building with IATP!\n")
+        
+    except Exception as e:
+        console.print(f"\n❌ Error: {e}", style="bold red")
+        import traceback
+        console.print(traceback.format_exc(), style="red")
+        raise typer.Exit(code=1)
+
+
 @app.command()
 def create_agency(
     name: str = typer.Option(..., "--name", "-n", help="Name of the utility agency"),
@@ -438,7 +522,7 @@ def example_crew():
 # Example: Using utility agencies in a CrewAI crew
 
 from crewai import Agent, Crew, Task
-from iatp import create_utility_agency_tools
+from traia_iatp import create_utility_agency_tools
 
 # Find and create tools from utility agencies
 tools = create_utility_agency_tools(

traia_iatp/client/__init__.py

@@ -1,10 +1,35 @@
-"""IATP client module for A2A integration."""
+"""IATP client module for A2A integration with lazy loading."""
 
-from .a2a_client import UtilityAgencyTool, create_utility_agency_tools
-from .crewai_a2a_tools import A2AToolSchema
+from typing import TYPE_CHECKING
+
+# Type hints for IDEs and type checkers (not loaded at runtime)
+if TYPE_CHECKING:
+    from .a2a_client import UtilityAgencyTool, create_utility_agency_tools
+    from .crewai_a2a_tools import A2AToolSchema
+
+# Lazy imports to avoid loading CrewAI unless needed
+_LAZY_IMPORTS = {
+    "UtilityAgencyTool": ".a2a_client",
+    "create_utility_agency_tools": ".a2a_client",
+    "A2AToolSchema": ".crewai_a2a_tools",
+}
 
 __all__ = [
     "UtilityAgencyTool",
     "create_utility_agency_tools", 
     "A2AToolSchema",
 ]
+
+
+def __getattr__(name: str):
+    """Lazy import mechanism to load modules only when accessed."""
+    if name in _LAZY_IMPORTS:
+        from importlib import import_module
+        module_path = _LAZY_IMPORTS[name]
+        module = import_module(module_path, package=__package__)
+        attr = getattr(module, name)
+        # Cache the imported attribute
+        globals()[name] = attr
+        return attr
+    
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

traia_iatp/client/crewai_a2a_tools.py

@@ -8,6 +8,7 @@ from datetime import datetime
 import json
 import httpx
 import uuid
+import os
 from contextlib import asynccontextmanager
 import httpcore
 from enum import Enum
@@ -32,7 +33,7 @@ _thread_local = threading.local()
 
 class A2AToolSchema(BaseModel):
     """Input schema for A2A tools."""
-    request: str = Field(description="The request or query to send to the A2A agent")
+    request: str = Field(description="The request or query to send to the A2A agent. Send only 'request' key when using this tool")
 
 
 class A2AToolConfig(BaseModel):
@@ -83,8 +84,28 @@ class A2ATool(BaseTool):
         logger.info(f"Tool name: {self.name}, Endpoint: {self.config.endpoint}")
         
         try:
-            # Create a fresh httpx client for this request
-            async with httpx.AsyncClient(
+            # Check if D402 payment credentials are available from environment
+            # Use D402_CLIENT_OPERATOR_PRIVATE_KEY for client-side payments
+            payment_private_key = os.getenv("D402_CLIENT_OPERATOR_PRIVATE_KEY") or os.getenv("EVM_PRIVATE_KEY")
+            wallet_address = os.getenv("D402_CLIENT_WALLET_ADDRESS")
+            
+            # Create httpx client with D402 payment support if credentials available
+            if payment_private_key:
+                from eth_account import Account
+                from ..d402.clients.httpx import d402HttpxClient
+                
+                operator_key = payment_private_key if payment_private_key.startswith("0x") else f"0x{payment_private_key}"
+                operator_account = Account.from_key(operator_key)
+                
+                logger.info(f"Using D402 payment client for A2A tool")
+                httpx_client = d402HttpxClient(
+                    operator_account,
+                    wallet_address=wallet_address,
+                    timeout=self.config.timeout
+                )
+            else:
+                logger.info(f"No D402 credentials, using standard httpx client")
+                httpx_client = httpx.AsyncClient(
                 timeout=httpx.Timeout(
                     connect=5.0,
                     read=self.config.timeout,
@@ -92,7 +113,9 @@ class A2ATool(BaseTool):
                     pool=5.0
                 ),
                 http2=True
-            ) as httpx_client:
+                )
+            
+            async with httpx_client:
                 
                 # Resolve agent card
                 card_resolver = A2ACardResolver(
@@ -101,20 +124,17 @@ class A2ATool(BaseTool):
                 )
                 agent_card = await card_resolver.get_agent_card()
                 logger.info(f"Resolved agent card for: {agent_card.name}")
+                logger.info(f"Agent card URL: {agent_card.url if hasattr(agent_card, 'url') else 'N/A'}")
                 
-                # Patch the agent card URL to use the actual endpoint
-                if hasattr(agent_card, 'url'):
-                    from a2a.types import AgentCard
-                    agent_card_dict = agent_card.model_dump()
-                    agent_card_dict['url'] = self.config.endpoint
-                    agent_card = AgentCard(**agent_card_dict)
+                # Use the URL from agent card (don't override it)
+                # The agent card knows the correct A2A endpoint
                 
                 # Create A2A client
-                iatp_endpoint = self.config.iatp_endpoint or self.config.endpoint
+                iatp_endpoint = self.config.iatp_endpoint or agent_card.url
                 a2a_client = A2AClient(
                     httpx_client=httpx_client,
                     agent_card=agent_card,
-                    url=iatp_endpoint
+                    url=agent_card.url  # Use agent card's URL (includes /a2a for utility agents)
                 )
                 
                 # Create message