ugarapi-mcp-server 1.1.0

package/test_agent_simulator.py

@@ -0,0 +1,296 @@
+"""
+AI Agent Simulator - Test Your AgentHub Services
+This simulates how an AI agent would discover and use your services
+"""
+
+import asyncio
+import httpx
+import json
+from typing import Dict, List
+
+class AIAgentSimulator:
+    """
+    Simulates an autonomous AI agent that:
+    1. Discovers your services
+    2. Creates payment
+    3. Uses the services
+    4. Evaluates results
+    """
+    
+    def __init__(self, base_url: str):
+        self.base_url = base_url
+        self.discovered_services = {}
+        self.payment_proofs = {}
+    
+    async def discover_services(self):
+        """
+        Step 1: AI agents discover services via .well-known manifest
+        """
+        print("🤖 AI Agent: Discovering available services...")
+        
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(f"{self.base_url}/.well-known/ai-services.json")
+                manifest = response.json()
+                
+                self.discovered_services = {
+                    service["id"]: service 
+                    for service in manifest["services"]
+                }
+                
+                print(f"✅ Discovered {len(self.discovered_services)} services:")
+                for service_id, service in self.discovered_services.items():
+                    print(f"  - {service['name']}: {service['price_sats']} sats")
+                
+                return True
+            
+            except Exception as e:
+                print(f"❌ Failed to discover services: {e}")
+                return False
+    
+    async def create_payment(self, service_id: str) -> str:
+        """
+        Step 2: Create a Lightning invoice for the service
+        """
+        if service_id not in self.discovered_services:
+            raise ValueError(f"Unknown service: {service_id}")
+        
+        service = self.discovered_services[service_id]
+        print(f"
+💰 Creating payment for {service['name']}...")
+        
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    f"{self.base_url}/api/v1/payment/create",
+                    json={
+                        "service": service_id,
+                        "amount_sats": service["price_sats"]
+                    }
+                )
+                payment_data = response.json()
+                
+                invoice_id = payment_data["invoice_id"]
+                self.payment_proofs[service_id] = invoice_id
+                
+                print(f"✅ Payment created: {invoice_id}")
+                print(f"   Lightning Invoice: {payment_data['payment_request'][:50]}...")
+                print(f"   Amount: {payment_data['amount_sats']} sats")
+                
+                # Simulate payment (in production, AI agent would actually pay)
+                await self._simulate_payment(invoice_id)
+                
+                return invoice_id
+            
+            except Exception as e:
+                print(f"❌ Payment creation failed: {e}")
+                raise
+    
+    async def _simulate_payment(self, invoice_id: str):
+        """
+        Simulate Lightning payment (for testing)
+        In production, AI agent would actually send Bitcoin
+        """
+        print("⚡ Simulating Lightning payment...")
+        
+        # Mark payment as paid in the system
+        async with httpx.AsyncClient() as client:
+            await client.post(
+                f"{self.base_url}/api/v1/payment/webhook",
+                json={
+                    "invoiceId": invoice_id,
+                    "status": "paid"
+                }
+            )
+        
+        print("✅ Payment confirmed!")
+        await asyncio.sleep(1)  # Simulate network delay
+    
+    async def test_web_extraction(self):
+        """
+        Test Service 1: Web Data Extraction
+        """
+        print("
+🔍 Testing Web Extraction Service...")
+        
+        # Create payment
+        invoice_id = await self.create_payment("web_extraction")
+        
+        # Use service
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    f"{self.base_url}/api/v1/extract",
+                    json={
+                        "url": "https://example.com",
+                        "selectors": {
+                            "title": "h1",
+                            "paragraphs": "p"
+                        },
+                        "payment_proof": invoice_id
+                    }
+                )
+                result = response.json()
+                
+                if result["success"]:
+                    print("✅ Extraction successful!")
+                    print(f"   Extracted data: {json.dumps(result['data'], indent=2)}")
+                else:
+                    print(f"❌ Extraction failed: {result.get('error')}")
+                
+                return result
+            
+            except Exception as e:
+                print(f"❌ Service call failed: {e}")
+                raise
+    
+    async def test_document_timestamp(self):
+        """
+        Test Service 2: Document Timestamping
+        """
+        print("
+📝 Testing Document Timestamp Service...")
+        
+        # Create payment
+        invoice_id = await self.create_payment("document_timestamp")
+        
+        # Create a document hash
+        import hashlib
+        document = "This is a test document for timestamping"
+        doc_hash = hashlib.sha256(document.encode()).hexdigest()
+        
+        # Use service
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    f"{self.base_url}/api/v1/timestamp",
+                    json={
+                        "document_hash": doc_hash,
+                        "metadata": {
+                            "title": "Test Document",
+                            "author": "AI Agent"
+                        },
+                        "payment_proof": invoice_id
+                    }
+                )
+                result = response.json()
+                
+                if result["success"]:
+                    print("✅ Timestamp successful!")
+                    print(f"   Blockchain TX: {result['proof']['blockchain_tx']}")
+                    print(f"   Verification URL: {result['proof']['verification_url']}")
+                else:
+                    print(f"❌ Timestamp failed")
+                
+                return result
+            
+            except Exception as e:
+                print(f"❌ Service call failed: {e}")
+                raise
+    
+    async def test_api_aggregator(self):
+        """
+        Test Service 3: API Aggregator
+        """
+        print("
+🌐 Testing API Aggregator Service...")
+        
+        # Create payment
+        invoice_id = await self.create_payment("api_aggregator")
+        
+        # Use service (test with exchange rate API - it's free)
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    f"{self.base_url}/api/v1/aggregate",
+                    json={
+                        "service": "exchange_rate",
+                        "endpoint": "USD",
+                        "params": {},
+                        "payment_proof": invoice_id
+                    }
+                )
+                result = response.json()
+                
+                if result["success"]:
+                    print("✅ API call successful!")
+                    print(f"   Service: {result['service']}")
+                    print(f"   Data sample: {str(result['data'])[:100]}...")
+                else:
+                    print(f"❌ API call failed: {result.get('error')}")
+                
+                return result
+            
+            except Exception as e:
+                print(f"❌ Service call failed: {e}")
+                raise
+    
+    async def evaluate_services(self):
+        """
+        AI agent evaluates service quality and decides if it will use again
+        """
+        print("
+📊 Evaluating Service Quality...")
+        
+        async with httpx.AsyncClient() as client:
+            response = await client.get(f"{self.base_url}/api/v1/stats")
+            stats = response.json()
+            
+            print(f"   Total requests processed: {stats['total_requests']}")
+            print(f"   Advertised uptime: {stats['uptime']}")
+            
+            # AI decision logic
+            if stats['total_requests'] > 0:
+                print("
+✅ DECISION: Will add to preferred service list")
+                print("   Reasoning: Service is functional and has processing history")
+            else:
+                print("
+⚠️  DECISION: Will monitor but not add yet")
+                print("   Reasoning: No processing history, need more data")
+
+async def main():
+    """
+    Run full AI agent simulation
+    """
+    # Replace with your actual domain when deployed
+    BASE_URL = "http://localhost:8000"  # Change to https://yourdomain.com when live
+    
+    print("=" * 60)
+    print("AI AGENT SIMULATOR - AgentHub Services Test")
+    print("=" * 60)
+    
+    agent = AIAgentSimulator(BASE_URL)
+    
+    try:
+        # Step 1: Discover services
+        if not await agent.discover_services():
+            print("❌ Cannot proceed without service discovery")
+            return
+        
+        # Step 2: Test each service
+        await agent.test_web_extraction()
+        await asyncio.sleep(2)
+        
+        await agent.test_document_timestamp()
+        await asyncio.sleep(2)
+        
+        await agent.test_api_aggregator()
+        await asyncio.sleep(2)
+        
+        # Step 3: Evaluate
+        await agent.evaluate_services()
+        
+        print("
+" + "=" * 60)
+        print("✅ All tests completed successfully!")
+        print("=" * 60)
+        
+    except Exception as e:
+        print(f"
+❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    asyncio.run(main())