agent0-sdk 0.2.2__py3-none-any.whl → 0.5__py3-none-any.whl

tests/test_models.py

@@ -1,224 +0,0 @@
-"""
-Tests for core models.
-"""
-
-import pytest
-from datetime import datetime
-
-from agent0_sdk.core.models import (
-    EndpointType, TrustModel, Endpoint, RegistrationFile,
-    AgentSummary, Feedback, SearchParams
-)
-
-
-class TestEndpointType:
-    """Test EndpointType enum."""
-    
-    def test_endpoint_types(self):
-        """Test endpoint type values."""
-        assert EndpointType.MCP.value == "MCP"
-        assert EndpointType.A2A.value == "A2A"
-        assert EndpointType.ENS.value == "ENS"
-        assert EndpointType.DID.value == "DID"
-
-
-class TestTrustModel:
-    """Test TrustModel enum."""
-    
-    def test_trust_models(self):
-        """Test trust model values."""
-        assert TrustModel.REPUTATION.value == "reputation"
-        assert TrustModel.CRYPTO_ECONOMIC.value == "crypto-economic"
-        assert TrustModel.TEE_ATTESTATION.value == "tee-attestation"
-
-
-class TestEndpoint:
-    """Test Endpoint class."""
-    
-    def test_endpoint_creation(self):
-        """Test endpoint creation."""
-        endpoint = Endpoint(
-            type=EndpointType.MCP,
-            value="https://mcp.example.com/",
-            meta={"version": "1.0"}
-        )
-        
-        assert endpoint.type == EndpointType.MCP
-        assert endpoint.value == "https://mcp.example.com/"
-        assert endpoint.meta == {"version": "1.0"}
-    
-    def test_endpoint_default_meta(self):
-        """Test endpoint with default meta."""
-        endpoint = Endpoint(type=EndpointType.A2A, value="https://a2a.example.com/")
-        assert endpoint.meta == {}
-
-
-class TestRegistrationFile:
-    """Test RegistrationFile class."""
-    
-    def test_registration_file_creation(self):
-        """Test registration file creation."""
-        rf = RegistrationFile(
-            name="Test Agent",
-            description="A test agent",
-            image="https://example.com/image.png"
-        )
-        
-        assert rf.name == "Test Agent"
-        assert rf.description == "A test agent"
-        assert rf.image == "https://example.com/image.png"
-        assert rf.active is False
-        assert rf.x402support is False
-        assert rf.endpoints == []
-        assert rf.trustModels == []
-    
-    def test_registration_file_to_dict(self):
-        """Test conversion to dictionary."""
-        rf = RegistrationFile(
-            name="Test Agent",
-            description="A test agent",
-            image="https://example.com/image.png",
-            agentId="1:123",
-            endpoints=[
-                Endpoint(type=EndpointType.MCP, value="https://mcp.example.com/")
-            ],
-            trustModels=[TrustModel.REPUTATION]
-        )
-        
-        data = rf.to_dict()
-        
-        assert data["name"] == "Test Agent"
-        assert data["description"] == "A test agent"
-        assert data["image"] == "https://example.com/image.png"
-        assert data["type"] == "https://eips.ethereum.org/EIPS/eip-8004#registration-v1"
-        assert data["x402support"] is False
-        assert len(data["endpoints"]) == 1
-        assert data["endpoints"][0]["name"] == "MCP"
-        assert data["endpoints"][0]["endpoint"] == "https://mcp.example.com/"
-        assert data["supportedTrust"] == ["reputation"]
-    
-    def test_registration_file_from_dict(self):
-        """Test creation from dictionary."""
-        data = {
-            "name": "Test Agent",
-            "description": "A test agent",
-            "image": "https://example.com/image.png",
-            "endpoints": [
-                {
-                    "name": "MCP",
-                    "endpoint": "https://mcp.example.com/",
-                    "version": "1.0"
-                }
-            ],
-            "supportedTrust": ["reputation"],
-            "x402support": True
-        }
-        
-        rf = RegistrationFile.from_dict(data)
-        
-        assert rf.name == "Test Agent"
-        assert rf.description == "A test agent"
-        assert rf.image == "https://example.com/image.png"
-        assert rf.x402support is True
-        assert len(rf.endpoints) == 1
-        assert rf.endpoints[0].type == EndpointType.MCP
-        assert rf.endpoints[0].value == "https://mcp.example.com/"
-        assert rf.endpoints[0].meta == {"version": "1.0"}
-        assert len(rf.trustModels) == 1
-        assert rf.trustModels[0] == TrustModel.REPUTATION
-
-
-class TestAgentSummary:
-    """Test AgentSummary class."""
-    
-    def test_agent_summary_creation(self):
-        """Test agent summary creation."""
-        summary = AgentSummary(
-            chainId=1,
-            agentId="1:123",
-            name="Test Agent",
-            image="https://example.com/image.png",
-            description="A test agent",
-            owners=["0x123"],
-            operators=["0x456"],
-            mcp=True,
-            a2a=False,
-            ens="test.eth",
-            did=None,
-            walletAddress="0x789",
-            supportedTrusts=["onchain_feedback_v1"],
-            a2aSkills=[],
-            mcpTools=["tool1"],
-            mcpPrompts=[],
-            mcpResources=[],
-            active=True
-        )
-        
-        assert summary.chainId == 1
-        assert summary.agentId == "1:123"
-        assert summary.name == "Test Agent"
-        assert summary.mcp is True
-        assert summary.a2a is False
-        assert summary.ens == "test.eth"
-        assert summary.did is None
-
-
-class TestFeedback:
-    """Test Feedback class."""
-    
-    def test_feedback_creation(self):
-        """Test feedback creation."""
-        feedback = Feedback(
-            id=("1:123", "0x456", 1),
-            agentId="1:123",
-            reviewer="0x456",
-            score=4.5,
-            tags=["quality", "speed"],
-            text="Great service!",
-            capability="tools"
-        )
-        
-        assert feedback.id == ("1:123", "0x456", 1)
-        assert feedback.id_string == "1:123:0x456:1"
-        assert feedback.agentId == "1:123"
-        assert feedback.reviewer == "0x456"
-        assert feedback.score == 4.5
-        assert feedback.tags == ["quality", "speed"]
-        assert feedback.text == "Great service!"
-        assert feedback.capability == "tools"
-
-
-class TestSearchParams:
-    """Test SearchParams class."""
-    
-    def test_search_params_creation(self):
-        """Test search params creation."""
-        params = SearchParams(
-            name="test",
-            mcp=True,
-            a2a=False,
-            active=True,
-            x402support=True
-        )
-        
-        assert params.name == "test"
-        assert params.mcp is True
-        assert params.a2a is False
-        assert params.active is True
-        assert params.x402support is True
-        assert params.chains is None
-    
-    def test_search_params_to_dict(self):
-        """Test conversion to dictionary."""
-        params = SearchParams(
-            name="test",
-            mcp=True,
-            chains=[1, 8453]
-        )
-        
-        data = params.to_dict()
-        
-        assert data["name"] == "test"
-        assert data["mcp"] is True
-        assert data["chains"] == [1, 8453]
-        assert "a2a" not in data  # None values should be excluded

tests/test_real_public_servers.py

@@ -1,103 +0,0 @@
-"""
-Test Endpoint Crawler with Real Public MCP and A2A Servers
-Tests against actual public servers provided by the user.
-"""
-
-import logging
-import sys
-import os
-
-# Configure logging: root logger at WARNING to suppress noisy dependencies
-logging.basicConfig(
-    level=logging.WARNING,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    datefmt='%Y-%m-%d %H:%M:%S',
-    handlers=[logging.StreamHandler(sys.stdout)]
-)
-
-# Set debug level ONLY for agent0_sdk
-logging.getLogger('agent0_sdk').setLevel(logging.DEBUG)
-logging.getLogger('agent0_sdk.core').setLevel(logging.DEBUG)
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
-
-from agent0_sdk.core.endpoint_crawler import EndpointCrawler
-import json
-
-def main():
-    print("🧪 Testing Endpoint Crawler with Real Public Servers")
-    print("=" * 70)
-    
-    crawler = EndpointCrawler(timeout=10)  # Longer timeout for real servers
-    
-    # Real public endpoints
-    test_cases = [
-        {
-            "type": "A2A",
-            "endpoint": "https://hello-world-gxfr.onrender.com",
-            "description": "Real A2A Hello World Server"
-        },
-        {
-            "type": "MCP",
-            "endpoint": "https://mcp.atlassian.com/v1/forge/mcp",
-            "description": "Atlassian MCP Server (requires authentication, will fail gracefully)"
-        }
-    ]
-    
-    successful_tests = []
-    failed_tests = []
-    
-    for i, test_case in enumerate(test_cases, 1):
-        print(f"\n📍 Test {i}: {test_case['type']} Endpoint")
-        print("-" * 70)
-        print(f"URL: {test_case['endpoint']}")
-        print(f"Description: {test_case['description']}")
-        print()
-        
-        if test_case['type'] == 'A2A':
-            capabilities = crawler.fetch_a2a_capabilities(test_case['endpoint'])
-            if capabilities:
-                print("✅ SUCCESS! Fetched A2A capabilities:")
-                print(json.dumps(capabilities, indent=2))
-                successful_tests.append(test_case)
-            else:
-                print("❌ Failed to fetch A2A capabilities")
-                failed_tests.append(test_case)
-        
-        elif test_case['type'] == 'MCP':
-            capabilities = crawler.fetch_mcp_capabilities(test_case['endpoint'])
-            if capabilities:
-                print("✅ SUCCESS! Fetched MCP capabilities:")
-                print(json.dumps(capabilities, indent=2))
-                successful_tests.append(test_case)
-            else:
-                print("❌ Failed to fetch MCP capabilities")
-                failed_tests.append(test_case)
-    
-    # Summary
-    print("\n" + "=" * 70)
-    print("📊 Summary")
-    print("-" * 70)
-    print(f"✅ Successful: {len(successful_tests)}")
-    print(f"❌ Failed: {len(failed_tests)}")
-    
-    if successful_tests:
-        print("\n✅ Successfully tested endpoints:")
-        for test in successful_tests:
-            print(f"   - {test['type']}: {test['endpoint']}")
-    
-    if failed_tests:
-        print("\n⚠️  Failed endpoints:")
-        for test in failed_tests:
-            print(f"   - {test['type']}: {test['endpoint']}")
-    
-    print("\n" + "=" * 70)
-    if successful_tests:
-        print("🎉 Endpoint crawler is working with real public servers!")
-    else:
-        print("⚠️  No capabilities fetched. Check endpoints or network connection.")
-    print("=" * 70)
-
-if __name__ == "__main__":
-    main()
-

tests/test_registration.py

@@ -1,267 +0,0 @@
-"""
-Test for Agent Registration with HTTP URI
-Creates an agent, registers it with a mock HTTP URI, updates it, and verifies data integrity.
-
-Flow:
-1. Register agent on-chain with mock URI (obtain agentId)
-2. Prepare registration file with obtained agentId
-3. Print registration file JSON for developer to host
-4. Update agent and verify consistency
-"""
-
-import logging
-import time
-import random
-import json
-import sys
-
-# Configure logging: root logger at WARNING to suppress noisy dependencies
-logging.basicConfig(
-    level=logging.WARNING,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    datefmt='%Y-%m-%d %H:%M:%S',
-    handlers=[logging.StreamHandler(sys.stdout)]
-)
-
-# Set debug level ONLY for agent0_sdk
-logging.getLogger('agent0_sdk').setLevel(logging.DEBUG)
-logging.getLogger('agent0_sdk.core').setLevel(logging.DEBUG)
-
-from agent0_sdk import SDK
-from config import CHAIN_ID, RPC_URL, AGENT_PRIVATE_KEY, print_config
-
-
-def generateRandomData():
-    """Generate random test data for the agent."""
-    randomSuffix = random.randint(1000, 9999)
-    timestamp = int(time.time())
-    
-    return {
-        'name': f"Test Agent {randomSuffix}",
-        'description': f"Created at {timestamp}",
-        'image': f"https://example.com/image_{randomSuffix}.png",
-        'mcpEndpoint': f"https://api.example.com/mcp/{randomSuffix}",
-        'mcpVersion': f"2025-06-{random.randint(1, 28)}",
-        'a2aEndpoint': f"https://api.example.com/a2a/{randomSuffix}.json",
-        'a2aVersion': f"0.{random.randint(30, 35)}",
-        'ensName': f"test{randomSuffix}.eth",
-        'ensVersion': f"1.{random.randint(0, 9)}",
-        'walletAddress': f"0x{'a' * 40}",
-        'walletChainId': random.choice([1, 11155111, 8453, 137, 42161]),
-        'active': True,
-        'x402support': False,
-        'reputation': random.choice([True, False]),
-        'cryptoEconomic': random.choice([True, False]),
-        'teeAttestation': random.choice([True, False])
-    }
-
-
-def main():
-    print("🧪 Testing Agent Registration with HTTP URI")
-    print_config()
-    
-    # SDK Configuration - no IPFS
-    sdkConfig = {
-        'chainId': CHAIN_ID,
-        'rpcUrl': RPC_URL
-    }
-    
-    sdk = SDK(signer=AGENT_PRIVATE_KEY, **sdkConfig)
-    testData = generateRandomData()
-    
-    # Step 1: Register agent on-chain with mock HTTP URI
-    print("\n📍 Step 1: Register Agent on-Chain with Mock URI")
-    print("-" * 60)
-    
-    agent = sdk.createAgent(
-        name=testData['name'],
-        description=testData['description'],
-        image=testData['image']
-    )
-    
-    # Register with mock URI to get agentId
-    mockUri = "https://example.com/agents/registration.json"
-    agent.register(mockUri)
-    agentId = agent.agentId
-    print(f"✅ Registered: ID={agentId}")
-    print(f"   Mock URI: {mockUri}")
-    
-    # Step 2: Configure agent with all details
-    print("\n📍 Step 2: Configure Agent Details")
-    print("-" * 60)
-    print(f"✅ Created: {testData['name']}")
-    
-    agent.setMCP(testData['mcpEndpoint'], testData['mcpVersion'])
-    agent.setA2A(testData['a2aEndpoint'], testData['a2aVersion'])
-    agent.setENS(testData['ensName'], testData['ensVersion'])
-    agent.setAgentWallet(testData['walletAddress'], testData['walletChainId'])
-    agent.setActive(testData['active'])
-    agent.setX402Support(testData['x402support'])
-    agent.setTrust(
-        reputation=testData['reputation'],
-        cryptoEconomic=testData['cryptoEconomic'],
-        teeAttestation=testData['teeAttestation']
-    )
-    
-    # Step 3: Get registration file and print it
-    print("\n📍 Step 3: Registration File for Hosting")
-    print("-" * 60)
-    
-    registrationFile = agent.getRegistrationFile()
-    registrationJson = json.dumps(registrationFile.to_dict(), indent=2)
-    
-    print("Registration file JSON (host this at the URL you specified):")
-    print("\n" + registrationJson)
-    
-    # Save to file
-    filename = f"agent_registration_{agentId.replace(':', '_')}.json"
-    with open(filename, 'w') as f:
-        f.write(registrationJson)
-    print(f"\n✅ Saved to: {filename}")
-    
-    capturedState = {
-        'agentId': agent.agentId,
-        'agentURI': agent.agentURI,
-        'name': agent.name,
-        'description': agent.description,
-        'image': agent.image,
-        'walletAddress': agent.walletAddress,
-        'walletChainId': agent.walletChainId,
-        'active': agent.active,
-        'x402support': agent.x402support,
-        'mcpEndpoint': agent.mcpEndpoint,
-        'a2aEndpoint': agent.a2aEndpoint,
-        'ensEndpoint': agent.ensEndpoint,
-        'metadata': agent.metadata.copy()
-    }
-    
-    # Step 4: Update agent
-    print("\n📍 Step 4: Update Agent")
-    print("-" * 60)
-    
-    agent.updateInfo(
-        name=testData['name'] + " UPDATED",
-        description=testData['description'] + " - UPDATED",
-        image=f"https://example.com/image_{random.randint(1000, 9999)}_updated.png"
-    )
-    agent.setMCP(f"https://api.example.com/mcp/{random.randint(10000, 99999)}", f"2025-06-{random.randint(1, 28)}")
-    agent.setA2A(f"https://api.example.com/a2a/{random.randint(10000, 99999)}.json", f"0.{random.randint(30, 35)}")
-    agent.setAgentWallet(f"0x{'b' * 40}", random.choice([1, 11155111, 8453, 137, 42161]))
-    agent.setENS(f"{testData['ensName']}.updated", f"1.{random.randint(0, 9)}")
-    agent.setActive(False)
-    agent.setX402Support(True)
-    agent.setTrust(
-        reputation=random.choice([True, False]),
-        cryptoEconomic=random.choice([True, False]),
-        teeAttestation=random.choice([True, False])
-    )
-    agent.setMetadata({
-        "testKey": "testValue",
-        "timestamp": int(time.time()),
-        "customField": "customValue",
-        "anotherField": "anotherValue",
-        "numericField": random.randint(1000, 9999)
-    })
-    
-    # Update registration file and re-register
-    registrationFileUpdated = agent.getRegistrationFile()
-    registrationJsonUpdated = json.dumps(registrationFileUpdated.to_dict(), indent=2)
-    
-    filenameUpdated = f"agent_registration_{agentId.replace(':', '_')}_updated.json"
-    with open(filenameUpdated, 'w') as f:
-        f.write(registrationJsonUpdated)
-    
-    agent.register(mockUri)
-    print(f"✅ Updated & re-registered")
-    print(f"   Updated registration file: {filenameUpdated}")
-    
-    # Capture updated state
-    updatedState = {
-        'name': agent.name,
-        'description': agent.description,
-        'image': agent.image,
-        'walletAddress': agent.walletAddress,
-        'walletChainId': agent.walletChainId,
-        'active': agent.active,
-        'x402support': agent.x402support,
-        'mcpEndpoint': agent.mcpEndpoint,
-        'a2aEndpoint': agent.a2aEndpoint,
-        'ensEndpoint': agent.ensEndpoint,
-        'metadata': agent.metadata.copy()
-    }
-    
-    # Step 5: Reload and verify
-    print("\n📍 Step 5: Reload and Verify")
-    print("-" * 60)
-    
-    reloadedAgentId = agent.agentId
-    del agent
-    print("⏳ Waiting for blockchain transaction to be mined (15 seconds)...")
-    time.sleep(15)
-    reloadedAgent = sdk.loadAgent(reloadedAgentId)
-    print(f"✅ Reloaded from blockchain")
-    
-    reloadedState = {
-        'name': reloadedAgent.name,
-        'description': reloadedAgent.description,
-        'image': reloadedAgent.image,
-        'walletAddress': reloadedAgent.walletAddress,
-        'walletChainId': reloadedAgent.walletChainId,
-        'active': reloadedAgent.active,
-        'x402support': reloadedAgent.x402support,
-        'mcpEndpoint': reloadedAgent.mcpEndpoint,
-        'a2aEndpoint': reloadedAgent.a2aEndpoint,
-        'ensEndpoint': reloadedAgent.ensEndpoint,
-        'metadata': reloadedAgent.metadata.copy()
-    }
-    
-    expectedState = updatedState
-    expectedState['walletAddress'] = f"0x{'b' * 40}"
-    expectedState['walletChainId'] = sdk.chainId
-    
-    allMatch = True
-    for field, expected in expectedState.items():
-        actual = reloadedState.get(field)
-        
-        # Handle type casting for metadata fields
-        if field == 'metadata' and isinstance(actual, dict) and isinstance(expected, dict):
-            normalized_actual = {}
-            for k, v in actual.items():
-                if k in expected:
-                    expected_val = expected[k]
-                    if isinstance(expected_val, int):
-                        try:
-                            normalized_actual[k] = int(v) if isinstance(v, str) else v
-                        except (ValueError, TypeError):
-                            normalized_actual[k] = v
-                    elif isinstance(expected_val, float):
-                        try:
-                            normalized_actual[k] = float(v) if isinstance(v, str) else v
-                        except (ValueError, TypeError):
-                            normalized_actual[k] = v
-                    else:
-                        normalized_actual[k] = v
-                else:
-                    normalized_actual[k] = v
-            actual = normalized_actual
-        
-        if actual == expected:
-            print(f"✅ {field}: {actual}")
-        else:
-            print(f"❌ {field}: expected={expected}, got={actual}")
-            allMatch = False
-    
-    if allMatch:
-        print("\n✅ ALL CHECKS PASSED")
-    else:
-        print("\n❌ SOME CHECKS FAILED")
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except Exception as e:
-        print(f"\n❌ Error: {e}")
-        import traceback
-        traceback.print_exc()
-        exit(1)