diff --git a/apps/agent-services_backup_20260402_120554/agent-bridge/src/integration_layer.py b/apps/agent-services_backup_20260402_120554/agent-bridge/src/integration_layer.py deleted file mode 100644 index f1be04db..00000000 --- a/apps/agent-services_backup_20260402_120554/agent-bridge/src/integration_layer.py +++ /dev/null @@ -1,229 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Integration Layer -Connects agent protocols to existing AITBC services -""" - -import asyncio -import aiohttp -import json -from typing import Dict, Any, List, Optional -from datetime import datetime - -class AITBCServiceIntegration: - """Integration layer for AITBC services""" - - def __init__(self): - self.service_endpoints = { - "coordinator_api": "http://localhost:8000", - "blockchain_rpc": "http://localhost:8006", - "exchange_service": "http://localhost:8001", - "marketplace": "http://localhost:8002", - "agent_registry": "http://localhost:8013" - } - self.session = None - - async def __aenter__(self): - self.session = aiohttp.ClientSession() - return self - - async def __aexit__(self, exc_type, exc_val, exc_tb): - if self.session: - await self.session.close() - - async def get_blockchain_info(self) -> Dict[str, Any]: - """Get blockchain information""" - try: - async with self.session.get(f"{self.service_endpoints['blockchain_rpc']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_exchange_status(self) -> Dict[str, Any]: - """Get exchange service status""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_coordinator_status(self) -> Dict[str, Any]: - """Get coordinator API status""" - try: - async with self.session.get(f"{self.service_endpoints['coordinator_api']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def submit_transaction(self, transaction_data: Dict[str, Any]) -> Dict[str, Any]: - """Submit transaction to blockchain""" - try: - async with self.session.post( - f"{self.service_endpoints['blockchain_rpc']}/rpc/submit", - json=transaction_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def get_market_data(self, symbol: str = "AITBC/BTC") -> Dict[str, Any]: - """Get market data from exchange""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/market/{symbol}") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def register_agent_with_coordinator(self, agent_data: Dict[str, Any]) -> Dict[str, Any]: - """Register agent with coordinator""" - try: - async with self.session.post( - f"{self.service_endpoints['agent_registry']}/api/agents/register", - json=agent_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - -class AgentServiceBridge: - """Bridge between agents and AITBC services""" - - def __init__(self): - self.integration = AITBCServiceIntegration() - self.active_agents = {} - - async def start_agent(self, agent_id: str, agent_config: Dict[str, Any]) -> bool: - """Start an agent with service integration""" - try: - # Register agent with coordinator - async with self.integration as integration: - registration_result = await integration.register_agent_with_coordinator({ - "name": agent_id, - "type": agent_config.get("type", "generic"), - "capabilities": agent_config.get("capabilities", []), - "chain_id": agent_config.get("chain_id", "ait-mainnet"), - "endpoint": agent_config.get("endpoint", f"http://localhost:{8000 + len(self.active_agents) + 10}") - }) - - # The registry returns the created agent dict on success, not a {"status": "ok"} wrapper - if registration_result and "id" in registration_result: - self.active_agents[agent_id] = { - "config": agent_config, - "registration": registration_result, - "started_at": datetime.utcnow() - } - return True - else: - print(f"Registration failed: {registration_result}") - return False - except Exception as e: - print(f"Failed to start agent {agent_id}: {e}") - return False - - async def stop_agent(self, agent_id: str) -> bool: - """Stop an agent""" - if agent_id in self.active_agents: - del self.active_agents[agent_id] - return True - return False - - async def get_agent_status(self, agent_id: str) -> Dict[str, Any]: - """Get agent status with service integration""" - if agent_id not in self.active_agents: - return {"status": "not_found"} - - agent_info = self.active_agents[agent_id] - - async with self.integration as integration: - # Get service statuses - blockchain_status = await integration.get_blockchain_info() - exchange_status = await integration.get_exchange_status() - coordinator_status = await integration.get_coordinator_status() - - return { - "agent_id": agent_id, - "status": "active", - "started_at": agent_info["started_at"].isoformat(), - "services": { - "blockchain": blockchain_status, - "exchange": exchange_status, - "coordinator": coordinator_status - } - } - - async def execute_agent_task(self, agent_id: str, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute agent task with service integration""" - if agent_id not in self.active_agents: - return {"status": "error", "message": "Agent not found"} - - task_type = task_data.get("type") - - if task_type == "market_analysis": - return await self._execute_market_analysis(task_data) - elif task_type == "trading": - return await self._execute_trading_task(task_data) - elif task_type == "compliance_check": - return await self._execute_compliance_check(task_data) - else: - return {"status": "error", "message": f"Unknown task type: {task_type}"} - - async def _execute_market_analysis(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute market analysis task""" - try: - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Perform basic analysis - analysis_result = { - "symbol": task_data.get("symbol", "AITBC/BTC"), - "market_data": market_data, - "analysis": { - "trend": "neutral", - "volatility": "medium", - "recommendation": "hold" - }, - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": analysis_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_trading_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute trading task""" - try: - # Get market data first - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Create transaction - transaction = { - "type": "trade", - "symbol": task_data.get("symbol", "AITBC/BTC"), - "side": task_data.get("side", "buy"), - "amount": task_data.get("amount", 0.1), - "price": task_data.get("price", market_data.get("price", 0.001)) - } - - # Submit transaction - tx_result = await integration.submit_transaction(transaction) - - return {"status": "success", "transaction": tx_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_compliance_check(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute compliance check task""" - try: - # Basic compliance check - compliance_result = { - "user_id": task_data.get("user_id"), - "check_type": task_data.get("check_type", "basic"), - "status": "passed", - "checks_performed": ["kyc", "aml", "sanctions"], - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": compliance_result} - except Exception as e: - return {"status": "error", "message": str(e)} diff --git a/apps/agent-services_backup_20260402_120554/agent-compliance/src/compliance_agent.py b/apps/agent-services_backup_20260402_120554/agent-compliance/src/compliance_agent.py deleted file mode 100644 index a04ad5bd..00000000 --- a/apps/agent-services_backup_20260402_120554/agent-compliance/src/compliance_agent.py +++ /dev/null @@ -1,149 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Compliance Agent -Automated compliance and regulatory monitoring agent -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class ComplianceAgent: - """Automated compliance agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.check_interval = config.get("check_interval", 300) # 5 minutes - self.monitored_entities = config.get("monitored_entities", []) - - async def start(self) -> bool: - """Start compliance agent""" - try: - success = await self.bridge.start_agent(self.agent_id, { - "type": "compliance", - "capabilities": ["kyc_check", "aml_screening", "regulatory_reporting"], - "endpoint": f"http://localhost:8006" - }) - - if success: - self.is_running = True - print(f"Compliance agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start compliance agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting compliance agent: {e}") - return False - - async def stop(self) -> bool: - """Stop compliance agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Compliance agent {self.agent_id} stopped successfully") - return success - - async def run_compliance_loop(self): - """Main compliance monitoring loop""" - while self.is_running: - try: - for entity in self.monitored_entities: - await self._perform_compliance_check(entity) - - await asyncio.sleep(self.check_interval) - except Exception as e: - print(f"Error in compliance loop: {e}") - await asyncio.sleep(30) # Wait before retrying - - async def _perform_compliance_check(self, entity_id: str) -> None: - """Perform compliance check for entity""" - try: - compliance_task = { - "type": "compliance_check", - "user_id": entity_id, - "check_type": "full", - "monitored_activities": ["trading", "transfers", "wallet_creation"] - } - - result = await self.bridge.execute_agent_task(self.agent_id, compliance_task) - - if result.get("status") == "success": - compliance_result = result["result"] - await self._handle_compliance_result(entity_id, compliance_result) - else: - print(f"Compliance check failed for {entity_id}: {result}") - - except Exception as e: - print(f"Error performing compliance check for {entity_id}: {e}") - - async def _handle_compliance_result(self, entity_id: str, result: Dict[str, Any]) -> None: - """Handle compliance check result""" - status = result.get("status", "unknown") - - if status == "passed": - print(f"✅ Compliance check passed for {entity_id}") - elif status == "failed": - print(f"❌ Compliance check failed for {entity_id}") - # Trigger alert or further investigation - await self._trigger_compliance_alert(entity_id, result) - else: - print(f"⚠️ Compliance check inconclusive for {entity_id}") - - async def _trigger_compliance_alert(self, entity_id: str, result: Dict[str, Any]) -> None: - """Trigger compliance alert""" - alert_data = { - "entity_id": entity_id, - "alert_type": "compliance_failure", - "severity": "high", - "details": result, - "timestamp": datetime.utcnow().isoformat() - } - - # In a real implementation, this would send to alert system - print(f"🚨 COMPLIANCE ALERT: {json.dumps(alert_data, indent=2)}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - status = await self.bridge.get_agent_status(self.agent_id) - status["monitored_entities"] = len(self.monitored_entities) - status["check_interval"] = self.check_interval - return status - -# Main execution -async def main(): - """Main compliance agent execution""" - agent_id = "compliance-agent-001" - config = { - "check_interval": 60, # 1 minute for testing - "monitored_entities": ["user001", "user002", "user003"] - } - - agent = ComplianceAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run compliance loop - await agent.run_compliance_loop() - except KeyboardInterrupt: - print("Shutting down compliance agent...") - finally: - await agent.stop() - else: - print("Failed to start compliance agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_120554/agent-coordinator/src/coordinator.py b/apps/agent-services_backup_20260402_120554/agent-coordinator/src/coordinator.py deleted file mode 100644 index ce39c3cc..00000000 --- a/apps/agent-services_backup_20260402_120554/agent-coordinator/src/coordinator.py +++ /dev/null @@ -1,132 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Coordinator Service -Agent task coordination and management -""" - -from fastapi import FastAPI, HTTPException -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import uuid -from datetime import datetime -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Coordinator API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_coordinator.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS tasks ( - id TEXT PRIMARY KEY, - task_type TEXT NOT NULL, - payload TEXT NOT NULL, - required_capabilities TEXT NOT NULL, - priority TEXT NOT NULL, - status TEXT NOT NULL, - assigned_agent_id TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - result TEXT - ) - ''') - -# Models -class Task(BaseModel): - id: str - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str - status: str - assigned_agent_id: Optional[str] = None - -class TaskCreation(BaseModel): - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str = "normal" - -# API Endpoints - -@app.post("/api/tasks", response_model=Task) -async def create_task(task: TaskCreation): - """Create a new task""" - task_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO tasks (id, task_type, payload, required_capabilities, priority, status) - VALUES (?, ?, ?, ?, ?, ?) - ''', ( - task_id, task.task_type, json.dumps(task.payload), - json.dumps(task.required_capabilities), task.priority, "pending" - )) - - return Task( - id=task_id, - task_type=task.task_type, - payload=task.payload, - required_capabilities=task.required_capabilities, - priority=task.priority, - status="pending" - ) - -@app.get("/api/tasks", response_model=List[Task]) -async def list_tasks(status: Optional[str] = None): - """List tasks with optional status filter""" - with get_db_connection() as conn: - query = "SELECT * FROM tasks" - params = [] - - if status: - query += " WHERE status = ?" - params.append(status) - - tasks = conn.execute(query, params).fetchall() - - return [ - Task( - id=task["id"], - task_type=task["task_type"], - payload=json.loads(task["payload"]), - required_capabilities=json.loads(task["required_capabilities"]), - priority=task["priority"], - status=task["status"], - assigned_agent_id=task["assigned_agent_id"] - ) - for task in tasks - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8012) diff --git a/apps/agent-services_backup_20260402_120554/agent-protocols/.env.example b/apps/agent-services_backup_20260402_120554/agent-protocols/.env.example deleted file mode 100644 index bf8ed394..00000000 --- a/apps/agent-services_backup_20260402_120554/agent-protocols/.env.example +++ /dev/null @@ -1,19 +0,0 @@ -# AITBC Agent Protocols Environment Configuration -# Copy this file to .env and update with your secure values - -# Agent Protocol Encryption Key (generate a strong, unique key) -AITBC_AGENT_PROTOCOL_KEY=your-secure-encryption-key-here - -# Agent Protocol Salt (generate a unique salt value) -AITBC_AGENT_PROTOCOL_SALT=your-unique-salt-value-here - -# Agent Registry Configuration -AGENT_REGISTRY_HOST=0.0.0.0 -AGENT_REGISTRY_PORT=8003 - -# Database Configuration -AGENT_REGISTRY_DB_PATH=agent_registry.db - -# Security Settings -AGENT_PROTOCOL_TIMEOUT=300 -AGENT_PROTOCOL_MAX_RETRIES=3 diff --git a/apps/agent-services_backup_20260402_120554/agent-protocols/src/__init__.py b/apps/agent-services_backup_20260402_120554/agent-protocols/src/__init__.py deleted file mode 100644 index 9dfeaacd..00000000 --- a/apps/agent-services_backup_20260402_120554/agent-protocols/src/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -""" -Agent Protocols Package -""" - -from .message_protocol import MessageProtocol, MessageTypes, AgentMessageClient -from .task_manager import TaskManager, TaskStatus, TaskPriority, Task - -__all__ = [ - "MessageProtocol", - "MessageTypes", - "AgentMessageClient", - "TaskManager", - "TaskStatus", - "TaskPriority", - "Task" -] diff --git a/apps/agent-services_backup_20260402_120554/agent-protocols/src/message_protocol.py b/apps/agent-services_backup_20260402_120554/agent-protocols/src/message_protocol.py deleted file mode 100644 index 48289d6b..00000000 --- a/apps/agent-services_backup_20260402_120554/agent-protocols/src/message_protocol.py +++ /dev/null @@ -1,113 +0,0 @@ -""" -Message Protocol for AITBC Agents -Handles message creation, routing, and delivery between agents -""" - -import json -import uuid -from datetime import datetime -from typing import Dict, Any, Optional, List -from enum import Enum - -class MessageTypes(Enum): - """Message type enumeration""" - TASK_REQUEST = "task_request" - TASK_RESPONSE = "task_response" - HEARTBEAT = "heartbeat" - STATUS_UPDATE = "status_update" - ERROR = "error" - DATA = "data" - -class MessageProtocol: - """Message protocol handler for agent communication""" - - def __init__(self): - self.messages = [] - self.message_handlers = {} - - def create_message( - self, - sender_id: str, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any], - message_id: Optional[str] = None - ) -> Dict[str, Any]: - """Create a new message""" - if message_id is None: - message_id = str(uuid.uuid4()) - - message = { - "message_id": message_id, - "sender_id": sender_id, - "receiver_id": receiver_id, - "message_type": message_type.value, - "content": content, - "timestamp": datetime.utcnow().isoformat(), - "status": "pending" - } - - self.messages.append(message) - return message - - def send_message(self, message: Dict[str, Any]) -> bool: - """Send a message to the receiver""" - try: - message["status"] = "sent" - message["sent_timestamp"] = datetime.utcnow().isoformat() - return True - except Exception: - message["status"] = "failed" - return False - - def receive_message(self, message_id: str) -> Optional[Dict[str, Any]]: - """Receive and process a message""" - for message in self.messages: - if message["message_id"] == message_id: - message["status"] = "received" - message["received_timestamp"] = datetime.utcnow().isoformat() - return message - return None - - def get_messages_by_agent(self, agent_id: str) -> List[Dict[str, Any]]: - """Get all messages for a specific agent""" - return [ - msg for msg in self.messages - if msg["sender_id"] == agent_id or msg["receiver_id"] == agent_id - ] - -class AgentMessageClient: - """Client for agent message communication""" - - def __init__(self, agent_id: str, protocol: MessageProtocol): - self.agent_id = agent_id - self.protocol = protocol - self.received_messages = [] - - def send_message( - self, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any] - ) -> Dict[str, Any]: - """Send a message to another agent""" - message = self.protocol.create_message( - sender_id=self.agent_id, - receiver_id=receiver_id, - message_type=message_type, - content=content - ) - self.protocol.send_message(message) - return message - - def receive_messages(self) -> List[Dict[str, Any]]: - """Receive all pending messages for this agent""" - messages = [] - for message in self.protocol.messages: - if (message["receiver_id"] == self.agent_id and - message["status"] == "sent" and - message not in self.received_messages): - self.protocol.receive_message(message["message_id"]) - self.received_messages.append(message) - messages.append(message) - return messages diff --git a/apps/agent-services_backup_20260402_120554/agent-protocols/src/task_manager.py b/apps/agent-services_backup_20260402_120554/agent-protocols/src/task_manager.py deleted file mode 100644 index af680c99..00000000 --- a/apps/agent-services_backup_20260402_120554/agent-protocols/src/task_manager.py +++ /dev/null @@ -1,128 +0,0 @@ -""" -Task Manager for AITBC Agents -Handles task creation, assignment, and tracking -""" - -import uuid -from datetime import datetime, timedelta -from typing import Dict, Any, Optional, List -from enum import Enum - -class TaskStatus(Enum): - """Task status enumeration""" - PENDING = "pending" - IN_PROGRESS = "in_progress" - COMPLETED = "completed" - FAILED = "failed" - CANCELLED = "cancelled" - -class TaskPriority(Enum): - """Task priority enumeration""" - LOW = "low" - MEDIUM = "medium" - HIGH = "high" - URGENT = "urgent" - -class Task: - """Task representation""" - - def __init__( - self, - task_id: str, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ): - self.task_id = task_id - self.title = title - self.description = description - self.assigned_to = assigned_to - self.priority = priority - self.created_by = created_by or assigned_to - self.status = TaskStatus.PENDING - self.created_at = datetime.utcnow() - self.updated_at = datetime.utcnow() - self.completed_at = None - self.result = None - self.error = None - -class TaskManager: - """Task manager for agent coordination""" - - def __init__(self): - self.tasks = {} - self.task_history = [] - - def create_task( - self, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ) -> Task: - """Create a new task""" - task_id = str(uuid.uuid4()) - task = Task( - task_id=task_id, - title=title, - description=description, - assigned_to=assigned_to, - priority=priority, - created_by=created_by - ) - - self.tasks[task_id] = task - return task - - def get_task(self, task_id: str) -> Optional[Task]: - """Get a task by ID""" - return self.tasks.get(task_id) - - def update_task_status( - self, - task_id: str, - status: TaskStatus, - result: Optional[Dict[str, Any]] = None, - error: Optional[str] = None - ) -> bool: - """Update task status""" - task = self.get_task(task_id) - if not task: - return False - - task.status = status - task.updated_at = datetime.utcnow() - - if status == TaskStatus.COMPLETED: - task.completed_at = datetime.utcnow() - task.result = result - elif status == TaskStatus.FAILED: - task.error = error - - return True - - def get_tasks_by_agent(self, agent_id: str) -> List[Task]: - """Get all tasks assigned to an agent""" - return [ - task for task in self.tasks.values() - if task.assigned_to == agent_id - ] - - def get_tasks_by_status(self, status: TaskStatus) -> List[Task]: - """Get all tasks with a specific status""" - return [ - task for task in self.tasks.values() - if task.status == status - ] - - def get_overdue_tasks(self, hours: int = 24) -> List[Task]: - """Get tasks that are overdue""" - cutoff_time = datetime.utcnow() - timedelta(hours=hours) - return [ - task for task in self.tasks.values() - if task.status in [TaskStatus.PENDING, TaskStatus.IN_PROGRESS] and - task.created_at < cutoff_time - ] diff --git a/apps/agent-services_backup_20260402_120554/agent-registry/src/app.py b/apps/agent-services_backup_20260402_120554/agent-registry/src/app.py deleted file mode 100644 index 70eb95f7..00000000 --- a/apps/agent-services_backup_20260402_120554/agent-registry/src/app.py +++ /dev/null @@ -1,151 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Registry Service -Central agent discovery and registration system -""" - -from fastapi import FastAPI, HTTPException, Depends -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import time -import uuid -from datetime import datetime, timedelta -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Registry API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_registry.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS agents ( - id TEXT PRIMARY KEY, - name TEXT NOT NULL, - type TEXT NOT NULL, - capabilities TEXT NOT NULL, - chain_id TEXT NOT NULL, - endpoint TEXT NOT NULL, - status TEXT DEFAULT 'active', - last_heartbeat TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - metadata TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP - ) - ''') - -# Models -class Agent(BaseModel): - id: str - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -class AgentRegistration(BaseModel): - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -# API Endpoints - -@app.post("/api/agents/register", response_model=Agent) -async def register_agent(agent: AgentRegistration): - """Register a new agent""" - agent_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO agents (id, name, type, capabilities, chain_id, endpoint, metadata) - VALUES (?, ?, ?, ?, ?, ?, ?) - ''', ( - agent_id, agent.name, agent.type, - json.dumps(agent.capabilities), agent.chain_id, - agent.endpoint, json.dumps(agent.metadata) - )) - conn.commit() - - return Agent( - id=agent_id, - name=agent.name, - type=agent.type, - capabilities=agent.capabilities, - chain_id=agent.chain_id, - endpoint=agent.endpoint, - metadata=agent.metadata - ) - -@app.get("/api/agents", response_model=List[Agent]) -async def list_agents( - agent_type: Optional[str] = None, - chain_id: Optional[str] = None, - capability: Optional[str] = None -): - """List registered agents with optional filters""" - with get_db_connection() as conn: - query = "SELECT * FROM agents WHERE status = 'active'" - params = [] - - if agent_type: - query += " AND type = ?" - params.append(agent_type) - - if chain_id: - query += " AND chain_id = ?" - params.append(chain_id) - - if capability: - query += " AND capabilities LIKE ?" - params.append(f'%{capability}%') - - agents = conn.execute(query, params).fetchall() - - return [ - Agent( - id=agent["id"], - name=agent["name"], - type=agent["type"], - capabilities=json.loads(agent["capabilities"]), - chain_id=agent["chain_id"], - endpoint=agent["endpoint"], - metadata=json.loads(agent["metadata"] or "{}") - ) - for agent in agents - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8013) diff --git a/apps/agent-services_backup_20260402_120554/agent-trading/src/trading_agent.py b/apps/agent-services_backup_20260402_120554/agent-trading/src/trading_agent.py deleted file mode 100644 index 181d963b..00000000 --- a/apps/agent-services_backup_20260402_120554/agent-trading/src/trading_agent.py +++ /dev/null @@ -1,166 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Trading Agent -Automated trading agent for AITBC marketplace -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class TradingAgent: - """Automated trading agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.trading_strategy = config.get("strategy", "basic") - self.symbols = config.get("symbols", ["AITBC/BTC"]) - self.trade_interval = config.get("trade_interval", 60) # seconds - - async def start(self) -> bool: - """Start trading agent""" - try: - # Register with service bridge - success = await self.bridge.start_agent(self.agent_id, { - "type": "trading", - "capabilities": ["market_analysis", "trading", "risk_management"], - "endpoint": f"http://localhost:8005" - }) - - if success: - self.is_running = True - print(f"Trading agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start trading agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting trading agent: {e}") - return False - - async def stop(self) -> bool: - """Stop trading agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Trading agent {self.agent_id} stopped successfully") - return success - - async def run_trading_loop(self): - """Main trading loop""" - while self.is_running: - try: - for symbol in self.symbols: - await self._analyze_and_trade(symbol) - - await asyncio.sleep(self.trade_interval) - except Exception as e: - print(f"Error in trading loop: {e}") - await asyncio.sleep(10) # Wait before retrying - - async def _analyze_and_trade(self, symbol: str) -> None: - """Analyze market and execute trades""" - try: - # Perform market analysis - analysis_task = { - "type": "market_analysis", - "symbol": symbol, - "strategy": self.trading_strategy - } - - analysis_result = await self.bridge.execute_agent_task(self.agent_id, analysis_task) - - if analysis_result.get("status") == "success": - analysis = analysis_result["result"]["analysis"] - - # Make trading decision - if self._should_trade(analysis): - await self._execute_trade(symbol, analysis) - else: - print(f"Market analysis failed for {symbol}: {analysis_result}") - - except Exception as e: - print(f"Error in analyze_and_trade for {symbol}: {e}") - - def _should_trade(self, analysis: Dict[str, Any]) -> bool: - """Determine if should execute trade""" - recommendation = analysis.get("recommendation", "hold") - return recommendation in ["buy", "sell"] - - async def _execute_trade(self, symbol: str, analysis: Dict[str, Any]) -> None: - """Execute trade based on analysis""" - try: - recommendation = analysis.get("recommendation", "hold") - - if recommendation == "buy": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "buy", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - elif recommendation == "sell": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "sell", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - else: - return - - trade_result = await self.bridge.execute_agent_task(self.agent_id, trade_task) - - if trade_result.get("status") == "success": - print(f"Trade executed successfully: {trade_result}") - else: - print(f"Trade execution failed: {trade_result}") - - except Exception as e: - print(f"Error executing trade: {e}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - return await self.bridge.get_agent_status(self.agent_id) - -# Main execution -async def main(): - """Main trading agent execution""" - agent_id = "trading-agent-001" - config = { - "strategy": "basic", - "symbols": ["AITBC/BTC"], - "trade_interval": 30, - "trade_amount": 0.1 - } - - agent = TradingAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run trading loop - await agent.run_trading_loop() - except KeyboardInterrupt: - print("Shutting down trading agent...") - finally: - await agent.stop() - else: - print("Failed to start trading agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_120608/agent-bridge/src/integration_layer.py b/apps/agent-services_backup_20260402_120608/agent-bridge/src/integration_layer.py deleted file mode 100644 index f1be04db..00000000 --- a/apps/agent-services_backup_20260402_120608/agent-bridge/src/integration_layer.py +++ /dev/null @@ -1,229 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Integration Layer -Connects agent protocols to existing AITBC services -""" - -import asyncio -import aiohttp -import json -from typing import Dict, Any, List, Optional -from datetime import datetime - -class AITBCServiceIntegration: - """Integration layer for AITBC services""" - - def __init__(self): - self.service_endpoints = { - "coordinator_api": "http://localhost:8000", - "blockchain_rpc": "http://localhost:8006", - "exchange_service": "http://localhost:8001", - "marketplace": "http://localhost:8002", - "agent_registry": "http://localhost:8013" - } - self.session = None - - async def __aenter__(self): - self.session = aiohttp.ClientSession() - return self - - async def __aexit__(self, exc_type, exc_val, exc_tb): - if self.session: - await self.session.close() - - async def get_blockchain_info(self) -> Dict[str, Any]: - """Get blockchain information""" - try: - async with self.session.get(f"{self.service_endpoints['blockchain_rpc']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_exchange_status(self) -> Dict[str, Any]: - """Get exchange service status""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_coordinator_status(self) -> Dict[str, Any]: - """Get coordinator API status""" - try: - async with self.session.get(f"{self.service_endpoints['coordinator_api']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def submit_transaction(self, transaction_data: Dict[str, Any]) -> Dict[str, Any]: - """Submit transaction to blockchain""" - try: - async with self.session.post( - f"{self.service_endpoints['blockchain_rpc']}/rpc/submit", - json=transaction_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def get_market_data(self, symbol: str = "AITBC/BTC") -> Dict[str, Any]: - """Get market data from exchange""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/market/{symbol}") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def register_agent_with_coordinator(self, agent_data: Dict[str, Any]) -> Dict[str, Any]: - """Register agent with coordinator""" - try: - async with self.session.post( - f"{self.service_endpoints['agent_registry']}/api/agents/register", - json=agent_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - -class AgentServiceBridge: - """Bridge between agents and AITBC services""" - - def __init__(self): - self.integration = AITBCServiceIntegration() - self.active_agents = {} - - async def start_agent(self, agent_id: str, agent_config: Dict[str, Any]) -> bool: - """Start an agent with service integration""" - try: - # Register agent with coordinator - async with self.integration as integration: - registration_result = await integration.register_agent_with_coordinator({ - "name": agent_id, - "type": agent_config.get("type", "generic"), - "capabilities": agent_config.get("capabilities", []), - "chain_id": agent_config.get("chain_id", "ait-mainnet"), - "endpoint": agent_config.get("endpoint", f"http://localhost:{8000 + len(self.active_agents) + 10}") - }) - - # The registry returns the created agent dict on success, not a {"status": "ok"} wrapper - if registration_result and "id" in registration_result: - self.active_agents[agent_id] = { - "config": agent_config, - "registration": registration_result, - "started_at": datetime.utcnow() - } - return True - else: - print(f"Registration failed: {registration_result}") - return False - except Exception as e: - print(f"Failed to start agent {agent_id}: {e}") - return False - - async def stop_agent(self, agent_id: str) -> bool: - """Stop an agent""" - if agent_id in self.active_agents: - del self.active_agents[agent_id] - return True - return False - - async def get_agent_status(self, agent_id: str) -> Dict[str, Any]: - """Get agent status with service integration""" - if agent_id not in self.active_agents: - return {"status": "not_found"} - - agent_info = self.active_agents[agent_id] - - async with self.integration as integration: - # Get service statuses - blockchain_status = await integration.get_blockchain_info() - exchange_status = await integration.get_exchange_status() - coordinator_status = await integration.get_coordinator_status() - - return { - "agent_id": agent_id, - "status": "active", - "started_at": agent_info["started_at"].isoformat(), - "services": { - "blockchain": blockchain_status, - "exchange": exchange_status, - "coordinator": coordinator_status - } - } - - async def execute_agent_task(self, agent_id: str, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute agent task with service integration""" - if agent_id not in self.active_agents: - return {"status": "error", "message": "Agent not found"} - - task_type = task_data.get("type") - - if task_type == "market_analysis": - return await self._execute_market_analysis(task_data) - elif task_type == "trading": - return await self._execute_trading_task(task_data) - elif task_type == "compliance_check": - return await self._execute_compliance_check(task_data) - else: - return {"status": "error", "message": f"Unknown task type: {task_type}"} - - async def _execute_market_analysis(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute market analysis task""" - try: - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Perform basic analysis - analysis_result = { - "symbol": task_data.get("symbol", "AITBC/BTC"), - "market_data": market_data, - "analysis": { - "trend": "neutral", - "volatility": "medium", - "recommendation": "hold" - }, - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": analysis_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_trading_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute trading task""" - try: - # Get market data first - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Create transaction - transaction = { - "type": "trade", - "symbol": task_data.get("symbol", "AITBC/BTC"), - "side": task_data.get("side", "buy"), - "amount": task_data.get("amount", 0.1), - "price": task_data.get("price", market_data.get("price", 0.001)) - } - - # Submit transaction - tx_result = await integration.submit_transaction(transaction) - - return {"status": "success", "transaction": tx_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_compliance_check(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute compliance check task""" - try: - # Basic compliance check - compliance_result = { - "user_id": task_data.get("user_id"), - "check_type": task_data.get("check_type", "basic"), - "status": "passed", - "checks_performed": ["kyc", "aml", "sanctions"], - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": compliance_result} - except Exception as e: - return {"status": "error", "message": str(e)} diff --git a/apps/agent-services_backup_20260402_120608/agent-compliance/src/compliance_agent.py b/apps/agent-services_backup_20260402_120608/agent-compliance/src/compliance_agent.py deleted file mode 100644 index a04ad5bd..00000000 --- a/apps/agent-services_backup_20260402_120608/agent-compliance/src/compliance_agent.py +++ /dev/null @@ -1,149 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Compliance Agent -Automated compliance and regulatory monitoring agent -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class ComplianceAgent: - """Automated compliance agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.check_interval = config.get("check_interval", 300) # 5 minutes - self.monitored_entities = config.get("monitored_entities", []) - - async def start(self) -> bool: - """Start compliance agent""" - try: - success = await self.bridge.start_agent(self.agent_id, { - "type": "compliance", - "capabilities": ["kyc_check", "aml_screening", "regulatory_reporting"], - "endpoint": f"http://localhost:8006" - }) - - if success: - self.is_running = True - print(f"Compliance agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start compliance agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting compliance agent: {e}") - return False - - async def stop(self) -> bool: - """Stop compliance agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Compliance agent {self.agent_id} stopped successfully") - return success - - async def run_compliance_loop(self): - """Main compliance monitoring loop""" - while self.is_running: - try: - for entity in self.monitored_entities: - await self._perform_compliance_check(entity) - - await asyncio.sleep(self.check_interval) - except Exception as e: - print(f"Error in compliance loop: {e}") - await asyncio.sleep(30) # Wait before retrying - - async def _perform_compliance_check(self, entity_id: str) -> None: - """Perform compliance check for entity""" - try: - compliance_task = { - "type": "compliance_check", - "user_id": entity_id, - "check_type": "full", - "monitored_activities": ["trading", "transfers", "wallet_creation"] - } - - result = await self.bridge.execute_agent_task(self.agent_id, compliance_task) - - if result.get("status") == "success": - compliance_result = result["result"] - await self._handle_compliance_result(entity_id, compliance_result) - else: - print(f"Compliance check failed for {entity_id}: {result}") - - except Exception as e: - print(f"Error performing compliance check for {entity_id}: {e}") - - async def _handle_compliance_result(self, entity_id: str, result: Dict[str, Any]) -> None: - """Handle compliance check result""" - status = result.get("status", "unknown") - - if status == "passed": - print(f"✅ Compliance check passed for {entity_id}") - elif status == "failed": - print(f"❌ Compliance check failed for {entity_id}") - # Trigger alert or further investigation - await self._trigger_compliance_alert(entity_id, result) - else: - print(f"⚠️ Compliance check inconclusive for {entity_id}") - - async def _trigger_compliance_alert(self, entity_id: str, result: Dict[str, Any]) -> None: - """Trigger compliance alert""" - alert_data = { - "entity_id": entity_id, - "alert_type": "compliance_failure", - "severity": "high", - "details": result, - "timestamp": datetime.utcnow().isoformat() - } - - # In a real implementation, this would send to alert system - print(f"🚨 COMPLIANCE ALERT: {json.dumps(alert_data, indent=2)}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - status = await self.bridge.get_agent_status(self.agent_id) - status["monitored_entities"] = len(self.monitored_entities) - status["check_interval"] = self.check_interval - return status - -# Main execution -async def main(): - """Main compliance agent execution""" - agent_id = "compliance-agent-001" - config = { - "check_interval": 60, # 1 minute for testing - "monitored_entities": ["user001", "user002", "user003"] - } - - agent = ComplianceAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run compliance loop - await agent.run_compliance_loop() - except KeyboardInterrupt: - print("Shutting down compliance agent...") - finally: - await agent.stop() - else: - print("Failed to start compliance agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_120608/agent-coordinator/src/coordinator.py b/apps/agent-services_backup_20260402_120608/agent-coordinator/src/coordinator.py deleted file mode 100644 index ce39c3cc..00000000 --- a/apps/agent-services_backup_20260402_120608/agent-coordinator/src/coordinator.py +++ /dev/null @@ -1,132 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Coordinator Service -Agent task coordination and management -""" - -from fastapi import FastAPI, HTTPException -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import uuid -from datetime import datetime -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Coordinator API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_coordinator.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS tasks ( - id TEXT PRIMARY KEY, - task_type TEXT NOT NULL, - payload TEXT NOT NULL, - required_capabilities TEXT NOT NULL, - priority TEXT NOT NULL, - status TEXT NOT NULL, - assigned_agent_id TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - result TEXT - ) - ''') - -# Models -class Task(BaseModel): - id: str - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str - status: str - assigned_agent_id: Optional[str] = None - -class TaskCreation(BaseModel): - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str = "normal" - -# API Endpoints - -@app.post("/api/tasks", response_model=Task) -async def create_task(task: TaskCreation): - """Create a new task""" - task_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO tasks (id, task_type, payload, required_capabilities, priority, status) - VALUES (?, ?, ?, ?, ?, ?) - ''', ( - task_id, task.task_type, json.dumps(task.payload), - json.dumps(task.required_capabilities), task.priority, "pending" - )) - - return Task( - id=task_id, - task_type=task.task_type, - payload=task.payload, - required_capabilities=task.required_capabilities, - priority=task.priority, - status="pending" - ) - -@app.get("/api/tasks", response_model=List[Task]) -async def list_tasks(status: Optional[str] = None): - """List tasks with optional status filter""" - with get_db_connection() as conn: - query = "SELECT * FROM tasks" - params = [] - - if status: - query += " WHERE status = ?" - params.append(status) - - tasks = conn.execute(query, params).fetchall() - - return [ - Task( - id=task["id"], - task_type=task["task_type"], - payload=json.loads(task["payload"]), - required_capabilities=json.loads(task["required_capabilities"]), - priority=task["priority"], - status=task["status"], - assigned_agent_id=task["assigned_agent_id"] - ) - for task in tasks - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8012) diff --git a/apps/agent-services_backup_20260402_120608/agent-protocols/.env.example b/apps/agent-services_backup_20260402_120608/agent-protocols/.env.example deleted file mode 100644 index bf8ed394..00000000 --- a/apps/agent-services_backup_20260402_120608/agent-protocols/.env.example +++ /dev/null @@ -1,19 +0,0 @@ -# AITBC Agent Protocols Environment Configuration -# Copy this file to .env and update with your secure values - -# Agent Protocol Encryption Key (generate a strong, unique key) -AITBC_AGENT_PROTOCOL_KEY=your-secure-encryption-key-here - -# Agent Protocol Salt (generate a unique salt value) -AITBC_AGENT_PROTOCOL_SALT=your-unique-salt-value-here - -# Agent Registry Configuration -AGENT_REGISTRY_HOST=0.0.0.0 -AGENT_REGISTRY_PORT=8003 - -# Database Configuration -AGENT_REGISTRY_DB_PATH=agent_registry.db - -# Security Settings -AGENT_PROTOCOL_TIMEOUT=300 -AGENT_PROTOCOL_MAX_RETRIES=3 diff --git a/apps/agent-services_backup_20260402_120608/agent-protocols/src/__init__.py b/apps/agent-services_backup_20260402_120608/agent-protocols/src/__init__.py deleted file mode 100644 index 9dfeaacd..00000000 --- a/apps/agent-services_backup_20260402_120608/agent-protocols/src/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -""" -Agent Protocols Package -""" - -from .message_protocol import MessageProtocol, MessageTypes, AgentMessageClient -from .task_manager import TaskManager, TaskStatus, TaskPriority, Task - -__all__ = [ - "MessageProtocol", - "MessageTypes", - "AgentMessageClient", - "TaskManager", - "TaskStatus", - "TaskPriority", - "Task" -] diff --git a/apps/agent-services_backup_20260402_120608/agent-protocols/src/message_protocol.py b/apps/agent-services_backup_20260402_120608/agent-protocols/src/message_protocol.py deleted file mode 100644 index 48289d6b..00000000 --- a/apps/agent-services_backup_20260402_120608/agent-protocols/src/message_protocol.py +++ /dev/null @@ -1,113 +0,0 @@ -""" -Message Protocol for AITBC Agents -Handles message creation, routing, and delivery between agents -""" - -import json -import uuid -from datetime import datetime -from typing import Dict, Any, Optional, List -from enum import Enum - -class MessageTypes(Enum): - """Message type enumeration""" - TASK_REQUEST = "task_request" - TASK_RESPONSE = "task_response" - HEARTBEAT = "heartbeat" - STATUS_UPDATE = "status_update" - ERROR = "error" - DATA = "data" - -class MessageProtocol: - """Message protocol handler for agent communication""" - - def __init__(self): - self.messages = [] - self.message_handlers = {} - - def create_message( - self, - sender_id: str, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any], - message_id: Optional[str] = None - ) -> Dict[str, Any]: - """Create a new message""" - if message_id is None: - message_id = str(uuid.uuid4()) - - message = { - "message_id": message_id, - "sender_id": sender_id, - "receiver_id": receiver_id, - "message_type": message_type.value, - "content": content, - "timestamp": datetime.utcnow().isoformat(), - "status": "pending" - } - - self.messages.append(message) - return message - - def send_message(self, message: Dict[str, Any]) -> bool: - """Send a message to the receiver""" - try: - message["status"] = "sent" - message["sent_timestamp"] = datetime.utcnow().isoformat() - return True - except Exception: - message["status"] = "failed" - return False - - def receive_message(self, message_id: str) -> Optional[Dict[str, Any]]: - """Receive and process a message""" - for message in self.messages: - if message["message_id"] == message_id: - message["status"] = "received" - message["received_timestamp"] = datetime.utcnow().isoformat() - return message - return None - - def get_messages_by_agent(self, agent_id: str) -> List[Dict[str, Any]]: - """Get all messages for a specific agent""" - return [ - msg for msg in self.messages - if msg["sender_id"] == agent_id or msg["receiver_id"] == agent_id - ] - -class AgentMessageClient: - """Client for agent message communication""" - - def __init__(self, agent_id: str, protocol: MessageProtocol): - self.agent_id = agent_id - self.protocol = protocol - self.received_messages = [] - - def send_message( - self, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any] - ) -> Dict[str, Any]: - """Send a message to another agent""" - message = self.protocol.create_message( - sender_id=self.agent_id, - receiver_id=receiver_id, - message_type=message_type, - content=content - ) - self.protocol.send_message(message) - return message - - def receive_messages(self) -> List[Dict[str, Any]]: - """Receive all pending messages for this agent""" - messages = [] - for message in self.protocol.messages: - if (message["receiver_id"] == self.agent_id and - message["status"] == "sent" and - message not in self.received_messages): - self.protocol.receive_message(message["message_id"]) - self.received_messages.append(message) - messages.append(message) - return messages diff --git a/apps/agent-services_backup_20260402_120608/agent-protocols/src/task_manager.py b/apps/agent-services_backup_20260402_120608/agent-protocols/src/task_manager.py deleted file mode 100644 index af680c99..00000000 --- a/apps/agent-services_backup_20260402_120608/agent-protocols/src/task_manager.py +++ /dev/null @@ -1,128 +0,0 @@ -""" -Task Manager for AITBC Agents -Handles task creation, assignment, and tracking -""" - -import uuid -from datetime import datetime, timedelta -from typing import Dict, Any, Optional, List -from enum import Enum - -class TaskStatus(Enum): - """Task status enumeration""" - PENDING = "pending" - IN_PROGRESS = "in_progress" - COMPLETED = "completed" - FAILED = "failed" - CANCELLED = "cancelled" - -class TaskPriority(Enum): - """Task priority enumeration""" - LOW = "low" - MEDIUM = "medium" - HIGH = "high" - URGENT = "urgent" - -class Task: - """Task representation""" - - def __init__( - self, - task_id: str, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ): - self.task_id = task_id - self.title = title - self.description = description - self.assigned_to = assigned_to - self.priority = priority - self.created_by = created_by or assigned_to - self.status = TaskStatus.PENDING - self.created_at = datetime.utcnow() - self.updated_at = datetime.utcnow() - self.completed_at = None - self.result = None - self.error = None - -class TaskManager: - """Task manager for agent coordination""" - - def __init__(self): - self.tasks = {} - self.task_history = [] - - def create_task( - self, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ) -> Task: - """Create a new task""" - task_id = str(uuid.uuid4()) - task = Task( - task_id=task_id, - title=title, - description=description, - assigned_to=assigned_to, - priority=priority, - created_by=created_by - ) - - self.tasks[task_id] = task - return task - - def get_task(self, task_id: str) -> Optional[Task]: - """Get a task by ID""" - return self.tasks.get(task_id) - - def update_task_status( - self, - task_id: str, - status: TaskStatus, - result: Optional[Dict[str, Any]] = None, - error: Optional[str] = None - ) -> bool: - """Update task status""" - task = self.get_task(task_id) - if not task: - return False - - task.status = status - task.updated_at = datetime.utcnow() - - if status == TaskStatus.COMPLETED: - task.completed_at = datetime.utcnow() - task.result = result - elif status == TaskStatus.FAILED: - task.error = error - - return True - - def get_tasks_by_agent(self, agent_id: str) -> List[Task]: - """Get all tasks assigned to an agent""" - return [ - task for task in self.tasks.values() - if task.assigned_to == agent_id - ] - - def get_tasks_by_status(self, status: TaskStatus) -> List[Task]: - """Get all tasks with a specific status""" - return [ - task for task in self.tasks.values() - if task.status == status - ] - - def get_overdue_tasks(self, hours: int = 24) -> List[Task]: - """Get tasks that are overdue""" - cutoff_time = datetime.utcnow() - timedelta(hours=hours) - return [ - task for task in self.tasks.values() - if task.status in [TaskStatus.PENDING, TaskStatus.IN_PROGRESS] and - task.created_at < cutoff_time - ] diff --git a/apps/agent-services_backup_20260402_120608/agent-registry/src/app.py b/apps/agent-services_backup_20260402_120608/agent-registry/src/app.py deleted file mode 100644 index 70eb95f7..00000000 --- a/apps/agent-services_backup_20260402_120608/agent-registry/src/app.py +++ /dev/null @@ -1,151 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Registry Service -Central agent discovery and registration system -""" - -from fastapi import FastAPI, HTTPException, Depends -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import time -import uuid -from datetime import datetime, timedelta -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Registry API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_registry.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS agents ( - id TEXT PRIMARY KEY, - name TEXT NOT NULL, - type TEXT NOT NULL, - capabilities TEXT NOT NULL, - chain_id TEXT NOT NULL, - endpoint TEXT NOT NULL, - status TEXT DEFAULT 'active', - last_heartbeat TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - metadata TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP - ) - ''') - -# Models -class Agent(BaseModel): - id: str - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -class AgentRegistration(BaseModel): - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -# API Endpoints - -@app.post("/api/agents/register", response_model=Agent) -async def register_agent(agent: AgentRegistration): - """Register a new agent""" - agent_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO agents (id, name, type, capabilities, chain_id, endpoint, metadata) - VALUES (?, ?, ?, ?, ?, ?, ?) - ''', ( - agent_id, agent.name, agent.type, - json.dumps(agent.capabilities), agent.chain_id, - agent.endpoint, json.dumps(agent.metadata) - )) - conn.commit() - - return Agent( - id=agent_id, - name=agent.name, - type=agent.type, - capabilities=agent.capabilities, - chain_id=agent.chain_id, - endpoint=agent.endpoint, - metadata=agent.metadata - ) - -@app.get("/api/agents", response_model=List[Agent]) -async def list_agents( - agent_type: Optional[str] = None, - chain_id: Optional[str] = None, - capability: Optional[str] = None -): - """List registered agents with optional filters""" - with get_db_connection() as conn: - query = "SELECT * FROM agents WHERE status = 'active'" - params = [] - - if agent_type: - query += " AND type = ?" - params.append(agent_type) - - if chain_id: - query += " AND chain_id = ?" - params.append(chain_id) - - if capability: - query += " AND capabilities LIKE ?" - params.append(f'%{capability}%') - - agents = conn.execute(query, params).fetchall() - - return [ - Agent( - id=agent["id"], - name=agent["name"], - type=agent["type"], - capabilities=json.loads(agent["capabilities"]), - chain_id=agent["chain_id"], - endpoint=agent["endpoint"], - metadata=json.loads(agent["metadata"] or "{}") - ) - for agent in agents - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8013) diff --git a/apps/agent-services_backup_20260402_120608/agent-registry/src/registration.py b/apps/agent-services_backup_20260402_120608/agent-registry/src/registration.py deleted file mode 100644 index 3793139d..00000000 --- a/apps/agent-services_backup_20260402_120608/agent-registry/src/registration.py +++ /dev/null @@ -1,431 +0,0 @@ -""" -Agent Registration System -Handles AI agent registration, capability management, and discovery -""" - -import asyncio -import time -import json -import hashlib -from typing import Dict, List, Optional, Set, Tuple -from dataclasses import dataclass, asdict -from enum import Enum -from decimal import Decimal - -class AgentType(Enum): - AI_MODEL = "ai_model" - DATA_PROVIDER = "data_provider" - VALIDATOR = "validator" - MARKET_MAKER = "market_maker" - BROKER = "broker" - ORACLE = "oracle" - -class AgentStatus(Enum): - REGISTERED = "registered" - ACTIVE = "active" - INACTIVE = "inactive" - SUSPENDED = "suspended" - BANNED = "banned" - -class CapabilityType(Enum): - TEXT_GENERATION = "text_generation" - IMAGE_GENERATION = "image_generation" - DATA_ANALYSIS = "data_analysis" - PREDICTION = "prediction" - VALIDATION = "validation" - COMPUTATION = "computation" - -@dataclass -class AgentCapability: - capability_type: CapabilityType - name: str - version: str - parameters: Dict - performance_metrics: Dict - cost_per_use: Decimal - availability: float - max_concurrent_jobs: int - -@dataclass -class AgentInfo: - agent_id: str - agent_type: AgentType - name: str - owner_address: str - public_key: str - endpoint_url: str - capabilities: List[AgentCapability] - reputation_score: float - total_jobs_completed: int - total_earnings: Decimal - registration_time: float - last_active: float - status: AgentStatus - metadata: Dict - -class AgentRegistry: - """Manages AI agent registration and discovery""" - - def __init__(self): - self.agents: Dict[str, AgentInfo] = {} - self.capability_index: Dict[CapabilityType, Set[str]] = {} # capability -> agent_ids - self.type_index: Dict[AgentType, Set[str]] = {} # agent_type -> agent_ids - self.reputation_scores: Dict[str, float] = {} - self.registration_queue: List[Dict] = [] - - # Registry parameters - self.min_reputation_threshold = 0.5 - self.max_agents_per_type = 1000 - self.registration_fee = Decimal('100.0') - self.inactivity_threshold = 86400 * 7 # 7 days - - # Initialize capability index - for capability_type in CapabilityType: - self.capability_index[capability_type] = set() - - # Initialize type index - for agent_type in AgentType: - self.type_index[agent_type] = set() - - async def register_agent(self, agent_type: AgentType, name: str, owner_address: str, - public_key: str, endpoint_url: str, capabilities: List[Dict], - metadata: Dict = None) -> Tuple[bool, str, Optional[str]]: - """Register a new AI agent""" - try: - # Validate inputs - if not self._validate_registration_inputs(agent_type, name, owner_address, public_key, endpoint_url): - return False, "Invalid registration inputs", None - - # Check if agent already exists - agent_id = self._generate_agent_id(owner_address, name) - if agent_id in self.agents: - return False, "Agent already registered", None - - # Check type limits - if len(self.type_index[agent_type]) >= self.max_agents_per_type: - return False, f"Maximum agents of type {agent_type.value} reached", None - - # Convert capabilities - agent_capabilities = [] - for cap_data in capabilities: - capability = self._create_capability_from_data(cap_data) - if capability: - agent_capabilities.append(capability) - - if not agent_capabilities: - return False, "Agent must have at least one valid capability", None - - # Create agent info - agent_info = AgentInfo( - agent_id=agent_id, - agent_type=agent_type, - name=name, - owner_address=owner_address, - public_key=public_key, - endpoint_url=endpoint_url, - capabilities=agent_capabilities, - reputation_score=1.0, # Start with neutral reputation - total_jobs_completed=0, - total_earnings=Decimal('0'), - registration_time=time.time(), - last_active=time.time(), - status=AgentStatus.REGISTERED, - metadata=metadata or {} - ) - - # Add to registry - self.agents[agent_id] = agent_info - - # Update indexes - self.type_index[agent_type].add(agent_id) - for capability in agent_capabilities: - self.capability_index[capability.capability_type].add(agent_id) - - log_info(f"Agent registered: {agent_id} ({name})") - return True, "Registration successful", agent_id - - except Exception as e: - return False, f"Registration failed: {str(e)}", None - - def _validate_registration_inputs(self, agent_type: AgentType, name: str, - owner_address: str, public_key: str, endpoint_url: str) -> bool: - """Validate registration inputs""" - # Check required fields - if not all([agent_type, name, owner_address, public_key, endpoint_url]): - return False - - # Validate address format (simplified) - if not owner_address.startswith('0x') or len(owner_address) != 42: - return False - - # Validate URL format (simplified) - if not endpoint_url.startswith(('http://', 'https://')): - return False - - # Validate name - if len(name) < 3 or len(name) > 100: - return False - - return True - - def _generate_agent_id(self, owner_address: str, name: str) -> str: - """Generate unique agent ID""" - content = f"{owner_address}:{name}:{time.time()}" - return hashlib.sha256(content.encode()).hexdigest()[:16] - - def _create_capability_from_data(self, cap_data: Dict) -> Optional[AgentCapability]: - """Create capability from data dictionary""" - try: - # Validate required fields - required_fields = ['type', 'name', 'version', 'cost_per_use'] - if not all(field in cap_data for field in required_fields): - return None - - # Parse capability type - try: - capability_type = CapabilityType(cap_data['type']) - except ValueError: - return None - - # Create capability - return AgentCapability( - capability_type=capability_type, - name=cap_data['name'], - version=cap_data['version'], - parameters=cap_data.get('parameters', {}), - performance_metrics=cap_data.get('performance_metrics', {}), - cost_per_use=Decimal(str(cap_data['cost_per_use'])), - availability=cap_data.get('availability', 1.0), - max_concurrent_jobs=cap_data.get('max_concurrent_jobs', 1) - ) - - except Exception as e: - log_error(f"Error creating capability: {e}") - return None - - async def update_agent_status(self, agent_id: str, status: AgentStatus) -> Tuple[bool, str]: - """Update agent status""" - if agent_id not in self.agents: - return False, "Agent not found" - - agent = self.agents[agent_id] - old_status = agent.status - agent.status = status - agent.last_active = time.time() - - log_info(f"Agent {agent_id} status changed: {old_status.value} -> {status.value}") - return True, "Status updated successfully" - - async def update_agent_capabilities(self, agent_id: str, capabilities: List[Dict]) -> Tuple[bool, str]: - """Update agent capabilities""" - if agent_id not in self.agents: - return False, "Agent not found" - - agent = self.agents[agent_id] - - # Remove old capabilities from index - for old_capability in agent.capabilities: - self.capability_index[old_capability.capability_type].discard(agent_id) - - # Add new capabilities - new_capabilities = [] - for cap_data in capabilities: - capability = self._create_capability_from_data(cap_data) - if capability: - new_capabilities.append(capability) - self.capability_index[capability.capability_type].add(agent_id) - - if not new_capabilities: - return False, "No valid capabilities provided" - - agent.capabilities = new_capabilities - agent.last_active = time.time() - - return True, "Capabilities updated successfully" - - async def find_agents_by_capability(self, capability_type: CapabilityType, - filters: Dict = None) -> List[AgentInfo]: - """Find agents by capability type""" - agent_ids = self.capability_index.get(capability_type, set()) - - agents = [] - for agent_id in agent_ids: - agent = self.agents.get(agent_id) - if agent and agent.status == AgentStatus.ACTIVE: - if self._matches_filters(agent, filters): - agents.append(agent) - - # Sort by reputation (highest first) - agents.sort(key=lambda x: x.reputation_score, reverse=True) - return agents - - async def find_agents_by_type(self, agent_type: AgentType, filters: Dict = None) -> List[AgentInfo]: - """Find agents by type""" - agent_ids = self.type_index.get(agent_type, set()) - - agents = [] - for agent_id in agent_ids: - agent = self.agents.get(agent_id) - if agent and agent.status == AgentStatus.ACTIVE: - if self._matches_filters(agent, filters): - agents.append(agent) - - # Sort by reputation (highest first) - agents.sort(key=lambda x: x.reputation_score, reverse=True) - return agents - - def _matches_filters(self, agent: AgentInfo, filters: Dict) -> bool: - """Check if agent matches filters""" - if not filters: - return True - - # Reputation filter - if 'min_reputation' in filters: - if agent.reputation_score < filters['min_reputation']: - return False - - # Cost filter - if 'max_cost_per_use' in filters: - max_cost = Decimal(str(filters['max_cost_per_use'])) - if any(cap.cost_per_use > max_cost for cap in agent.capabilities): - return False - - # Availability filter - if 'min_availability' in filters: - min_availability = filters['min_availability'] - if any(cap.availability < min_availability for cap in agent.capabilities): - return False - - # Location filter (if implemented) - if 'location' in filters: - agent_location = agent.metadata.get('location') - if agent_location != filters['location']: - return False - - return True - - async def get_agent_info(self, agent_id: str) -> Optional[AgentInfo]: - """Get agent information""" - return self.agents.get(agent_id) - - async def search_agents(self, query: str, limit: int = 50) -> List[AgentInfo]: - """Search agents by name or capability""" - query_lower = query.lower() - results = [] - - for agent in self.agents.values(): - if agent.status != AgentStatus.ACTIVE: - continue - - # Search in name - if query_lower in agent.name.lower(): - results.append(agent) - continue - - # Search in capabilities - for capability in agent.capabilities: - if (query_lower in capability.name.lower() or - query_lower in capability.capability_type.value): - results.append(agent) - break - - # Sort by relevance (reputation) - results.sort(key=lambda x: x.reputation_score, reverse=True) - return results[:limit] - - async def get_agent_statistics(self, agent_id: str) -> Optional[Dict]: - """Get detailed statistics for an agent""" - agent = self.agents.get(agent_id) - if not agent: - return None - - # Calculate additional statistics - avg_job_earnings = agent.total_earnings / agent.total_jobs_completed if agent.total_jobs_completed > 0 else Decimal('0') - days_active = (time.time() - agent.registration_time) / 86400 - jobs_per_day = agent.total_jobs_completed / days_active if days_active > 0 else 0 - - return { - 'agent_id': agent_id, - 'name': agent.name, - 'type': agent.agent_type.value, - 'status': agent.status.value, - 'reputation_score': agent.reputation_score, - 'total_jobs_completed': agent.total_jobs_completed, - 'total_earnings': float(agent.total_earnings), - 'avg_job_earnings': float(avg_job_earnings), - 'jobs_per_day': jobs_per_day, - 'days_active': int(days_active), - 'capabilities_count': len(agent.capabilities), - 'last_active': agent.last_active, - 'registration_time': agent.registration_time - } - - async def get_registry_statistics(self) -> Dict: - """Get registry-wide statistics""" - total_agents = len(self.agents) - active_agents = len([a for a in self.agents.values() if a.status == AgentStatus.ACTIVE]) - - # Count by type - type_counts = {} - for agent_type in AgentType: - type_counts[agent_type.value] = len(self.type_index[agent_type]) - - # Count by capability - capability_counts = {} - for capability_type in CapabilityType: - capability_counts[capability_type.value] = len(self.capability_index[capability_type]) - - # Reputation statistics - reputations = [a.reputation_score for a in self.agents.values()] - avg_reputation = sum(reputations) / len(reputations) if reputations else 0 - - # Earnings statistics - total_earnings = sum(a.total_earnings for a in self.agents.values()) - - return { - 'total_agents': total_agents, - 'active_agents': active_agents, - 'inactive_agents': total_agents - active_agents, - 'agent_types': type_counts, - 'capabilities': capability_counts, - 'average_reputation': avg_reputation, - 'total_earnings': float(total_earnings), - 'registration_fee': float(self.registration_fee) - } - - async def cleanup_inactive_agents(self) -> Tuple[int, str]: - """Clean up inactive agents""" - current_time = time.time() - cleaned_count = 0 - - for agent_id, agent in list(self.agents.items()): - if (agent.status == AgentStatus.INACTIVE and - current_time - agent.last_active > self.inactivity_threshold): - - # Remove from registry - del self.agents[agent_id] - - # Update indexes - self.type_index[agent.agent_type].discard(agent_id) - for capability in agent.capabilities: - self.capability_index[capability.capability_type].discard(agent_id) - - cleaned_count += 1 - - if cleaned_count > 0: - log_info(f"Cleaned up {cleaned_count} inactive agents") - - return cleaned_count, f"Cleaned up {cleaned_count} inactive agents" - -# Global agent registry -agent_registry: Optional[AgentRegistry] = None - -def get_agent_registry() -> Optional[AgentRegistry]: - """Get global agent registry""" - return agent_registry - -def create_agent_registry() -> AgentRegistry: - """Create and set global agent registry""" - global agent_registry - agent_registry = AgentRegistry() - return agent_registry diff --git a/apps/agent-services_backup_20260402_120608/agent-trading/src/trading_agent.py b/apps/agent-services_backup_20260402_120608/agent-trading/src/trading_agent.py deleted file mode 100644 index 181d963b..00000000 --- a/apps/agent-services_backup_20260402_120608/agent-trading/src/trading_agent.py +++ /dev/null @@ -1,166 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Trading Agent -Automated trading agent for AITBC marketplace -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class TradingAgent: - """Automated trading agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.trading_strategy = config.get("strategy", "basic") - self.symbols = config.get("symbols", ["AITBC/BTC"]) - self.trade_interval = config.get("trade_interval", 60) # seconds - - async def start(self) -> bool: - """Start trading agent""" - try: - # Register with service bridge - success = await self.bridge.start_agent(self.agent_id, { - "type": "trading", - "capabilities": ["market_analysis", "trading", "risk_management"], - "endpoint": f"http://localhost:8005" - }) - - if success: - self.is_running = True - print(f"Trading agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start trading agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting trading agent: {e}") - return False - - async def stop(self) -> bool: - """Stop trading agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Trading agent {self.agent_id} stopped successfully") - return success - - async def run_trading_loop(self): - """Main trading loop""" - while self.is_running: - try: - for symbol in self.symbols: - await self._analyze_and_trade(symbol) - - await asyncio.sleep(self.trade_interval) - except Exception as e: - print(f"Error in trading loop: {e}") - await asyncio.sleep(10) # Wait before retrying - - async def _analyze_and_trade(self, symbol: str) -> None: - """Analyze market and execute trades""" - try: - # Perform market analysis - analysis_task = { - "type": "market_analysis", - "symbol": symbol, - "strategy": self.trading_strategy - } - - analysis_result = await self.bridge.execute_agent_task(self.agent_id, analysis_task) - - if analysis_result.get("status") == "success": - analysis = analysis_result["result"]["analysis"] - - # Make trading decision - if self._should_trade(analysis): - await self._execute_trade(symbol, analysis) - else: - print(f"Market analysis failed for {symbol}: {analysis_result}") - - except Exception as e: - print(f"Error in analyze_and_trade for {symbol}: {e}") - - def _should_trade(self, analysis: Dict[str, Any]) -> bool: - """Determine if should execute trade""" - recommendation = analysis.get("recommendation", "hold") - return recommendation in ["buy", "sell"] - - async def _execute_trade(self, symbol: str, analysis: Dict[str, Any]) -> None: - """Execute trade based on analysis""" - try: - recommendation = analysis.get("recommendation", "hold") - - if recommendation == "buy": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "buy", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - elif recommendation == "sell": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "sell", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - else: - return - - trade_result = await self.bridge.execute_agent_task(self.agent_id, trade_task) - - if trade_result.get("status") == "success": - print(f"Trade executed successfully: {trade_result}") - else: - print(f"Trade execution failed: {trade_result}") - - except Exception as e: - print(f"Error executing trade: {e}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - return await self.bridge.get_agent_status(self.agent_id) - -# Main execution -async def main(): - """Main trading agent execution""" - agent_id = "trading-agent-001" - config = { - "strategy": "basic", - "symbols": ["AITBC/BTC"], - "trade_interval": 30, - "trade_amount": 0.1 - } - - agent = TradingAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run trading loop - await agent.run_trading_loop() - except KeyboardInterrupt: - print("Shutting down trading agent...") - finally: - await agent.stop() - else: - print("Failed to start trading agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_120842/agent-bridge/src/integration_layer.py b/apps/agent-services_backup_20260402_120842/agent-bridge/src/integration_layer.py deleted file mode 100644 index f1be04db..00000000 --- a/apps/agent-services_backup_20260402_120842/agent-bridge/src/integration_layer.py +++ /dev/null @@ -1,229 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Integration Layer -Connects agent protocols to existing AITBC services -""" - -import asyncio -import aiohttp -import json -from typing import Dict, Any, List, Optional -from datetime import datetime - -class AITBCServiceIntegration: - """Integration layer for AITBC services""" - - def __init__(self): - self.service_endpoints = { - "coordinator_api": "http://localhost:8000", - "blockchain_rpc": "http://localhost:8006", - "exchange_service": "http://localhost:8001", - "marketplace": "http://localhost:8002", - "agent_registry": "http://localhost:8013" - } - self.session = None - - async def __aenter__(self): - self.session = aiohttp.ClientSession() - return self - - async def __aexit__(self, exc_type, exc_val, exc_tb): - if self.session: - await self.session.close() - - async def get_blockchain_info(self) -> Dict[str, Any]: - """Get blockchain information""" - try: - async with self.session.get(f"{self.service_endpoints['blockchain_rpc']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_exchange_status(self) -> Dict[str, Any]: - """Get exchange service status""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_coordinator_status(self) -> Dict[str, Any]: - """Get coordinator API status""" - try: - async with self.session.get(f"{self.service_endpoints['coordinator_api']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def submit_transaction(self, transaction_data: Dict[str, Any]) -> Dict[str, Any]: - """Submit transaction to blockchain""" - try: - async with self.session.post( - f"{self.service_endpoints['blockchain_rpc']}/rpc/submit", - json=transaction_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def get_market_data(self, symbol: str = "AITBC/BTC") -> Dict[str, Any]: - """Get market data from exchange""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/market/{symbol}") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def register_agent_with_coordinator(self, agent_data: Dict[str, Any]) -> Dict[str, Any]: - """Register agent with coordinator""" - try: - async with self.session.post( - f"{self.service_endpoints['agent_registry']}/api/agents/register", - json=agent_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - -class AgentServiceBridge: - """Bridge between agents and AITBC services""" - - def __init__(self): - self.integration = AITBCServiceIntegration() - self.active_agents = {} - - async def start_agent(self, agent_id: str, agent_config: Dict[str, Any]) -> bool: - """Start an agent with service integration""" - try: - # Register agent with coordinator - async with self.integration as integration: - registration_result = await integration.register_agent_with_coordinator({ - "name": agent_id, - "type": agent_config.get("type", "generic"), - "capabilities": agent_config.get("capabilities", []), - "chain_id": agent_config.get("chain_id", "ait-mainnet"), - "endpoint": agent_config.get("endpoint", f"http://localhost:{8000 + len(self.active_agents) + 10}") - }) - - # The registry returns the created agent dict on success, not a {"status": "ok"} wrapper - if registration_result and "id" in registration_result: - self.active_agents[agent_id] = { - "config": agent_config, - "registration": registration_result, - "started_at": datetime.utcnow() - } - return True - else: - print(f"Registration failed: {registration_result}") - return False - except Exception as e: - print(f"Failed to start agent {agent_id}: {e}") - return False - - async def stop_agent(self, agent_id: str) -> bool: - """Stop an agent""" - if agent_id in self.active_agents: - del self.active_agents[agent_id] - return True - return False - - async def get_agent_status(self, agent_id: str) -> Dict[str, Any]: - """Get agent status with service integration""" - if agent_id not in self.active_agents: - return {"status": "not_found"} - - agent_info = self.active_agents[agent_id] - - async with self.integration as integration: - # Get service statuses - blockchain_status = await integration.get_blockchain_info() - exchange_status = await integration.get_exchange_status() - coordinator_status = await integration.get_coordinator_status() - - return { - "agent_id": agent_id, - "status": "active", - "started_at": agent_info["started_at"].isoformat(), - "services": { - "blockchain": blockchain_status, - "exchange": exchange_status, - "coordinator": coordinator_status - } - } - - async def execute_agent_task(self, agent_id: str, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute agent task with service integration""" - if agent_id not in self.active_agents: - return {"status": "error", "message": "Agent not found"} - - task_type = task_data.get("type") - - if task_type == "market_analysis": - return await self._execute_market_analysis(task_data) - elif task_type == "trading": - return await self._execute_trading_task(task_data) - elif task_type == "compliance_check": - return await self._execute_compliance_check(task_data) - else: - return {"status": "error", "message": f"Unknown task type: {task_type}"} - - async def _execute_market_analysis(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute market analysis task""" - try: - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Perform basic analysis - analysis_result = { - "symbol": task_data.get("symbol", "AITBC/BTC"), - "market_data": market_data, - "analysis": { - "trend": "neutral", - "volatility": "medium", - "recommendation": "hold" - }, - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": analysis_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_trading_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute trading task""" - try: - # Get market data first - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Create transaction - transaction = { - "type": "trade", - "symbol": task_data.get("symbol", "AITBC/BTC"), - "side": task_data.get("side", "buy"), - "amount": task_data.get("amount", 0.1), - "price": task_data.get("price", market_data.get("price", 0.001)) - } - - # Submit transaction - tx_result = await integration.submit_transaction(transaction) - - return {"status": "success", "transaction": tx_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_compliance_check(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute compliance check task""" - try: - # Basic compliance check - compliance_result = { - "user_id": task_data.get("user_id"), - "check_type": task_data.get("check_type", "basic"), - "status": "passed", - "checks_performed": ["kyc", "aml", "sanctions"], - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": compliance_result} - except Exception as e: - return {"status": "error", "message": str(e)} diff --git a/apps/agent-services_backup_20260402_120842/agent-compliance/src/compliance_agent.py b/apps/agent-services_backup_20260402_120842/agent-compliance/src/compliance_agent.py deleted file mode 100644 index a04ad5bd..00000000 --- a/apps/agent-services_backup_20260402_120842/agent-compliance/src/compliance_agent.py +++ /dev/null @@ -1,149 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Compliance Agent -Automated compliance and regulatory monitoring agent -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class ComplianceAgent: - """Automated compliance agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.check_interval = config.get("check_interval", 300) # 5 minutes - self.monitored_entities = config.get("monitored_entities", []) - - async def start(self) -> bool: - """Start compliance agent""" - try: - success = await self.bridge.start_agent(self.agent_id, { - "type": "compliance", - "capabilities": ["kyc_check", "aml_screening", "regulatory_reporting"], - "endpoint": f"http://localhost:8006" - }) - - if success: - self.is_running = True - print(f"Compliance agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start compliance agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting compliance agent: {e}") - return False - - async def stop(self) -> bool: - """Stop compliance agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Compliance agent {self.agent_id} stopped successfully") - return success - - async def run_compliance_loop(self): - """Main compliance monitoring loop""" - while self.is_running: - try: - for entity in self.monitored_entities: - await self._perform_compliance_check(entity) - - await asyncio.sleep(self.check_interval) - except Exception as e: - print(f"Error in compliance loop: {e}") - await asyncio.sleep(30) # Wait before retrying - - async def _perform_compliance_check(self, entity_id: str) -> None: - """Perform compliance check for entity""" - try: - compliance_task = { - "type": "compliance_check", - "user_id": entity_id, - "check_type": "full", - "monitored_activities": ["trading", "transfers", "wallet_creation"] - } - - result = await self.bridge.execute_agent_task(self.agent_id, compliance_task) - - if result.get("status") == "success": - compliance_result = result["result"] - await self._handle_compliance_result(entity_id, compliance_result) - else: - print(f"Compliance check failed for {entity_id}: {result}") - - except Exception as e: - print(f"Error performing compliance check for {entity_id}: {e}") - - async def _handle_compliance_result(self, entity_id: str, result: Dict[str, Any]) -> None: - """Handle compliance check result""" - status = result.get("status", "unknown") - - if status == "passed": - print(f"✅ Compliance check passed for {entity_id}") - elif status == "failed": - print(f"❌ Compliance check failed for {entity_id}") - # Trigger alert or further investigation - await self._trigger_compliance_alert(entity_id, result) - else: - print(f"⚠️ Compliance check inconclusive for {entity_id}") - - async def _trigger_compliance_alert(self, entity_id: str, result: Dict[str, Any]) -> None: - """Trigger compliance alert""" - alert_data = { - "entity_id": entity_id, - "alert_type": "compliance_failure", - "severity": "high", - "details": result, - "timestamp": datetime.utcnow().isoformat() - } - - # In a real implementation, this would send to alert system - print(f"🚨 COMPLIANCE ALERT: {json.dumps(alert_data, indent=2)}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - status = await self.bridge.get_agent_status(self.agent_id) - status["monitored_entities"] = len(self.monitored_entities) - status["check_interval"] = self.check_interval - return status - -# Main execution -async def main(): - """Main compliance agent execution""" - agent_id = "compliance-agent-001" - config = { - "check_interval": 60, # 1 minute for testing - "monitored_entities": ["user001", "user002", "user003"] - } - - agent = ComplianceAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run compliance loop - await agent.run_compliance_loop() - except KeyboardInterrupt: - print("Shutting down compliance agent...") - finally: - await agent.stop() - else: - print("Failed to start compliance agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_120842/agent-coordinator/src/coordinator.py b/apps/agent-services_backup_20260402_120842/agent-coordinator/src/coordinator.py deleted file mode 100644 index ce39c3cc..00000000 --- a/apps/agent-services_backup_20260402_120842/agent-coordinator/src/coordinator.py +++ /dev/null @@ -1,132 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Coordinator Service -Agent task coordination and management -""" - -from fastapi import FastAPI, HTTPException -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import uuid -from datetime import datetime -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Coordinator API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_coordinator.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS tasks ( - id TEXT PRIMARY KEY, - task_type TEXT NOT NULL, - payload TEXT NOT NULL, - required_capabilities TEXT NOT NULL, - priority TEXT NOT NULL, - status TEXT NOT NULL, - assigned_agent_id TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - result TEXT - ) - ''') - -# Models -class Task(BaseModel): - id: str - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str - status: str - assigned_agent_id: Optional[str] = None - -class TaskCreation(BaseModel): - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str = "normal" - -# API Endpoints - -@app.post("/api/tasks", response_model=Task) -async def create_task(task: TaskCreation): - """Create a new task""" - task_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO tasks (id, task_type, payload, required_capabilities, priority, status) - VALUES (?, ?, ?, ?, ?, ?) - ''', ( - task_id, task.task_type, json.dumps(task.payload), - json.dumps(task.required_capabilities), task.priority, "pending" - )) - - return Task( - id=task_id, - task_type=task.task_type, - payload=task.payload, - required_capabilities=task.required_capabilities, - priority=task.priority, - status="pending" - ) - -@app.get("/api/tasks", response_model=List[Task]) -async def list_tasks(status: Optional[str] = None): - """List tasks with optional status filter""" - with get_db_connection() as conn: - query = "SELECT * FROM tasks" - params = [] - - if status: - query += " WHERE status = ?" - params.append(status) - - tasks = conn.execute(query, params).fetchall() - - return [ - Task( - id=task["id"], - task_type=task["task_type"], - payload=json.loads(task["payload"]), - required_capabilities=json.loads(task["required_capabilities"]), - priority=task["priority"], - status=task["status"], - assigned_agent_id=task["assigned_agent_id"] - ) - for task in tasks - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8012) diff --git a/apps/agent-services_backup_20260402_120842/agent-protocols/.env.example b/apps/agent-services_backup_20260402_120842/agent-protocols/.env.example deleted file mode 100644 index bf8ed394..00000000 --- a/apps/agent-services_backup_20260402_120842/agent-protocols/.env.example +++ /dev/null @@ -1,19 +0,0 @@ -# AITBC Agent Protocols Environment Configuration -# Copy this file to .env and update with your secure values - -# Agent Protocol Encryption Key (generate a strong, unique key) -AITBC_AGENT_PROTOCOL_KEY=your-secure-encryption-key-here - -# Agent Protocol Salt (generate a unique salt value) -AITBC_AGENT_PROTOCOL_SALT=your-unique-salt-value-here - -# Agent Registry Configuration -AGENT_REGISTRY_HOST=0.0.0.0 -AGENT_REGISTRY_PORT=8003 - -# Database Configuration -AGENT_REGISTRY_DB_PATH=agent_registry.db - -# Security Settings -AGENT_PROTOCOL_TIMEOUT=300 -AGENT_PROTOCOL_MAX_RETRIES=3 diff --git a/apps/agent-services_backup_20260402_120842/agent-protocols/src/__init__.py b/apps/agent-services_backup_20260402_120842/agent-protocols/src/__init__.py deleted file mode 100644 index 9dfeaacd..00000000 --- a/apps/agent-services_backup_20260402_120842/agent-protocols/src/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -""" -Agent Protocols Package -""" - -from .message_protocol import MessageProtocol, MessageTypes, AgentMessageClient -from .task_manager import TaskManager, TaskStatus, TaskPriority, Task - -__all__ = [ - "MessageProtocol", - "MessageTypes", - "AgentMessageClient", - "TaskManager", - "TaskStatus", - "TaskPriority", - "Task" -] diff --git a/apps/agent-services_backup_20260402_120842/agent-protocols/src/message_protocol.py b/apps/agent-services_backup_20260402_120842/agent-protocols/src/message_protocol.py deleted file mode 100644 index 48289d6b..00000000 --- a/apps/agent-services_backup_20260402_120842/agent-protocols/src/message_protocol.py +++ /dev/null @@ -1,113 +0,0 @@ -""" -Message Protocol for AITBC Agents -Handles message creation, routing, and delivery between agents -""" - -import json -import uuid -from datetime import datetime -from typing import Dict, Any, Optional, List -from enum import Enum - -class MessageTypes(Enum): - """Message type enumeration""" - TASK_REQUEST = "task_request" - TASK_RESPONSE = "task_response" - HEARTBEAT = "heartbeat" - STATUS_UPDATE = "status_update" - ERROR = "error" - DATA = "data" - -class MessageProtocol: - """Message protocol handler for agent communication""" - - def __init__(self): - self.messages = [] - self.message_handlers = {} - - def create_message( - self, - sender_id: str, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any], - message_id: Optional[str] = None - ) -> Dict[str, Any]: - """Create a new message""" - if message_id is None: - message_id = str(uuid.uuid4()) - - message = { - "message_id": message_id, - "sender_id": sender_id, - "receiver_id": receiver_id, - "message_type": message_type.value, - "content": content, - "timestamp": datetime.utcnow().isoformat(), - "status": "pending" - } - - self.messages.append(message) - return message - - def send_message(self, message: Dict[str, Any]) -> bool: - """Send a message to the receiver""" - try: - message["status"] = "sent" - message["sent_timestamp"] = datetime.utcnow().isoformat() - return True - except Exception: - message["status"] = "failed" - return False - - def receive_message(self, message_id: str) -> Optional[Dict[str, Any]]: - """Receive and process a message""" - for message in self.messages: - if message["message_id"] == message_id: - message["status"] = "received" - message["received_timestamp"] = datetime.utcnow().isoformat() - return message - return None - - def get_messages_by_agent(self, agent_id: str) -> List[Dict[str, Any]]: - """Get all messages for a specific agent""" - return [ - msg for msg in self.messages - if msg["sender_id"] == agent_id or msg["receiver_id"] == agent_id - ] - -class AgentMessageClient: - """Client for agent message communication""" - - def __init__(self, agent_id: str, protocol: MessageProtocol): - self.agent_id = agent_id - self.protocol = protocol - self.received_messages = [] - - def send_message( - self, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any] - ) -> Dict[str, Any]: - """Send a message to another agent""" - message = self.protocol.create_message( - sender_id=self.agent_id, - receiver_id=receiver_id, - message_type=message_type, - content=content - ) - self.protocol.send_message(message) - return message - - def receive_messages(self) -> List[Dict[str, Any]]: - """Receive all pending messages for this agent""" - messages = [] - for message in self.protocol.messages: - if (message["receiver_id"] == self.agent_id and - message["status"] == "sent" and - message not in self.received_messages): - self.protocol.receive_message(message["message_id"]) - self.received_messages.append(message) - messages.append(message) - return messages diff --git a/apps/agent-services_backup_20260402_120842/agent-protocols/src/task_manager.py b/apps/agent-services_backup_20260402_120842/agent-protocols/src/task_manager.py deleted file mode 100644 index af680c99..00000000 --- a/apps/agent-services_backup_20260402_120842/agent-protocols/src/task_manager.py +++ /dev/null @@ -1,128 +0,0 @@ -""" -Task Manager for AITBC Agents -Handles task creation, assignment, and tracking -""" - -import uuid -from datetime import datetime, timedelta -from typing import Dict, Any, Optional, List -from enum import Enum - -class TaskStatus(Enum): - """Task status enumeration""" - PENDING = "pending" - IN_PROGRESS = "in_progress" - COMPLETED = "completed" - FAILED = "failed" - CANCELLED = "cancelled" - -class TaskPriority(Enum): - """Task priority enumeration""" - LOW = "low" - MEDIUM = "medium" - HIGH = "high" - URGENT = "urgent" - -class Task: - """Task representation""" - - def __init__( - self, - task_id: str, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ): - self.task_id = task_id - self.title = title - self.description = description - self.assigned_to = assigned_to - self.priority = priority - self.created_by = created_by or assigned_to - self.status = TaskStatus.PENDING - self.created_at = datetime.utcnow() - self.updated_at = datetime.utcnow() - self.completed_at = None - self.result = None - self.error = None - -class TaskManager: - """Task manager for agent coordination""" - - def __init__(self): - self.tasks = {} - self.task_history = [] - - def create_task( - self, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ) -> Task: - """Create a new task""" - task_id = str(uuid.uuid4()) - task = Task( - task_id=task_id, - title=title, - description=description, - assigned_to=assigned_to, - priority=priority, - created_by=created_by - ) - - self.tasks[task_id] = task - return task - - def get_task(self, task_id: str) -> Optional[Task]: - """Get a task by ID""" - return self.tasks.get(task_id) - - def update_task_status( - self, - task_id: str, - status: TaskStatus, - result: Optional[Dict[str, Any]] = None, - error: Optional[str] = None - ) -> bool: - """Update task status""" - task = self.get_task(task_id) - if not task: - return False - - task.status = status - task.updated_at = datetime.utcnow() - - if status == TaskStatus.COMPLETED: - task.completed_at = datetime.utcnow() - task.result = result - elif status == TaskStatus.FAILED: - task.error = error - - return True - - def get_tasks_by_agent(self, agent_id: str) -> List[Task]: - """Get all tasks assigned to an agent""" - return [ - task for task in self.tasks.values() - if task.assigned_to == agent_id - ] - - def get_tasks_by_status(self, status: TaskStatus) -> List[Task]: - """Get all tasks with a specific status""" - return [ - task for task in self.tasks.values() - if task.status == status - ] - - def get_overdue_tasks(self, hours: int = 24) -> List[Task]: - """Get tasks that are overdue""" - cutoff_time = datetime.utcnow() - timedelta(hours=hours) - return [ - task for task in self.tasks.values() - if task.status in [TaskStatus.PENDING, TaskStatus.IN_PROGRESS] and - task.created_at < cutoff_time - ] diff --git a/apps/agent-services_backup_20260402_120842/agent-registry/src/app.py b/apps/agent-services_backup_20260402_120842/agent-registry/src/app.py deleted file mode 100644 index 70eb95f7..00000000 --- a/apps/agent-services_backup_20260402_120842/agent-registry/src/app.py +++ /dev/null @@ -1,151 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Registry Service -Central agent discovery and registration system -""" - -from fastapi import FastAPI, HTTPException, Depends -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import time -import uuid -from datetime import datetime, timedelta -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Registry API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_registry.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS agents ( - id TEXT PRIMARY KEY, - name TEXT NOT NULL, - type TEXT NOT NULL, - capabilities TEXT NOT NULL, - chain_id TEXT NOT NULL, - endpoint TEXT NOT NULL, - status TEXT DEFAULT 'active', - last_heartbeat TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - metadata TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP - ) - ''') - -# Models -class Agent(BaseModel): - id: str - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -class AgentRegistration(BaseModel): - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -# API Endpoints - -@app.post("/api/agents/register", response_model=Agent) -async def register_agent(agent: AgentRegistration): - """Register a new agent""" - agent_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO agents (id, name, type, capabilities, chain_id, endpoint, metadata) - VALUES (?, ?, ?, ?, ?, ?, ?) - ''', ( - agent_id, agent.name, agent.type, - json.dumps(agent.capabilities), agent.chain_id, - agent.endpoint, json.dumps(agent.metadata) - )) - conn.commit() - - return Agent( - id=agent_id, - name=agent.name, - type=agent.type, - capabilities=agent.capabilities, - chain_id=agent.chain_id, - endpoint=agent.endpoint, - metadata=agent.metadata - ) - -@app.get("/api/agents", response_model=List[Agent]) -async def list_agents( - agent_type: Optional[str] = None, - chain_id: Optional[str] = None, - capability: Optional[str] = None -): - """List registered agents with optional filters""" - with get_db_connection() as conn: - query = "SELECT * FROM agents WHERE status = 'active'" - params = [] - - if agent_type: - query += " AND type = ?" - params.append(agent_type) - - if chain_id: - query += " AND chain_id = ?" - params.append(chain_id) - - if capability: - query += " AND capabilities LIKE ?" - params.append(f'%{capability}%') - - agents = conn.execute(query, params).fetchall() - - return [ - Agent( - id=agent["id"], - name=agent["name"], - type=agent["type"], - capabilities=json.loads(agent["capabilities"]), - chain_id=agent["chain_id"], - endpoint=agent["endpoint"], - metadata=json.loads(agent["metadata"] or "{}") - ) - for agent in agents - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8013) diff --git a/apps/agent-services_backup_20260402_120842/agent-registry/src/registration.py b/apps/agent-services_backup_20260402_120842/agent-registry/src/registration.py deleted file mode 100644 index 3793139d..00000000 --- a/apps/agent-services_backup_20260402_120842/agent-registry/src/registration.py +++ /dev/null @@ -1,431 +0,0 @@ -""" -Agent Registration System -Handles AI agent registration, capability management, and discovery -""" - -import asyncio -import time -import json -import hashlib -from typing import Dict, List, Optional, Set, Tuple -from dataclasses import dataclass, asdict -from enum import Enum -from decimal import Decimal - -class AgentType(Enum): - AI_MODEL = "ai_model" - DATA_PROVIDER = "data_provider" - VALIDATOR = "validator" - MARKET_MAKER = "market_maker" - BROKER = "broker" - ORACLE = "oracle" - -class AgentStatus(Enum): - REGISTERED = "registered" - ACTIVE = "active" - INACTIVE = "inactive" - SUSPENDED = "suspended" - BANNED = "banned" - -class CapabilityType(Enum): - TEXT_GENERATION = "text_generation" - IMAGE_GENERATION = "image_generation" - DATA_ANALYSIS = "data_analysis" - PREDICTION = "prediction" - VALIDATION = "validation" - COMPUTATION = "computation" - -@dataclass -class AgentCapability: - capability_type: CapabilityType - name: str - version: str - parameters: Dict - performance_metrics: Dict - cost_per_use: Decimal - availability: float - max_concurrent_jobs: int - -@dataclass -class AgentInfo: - agent_id: str - agent_type: AgentType - name: str - owner_address: str - public_key: str - endpoint_url: str - capabilities: List[AgentCapability] - reputation_score: float - total_jobs_completed: int - total_earnings: Decimal - registration_time: float - last_active: float - status: AgentStatus - metadata: Dict - -class AgentRegistry: - """Manages AI agent registration and discovery""" - - def __init__(self): - self.agents: Dict[str, AgentInfo] = {} - self.capability_index: Dict[CapabilityType, Set[str]] = {} # capability -> agent_ids - self.type_index: Dict[AgentType, Set[str]] = {} # agent_type -> agent_ids - self.reputation_scores: Dict[str, float] = {} - self.registration_queue: List[Dict] = [] - - # Registry parameters - self.min_reputation_threshold = 0.5 - self.max_agents_per_type = 1000 - self.registration_fee = Decimal('100.0') - self.inactivity_threshold = 86400 * 7 # 7 days - - # Initialize capability index - for capability_type in CapabilityType: - self.capability_index[capability_type] = set() - - # Initialize type index - for agent_type in AgentType: - self.type_index[agent_type] = set() - - async def register_agent(self, agent_type: AgentType, name: str, owner_address: str, - public_key: str, endpoint_url: str, capabilities: List[Dict], - metadata: Dict = None) -> Tuple[bool, str, Optional[str]]: - """Register a new AI agent""" - try: - # Validate inputs - if not self._validate_registration_inputs(agent_type, name, owner_address, public_key, endpoint_url): - return False, "Invalid registration inputs", None - - # Check if agent already exists - agent_id = self._generate_agent_id(owner_address, name) - if agent_id in self.agents: - return False, "Agent already registered", None - - # Check type limits - if len(self.type_index[agent_type]) >= self.max_agents_per_type: - return False, f"Maximum agents of type {agent_type.value} reached", None - - # Convert capabilities - agent_capabilities = [] - for cap_data in capabilities: - capability = self._create_capability_from_data(cap_data) - if capability: - agent_capabilities.append(capability) - - if not agent_capabilities: - return False, "Agent must have at least one valid capability", None - - # Create agent info - agent_info = AgentInfo( - agent_id=agent_id, - agent_type=agent_type, - name=name, - owner_address=owner_address, - public_key=public_key, - endpoint_url=endpoint_url, - capabilities=agent_capabilities, - reputation_score=1.0, # Start with neutral reputation - total_jobs_completed=0, - total_earnings=Decimal('0'), - registration_time=time.time(), - last_active=time.time(), - status=AgentStatus.REGISTERED, - metadata=metadata or {} - ) - - # Add to registry - self.agents[agent_id] = agent_info - - # Update indexes - self.type_index[agent_type].add(agent_id) - for capability in agent_capabilities: - self.capability_index[capability.capability_type].add(agent_id) - - log_info(f"Agent registered: {agent_id} ({name})") - return True, "Registration successful", agent_id - - except Exception as e: - return False, f"Registration failed: {str(e)}", None - - def _validate_registration_inputs(self, agent_type: AgentType, name: str, - owner_address: str, public_key: str, endpoint_url: str) -> bool: - """Validate registration inputs""" - # Check required fields - if not all([agent_type, name, owner_address, public_key, endpoint_url]): - return False - - # Validate address format (simplified) - if not owner_address.startswith('0x') or len(owner_address) != 42: - return False - - # Validate URL format (simplified) - if not endpoint_url.startswith(('http://', 'https://')): - return False - - # Validate name - if len(name) < 3 or len(name) > 100: - return False - - return True - - def _generate_agent_id(self, owner_address: str, name: str) -> str: - """Generate unique agent ID""" - content = f"{owner_address}:{name}:{time.time()}" - return hashlib.sha256(content.encode()).hexdigest()[:16] - - def _create_capability_from_data(self, cap_data: Dict) -> Optional[AgentCapability]: - """Create capability from data dictionary""" - try: - # Validate required fields - required_fields = ['type', 'name', 'version', 'cost_per_use'] - if not all(field in cap_data for field in required_fields): - return None - - # Parse capability type - try: - capability_type = CapabilityType(cap_data['type']) - except ValueError: - return None - - # Create capability - return AgentCapability( - capability_type=capability_type, - name=cap_data['name'], - version=cap_data['version'], - parameters=cap_data.get('parameters', {}), - performance_metrics=cap_data.get('performance_metrics', {}), - cost_per_use=Decimal(str(cap_data['cost_per_use'])), - availability=cap_data.get('availability', 1.0), - max_concurrent_jobs=cap_data.get('max_concurrent_jobs', 1) - ) - - except Exception as e: - log_error(f"Error creating capability: {e}") - return None - - async def update_agent_status(self, agent_id: str, status: AgentStatus) -> Tuple[bool, str]: - """Update agent status""" - if agent_id not in self.agents: - return False, "Agent not found" - - agent = self.agents[agent_id] - old_status = agent.status - agent.status = status - agent.last_active = time.time() - - log_info(f"Agent {agent_id} status changed: {old_status.value} -> {status.value}") - return True, "Status updated successfully" - - async def update_agent_capabilities(self, agent_id: str, capabilities: List[Dict]) -> Tuple[bool, str]: - """Update agent capabilities""" - if agent_id not in self.agents: - return False, "Agent not found" - - agent = self.agents[agent_id] - - # Remove old capabilities from index - for old_capability in agent.capabilities: - self.capability_index[old_capability.capability_type].discard(agent_id) - - # Add new capabilities - new_capabilities = [] - for cap_data in capabilities: - capability = self._create_capability_from_data(cap_data) - if capability: - new_capabilities.append(capability) - self.capability_index[capability.capability_type].add(agent_id) - - if not new_capabilities: - return False, "No valid capabilities provided" - - agent.capabilities = new_capabilities - agent.last_active = time.time() - - return True, "Capabilities updated successfully" - - async def find_agents_by_capability(self, capability_type: CapabilityType, - filters: Dict = None) -> List[AgentInfo]: - """Find agents by capability type""" - agent_ids = self.capability_index.get(capability_type, set()) - - agents = [] - for agent_id in agent_ids: - agent = self.agents.get(agent_id) - if agent and agent.status == AgentStatus.ACTIVE: - if self._matches_filters(agent, filters): - agents.append(agent) - - # Sort by reputation (highest first) - agents.sort(key=lambda x: x.reputation_score, reverse=True) - return agents - - async def find_agents_by_type(self, agent_type: AgentType, filters: Dict = None) -> List[AgentInfo]: - """Find agents by type""" - agent_ids = self.type_index.get(agent_type, set()) - - agents = [] - for agent_id in agent_ids: - agent = self.agents.get(agent_id) - if agent and agent.status == AgentStatus.ACTIVE: - if self._matches_filters(agent, filters): - agents.append(agent) - - # Sort by reputation (highest first) - agents.sort(key=lambda x: x.reputation_score, reverse=True) - return agents - - def _matches_filters(self, agent: AgentInfo, filters: Dict) -> bool: - """Check if agent matches filters""" - if not filters: - return True - - # Reputation filter - if 'min_reputation' in filters: - if agent.reputation_score < filters['min_reputation']: - return False - - # Cost filter - if 'max_cost_per_use' in filters: - max_cost = Decimal(str(filters['max_cost_per_use'])) - if any(cap.cost_per_use > max_cost for cap in agent.capabilities): - return False - - # Availability filter - if 'min_availability' in filters: - min_availability = filters['min_availability'] - if any(cap.availability < min_availability for cap in agent.capabilities): - return False - - # Location filter (if implemented) - if 'location' in filters: - agent_location = agent.metadata.get('location') - if agent_location != filters['location']: - return False - - return True - - async def get_agent_info(self, agent_id: str) -> Optional[AgentInfo]: - """Get agent information""" - return self.agents.get(agent_id) - - async def search_agents(self, query: str, limit: int = 50) -> List[AgentInfo]: - """Search agents by name or capability""" - query_lower = query.lower() - results = [] - - for agent in self.agents.values(): - if agent.status != AgentStatus.ACTIVE: - continue - - # Search in name - if query_lower in agent.name.lower(): - results.append(agent) - continue - - # Search in capabilities - for capability in agent.capabilities: - if (query_lower in capability.name.lower() or - query_lower in capability.capability_type.value): - results.append(agent) - break - - # Sort by relevance (reputation) - results.sort(key=lambda x: x.reputation_score, reverse=True) - return results[:limit] - - async def get_agent_statistics(self, agent_id: str) -> Optional[Dict]: - """Get detailed statistics for an agent""" - agent = self.agents.get(agent_id) - if not agent: - return None - - # Calculate additional statistics - avg_job_earnings = agent.total_earnings / agent.total_jobs_completed if agent.total_jobs_completed > 0 else Decimal('0') - days_active = (time.time() - agent.registration_time) / 86400 - jobs_per_day = agent.total_jobs_completed / days_active if days_active > 0 else 0 - - return { - 'agent_id': agent_id, - 'name': agent.name, - 'type': agent.agent_type.value, - 'status': agent.status.value, - 'reputation_score': agent.reputation_score, - 'total_jobs_completed': agent.total_jobs_completed, - 'total_earnings': float(agent.total_earnings), - 'avg_job_earnings': float(avg_job_earnings), - 'jobs_per_day': jobs_per_day, - 'days_active': int(days_active), - 'capabilities_count': len(agent.capabilities), - 'last_active': agent.last_active, - 'registration_time': agent.registration_time - } - - async def get_registry_statistics(self) -> Dict: - """Get registry-wide statistics""" - total_agents = len(self.agents) - active_agents = len([a for a in self.agents.values() if a.status == AgentStatus.ACTIVE]) - - # Count by type - type_counts = {} - for agent_type in AgentType: - type_counts[agent_type.value] = len(self.type_index[agent_type]) - - # Count by capability - capability_counts = {} - for capability_type in CapabilityType: - capability_counts[capability_type.value] = len(self.capability_index[capability_type]) - - # Reputation statistics - reputations = [a.reputation_score for a in self.agents.values()] - avg_reputation = sum(reputations) / len(reputations) if reputations else 0 - - # Earnings statistics - total_earnings = sum(a.total_earnings for a in self.agents.values()) - - return { - 'total_agents': total_agents, - 'active_agents': active_agents, - 'inactive_agents': total_agents - active_agents, - 'agent_types': type_counts, - 'capabilities': capability_counts, - 'average_reputation': avg_reputation, - 'total_earnings': float(total_earnings), - 'registration_fee': float(self.registration_fee) - } - - async def cleanup_inactive_agents(self) -> Tuple[int, str]: - """Clean up inactive agents""" - current_time = time.time() - cleaned_count = 0 - - for agent_id, agent in list(self.agents.items()): - if (agent.status == AgentStatus.INACTIVE and - current_time - agent.last_active > self.inactivity_threshold): - - # Remove from registry - del self.agents[agent_id] - - # Update indexes - self.type_index[agent.agent_type].discard(agent_id) - for capability in agent.capabilities: - self.capability_index[capability.capability_type].discard(agent_id) - - cleaned_count += 1 - - if cleaned_count > 0: - log_info(f"Cleaned up {cleaned_count} inactive agents") - - return cleaned_count, f"Cleaned up {cleaned_count} inactive agents" - -# Global agent registry -agent_registry: Optional[AgentRegistry] = None - -def get_agent_registry() -> Optional[AgentRegistry]: - """Get global agent registry""" - return agent_registry - -def create_agent_registry() -> AgentRegistry: - """Create and set global agent registry""" - global agent_registry - agent_registry = AgentRegistry() - return agent_registry diff --git a/apps/agent-services_backup_20260402_120842/agent-trading/src/trading_agent.py b/apps/agent-services_backup_20260402_120842/agent-trading/src/trading_agent.py deleted file mode 100644 index 181d963b..00000000 --- a/apps/agent-services_backup_20260402_120842/agent-trading/src/trading_agent.py +++ /dev/null @@ -1,166 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Trading Agent -Automated trading agent for AITBC marketplace -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class TradingAgent: - """Automated trading agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.trading_strategy = config.get("strategy", "basic") - self.symbols = config.get("symbols", ["AITBC/BTC"]) - self.trade_interval = config.get("trade_interval", 60) # seconds - - async def start(self) -> bool: - """Start trading agent""" - try: - # Register with service bridge - success = await self.bridge.start_agent(self.agent_id, { - "type": "trading", - "capabilities": ["market_analysis", "trading", "risk_management"], - "endpoint": f"http://localhost:8005" - }) - - if success: - self.is_running = True - print(f"Trading agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start trading agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting trading agent: {e}") - return False - - async def stop(self) -> bool: - """Stop trading agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Trading agent {self.agent_id} stopped successfully") - return success - - async def run_trading_loop(self): - """Main trading loop""" - while self.is_running: - try: - for symbol in self.symbols: - await self._analyze_and_trade(symbol) - - await asyncio.sleep(self.trade_interval) - except Exception as e: - print(f"Error in trading loop: {e}") - await asyncio.sleep(10) # Wait before retrying - - async def _analyze_and_trade(self, symbol: str) -> None: - """Analyze market and execute trades""" - try: - # Perform market analysis - analysis_task = { - "type": "market_analysis", - "symbol": symbol, - "strategy": self.trading_strategy - } - - analysis_result = await self.bridge.execute_agent_task(self.agent_id, analysis_task) - - if analysis_result.get("status") == "success": - analysis = analysis_result["result"]["analysis"] - - # Make trading decision - if self._should_trade(analysis): - await self._execute_trade(symbol, analysis) - else: - print(f"Market analysis failed for {symbol}: {analysis_result}") - - except Exception as e: - print(f"Error in analyze_and_trade for {symbol}: {e}") - - def _should_trade(self, analysis: Dict[str, Any]) -> bool: - """Determine if should execute trade""" - recommendation = analysis.get("recommendation", "hold") - return recommendation in ["buy", "sell"] - - async def _execute_trade(self, symbol: str, analysis: Dict[str, Any]) -> None: - """Execute trade based on analysis""" - try: - recommendation = analysis.get("recommendation", "hold") - - if recommendation == "buy": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "buy", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - elif recommendation == "sell": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "sell", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - else: - return - - trade_result = await self.bridge.execute_agent_task(self.agent_id, trade_task) - - if trade_result.get("status") == "success": - print(f"Trade executed successfully: {trade_result}") - else: - print(f"Trade execution failed: {trade_result}") - - except Exception as e: - print(f"Error executing trade: {e}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - return await self.bridge.get_agent_status(self.agent_id) - -# Main execution -async def main(): - """Main trading agent execution""" - agent_id = "trading-agent-001" - config = { - "strategy": "basic", - "symbols": ["AITBC/BTC"], - "trade_interval": 30, - "trade_amount": 0.1 - } - - agent = TradingAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run trading loop - await agent.run_trading_loop() - except KeyboardInterrupt: - print("Shutting down trading agent...") - finally: - await agent.stop() - else: - print("Failed to start trading agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_120924/agent-bridge/src/integration_layer.py b/apps/agent-services_backup_20260402_120924/agent-bridge/src/integration_layer.py deleted file mode 100644 index f1be04db..00000000 --- a/apps/agent-services_backup_20260402_120924/agent-bridge/src/integration_layer.py +++ /dev/null @@ -1,229 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Integration Layer -Connects agent protocols to existing AITBC services -""" - -import asyncio -import aiohttp -import json -from typing import Dict, Any, List, Optional -from datetime import datetime - -class AITBCServiceIntegration: - """Integration layer for AITBC services""" - - def __init__(self): - self.service_endpoints = { - "coordinator_api": "http://localhost:8000", - "blockchain_rpc": "http://localhost:8006", - "exchange_service": "http://localhost:8001", - "marketplace": "http://localhost:8002", - "agent_registry": "http://localhost:8013" - } - self.session = None - - async def __aenter__(self): - self.session = aiohttp.ClientSession() - return self - - async def __aexit__(self, exc_type, exc_val, exc_tb): - if self.session: - await self.session.close() - - async def get_blockchain_info(self) -> Dict[str, Any]: - """Get blockchain information""" - try: - async with self.session.get(f"{self.service_endpoints['blockchain_rpc']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_exchange_status(self) -> Dict[str, Any]: - """Get exchange service status""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_coordinator_status(self) -> Dict[str, Any]: - """Get coordinator API status""" - try: - async with self.session.get(f"{self.service_endpoints['coordinator_api']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def submit_transaction(self, transaction_data: Dict[str, Any]) -> Dict[str, Any]: - """Submit transaction to blockchain""" - try: - async with self.session.post( - f"{self.service_endpoints['blockchain_rpc']}/rpc/submit", - json=transaction_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def get_market_data(self, symbol: str = "AITBC/BTC") -> Dict[str, Any]: - """Get market data from exchange""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/market/{symbol}") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def register_agent_with_coordinator(self, agent_data: Dict[str, Any]) -> Dict[str, Any]: - """Register agent with coordinator""" - try: - async with self.session.post( - f"{self.service_endpoints['agent_registry']}/api/agents/register", - json=agent_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - -class AgentServiceBridge: - """Bridge between agents and AITBC services""" - - def __init__(self): - self.integration = AITBCServiceIntegration() - self.active_agents = {} - - async def start_agent(self, agent_id: str, agent_config: Dict[str, Any]) -> bool: - """Start an agent with service integration""" - try: - # Register agent with coordinator - async with self.integration as integration: - registration_result = await integration.register_agent_with_coordinator({ - "name": agent_id, - "type": agent_config.get("type", "generic"), - "capabilities": agent_config.get("capabilities", []), - "chain_id": agent_config.get("chain_id", "ait-mainnet"), - "endpoint": agent_config.get("endpoint", f"http://localhost:{8000 + len(self.active_agents) + 10}") - }) - - # The registry returns the created agent dict on success, not a {"status": "ok"} wrapper - if registration_result and "id" in registration_result: - self.active_agents[agent_id] = { - "config": agent_config, - "registration": registration_result, - "started_at": datetime.utcnow() - } - return True - else: - print(f"Registration failed: {registration_result}") - return False - except Exception as e: - print(f"Failed to start agent {agent_id}: {e}") - return False - - async def stop_agent(self, agent_id: str) -> bool: - """Stop an agent""" - if agent_id in self.active_agents: - del self.active_agents[agent_id] - return True - return False - - async def get_agent_status(self, agent_id: str) -> Dict[str, Any]: - """Get agent status with service integration""" - if agent_id not in self.active_agents: - return {"status": "not_found"} - - agent_info = self.active_agents[agent_id] - - async with self.integration as integration: - # Get service statuses - blockchain_status = await integration.get_blockchain_info() - exchange_status = await integration.get_exchange_status() - coordinator_status = await integration.get_coordinator_status() - - return { - "agent_id": agent_id, - "status": "active", - "started_at": agent_info["started_at"].isoformat(), - "services": { - "blockchain": blockchain_status, - "exchange": exchange_status, - "coordinator": coordinator_status - } - } - - async def execute_agent_task(self, agent_id: str, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute agent task with service integration""" - if agent_id not in self.active_agents: - return {"status": "error", "message": "Agent not found"} - - task_type = task_data.get("type") - - if task_type == "market_analysis": - return await self._execute_market_analysis(task_data) - elif task_type == "trading": - return await self._execute_trading_task(task_data) - elif task_type == "compliance_check": - return await self._execute_compliance_check(task_data) - else: - return {"status": "error", "message": f"Unknown task type: {task_type}"} - - async def _execute_market_analysis(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute market analysis task""" - try: - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Perform basic analysis - analysis_result = { - "symbol": task_data.get("symbol", "AITBC/BTC"), - "market_data": market_data, - "analysis": { - "trend": "neutral", - "volatility": "medium", - "recommendation": "hold" - }, - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": analysis_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_trading_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute trading task""" - try: - # Get market data first - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Create transaction - transaction = { - "type": "trade", - "symbol": task_data.get("symbol", "AITBC/BTC"), - "side": task_data.get("side", "buy"), - "amount": task_data.get("amount", 0.1), - "price": task_data.get("price", market_data.get("price", 0.001)) - } - - # Submit transaction - tx_result = await integration.submit_transaction(transaction) - - return {"status": "success", "transaction": tx_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_compliance_check(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute compliance check task""" - try: - # Basic compliance check - compliance_result = { - "user_id": task_data.get("user_id"), - "check_type": task_data.get("check_type", "basic"), - "status": "passed", - "checks_performed": ["kyc", "aml", "sanctions"], - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": compliance_result} - except Exception as e: - return {"status": "error", "message": str(e)} diff --git a/apps/agent-services_backup_20260402_120924/agent-compliance/src/compliance_agent.py b/apps/agent-services_backup_20260402_120924/agent-compliance/src/compliance_agent.py deleted file mode 100644 index a04ad5bd..00000000 --- a/apps/agent-services_backup_20260402_120924/agent-compliance/src/compliance_agent.py +++ /dev/null @@ -1,149 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Compliance Agent -Automated compliance and regulatory monitoring agent -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class ComplianceAgent: - """Automated compliance agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.check_interval = config.get("check_interval", 300) # 5 minutes - self.monitored_entities = config.get("monitored_entities", []) - - async def start(self) -> bool: - """Start compliance agent""" - try: - success = await self.bridge.start_agent(self.agent_id, { - "type": "compliance", - "capabilities": ["kyc_check", "aml_screening", "regulatory_reporting"], - "endpoint": f"http://localhost:8006" - }) - - if success: - self.is_running = True - print(f"Compliance agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start compliance agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting compliance agent: {e}") - return False - - async def stop(self) -> bool: - """Stop compliance agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Compliance agent {self.agent_id} stopped successfully") - return success - - async def run_compliance_loop(self): - """Main compliance monitoring loop""" - while self.is_running: - try: - for entity in self.monitored_entities: - await self._perform_compliance_check(entity) - - await asyncio.sleep(self.check_interval) - except Exception as e: - print(f"Error in compliance loop: {e}") - await asyncio.sleep(30) # Wait before retrying - - async def _perform_compliance_check(self, entity_id: str) -> None: - """Perform compliance check for entity""" - try: - compliance_task = { - "type": "compliance_check", - "user_id": entity_id, - "check_type": "full", - "monitored_activities": ["trading", "transfers", "wallet_creation"] - } - - result = await self.bridge.execute_agent_task(self.agent_id, compliance_task) - - if result.get("status") == "success": - compliance_result = result["result"] - await self._handle_compliance_result(entity_id, compliance_result) - else: - print(f"Compliance check failed for {entity_id}: {result}") - - except Exception as e: - print(f"Error performing compliance check for {entity_id}: {e}") - - async def _handle_compliance_result(self, entity_id: str, result: Dict[str, Any]) -> None: - """Handle compliance check result""" - status = result.get("status", "unknown") - - if status == "passed": - print(f"✅ Compliance check passed for {entity_id}") - elif status == "failed": - print(f"❌ Compliance check failed for {entity_id}") - # Trigger alert or further investigation - await self._trigger_compliance_alert(entity_id, result) - else: - print(f"⚠️ Compliance check inconclusive for {entity_id}") - - async def _trigger_compliance_alert(self, entity_id: str, result: Dict[str, Any]) -> None: - """Trigger compliance alert""" - alert_data = { - "entity_id": entity_id, - "alert_type": "compliance_failure", - "severity": "high", - "details": result, - "timestamp": datetime.utcnow().isoformat() - } - - # In a real implementation, this would send to alert system - print(f"🚨 COMPLIANCE ALERT: {json.dumps(alert_data, indent=2)}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - status = await self.bridge.get_agent_status(self.agent_id) - status["monitored_entities"] = len(self.monitored_entities) - status["check_interval"] = self.check_interval - return status - -# Main execution -async def main(): - """Main compliance agent execution""" - agent_id = "compliance-agent-001" - config = { - "check_interval": 60, # 1 minute for testing - "monitored_entities": ["user001", "user002", "user003"] - } - - agent = ComplianceAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run compliance loop - await agent.run_compliance_loop() - except KeyboardInterrupt: - print("Shutting down compliance agent...") - finally: - await agent.stop() - else: - print("Failed to start compliance agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_120924/agent-coordinator/src/coordinator.py b/apps/agent-services_backup_20260402_120924/agent-coordinator/src/coordinator.py deleted file mode 100644 index ce39c3cc..00000000 --- a/apps/agent-services_backup_20260402_120924/agent-coordinator/src/coordinator.py +++ /dev/null @@ -1,132 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Coordinator Service -Agent task coordination and management -""" - -from fastapi import FastAPI, HTTPException -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import uuid -from datetime import datetime -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Coordinator API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_coordinator.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS tasks ( - id TEXT PRIMARY KEY, - task_type TEXT NOT NULL, - payload TEXT NOT NULL, - required_capabilities TEXT NOT NULL, - priority TEXT NOT NULL, - status TEXT NOT NULL, - assigned_agent_id TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - result TEXT - ) - ''') - -# Models -class Task(BaseModel): - id: str - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str - status: str - assigned_agent_id: Optional[str] = None - -class TaskCreation(BaseModel): - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str = "normal" - -# API Endpoints - -@app.post("/api/tasks", response_model=Task) -async def create_task(task: TaskCreation): - """Create a new task""" - task_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO tasks (id, task_type, payload, required_capabilities, priority, status) - VALUES (?, ?, ?, ?, ?, ?) - ''', ( - task_id, task.task_type, json.dumps(task.payload), - json.dumps(task.required_capabilities), task.priority, "pending" - )) - - return Task( - id=task_id, - task_type=task.task_type, - payload=task.payload, - required_capabilities=task.required_capabilities, - priority=task.priority, - status="pending" - ) - -@app.get("/api/tasks", response_model=List[Task]) -async def list_tasks(status: Optional[str] = None): - """List tasks with optional status filter""" - with get_db_connection() as conn: - query = "SELECT * FROM tasks" - params = [] - - if status: - query += " WHERE status = ?" - params.append(status) - - tasks = conn.execute(query, params).fetchall() - - return [ - Task( - id=task["id"], - task_type=task["task_type"], - payload=json.loads(task["payload"]), - required_capabilities=json.loads(task["required_capabilities"]), - priority=task["priority"], - status=task["status"], - assigned_agent_id=task["assigned_agent_id"] - ) - for task in tasks - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8012) diff --git a/apps/agent-services_backup_20260402_120924/agent-protocols/.env.example b/apps/agent-services_backup_20260402_120924/agent-protocols/.env.example deleted file mode 100644 index bf8ed394..00000000 --- a/apps/agent-services_backup_20260402_120924/agent-protocols/.env.example +++ /dev/null @@ -1,19 +0,0 @@ -# AITBC Agent Protocols Environment Configuration -# Copy this file to .env and update with your secure values - -# Agent Protocol Encryption Key (generate a strong, unique key) -AITBC_AGENT_PROTOCOL_KEY=your-secure-encryption-key-here - -# Agent Protocol Salt (generate a unique salt value) -AITBC_AGENT_PROTOCOL_SALT=your-unique-salt-value-here - -# Agent Registry Configuration -AGENT_REGISTRY_HOST=0.0.0.0 -AGENT_REGISTRY_PORT=8003 - -# Database Configuration -AGENT_REGISTRY_DB_PATH=agent_registry.db - -# Security Settings -AGENT_PROTOCOL_TIMEOUT=300 -AGENT_PROTOCOL_MAX_RETRIES=3 diff --git a/apps/agent-services_backup_20260402_120924/agent-protocols/src/__init__.py b/apps/agent-services_backup_20260402_120924/agent-protocols/src/__init__.py deleted file mode 100644 index 9dfeaacd..00000000 --- a/apps/agent-services_backup_20260402_120924/agent-protocols/src/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -""" -Agent Protocols Package -""" - -from .message_protocol import MessageProtocol, MessageTypes, AgentMessageClient -from .task_manager import TaskManager, TaskStatus, TaskPriority, Task - -__all__ = [ - "MessageProtocol", - "MessageTypes", - "AgentMessageClient", - "TaskManager", - "TaskStatus", - "TaskPriority", - "Task" -] diff --git a/apps/agent-services_backup_20260402_120924/agent-protocols/src/message_protocol.py b/apps/agent-services_backup_20260402_120924/agent-protocols/src/message_protocol.py deleted file mode 100644 index 48289d6b..00000000 --- a/apps/agent-services_backup_20260402_120924/agent-protocols/src/message_protocol.py +++ /dev/null @@ -1,113 +0,0 @@ -""" -Message Protocol for AITBC Agents -Handles message creation, routing, and delivery between agents -""" - -import json -import uuid -from datetime import datetime -from typing import Dict, Any, Optional, List -from enum import Enum - -class MessageTypes(Enum): - """Message type enumeration""" - TASK_REQUEST = "task_request" - TASK_RESPONSE = "task_response" - HEARTBEAT = "heartbeat" - STATUS_UPDATE = "status_update" - ERROR = "error" - DATA = "data" - -class MessageProtocol: - """Message protocol handler for agent communication""" - - def __init__(self): - self.messages = [] - self.message_handlers = {} - - def create_message( - self, - sender_id: str, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any], - message_id: Optional[str] = None - ) -> Dict[str, Any]: - """Create a new message""" - if message_id is None: - message_id = str(uuid.uuid4()) - - message = { - "message_id": message_id, - "sender_id": sender_id, - "receiver_id": receiver_id, - "message_type": message_type.value, - "content": content, - "timestamp": datetime.utcnow().isoformat(), - "status": "pending" - } - - self.messages.append(message) - return message - - def send_message(self, message: Dict[str, Any]) -> bool: - """Send a message to the receiver""" - try: - message["status"] = "sent" - message["sent_timestamp"] = datetime.utcnow().isoformat() - return True - except Exception: - message["status"] = "failed" - return False - - def receive_message(self, message_id: str) -> Optional[Dict[str, Any]]: - """Receive and process a message""" - for message in self.messages: - if message["message_id"] == message_id: - message["status"] = "received" - message["received_timestamp"] = datetime.utcnow().isoformat() - return message - return None - - def get_messages_by_agent(self, agent_id: str) -> List[Dict[str, Any]]: - """Get all messages for a specific agent""" - return [ - msg for msg in self.messages - if msg["sender_id"] == agent_id or msg["receiver_id"] == agent_id - ] - -class AgentMessageClient: - """Client for agent message communication""" - - def __init__(self, agent_id: str, protocol: MessageProtocol): - self.agent_id = agent_id - self.protocol = protocol - self.received_messages = [] - - def send_message( - self, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any] - ) -> Dict[str, Any]: - """Send a message to another agent""" - message = self.protocol.create_message( - sender_id=self.agent_id, - receiver_id=receiver_id, - message_type=message_type, - content=content - ) - self.protocol.send_message(message) - return message - - def receive_messages(self) -> List[Dict[str, Any]]: - """Receive all pending messages for this agent""" - messages = [] - for message in self.protocol.messages: - if (message["receiver_id"] == self.agent_id and - message["status"] == "sent" and - message not in self.received_messages): - self.protocol.receive_message(message["message_id"]) - self.received_messages.append(message) - messages.append(message) - return messages diff --git a/apps/agent-services_backup_20260402_120924/agent-protocols/src/task_manager.py b/apps/agent-services_backup_20260402_120924/agent-protocols/src/task_manager.py deleted file mode 100644 index af680c99..00000000 --- a/apps/agent-services_backup_20260402_120924/agent-protocols/src/task_manager.py +++ /dev/null @@ -1,128 +0,0 @@ -""" -Task Manager for AITBC Agents -Handles task creation, assignment, and tracking -""" - -import uuid -from datetime import datetime, timedelta -from typing import Dict, Any, Optional, List -from enum import Enum - -class TaskStatus(Enum): - """Task status enumeration""" - PENDING = "pending" - IN_PROGRESS = "in_progress" - COMPLETED = "completed" - FAILED = "failed" - CANCELLED = "cancelled" - -class TaskPriority(Enum): - """Task priority enumeration""" - LOW = "low" - MEDIUM = "medium" - HIGH = "high" - URGENT = "urgent" - -class Task: - """Task representation""" - - def __init__( - self, - task_id: str, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ): - self.task_id = task_id - self.title = title - self.description = description - self.assigned_to = assigned_to - self.priority = priority - self.created_by = created_by or assigned_to - self.status = TaskStatus.PENDING - self.created_at = datetime.utcnow() - self.updated_at = datetime.utcnow() - self.completed_at = None - self.result = None - self.error = None - -class TaskManager: - """Task manager for agent coordination""" - - def __init__(self): - self.tasks = {} - self.task_history = [] - - def create_task( - self, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ) -> Task: - """Create a new task""" - task_id = str(uuid.uuid4()) - task = Task( - task_id=task_id, - title=title, - description=description, - assigned_to=assigned_to, - priority=priority, - created_by=created_by - ) - - self.tasks[task_id] = task - return task - - def get_task(self, task_id: str) -> Optional[Task]: - """Get a task by ID""" - return self.tasks.get(task_id) - - def update_task_status( - self, - task_id: str, - status: TaskStatus, - result: Optional[Dict[str, Any]] = None, - error: Optional[str] = None - ) -> bool: - """Update task status""" - task = self.get_task(task_id) - if not task: - return False - - task.status = status - task.updated_at = datetime.utcnow() - - if status == TaskStatus.COMPLETED: - task.completed_at = datetime.utcnow() - task.result = result - elif status == TaskStatus.FAILED: - task.error = error - - return True - - def get_tasks_by_agent(self, agent_id: str) -> List[Task]: - """Get all tasks assigned to an agent""" - return [ - task for task in self.tasks.values() - if task.assigned_to == agent_id - ] - - def get_tasks_by_status(self, status: TaskStatus) -> List[Task]: - """Get all tasks with a specific status""" - return [ - task for task in self.tasks.values() - if task.status == status - ] - - def get_overdue_tasks(self, hours: int = 24) -> List[Task]: - """Get tasks that are overdue""" - cutoff_time = datetime.utcnow() - timedelta(hours=hours) - return [ - task for task in self.tasks.values() - if task.status in [TaskStatus.PENDING, TaskStatus.IN_PROGRESS] and - task.created_at < cutoff_time - ] diff --git a/apps/agent-services_backup_20260402_120924/agent-registry/src/app.py b/apps/agent-services_backup_20260402_120924/agent-registry/src/app.py deleted file mode 100644 index 70eb95f7..00000000 --- a/apps/agent-services_backup_20260402_120924/agent-registry/src/app.py +++ /dev/null @@ -1,151 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Registry Service -Central agent discovery and registration system -""" - -from fastapi import FastAPI, HTTPException, Depends -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import time -import uuid -from datetime import datetime, timedelta -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Registry API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_registry.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS agents ( - id TEXT PRIMARY KEY, - name TEXT NOT NULL, - type TEXT NOT NULL, - capabilities TEXT NOT NULL, - chain_id TEXT NOT NULL, - endpoint TEXT NOT NULL, - status TEXT DEFAULT 'active', - last_heartbeat TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - metadata TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP - ) - ''') - -# Models -class Agent(BaseModel): - id: str - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -class AgentRegistration(BaseModel): - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -# API Endpoints - -@app.post("/api/agents/register", response_model=Agent) -async def register_agent(agent: AgentRegistration): - """Register a new agent""" - agent_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO agents (id, name, type, capabilities, chain_id, endpoint, metadata) - VALUES (?, ?, ?, ?, ?, ?, ?) - ''', ( - agent_id, agent.name, agent.type, - json.dumps(agent.capabilities), agent.chain_id, - agent.endpoint, json.dumps(agent.metadata) - )) - conn.commit() - - return Agent( - id=agent_id, - name=agent.name, - type=agent.type, - capabilities=agent.capabilities, - chain_id=agent.chain_id, - endpoint=agent.endpoint, - metadata=agent.metadata - ) - -@app.get("/api/agents", response_model=List[Agent]) -async def list_agents( - agent_type: Optional[str] = None, - chain_id: Optional[str] = None, - capability: Optional[str] = None -): - """List registered agents with optional filters""" - with get_db_connection() as conn: - query = "SELECT * FROM agents WHERE status = 'active'" - params = [] - - if agent_type: - query += " AND type = ?" - params.append(agent_type) - - if chain_id: - query += " AND chain_id = ?" - params.append(chain_id) - - if capability: - query += " AND capabilities LIKE ?" - params.append(f'%{capability}%') - - agents = conn.execute(query, params).fetchall() - - return [ - Agent( - id=agent["id"], - name=agent["name"], - type=agent["type"], - capabilities=json.loads(agent["capabilities"]), - chain_id=agent["chain_id"], - endpoint=agent["endpoint"], - metadata=json.loads(agent["metadata"] or "{}") - ) - for agent in agents - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8013) diff --git a/apps/agent-services_backup_20260402_120924/agent-registry/src/registration.py b/apps/agent-services_backup_20260402_120924/agent-registry/src/registration.py deleted file mode 100644 index 3793139d..00000000 --- a/apps/agent-services_backup_20260402_120924/agent-registry/src/registration.py +++ /dev/null @@ -1,431 +0,0 @@ -""" -Agent Registration System -Handles AI agent registration, capability management, and discovery -""" - -import asyncio -import time -import json -import hashlib -from typing import Dict, List, Optional, Set, Tuple -from dataclasses import dataclass, asdict -from enum import Enum -from decimal import Decimal - -class AgentType(Enum): - AI_MODEL = "ai_model" - DATA_PROVIDER = "data_provider" - VALIDATOR = "validator" - MARKET_MAKER = "market_maker" - BROKER = "broker" - ORACLE = "oracle" - -class AgentStatus(Enum): - REGISTERED = "registered" - ACTIVE = "active" - INACTIVE = "inactive" - SUSPENDED = "suspended" - BANNED = "banned" - -class CapabilityType(Enum): - TEXT_GENERATION = "text_generation" - IMAGE_GENERATION = "image_generation" - DATA_ANALYSIS = "data_analysis" - PREDICTION = "prediction" - VALIDATION = "validation" - COMPUTATION = "computation" - -@dataclass -class AgentCapability: - capability_type: CapabilityType - name: str - version: str - parameters: Dict - performance_metrics: Dict - cost_per_use: Decimal - availability: float - max_concurrent_jobs: int - -@dataclass -class AgentInfo: - agent_id: str - agent_type: AgentType - name: str - owner_address: str - public_key: str - endpoint_url: str - capabilities: List[AgentCapability] - reputation_score: float - total_jobs_completed: int - total_earnings: Decimal - registration_time: float - last_active: float - status: AgentStatus - metadata: Dict - -class AgentRegistry: - """Manages AI agent registration and discovery""" - - def __init__(self): - self.agents: Dict[str, AgentInfo] = {} - self.capability_index: Dict[CapabilityType, Set[str]] = {} # capability -> agent_ids - self.type_index: Dict[AgentType, Set[str]] = {} # agent_type -> agent_ids - self.reputation_scores: Dict[str, float] = {} - self.registration_queue: List[Dict] = [] - - # Registry parameters - self.min_reputation_threshold = 0.5 - self.max_agents_per_type = 1000 - self.registration_fee = Decimal('100.0') - self.inactivity_threshold = 86400 * 7 # 7 days - - # Initialize capability index - for capability_type in CapabilityType: - self.capability_index[capability_type] = set() - - # Initialize type index - for agent_type in AgentType: - self.type_index[agent_type] = set() - - async def register_agent(self, agent_type: AgentType, name: str, owner_address: str, - public_key: str, endpoint_url: str, capabilities: List[Dict], - metadata: Dict = None) -> Tuple[bool, str, Optional[str]]: - """Register a new AI agent""" - try: - # Validate inputs - if not self._validate_registration_inputs(agent_type, name, owner_address, public_key, endpoint_url): - return False, "Invalid registration inputs", None - - # Check if agent already exists - agent_id = self._generate_agent_id(owner_address, name) - if agent_id in self.agents: - return False, "Agent already registered", None - - # Check type limits - if len(self.type_index[agent_type]) >= self.max_agents_per_type: - return False, f"Maximum agents of type {agent_type.value} reached", None - - # Convert capabilities - agent_capabilities = [] - for cap_data in capabilities: - capability = self._create_capability_from_data(cap_data) - if capability: - agent_capabilities.append(capability) - - if not agent_capabilities: - return False, "Agent must have at least one valid capability", None - - # Create agent info - agent_info = AgentInfo( - agent_id=agent_id, - agent_type=agent_type, - name=name, - owner_address=owner_address, - public_key=public_key, - endpoint_url=endpoint_url, - capabilities=agent_capabilities, - reputation_score=1.0, # Start with neutral reputation - total_jobs_completed=0, - total_earnings=Decimal('0'), - registration_time=time.time(), - last_active=time.time(), - status=AgentStatus.REGISTERED, - metadata=metadata or {} - ) - - # Add to registry - self.agents[agent_id] = agent_info - - # Update indexes - self.type_index[agent_type].add(agent_id) - for capability in agent_capabilities: - self.capability_index[capability.capability_type].add(agent_id) - - log_info(f"Agent registered: {agent_id} ({name})") - return True, "Registration successful", agent_id - - except Exception as e: - return False, f"Registration failed: {str(e)}", None - - def _validate_registration_inputs(self, agent_type: AgentType, name: str, - owner_address: str, public_key: str, endpoint_url: str) -> bool: - """Validate registration inputs""" - # Check required fields - if not all([agent_type, name, owner_address, public_key, endpoint_url]): - return False - - # Validate address format (simplified) - if not owner_address.startswith('0x') or len(owner_address) != 42: - return False - - # Validate URL format (simplified) - if not endpoint_url.startswith(('http://', 'https://')): - return False - - # Validate name - if len(name) < 3 or len(name) > 100: - return False - - return True - - def _generate_agent_id(self, owner_address: str, name: str) -> str: - """Generate unique agent ID""" - content = f"{owner_address}:{name}:{time.time()}" - return hashlib.sha256(content.encode()).hexdigest()[:16] - - def _create_capability_from_data(self, cap_data: Dict) -> Optional[AgentCapability]: - """Create capability from data dictionary""" - try: - # Validate required fields - required_fields = ['type', 'name', 'version', 'cost_per_use'] - if not all(field in cap_data for field in required_fields): - return None - - # Parse capability type - try: - capability_type = CapabilityType(cap_data['type']) - except ValueError: - return None - - # Create capability - return AgentCapability( - capability_type=capability_type, - name=cap_data['name'], - version=cap_data['version'], - parameters=cap_data.get('parameters', {}), - performance_metrics=cap_data.get('performance_metrics', {}), - cost_per_use=Decimal(str(cap_data['cost_per_use'])), - availability=cap_data.get('availability', 1.0), - max_concurrent_jobs=cap_data.get('max_concurrent_jobs', 1) - ) - - except Exception as e: - log_error(f"Error creating capability: {e}") - return None - - async def update_agent_status(self, agent_id: str, status: AgentStatus) -> Tuple[bool, str]: - """Update agent status""" - if agent_id not in self.agents: - return False, "Agent not found" - - agent = self.agents[agent_id] - old_status = agent.status - agent.status = status - agent.last_active = time.time() - - log_info(f"Agent {agent_id} status changed: {old_status.value} -> {status.value}") - return True, "Status updated successfully" - - async def update_agent_capabilities(self, agent_id: str, capabilities: List[Dict]) -> Tuple[bool, str]: - """Update agent capabilities""" - if agent_id not in self.agents: - return False, "Agent not found" - - agent = self.agents[agent_id] - - # Remove old capabilities from index - for old_capability in agent.capabilities: - self.capability_index[old_capability.capability_type].discard(agent_id) - - # Add new capabilities - new_capabilities = [] - for cap_data in capabilities: - capability = self._create_capability_from_data(cap_data) - if capability: - new_capabilities.append(capability) - self.capability_index[capability.capability_type].add(agent_id) - - if not new_capabilities: - return False, "No valid capabilities provided" - - agent.capabilities = new_capabilities - agent.last_active = time.time() - - return True, "Capabilities updated successfully" - - async def find_agents_by_capability(self, capability_type: CapabilityType, - filters: Dict = None) -> List[AgentInfo]: - """Find agents by capability type""" - agent_ids = self.capability_index.get(capability_type, set()) - - agents = [] - for agent_id in agent_ids: - agent = self.agents.get(agent_id) - if agent and agent.status == AgentStatus.ACTIVE: - if self._matches_filters(agent, filters): - agents.append(agent) - - # Sort by reputation (highest first) - agents.sort(key=lambda x: x.reputation_score, reverse=True) - return agents - - async def find_agents_by_type(self, agent_type: AgentType, filters: Dict = None) -> List[AgentInfo]: - """Find agents by type""" - agent_ids = self.type_index.get(agent_type, set()) - - agents = [] - for agent_id in agent_ids: - agent = self.agents.get(agent_id) - if agent and agent.status == AgentStatus.ACTIVE: - if self._matches_filters(agent, filters): - agents.append(agent) - - # Sort by reputation (highest first) - agents.sort(key=lambda x: x.reputation_score, reverse=True) - return agents - - def _matches_filters(self, agent: AgentInfo, filters: Dict) -> bool: - """Check if agent matches filters""" - if not filters: - return True - - # Reputation filter - if 'min_reputation' in filters: - if agent.reputation_score < filters['min_reputation']: - return False - - # Cost filter - if 'max_cost_per_use' in filters: - max_cost = Decimal(str(filters['max_cost_per_use'])) - if any(cap.cost_per_use > max_cost for cap in agent.capabilities): - return False - - # Availability filter - if 'min_availability' in filters: - min_availability = filters['min_availability'] - if any(cap.availability < min_availability for cap in agent.capabilities): - return False - - # Location filter (if implemented) - if 'location' in filters: - agent_location = agent.metadata.get('location') - if agent_location != filters['location']: - return False - - return True - - async def get_agent_info(self, agent_id: str) -> Optional[AgentInfo]: - """Get agent information""" - return self.agents.get(agent_id) - - async def search_agents(self, query: str, limit: int = 50) -> List[AgentInfo]: - """Search agents by name or capability""" - query_lower = query.lower() - results = [] - - for agent in self.agents.values(): - if agent.status != AgentStatus.ACTIVE: - continue - - # Search in name - if query_lower in agent.name.lower(): - results.append(agent) - continue - - # Search in capabilities - for capability in agent.capabilities: - if (query_lower in capability.name.lower() or - query_lower in capability.capability_type.value): - results.append(agent) - break - - # Sort by relevance (reputation) - results.sort(key=lambda x: x.reputation_score, reverse=True) - return results[:limit] - - async def get_agent_statistics(self, agent_id: str) -> Optional[Dict]: - """Get detailed statistics for an agent""" - agent = self.agents.get(agent_id) - if not agent: - return None - - # Calculate additional statistics - avg_job_earnings = agent.total_earnings / agent.total_jobs_completed if agent.total_jobs_completed > 0 else Decimal('0') - days_active = (time.time() - agent.registration_time) / 86400 - jobs_per_day = agent.total_jobs_completed / days_active if days_active > 0 else 0 - - return { - 'agent_id': agent_id, - 'name': agent.name, - 'type': agent.agent_type.value, - 'status': agent.status.value, - 'reputation_score': agent.reputation_score, - 'total_jobs_completed': agent.total_jobs_completed, - 'total_earnings': float(agent.total_earnings), - 'avg_job_earnings': float(avg_job_earnings), - 'jobs_per_day': jobs_per_day, - 'days_active': int(days_active), - 'capabilities_count': len(agent.capabilities), - 'last_active': agent.last_active, - 'registration_time': agent.registration_time - } - - async def get_registry_statistics(self) -> Dict: - """Get registry-wide statistics""" - total_agents = len(self.agents) - active_agents = len([a for a in self.agents.values() if a.status == AgentStatus.ACTIVE]) - - # Count by type - type_counts = {} - for agent_type in AgentType: - type_counts[agent_type.value] = len(self.type_index[agent_type]) - - # Count by capability - capability_counts = {} - for capability_type in CapabilityType: - capability_counts[capability_type.value] = len(self.capability_index[capability_type]) - - # Reputation statistics - reputations = [a.reputation_score for a in self.agents.values()] - avg_reputation = sum(reputations) / len(reputations) if reputations else 0 - - # Earnings statistics - total_earnings = sum(a.total_earnings for a in self.agents.values()) - - return { - 'total_agents': total_agents, - 'active_agents': active_agents, - 'inactive_agents': total_agents - active_agents, - 'agent_types': type_counts, - 'capabilities': capability_counts, - 'average_reputation': avg_reputation, - 'total_earnings': float(total_earnings), - 'registration_fee': float(self.registration_fee) - } - - async def cleanup_inactive_agents(self) -> Tuple[int, str]: - """Clean up inactive agents""" - current_time = time.time() - cleaned_count = 0 - - for agent_id, agent in list(self.agents.items()): - if (agent.status == AgentStatus.INACTIVE and - current_time - agent.last_active > self.inactivity_threshold): - - # Remove from registry - del self.agents[agent_id] - - # Update indexes - self.type_index[agent.agent_type].discard(agent_id) - for capability in agent.capabilities: - self.capability_index[capability.capability_type].discard(agent_id) - - cleaned_count += 1 - - if cleaned_count > 0: - log_info(f"Cleaned up {cleaned_count} inactive agents") - - return cleaned_count, f"Cleaned up {cleaned_count} inactive agents" - -# Global agent registry -agent_registry: Optional[AgentRegistry] = None - -def get_agent_registry() -> Optional[AgentRegistry]: - """Get global agent registry""" - return agent_registry - -def create_agent_registry() -> AgentRegistry: - """Create and set global agent registry""" - global agent_registry - agent_registry = AgentRegistry() - return agent_registry diff --git a/apps/agent-services_backup_20260402_120924/agent-trading/src/trading_agent.py b/apps/agent-services_backup_20260402_120924/agent-trading/src/trading_agent.py deleted file mode 100644 index 181d963b..00000000 --- a/apps/agent-services_backup_20260402_120924/agent-trading/src/trading_agent.py +++ /dev/null @@ -1,166 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Trading Agent -Automated trading agent for AITBC marketplace -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class TradingAgent: - """Automated trading agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.trading_strategy = config.get("strategy", "basic") - self.symbols = config.get("symbols", ["AITBC/BTC"]) - self.trade_interval = config.get("trade_interval", 60) # seconds - - async def start(self) -> bool: - """Start trading agent""" - try: - # Register with service bridge - success = await self.bridge.start_agent(self.agent_id, { - "type": "trading", - "capabilities": ["market_analysis", "trading", "risk_management"], - "endpoint": f"http://localhost:8005" - }) - - if success: - self.is_running = True - print(f"Trading agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start trading agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting trading agent: {e}") - return False - - async def stop(self) -> bool: - """Stop trading agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Trading agent {self.agent_id} stopped successfully") - return success - - async def run_trading_loop(self): - """Main trading loop""" - while self.is_running: - try: - for symbol in self.symbols: - await self._analyze_and_trade(symbol) - - await asyncio.sleep(self.trade_interval) - except Exception as e: - print(f"Error in trading loop: {e}") - await asyncio.sleep(10) # Wait before retrying - - async def _analyze_and_trade(self, symbol: str) -> None: - """Analyze market and execute trades""" - try: - # Perform market analysis - analysis_task = { - "type": "market_analysis", - "symbol": symbol, - "strategy": self.trading_strategy - } - - analysis_result = await self.bridge.execute_agent_task(self.agent_id, analysis_task) - - if analysis_result.get("status") == "success": - analysis = analysis_result["result"]["analysis"] - - # Make trading decision - if self._should_trade(analysis): - await self._execute_trade(symbol, analysis) - else: - print(f"Market analysis failed for {symbol}: {analysis_result}") - - except Exception as e: - print(f"Error in analyze_and_trade for {symbol}: {e}") - - def _should_trade(self, analysis: Dict[str, Any]) -> bool: - """Determine if should execute trade""" - recommendation = analysis.get("recommendation", "hold") - return recommendation in ["buy", "sell"] - - async def _execute_trade(self, symbol: str, analysis: Dict[str, Any]) -> None: - """Execute trade based on analysis""" - try: - recommendation = analysis.get("recommendation", "hold") - - if recommendation == "buy": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "buy", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - elif recommendation == "sell": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "sell", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - else: - return - - trade_result = await self.bridge.execute_agent_task(self.agent_id, trade_task) - - if trade_result.get("status") == "success": - print(f"Trade executed successfully: {trade_result}") - else: - print(f"Trade execution failed: {trade_result}") - - except Exception as e: - print(f"Error executing trade: {e}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - return await self.bridge.get_agent_status(self.agent_id) - -# Main execution -async def main(): - """Main trading agent execution""" - agent_id = "trading-agent-001" - config = { - "strategy": "basic", - "symbols": ["AITBC/BTC"], - "trade_interval": 30, - "trade_amount": 0.1 - } - - agent = TradingAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run trading loop - await agent.run_trading_loop() - except KeyboardInterrupt: - print("Shutting down trading agent...") - finally: - await agent.stop() - else: - print("Failed to start trading agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_121302/agent-bridge/src/integration_layer.py b/apps/agent-services_backup_20260402_121302/agent-bridge/src/integration_layer.py deleted file mode 100644 index f1be04db..00000000 --- a/apps/agent-services_backup_20260402_121302/agent-bridge/src/integration_layer.py +++ /dev/null @@ -1,229 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Integration Layer -Connects agent protocols to existing AITBC services -""" - -import asyncio -import aiohttp -import json -from typing import Dict, Any, List, Optional -from datetime import datetime - -class AITBCServiceIntegration: - """Integration layer for AITBC services""" - - def __init__(self): - self.service_endpoints = { - "coordinator_api": "http://localhost:8000", - "blockchain_rpc": "http://localhost:8006", - "exchange_service": "http://localhost:8001", - "marketplace": "http://localhost:8002", - "agent_registry": "http://localhost:8013" - } - self.session = None - - async def __aenter__(self): - self.session = aiohttp.ClientSession() - return self - - async def __aexit__(self, exc_type, exc_val, exc_tb): - if self.session: - await self.session.close() - - async def get_blockchain_info(self) -> Dict[str, Any]: - """Get blockchain information""" - try: - async with self.session.get(f"{self.service_endpoints['blockchain_rpc']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_exchange_status(self) -> Dict[str, Any]: - """Get exchange service status""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_coordinator_status(self) -> Dict[str, Any]: - """Get coordinator API status""" - try: - async with self.session.get(f"{self.service_endpoints['coordinator_api']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def submit_transaction(self, transaction_data: Dict[str, Any]) -> Dict[str, Any]: - """Submit transaction to blockchain""" - try: - async with self.session.post( - f"{self.service_endpoints['blockchain_rpc']}/rpc/submit", - json=transaction_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def get_market_data(self, symbol: str = "AITBC/BTC") -> Dict[str, Any]: - """Get market data from exchange""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/market/{symbol}") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def register_agent_with_coordinator(self, agent_data: Dict[str, Any]) -> Dict[str, Any]: - """Register agent with coordinator""" - try: - async with self.session.post( - f"{self.service_endpoints['agent_registry']}/api/agents/register", - json=agent_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - -class AgentServiceBridge: - """Bridge between agents and AITBC services""" - - def __init__(self): - self.integration = AITBCServiceIntegration() - self.active_agents = {} - - async def start_agent(self, agent_id: str, agent_config: Dict[str, Any]) -> bool: - """Start an agent with service integration""" - try: - # Register agent with coordinator - async with self.integration as integration: - registration_result = await integration.register_agent_with_coordinator({ - "name": agent_id, - "type": agent_config.get("type", "generic"), - "capabilities": agent_config.get("capabilities", []), - "chain_id": agent_config.get("chain_id", "ait-mainnet"), - "endpoint": agent_config.get("endpoint", f"http://localhost:{8000 + len(self.active_agents) + 10}") - }) - - # The registry returns the created agent dict on success, not a {"status": "ok"} wrapper - if registration_result and "id" in registration_result: - self.active_agents[agent_id] = { - "config": agent_config, - "registration": registration_result, - "started_at": datetime.utcnow() - } - return True - else: - print(f"Registration failed: {registration_result}") - return False - except Exception as e: - print(f"Failed to start agent {agent_id}: {e}") - return False - - async def stop_agent(self, agent_id: str) -> bool: - """Stop an agent""" - if agent_id in self.active_agents: - del self.active_agents[agent_id] - return True - return False - - async def get_agent_status(self, agent_id: str) -> Dict[str, Any]: - """Get agent status with service integration""" - if agent_id not in self.active_agents: - return {"status": "not_found"} - - agent_info = self.active_agents[agent_id] - - async with self.integration as integration: - # Get service statuses - blockchain_status = await integration.get_blockchain_info() - exchange_status = await integration.get_exchange_status() - coordinator_status = await integration.get_coordinator_status() - - return { - "agent_id": agent_id, - "status": "active", - "started_at": agent_info["started_at"].isoformat(), - "services": { - "blockchain": blockchain_status, - "exchange": exchange_status, - "coordinator": coordinator_status - } - } - - async def execute_agent_task(self, agent_id: str, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute agent task with service integration""" - if agent_id not in self.active_agents: - return {"status": "error", "message": "Agent not found"} - - task_type = task_data.get("type") - - if task_type == "market_analysis": - return await self._execute_market_analysis(task_data) - elif task_type == "trading": - return await self._execute_trading_task(task_data) - elif task_type == "compliance_check": - return await self._execute_compliance_check(task_data) - else: - return {"status": "error", "message": f"Unknown task type: {task_type}"} - - async def _execute_market_analysis(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute market analysis task""" - try: - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Perform basic analysis - analysis_result = { - "symbol": task_data.get("symbol", "AITBC/BTC"), - "market_data": market_data, - "analysis": { - "trend": "neutral", - "volatility": "medium", - "recommendation": "hold" - }, - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": analysis_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_trading_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute trading task""" - try: - # Get market data first - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Create transaction - transaction = { - "type": "trade", - "symbol": task_data.get("symbol", "AITBC/BTC"), - "side": task_data.get("side", "buy"), - "amount": task_data.get("amount", 0.1), - "price": task_data.get("price", market_data.get("price", 0.001)) - } - - # Submit transaction - tx_result = await integration.submit_transaction(transaction) - - return {"status": "success", "transaction": tx_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_compliance_check(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute compliance check task""" - try: - # Basic compliance check - compliance_result = { - "user_id": task_data.get("user_id"), - "check_type": task_data.get("check_type", "basic"), - "status": "passed", - "checks_performed": ["kyc", "aml", "sanctions"], - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": compliance_result} - except Exception as e: - return {"status": "error", "message": str(e)} diff --git a/apps/agent-services_backup_20260402_121302/agent-compliance/src/compliance_agent.py b/apps/agent-services_backup_20260402_121302/agent-compliance/src/compliance_agent.py deleted file mode 100644 index a04ad5bd..00000000 --- a/apps/agent-services_backup_20260402_121302/agent-compliance/src/compliance_agent.py +++ /dev/null @@ -1,149 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Compliance Agent -Automated compliance and regulatory monitoring agent -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class ComplianceAgent: - """Automated compliance agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.check_interval = config.get("check_interval", 300) # 5 minutes - self.monitored_entities = config.get("monitored_entities", []) - - async def start(self) -> bool: - """Start compliance agent""" - try: - success = await self.bridge.start_agent(self.agent_id, { - "type": "compliance", - "capabilities": ["kyc_check", "aml_screening", "regulatory_reporting"], - "endpoint": f"http://localhost:8006" - }) - - if success: - self.is_running = True - print(f"Compliance agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start compliance agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting compliance agent: {e}") - return False - - async def stop(self) -> bool: - """Stop compliance agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Compliance agent {self.agent_id} stopped successfully") - return success - - async def run_compliance_loop(self): - """Main compliance monitoring loop""" - while self.is_running: - try: - for entity in self.monitored_entities: - await self._perform_compliance_check(entity) - - await asyncio.sleep(self.check_interval) - except Exception as e: - print(f"Error in compliance loop: {e}") - await asyncio.sleep(30) # Wait before retrying - - async def _perform_compliance_check(self, entity_id: str) -> None: - """Perform compliance check for entity""" - try: - compliance_task = { - "type": "compliance_check", - "user_id": entity_id, - "check_type": "full", - "monitored_activities": ["trading", "transfers", "wallet_creation"] - } - - result = await self.bridge.execute_agent_task(self.agent_id, compliance_task) - - if result.get("status") == "success": - compliance_result = result["result"] - await self._handle_compliance_result(entity_id, compliance_result) - else: - print(f"Compliance check failed for {entity_id}: {result}") - - except Exception as e: - print(f"Error performing compliance check for {entity_id}: {e}") - - async def _handle_compliance_result(self, entity_id: str, result: Dict[str, Any]) -> None: - """Handle compliance check result""" - status = result.get("status", "unknown") - - if status == "passed": - print(f"✅ Compliance check passed for {entity_id}") - elif status == "failed": - print(f"❌ Compliance check failed for {entity_id}") - # Trigger alert or further investigation - await self._trigger_compliance_alert(entity_id, result) - else: - print(f"⚠️ Compliance check inconclusive for {entity_id}") - - async def _trigger_compliance_alert(self, entity_id: str, result: Dict[str, Any]) -> None: - """Trigger compliance alert""" - alert_data = { - "entity_id": entity_id, - "alert_type": "compliance_failure", - "severity": "high", - "details": result, - "timestamp": datetime.utcnow().isoformat() - } - - # In a real implementation, this would send to alert system - print(f"🚨 COMPLIANCE ALERT: {json.dumps(alert_data, indent=2)}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - status = await self.bridge.get_agent_status(self.agent_id) - status["monitored_entities"] = len(self.monitored_entities) - status["check_interval"] = self.check_interval - return status - -# Main execution -async def main(): - """Main compliance agent execution""" - agent_id = "compliance-agent-001" - config = { - "check_interval": 60, # 1 minute for testing - "monitored_entities": ["user001", "user002", "user003"] - } - - agent = ComplianceAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run compliance loop - await agent.run_compliance_loop() - except KeyboardInterrupt: - print("Shutting down compliance agent...") - finally: - await agent.stop() - else: - print("Failed to start compliance agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_121302/agent-coordinator/src/coordinator.py b/apps/agent-services_backup_20260402_121302/agent-coordinator/src/coordinator.py deleted file mode 100644 index ce39c3cc..00000000 --- a/apps/agent-services_backup_20260402_121302/agent-coordinator/src/coordinator.py +++ /dev/null @@ -1,132 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Coordinator Service -Agent task coordination and management -""" - -from fastapi import FastAPI, HTTPException -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import uuid -from datetime import datetime -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Coordinator API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_coordinator.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS tasks ( - id TEXT PRIMARY KEY, - task_type TEXT NOT NULL, - payload TEXT NOT NULL, - required_capabilities TEXT NOT NULL, - priority TEXT NOT NULL, - status TEXT NOT NULL, - assigned_agent_id TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - result TEXT - ) - ''') - -# Models -class Task(BaseModel): - id: str - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str - status: str - assigned_agent_id: Optional[str] = None - -class TaskCreation(BaseModel): - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str = "normal" - -# API Endpoints - -@app.post("/api/tasks", response_model=Task) -async def create_task(task: TaskCreation): - """Create a new task""" - task_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO tasks (id, task_type, payload, required_capabilities, priority, status) - VALUES (?, ?, ?, ?, ?, ?) - ''', ( - task_id, task.task_type, json.dumps(task.payload), - json.dumps(task.required_capabilities), task.priority, "pending" - )) - - return Task( - id=task_id, - task_type=task.task_type, - payload=task.payload, - required_capabilities=task.required_capabilities, - priority=task.priority, - status="pending" - ) - -@app.get("/api/tasks", response_model=List[Task]) -async def list_tasks(status: Optional[str] = None): - """List tasks with optional status filter""" - with get_db_connection() as conn: - query = "SELECT * FROM tasks" - params = [] - - if status: - query += " WHERE status = ?" - params.append(status) - - tasks = conn.execute(query, params).fetchall() - - return [ - Task( - id=task["id"], - task_type=task["task_type"], - payload=json.loads(task["payload"]), - required_capabilities=json.loads(task["required_capabilities"]), - priority=task["priority"], - status=task["status"], - assigned_agent_id=task["assigned_agent_id"] - ) - for task in tasks - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8012) diff --git a/apps/agent-services_backup_20260402_121302/agent-protocols/.env.example b/apps/agent-services_backup_20260402_121302/agent-protocols/.env.example deleted file mode 100644 index bf8ed394..00000000 --- a/apps/agent-services_backup_20260402_121302/agent-protocols/.env.example +++ /dev/null @@ -1,19 +0,0 @@ -# AITBC Agent Protocols Environment Configuration -# Copy this file to .env and update with your secure values - -# Agent Protocol Encryption Key (generate a strong, unique key) -AITBC_AGENT_PROTOCOL_KEY=your-secure-encryption-key-here - -# Agent Protocol Salt (generate a unique salt value) -AITBC_AGENT_PROTOCOL_SALT=your-unique-salt-value-here - -# Agent Registry Configuration -AGENT_REGISTRY_HOST=0.0.0.0 -AGENT_REGISTRY_PORT=8003 - -# Database Configuration -AGENT_REGISTRY_DB_PATH=agent_registry.db - -# Security Settings -AGENT_PROTOCOL_TIMEOUT=300 -AGENT_PROTOCOL_MAX_RETRIES=3 diff --git a/apps/agent-services_backup_20260402_121302/agent-protocols/src/__init__.py b/apps/agent-services_backup_20260402_121302/agent-protocols/src/__init__.py deleted file mode 100644 index 9dfeaacd..00000000 --- a/apps/agent-services_backup_20260402_121302/agent-protocols/src/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -""" -Agent Protocols Package -""" - -from .message_protocol import MessageProtocol, MessageTypes, AgentMessageClient -from .task_manager import TaskManager, TaskStatus, TaskPriority, Task - -__all__ = [ - "MessageProtocol", - "MessageTypes", - "AgentMessageClient", - "TaskManager", - "TaskStatus", - "TaskPriority", - "Task" -] diff --git a/apps/agent-services_backup_20260402_121302/agent-protocols/src/message_protocol.py b/apps/agent-services_backup_20260402_121302/agent-protocols/src/message_protocol.py deleted file mode 100644 index 48289d6b..00000000 --- a/apps/agent-services_backup_20260402_121302/agent-protocols/src/message_protocol.py +++ /dev/null @@ -1,113 +0,0 @@ -""" -Message Protocol for AITBC Agents -Handles message creation, routing, and delivery between agents -""" - -import json -import uuid -from datetime import datetime -from typing import Dict, Any, Optional, List -from enum import Enum - -class MessageTypes(Enum): - """Message type enumeration""" - TASK_REQUEST = "task_request" - TASK_RESPONSE = "task_response" - HEARTBEAT = "heartbeat" - STATUS_UPDATE = "status_update" - ERROR = "error" - DATA = "data" - -class MessageProtocol: - """Message protocol handler for agent communication""" - - def __init__(self): - self.messages = [] - self.message_handlers = {} - - def create_message( - self, - sender_id: str, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any], - message_id: Optional[str] = None - ) -> Dict[str, Any]: - """Create a new message""" - if message_id is None: - message_id = str(uuid.uuid4()) - - message = { - "message_id": message_id, - "sender_id": sender_id, - "receiver_id": receiver_id, - "message_type": message_type.value, - "content": content, - "timestamp": datetime.utcnow().isoformat(), - "status": "pending" - } - - self.messages.append(message) - return message - - def send_message(self, message: Dict[str, Any]) -> bool: - """Send a message to the receiver""" - try: - message["status"] = "sent" - message["sent_timestamp"] = datetime.utcnow().isoformat() - return True - except Exception: - message["status"] = "failed" - return False - - def receive_message(self, message_id: str) -> Optional[Dict[str, Any]]: - """Receive and process a message""" - for message in self.messages: - if message["message_id"] == message_id: - message["status"] = "received" - message["received_timestamp"] = datetime.utcnow().isoformat() - return message - return None - - def get_messages_by_agent(self, agent_id: str) -> List[Dict[str, Any]]: - """Get all messages for a specific agent""" - return [ - msg for msg in self.messages - if msg["sender_id"] == agent_id or msg["receiver_id"] == agent_id - ] - -class AgentMessageClient: - """Client for agent message communication""" - - def __init__(self, agent_id: str, protocol: MessageProtocol): - self.agent_id = agent_id - self.protocol = protocol - self.received_messages = [] - - def send_message( - self, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any] - ) -> Dict[str, Any]: - """Send a message to another agent""" - message = self.protocol.create_message( - sender_id=self.agent_id, - receiver_id=receiver_id, - message_type=message_type, - content=content - ) - self.protocol.send_message(message) - return message - - def receive_messages(self) -> List[Dict[str, Any]]: - """Receive all pending messages for this agent""" - messages = [] - for message in self.protocol.messages: - if (message["receiver_id"] == self.agent_id and - message["status"] == "sent" and - message not in self.received_messages): - self.protocol.receive_message(message["message_id"]) - self.received_messages.append(message) - messages.append(message) - return messages diff --git a/apps/agent-services_backup_20260402_121302/agent-protocols/src/task_manager.py b/apps/agent-services_backup_20260402_121302/agent-protocols/src/task_manager.py deleted file mode 100644 index af680c99..00000000 --- a/apps/agent-services_backup_20260402_121302/agent-protocols/src/task_manager.py +++ /dev/null @@ -1,128 +0,0 @@ -""" -Task Manager for AITBC Agents -Handles task creation, assignment, and tracking -""" - -import uuid -from datetime import datetime, timedelta -from typing import Dict, Any, Optional, List -from enum import Enum - -class TaskStatus(Enum): - """Task status enumeration""" - PENDING = "pending" - IN_PROGRESS = "in_progress" - COMPLETED = "completed" - FAILED = "failed" - CANCELLED = "cancelled" - -class TaskPriority(Enum): - """Task priority enumeration""" - LOW = "low" - MEDIUM = "medium" - HIGH = "high" - URGENT = "urgent" - -class Task: - """Task representation""" - - def __init__( - self, - task_id: str, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ): - self.task_id = task_id - self.title = title - self.description = description - self.assigned_to = assigned_to - self.priority = priority - self.created_by = created_by or assigned_to - self.status = TaskStatus.PENDING - self.created_at = datetime.utcnow() - self.updated_at = datetime.utcnow() - self.completed_at = None - self.result = None - self.error = None - -class TaskManager: - """Task manager for agent coordination""" - - def __init__(self): - self.tasks = {} - self.task_history = [] - - def create_task( - self, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ) -> Task: - """Create a new task""" - task_id = str(uuid.uuid4()) - task = Task( - task_id=task_id, - title=title, - description=description, - assigned_to=assigned_to, - priority=priority, - created_by=created_by - ) - - self.tasks[task_id] = task - return task - - def get_task(self, task_id: str) -> Optional[Task]: - """Get a task by ID""" - return self.tasks.get(task_id) - - def update_task_status( - self, - task_id: str, - status: TaskStatus, - result: Optional[Dict[str, Any]] = None, - error: Optional[str] = None - ) -> bool: - """Update task status""" - task = self.get_task(task_id) - if not task: - return False - - task.status = status - task.updated_at = datetime.utcnow() - - if status == TaskStatus.COMPLETED: - task.completed_at = datetime.utcnow() - task.result = result - elif status == TaskStatus.FAILED: - task.error = error - - return True - - def get_tasks_by_agent(self, agent_id: str) -> List[Task]: - """Get all tasks assigned to an agent""" - return [ - task for task in self.tasks.values() - if task.assigned_to == agent_id - ] - - def get_tasks_by_status(self, status: TaskStatus) -> List[Task]: - """Get all tasks with a specific status""" - return [ - task for task in self.tasks.values() - if task.status == status - ] - - def get_overdue_tasks(self, hours: int = 24) -> List[Task]: - """Get tasks that are overdue""" - cutoff_time = datetime.utcnow() - timedelta(hours=hours) - return [ - task for task in self.tasks.values() - if task.status in [TaskStatus.PENDING, TaskStatus.IN_PROGRESS] and - task.created_at < cutoff_time - ] diff --git a/apps/agent-services_backup_20260402_121302/agent-registry/src/app.py b/apps/agent-services_backup_20260402_121302/agent-registry/src/app.py deleted file mode 100644 index 70eb95f7..00000000 --- a/apps/agent-services_backup_20260402_121302/agent-registry/src/app.py +++ /dev/null @@ -1,151 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Registry Service -Central agent discovery and registration system -""" - -from fastapi import FastAPI, HTTPException, Depends -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import time -import uuid -from datetime import datetime, timedelta -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Registry API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_registry.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS agents ( - id TEXT PRIMARY KEY, - name TEXT NOT NULL, - type TEXT NOT NULL, - capabilities TEXT NOT NULL, - chain_id TEXT NOT NULL, - endpoint TEXT NOT NULL, - status TEXT DEFAULT 'active', - last_heartbeat TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - metadata TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP - ) - ''') - -# Models -class Agent(BaseModel): - id: str - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -class AgentRegistration(BaseModel): - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -# API Endpoints - -@app.post("/api/agents/register", response_model=Agent) -async def register_agent(agent: AgentRegistration): - """Register a new agent""" - agent_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO agents (id, name, type, capabilities, chain_id, endpoint, metadata) - VALUES (?, ?, ?, ?, ?, ?, ?) - ''', ( - agent_id, agent.name, agent.type, - json.dumps(agent.capabilities), agent.chain_id, - agent.endpoint, json.dumps(agent.metadata) - )) - conn.commit() - - return Agent( - id=agent_id, - name=agent.name, - type=agent.type, - capabilities=agent.capabilities, - chain_id=agent.chain_id, - endpoint=agent.endpoint, - metadata=agent.metadata - ) - -@app.get("/api/agents", response_model=List[Agent]) -async def list_agents( - agent_type: Optional[str] = None, - chain_id: Optional[str] = None, - capability: Optional[str] = None -): - """List registered agents with optional filters""" - with get_db_connection() as conn: - query = "SELECT * FROM agents WHERE status = 'active'" - params = [] - - if agent_type: - query += " AND type = ?" - params.append(agent_type) - - if chain_id: - query += " AND chain_id = ?" - params.append(chain_id) - - if capability: - query += " AND capabilities LIKE ?" - params.append(f'%{capability}%') - - agents = conn.execute(query, params).fetchall() - - return [ - Agent( - id=agent["id"], - name=agent["name"], - type=agent["type"], - capabilities=json.loads(agent["capabilities"]), - chain_id=agent["chain_id"], - endpoint=agent["endpoint"], - metadata=json.loads(agent["metadata"] or "{}") - ) - for agent in agents - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8013) diff --git a/apps/agent-services_backup_20260402_121302/agent-registry/src/registration.py b/apps/agent-services_backup_20260402_121302/agent-registry/src/registration.py deleted file mode 100644 index 3793139d..00000000 --- a/apps/agent-services_backup_20260402_121302/agent-registry/src/registration.py +++ /dev/null @@ -1,431 +0,0 @@ -""" -Agent Registration System -Handles AI agent registration, capability management, and discovery -""" - -import asyncio -import time -import json -import hashlib -from typing import Dict, List, Optional, Set, Tuple -from dataclasses import dataclass, asdict -from enum import Enum -from decimal import Decimal - -class AgentType(Enum): - AI_MODEL = "ai_model" - DATA_PROVIDER = "data_provider" - VALIDATOR = "validator" - MARKET_MAKER = "market_maker" - BROKER = "broker" - ORACLE = "oracle" - -class AgentStatus(Enum): - REGISTERED = "registered" - ACTIVE = "active" - INACTIVE = "inactive" - SUSPENDED = "suspended" - BANNED = "banned" - -class CapabilityType(Enum): - TEXT_GENERATION = "text_generation" - IMAGE_GENERATION = "image_generation" - DATA_ANALYSIS = "data_analysis" - PREDICTION = "prediction" - VALIDATION = "validation" - COMPUTATION = "computation" - -@dataclass -class AgentCapability: - capability_type: CapabilityType - name: str - version: str - parameters: Dict - performance_metrics: Dict - cost_per_use: Decimal - availability: float - max_concurrent_jobs: int - -@dataclass -class AgentInfo: - agent_id: str - agent_type: AgentType - name: str - owner_address: str - public_key: str - endpoint_url: str - capabilities: List[AgentCapability] - reputation_score: float - total_jobs_completed: int - total_earnings: Decimal - registration_time: float - last_active: float - status: AgentStatus - metadata: Dict - -class AgentRegistry: - """Manages AI agent registration and discovery""" - - def __init__(self): - self.agents: Dict[str, AgentInfo] = {} - self.capability_index: Dict[CapabilityType, Set[str]] = {} # capability -> agent_ids - self.type_index: Dict[AgentType, Set[str]] = {} # agent_type -> agent_ids - self.reputation_scores: Dict[str, float] = {} - self.registration_queue: List[Dict] = [] - - # Registry parameters - self.min_reputation_threshold = 0.5 - self.max_agents_per_type = 1000 - self.registration_fee = Decimal('100.0') - self.inactivity_threshold = 86400 * 7 # 7 days - - # Initialize capability index - for capability_type in CapabilityType: - self.capability_index[capability_type] = set() - - # Initialize type index - for agent_type in AgentType: - self.type_index[agent_type] = set() - - async def register_agent(self, agent_type: AgentType, name: str, owner_address: str, - public_key: str, endpoint_url: str, capabilities: List[Dict], - metadata: Dict = None) -> Tuple[bool, str, Optional[str]]: - """Register a new AI agent""" - try: - # Validate inputs - if not self._validate_registration_inputs(agent_type, name, owner_address, public_key, endpoint_url): - return False, "Invalid registration inputs", None - - # Check if agent already exists - agent_id = self._generate_agent_id(owner_address, name) - if agent_id in self.agents: - return False, "Agent already registered", None - - # Check type limits - if len(self.type_index[agent_type]) >= self.max_agents_per_type: - return False, f"Maximum agents of type {agent_type.value} reached", None - - # Convert capabilities - agent_capabilities = [] - for cap_data in capabilities: - capability = self._create_capability_from_data(cap_data) - if capability: - agent_capabilities.append(capability) - - if not agent_capabilities: - return False, "Agent must have at least one valid capability", None - - # Create agent info - agent_info = AgentInfo( - agent_id=agent_id, - agent_type=agent_type, - name=name, - owner_address=owner_address, - public_key=public_key, - endpoint_url=endpoint_url, - capabilities=agent_capabilities, - reputation_score=1.0, # Start with neutral reputation - total_jobs_completed=0, - total_earnings=Decimal('0'), - registration_time=time.time(), - last_active=time.time(), - status=AgentStatus.REGISTERED, - metadata=metadata or {} - ) - - # Add to registry - self.agents[agent_id] = agent_info - - # Update indexes - self.type_index[agent_type].add(agent_id) - for capability in agent_capabilities: - self.capability_index[capability.capability_type].add(agent_id) - - log_info(f"Agent registered: {agent_id} ({name})") - return True, "Registration successful", agent_id - - except Exception as e: - return False, f"Registration failed: {str(e)}", None - - def _validate_registration_inputs(self, agent_type: AgentType, name: str, - owner_address: str, public_key: str, endpoint_url: str) -> bool: - """Validate registration inputs""" - # Check required fields - if not all([agent_type, name, owner_address, public_key, endpoint_url]): - return False - - # Validate address format (simplified) - if not owner_address.startswith('0x') or len(owner_address) != 42: - return False - - # Validate URL format (simplified) - if not endpoint_url.startswith(('http://', 'https://')): - return False - - # Validate name - if len(name) < 3 or len(name) > 100: - return False - - return True - - def _generate_agent_id(self, owner_address: str, name: str) -> str: - """Generate unique agent ID""" - content = f"{owner_address}:{name}:{time.time()}" - return hashlib.sha256(content.encode()).hexdigest()[:16] - - def _create_capability_from_data(self, cap_data: Dict) -> Optional[AgentCapability]: - """Create capability from data dictionary""" - try: - # Validate required fields - required_fields = ['type', 'name', 'version', 'cost_per_use'] - if not all(field in cap_data for field in required_fields): - return None - - # Parse capability type - try: - capability_type = CapabilityType(cap_data['type']) - except ValueError: - return None - - # Create capability - return AgentCapability( - capability_type=capability_type, - name=cap_data['name'], - version=cap_data['version'], - parameters=cap_data.get('parameters', {}), - performance_metrics=cap_data.get('performance_metrics', {}), - cost_per_use=Decimal(str(cap_data['cost_per_use'])), - availability=cap_data.get('availability', 1.0), - max_concurrent_jobs=cap_data.get('max_concurrent_jobs', 1) - ) - - except Exception as e: - log_error(f"Error creating capability: {e}") - return None - - async def update_agent_status(self, agent_id: str, status: AgentStatus) -> Tuple[bool, str]: - """Update agent status""" - if agent_id not in self.agents: - return False, "Agent not found" - - agent = self.agents[agent_id] - old_status = agent.status - agent.status = status - agent.last_active = time.time() - - log_info(f"Agent {agent_id} status changed: {old_status.value} -> {status.value}") - return True, "Status updated successfully" - - async def update_agent_capabilities(self, agent_id: str, capabilities: List[Dict]) -> Tuple[bool, str]: - """Update agent capabilities""" - if agent_id not in self.agents: - return False, "Agent not found" - - agent = self.agents[agent_id] - - # Remove old capabilities from index - for old_capability in agent.capabilities: - self.capability_index[old_capability.capability_type].discard(agent_id) - - # Add new capabilities - new_capabilities = [] - for cap_data in capabilities: - capability = self._create_capability_from_data(cap_data) - if capability: - new_capabilities.append(capability) - self.capability_index[capability.capability_type].add(agent_id) - - if not new_capabilities: - return False, "No valid capabilities provided" - - agent.capabilities = new_capabilities - agent.last_active = time.time() - - return True, "Capabilities updated successfully" - - async def find_agents_by_capability(self, capability_type: CapabilityType, - filters: Dict = None) -> List[AgentInfo]: - """Find agents by capability type""" - agent_ids = self.capability_index.get(capability_type, set()) - - agents = [] - for agent_id in agent_ids: - agent = self.agents.get(agent_id) - if agent and agent.status == AgentStatus.ACTIVE: - if self._matches_filters(agent, filters): - agents.append(agent) - - # Sort by reputation (highest first) - agents.sort(key=lambda x: x.reputation_score, reverse=True) - return agents - - async def find_agents_by_type(self, agent_type: AgentType, filters: Dict = None) -> List[AgentInfo]: - """Find agents by type""" - agent_ids = self.type_index.get(agent_type, set()) - - agents = [] - for agent_id in agent_ids: - agent = self.agents.get(agent_id) - if agent and agent.status == AgentStatus.ACTIVE: - if self._matches_filters(agent, filters): - agents.append(agent) - - # Sort by reputation (highest first) - agents.sort(key=lambda x: x.reputation_score, reverse=True) - return agents - - def _matches_filters(self, agent: AgentInfo, filters: Dict) -> bool: - """Check if agent matches filters""" - if not filters: - return True - - # Reputation filter - if 'min_reputation' in filters: - if agent.reputation_score < filters['min_reputation']: - return False - - # Cost filter - if 'max_cost_per_use' in filters: - max_cost = Decimal(str(filters['max_cost_per_use'])) - if any(cap.cost_per_use > max_cost for cap in agent.capabilities): - return False - - # Availability filter - if 'min_availability' in filters: - min_availability = filters['min_availability'] - if any(cap.availability < min_availability for cap in agent.capabilities): - return False - - # Location filter (if implemented) - if 'location' in filters: - agent_location = agent.metadata.get('location') - if agent_location != filters['location']: - return False - - return True - - async def get_agent_info(self, agent_id: str) -> Optional[AgentInfo]: - """Get agent information""" - return self.agents.get(agent_id) - - async def search_agents(self, query: str, limit: int = 50) -> List[AgentInfo]: - """Search agents by name or capability""" - query_lower = query.lower() - results = [] - - for agent in self.agents.values(): - if agent.status != AgentStatus.ACTIVE: - continue - - # Search in name - if query_lower in agent.name.lower(): - results.append(agent) - continue - - # Search in capabilities - for capability in agent.capabilities: - if (query_lower in capability.name.lower() or - query_lower in capability.capability_type.value): - results.append(agent) - break - - # Sort by relevance (reputation) - results.sort(key=lambda x: x.reputation_score, reverse=True) - return results[:limit] - - async def get_agent_statistics(self, agent_id: str) -> Optional[Dict]: - """Get detailed statistics for an agent""" - agent = self.agents.get(agent_id) - if not agent: - return None - - # Calculate additional statistics - avg_job_earnings = agent.total_earnings / agent.total_jobs_completed if agent.total_jobs_completed > 0 else Decimal('0') - days_active = (time.time() - agent.registration_time) / 86400 - jobs_per_day = agent.total_jobs_completed / days_active if days_active > 0 else 0 - - return { - 'agent_id': agent_id, - 'name': agent.name, - 'type': agent.agent_type.value, - 'status': agent.status.value, - 'reputation_score': agent.reputation_score, - 'total_jobs_completed': agent.total_jobs_completed, - 'total_earnings': float(agent.total_earnings), - 'avg_job_earnings': float(avg_job_earnings), - 'jobs_per_day': jobs_per_day, - 'days_active': int(days_active), - 'capabilities_count': len(agent.capabilities), - 'last_active': agent.last_active, - 'registration_time': agent.registration_time - } - - async def get_registry_statistics(self) -> Dict: - """Get registry-wide statistics""" - total_agents = len(self.agents) - active_agents = len([a for a in self.agents.values() if a.status == AgentStatus.ACTIVE]) - - # Count by type - type_counts = {} - for agent_type in AgentType: - type_counts[agent_type.value] = len(self.type_index[agent_type]) - - # Count by capability - capability_counts = {} - for capability_type in CapabilityType: - capability_counts[capability_type.value] = len(self.capability_index[capability_type]) - - # Reputation statistics - reputations = [a.reputation_score for a in self.agents.values()] - avg_reputation = sum(reputations) / len(reputations) if reputations else 0 - - # Earnings statistics - total_earnings = sum(a.total_earnings for a in self.agents.values()) - - return { - 'total_agents': total_agents, - 'active_agents': active_agents, - 'inactive_agents': total_agents - active_agents, - 'agent_types': type_counts, - 'capabilities': capability_counts, - 'average_reputation': avg_reputation, - 'total_earnings': float(total_earnings), - 'registration_fee': float(self.registration_fee) - } - - async def cleanup_inactive_agents(self) -> Tuple[int, str]: - """Clean up inactive agents""" - current_time = time.time() - cleaned_count = 0 - - for agent_id, agent in list(self.agents.items()): - if (agent.status == AgentStatus.INACTIVE and - current_time - agent.last_active > self.inactivity_threshold): - - # Remove from registry - del self.agents[agent_id] - - # Update indexes - self.type_index[agent.agent_type].discard(agent_id) - for capability in agent.capabilities: - self.capability_index[capability.capability_type].discard(agent_id) - - cleaned_count += 1 - - if cleaned_count > 0: - log_info(f"Cleaned up {cleaned_count} inactive agents") - - return cleaned_count, f"Cleaned up {cleaned_count} inactive agents" - -# Global agent registry -agent_registry: Optional[AgentRegistry] = None - -def get_agent_registry() -> Optional[AgentRegistry]: - """Get global agent registry""" - return agent_registry - -def create_agent_registry() -> AgentRegistry: - """Create and set global agent registry""" - global agent_registry - agent_registry = AgentRegistry() - return agent_registry diff --git a/apps/agent-services_backup_20260402_121302/agent-trading/src/trading_agent.py b/apps/agent-services_backup_20260402_121302/agent-trading/src/trading_agent.py deleted file mode 100644 index 181d963b..00000000 --- a/apps/agent-services_backup_20260402_121302/agent-trading/src/trading_agent.py +++ /dev/null @@ -1,166 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Trading Agent -Automated trading agent for AITBC marketplace -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class TradingAgent: - """Automated trading agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.trading_strategy = config.get("strategy", "basic") - self.symbols = config.get("symbols", ["AITBC/BTC"]) - self.trade_interval = config.get("trade_interval", 60) # seconds - - async def start(self) -> bool: - """Start trading agent""" - try: - # Register with service bridge - success = await self.bridge.start_agent(self.agent_id, { - "type": "trading", - "capabilities": ["market_analysis", "trading", "risk_management"], - "endpoint": f"http://localhost:8005" - }) - - if success: - self.is_running = True - print(f"Trading agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start trading agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting trading agent: {e}") - return False - - async def stop(self) -> bool: - """Stop trading agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Trading agent {self.agent_id} stopped successfully") - return success - - async def run_trading_loop(self): - """Main trading loop""" - while self.is_running: - try: - for symbol in self.symbols: - await self._analyze_and_trade(symbol) - - await asyncio.sleep(self.trade_interval) - except Exception as e: - print(f"Error in trading loop: {e}") - await asyncio.sleep(10) # Wait before retrying - - async def _analyze_and_trade(self, symbol: str) -> None: - """Analyze market and execute trades""" - try: - # Perform market analysis - analysis_task = { - "type": "market_analysis", - "symbol": symbol, - "strategy": self.trading_strategy - } - - analysis_result = await self.bridge.execute_agent_task(self.agent_id, analysis_task) - - if analysis_result.get("status") == "success": - analysis = analysis_result["result"]["analysis"] - - # Make trading decision - if self._should_trade(analysis): - await self._execute_trade(symbol, analysis) - else: - print(f"Market analysis failed for {symbol}: {analysis_result}") - - except Exception as e: - print(f"Error in analyze_and_trade for {symbol}: {e}") - - def _should_trade(self, analysis: Dict[str, Any]) -> bool: - """Determine if should execute trade""" - recommendation = analysis.get("recommendation", "hold") - return recommendation in ["buy", "sell"] - - async def _execute_trade(self, symbol: str, analysis: Dict[str, Any]) -> None: - """Execute trade based on analysis""" - try: - recommendation = analysis.get("recommendation", "hold") - - if recommendation == "buy": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "buy", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - elif recommendation == "sell": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "sell", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - else: - return - - trade_result = await self.bridge.execute_agent_task(self.agent_id, trade_task) - - if trade_result.get("status") == "success": - print(f"Trade executed successfully: {trade_result}") - else: - print(f"Trade execution failed: {trade_result}") - - except Exception as e: - print(f"Error executing trade: {e}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - return await self.bridge.get_agent_status(self.agent_id) - -# Main execution -async def main(): - """Main trading agent execution""" - agent_id = "trading-agent-001" - config = { - "strategy": "basic", - "symbols": ["AITBC/BTC"], - "trade_interval": 30, - "trade_amount": 0.1 - } - - agent = TradingAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run trading loop - await agent.run_trading_loop() - except KeyboardInterrupt: - print("Shutting down trading agent...") - finally: - await agent.stop() - else: - print("Failed to start trading agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_121936/agent-bridge/src/integration_layer.py b/apps/agent-services_backup_20260402_121936/agent-bridge/src/integration_layer.py deleted file mode 100644 index f1be04db..00000000 --- a/apps/agent-services_backup_20260402_121936/agent-bridge/src/integration_layer.py +++ /dev/null @@ -1,229 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Integration Layer -Connects agent protocols to existing AITBC services -""" - -import asyncio -import aiohttp -import json -from typing import Dict, Any, List, Optional -from datetime import datetime - -class AITBCServiceIntegration: - """Integration layer for AITBC services""" - - def __init__(self): - self.service_endpoints = { - "coordinator_api": "http://localhost:8000", - "blockchain_rpc": "http://localhost:8006", - "exchange_service": "http://localhost:8001", - "marketplace": "http://localhost:8002", - "agent_registry": "http://localhost:8013" - } - self.session = None - - async def __aenter__(self): - self.session = aiohttp.ClientSession() - return self - - async def __aexit__(self, exc_type, exc_val, exc_tb): - if self.session: - await self.session.close() - - async def get_blockchain_info(self) -> Dict[str, Any]: - """Get blockchain information""" - try: - async with self.session.get(f"{self.service_endpoints['blockchain_rpc']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_exchange_status(self) -> Dict[str, Any]: - """Get exchange service status""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_coordinator_status(self) -> Dict[str, Any]: - """Get coordinator API status""" - try: - async with self.session.get(f"{self.service_endpoints['coordinator_api']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def submit_transaction(self, transaction_data: Dict[str, Any]) -> Dict[str, Any]: - """Submit transaction to blockchain""" - try: - async with self.session.post( - f"{self.service_endpoints['blockchain_rpc']}/rpc/submit", - json=transaction_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def get_market_data(self, symbol: str = "AITBC/BTC") -> Dict[str, Any]: - """Get market data from exchange""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/market/{symbol}") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def register_agent_with_coordinator(self, agent_data: Dict[str, Any]) -> Dict[str, Any]: - """Register agent with coordinator""" - try: - async with self.session.post( - f"{self.service_endpoints['agent_registry']}/api/agents/register", - json=agent_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - -class AgentServiceBridge: - """Bridge between agents and AITBC services""" - - def __init__(self): - self.integration = AITBCServiceIntegration() - self.active_agents = {} - - async def start_agent(self, agent_id: str, agent_config: Dict[str, Any]) -> bool: - """Start an agent with service integration""" - try: - # Register agent with coordinator - async with self.integration as integration: - registration_result = await integration.register_agent_with_coordinator({ - "name": agent_id, - "type": agent_config.get("type", "generic"), - "capabilities": agent_config.get("capabilities", []), - "chain_id": agent_config.get("chain_id", "ait-mainnet"), - "endpoint": agent_config.get("endpoint", f"http://localhost:{8000 + len(self.active_agents) + 10}") - }) - - # The registry returns the created agent dict on success, not a {"status": "ok"} wrapper - if registration_result and "id" in registration_result: - self.active_agents[agent_id] = { - "config": agent_config, - "registration": registration_result, - "started_at": datetime.utcnow() - } - return True - else: - print(f"Registration failed: {registration_result}") - return False - except Exception as e: - print(f"Failed to start agent {agent_id}: {e}") - return False - - async def stop_agent(self, agent_id: str) -> bool: - """Stop an agent""" - if agent_id in self.active_agents: - del self.active_agents[agent_id] - return True - return False - - async def get_agent_status(self, agent_id: str) -> Dict[str, Any]: - """Get agent status with service integration""" - if agent_id not in self.active_agents: - return {"status": "not_found"} - - agent_info = self.active_agents[agent_id] - - async with self.integration as integration: - # Get service statuses - blockchain_status = await integration.get_blockchain_info() - exchange_status = await integration.get_exchange_status() - coordinator_status = await integration.get_coordinator_status() - - return { - "agent_id": agent_id, - "status": "active", - "started_at": agent_info["started_at"].isoformat(), - "services": { - "blockchain": blockchain_status, - "exchange": exchange_status, - "coordinator": coordinator_status - } - } - - async def execute_agent_task(self, agent_id: str, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute agent task with service integration""" - if agent_id not in self.active_agents: - return {"status": "error", "message": "Agent not found"} - - task_type = task_data.get("type") - - if task_type == "market_analysis": - return await self._execute_market_analysis(task_data) - elif task_type == "trading": - return await self._execute_trading_task(task_data) - elif task_type == "compliance_check": - return await self._execute_compliance_check(task_data) - else: - return {"status": "error", "message": f"Unknown task type: {task_type}"} - - async def _execute_market_analysis(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute market analysis task""" - try: - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Perform basic analysis - analysis_result = { - "symbol": task_data.get("symbol", "AITBC/BTC"), - "market_data": market_data, - "analysis": { - "trend": "neutral", - "volatility": "medium", - "recommendation": "hold" - }, - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": analysis_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_trading_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute trading task""" - try: - # Get market data first - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Create transaction - transaction = { - "type": "trade", - "symbol": task_data.get("symbol", "AITBC/BTC"), - "side": task_data.get("side", "buy"), - "amount": task_data.get("amount", 0.1), - "price": task_data.get("price", market_data.get("price", 0.001)) - } - - # Submit transaction - tx_result = await integration.submit_transaction(transaction) - - return {"status": "success", "transaction": tx_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_compliance_check(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute compliance check task""" - try: - # Basic compliance check - compliance_result = { - "user_id": task_data.get("user_id"), - "check_type": task_data.get("check_type", "basic"), - "status": "passed", - "checks_performed": ["kyc", "aml", "sanctions"], - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": compliance_result} - except Exception as e: - return {"status": "error", "message": str(e)} diff --git a/apps/agent-services_backup_20260402_121936/agent-compliance/src/compliance_agent.py b/apps/agent-services_backup_20260402_121936/agent-compliance/src/compliance_agent.py deleted file mode 100644 index a04ad5bd..00000000 --- a/apps/agent-services_backup_20260402_121936/agent-compliance/src/compliance_agent.py +++ /dev/null @@ -1,149 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Compliance Agent -Automated compliance and regulatory monitoring agent -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class ComplianceAgent: - """Automated compliance agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.check_interval = config.get("check_interval", 300) # 5 minutes - self.monitored_entities = config.get("monitored_entities", []) - - async def start(self) -> bool: - """Start compliance agent""" - try: - success = await self.bridge.start_agent(self.agent_id, { - "type": "compliance", - "capabilities": ["kyc_check", "aml_screening", "regulatory_reporting"], - "endpoint": f"http://localhost:8006" - }) - - if success: - self.is_running = True - print(f"Compliance agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start compliance agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting compliance agent: {e}") - return False - - async def stop(self) -> bool: - """Stop compliance agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Compliance agent {self.agent_id} stopped successfully") - return success - - async def run_compliance_loop(self): - """Main compliance monitoring loop""" - while self.is_running: - try: - for entity in self.monitored_entities: - await self._perform_compliance_check(entity) - - await asyncio.sleep(self.check_interval) - except Exception as e: - print(f"Error in compliance loop: {e}") - await asyncio.sleep(30) # Wait before retrying - - async def _perform_compliance_check(self, entity_id: str) -> None: - """Perform compliance check for entity""" - try: - compliance_task = { - "type": "compliance_check", - "user_id": entity_id, - "check_type": "full", - "monitored_activities": ["trading", "transfers", "wallet_creation"] - } - - result = await self.bridge.execute_agent_task(self.agent_id, compliance_task) - - if result.get("status") == "success": - compliance_result = result["result"] - await self._handle_compliance_result(entity_id, compliance_result) - else: - print(f"Compliance check failed for {entity_id}: {result}") - - except Exception as e: - print(f"Error performing compliance check for {entity_id}: {e}") - - async def _handle_compliance_result(self, entity_id: str, result: Dict[str, Any]) -> None: - """Handle compliance check result""" - status = result.get("status", "unknown") - - if status == "passed": - print(f"✅ Compliance check passed for {entity_id}") - elif status == "failed": - print(f"❌ Compliance check failed for {entity_id}") - # Trigger alert or further investigation - await self._trigger_compliance_alert(entity_id, result) - else: - print(f"⚠️ Compliance check inconclusive for {entity_id}") - - async def _trigger_compliance_alert(self, entity_id: str, result: Dict[str, Any]) -> None: - """Trigger compliance alert""" - alert_data = { - "entity_id": entity_id, - "alert_type": "compliance_failure", - "severity": "high", - "details": result, - "timestamp": datetime.utcnow().isoformat() - } - - # In a real implementation, this would send to alert system - print(f"🚨 COMPLIANCE ALERT: {json.dumps(alert_data, indent=2)}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - status = await self.bridge.get_agent_status(self.agent_id) - status["monitored_entities"] = len(self.monitored_entities) - status["check_interval"] = self.check_interval - return status - -# Main execution -async def main(): - """Main compliance agent execution""" - agent_id = "compliance-agent-001" - config = { - "check_interval": 60, # 1 minute for testing - "monitored_entities": ["user001", "user002", "user003"] - } - - agent = ComplianceAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run compliance loop - await agent.run_compliance_loop() - except KeyboardInterrupt: - print("Shutting down compliance agent...") - finally: - await agent.stop() - else: - print("Failed to start compliance agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_121936/agent-coordinator/src/coordinator.py b/apps/agent-services_backup_20260402_121936/agent-coordinator/src/coordinator.py deleted file mode 100644 index ce39c3cc..00000000 --- a/apps/agent-services_backup_20260402_121936/agent-coordinator/src/coordinator.py +++ /dev/null @@ -1,132 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Coordinator Service -Agent task coordination and management -""" - -from fastapi import FastAPI, HTTPException -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import uuid -from datetime import datetime -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Coordinator API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_coordinator.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS tasks ( - id TEXT PRIMARY KEY, - task_type TEXT NOT NULL, - payload TEXT NOT NULL, - required_capabilities TEXT NOT NULL, - priority TEXT NOT NULL, - status TEXT NOT NULL, - assigned_agent_id TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - result TEXT - ) - ''') - -# Models -class Task(BaseModel): - id: str - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str - status: str - assigned_agent_id: Optional[str] = None - -class TaskCreation(BaseModel): - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str = "normal" - -# API Endpoints - -@app.post("/api/tasks", response_model=Task) -async def create_task(task: TaskCreation): - """Create a new task""" - task_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO tasks (id, task_type, payload, required_capabilities, priority, status) - VALUES (?, ?, ?, ?, ?, ?) - ''', ( - task_id, task.task_type, json.dumps(task.payload), - json.dumps(task.required_capabilities), task.priority, "pending" - )) - - return Task( - id=task_id, - task_type=task.task_type, - payload=task.payload, - required_capabilities=task.required_capabilities, - priority=task.priority, - status="pending" - ) - -@app.get("/api/tasks", response_model=List[Task]) -async def list_tasks(status: Optional[str] = None): - """List tasks with optional status filter""" - with get_db_connection() as conn: - query = "SELECT * FROM tasks" - params = [] - - if status: - query += " WHERE status = ?" - params.append(status) - - tasks = conn.execute(query, params).fetchall() - - return [ - Task( - id=task["id"], - task_type=task["task_type"], - payload=json.loads(task["payload"]), - required_capabilities=json.loads(task["required_capabilities"]), - priority=task["priority"], - status=task["status"], - assigned_agent_id=task["assigned_agent_id"] - ) - for task in tasks - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8012) diff --git a/apps/agent-services_backup_20260402_121936/agent-protocols/.env.example b/apps/agent-services_backup_20260402_121936/agent-protocols/.env.example deleted file mode 100644 index bf8ed394..00000000 --- a/apps/agent-services_backup_20260402_121936/agent-protocols/.env.example +++ /dev/null @@ -1,19 +0,0 @@ -# AITBC Agent Protocols Environment Configuration -# Copy this file to .env and update with your secure values - -# Agent Protocol Encryption Key (generate a strong, unique key) -AITBC_AGENT_PROTOCOL_KEY=your-secure-encryption-key-here - -# Agent Protocol Salt (generate a unique salt value) -AITBC_AGENT_PROTOCOL_SALT=your-unique-salt-value-here - -# Agent Registry Configuration -AGENT_REGISTRY_HOST=0.0.0.0 -AGENT_REGISTRY_PORT=8003 - -# Database Configuration -AGENT_REGISTRY_DB_PATH=agent_registry.db - -# Security Settings -AGENT_PROTOCOL_TIMEOUT=300 -AGENT_PROTOCOL_MAX_RETRIES=3 diff --git a/apps/agent-services_backup_20260402_121936/agent-protocols/src/__init__.py b/apps/agent-services_backup_20260402_121936/agent-protocols/src/__init__.py deleted file mode 100644 index 9dfeaacd..00000000 --- a/apps/agent-services_backup_20260402_121936/agent-protocols/src/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -""" -Agent Protocols Package -""" - -from .message_protocol import MessageProtocol, MessageTypes, AgentMessageClient -from .task_manager import TaskManager, TaskStatus, TaskPriority, Task - -__all__ = [ - "MessageProtocol", - "MessageTypes", - "AgentMessageClient", - "TaskManager", - "TaskStatus", - "TaskPriority", - "Task" -] diff --git a/apps/agent-services_backup_20260402_121936/agent-protocols/src/message_protocol.py b/apps/agent-services_backup_20260402_121936/agent-protocols/src/message_protocol.py deleted file mode 100644 index 48289d6b..00000000 --- a/apps/agent-services_backup_20260402_121936/agent-protocols/src/message_protocol.py +++ /dev/null @@ -1,113 +0,0 @@ -""" -Message Protocol for AITBC Agents -Handles message creation, routing, and delivery between agents -""" - -import json -import uuid -from datetime import datetime -from typing import Dict, Any, Optional, List -from enum import Enum - -class MessageTypes(Enum): - """Message type enumeration""" - TASK_REQUEST = "task_request" - TASK_RESPONSE = "task_response" - HEARTBEAT = "heartbeat" - STATUS_UPDATE = "status_update" - ERROR = "error" - DATA = "data" - -class MessageProtocol: - """Message protocol handler for agent communication""" - - def __init__(self): - self.messages = [] - self.message_handlers = {} - - def create_message( - self, - sender_id: str, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any], - message_id: Optional[str] = None - ) -> Dict[str, Any]: - """Create a new message""" - if message_id is None: - message_id = str(uuid.uuid4()) - - message = { - "message_id": message_id, - "sender_id": sender_id, - "receiver_id": receiver_id, - "message_type": message_type.value, - "content": content, - "timestamp": datetime.utcnow().isoformat(), - "status": "pending" - } - - self.messages.append(message) - return message - - def send_message(self, message: Dict[str, Any]) -> bool: - """Send a message to the receiver""" - try: - message["status"] = "sent" - message["sent_timestamp"] = datetime.utcnow().isoformat() - return True - except Exception: - message["status"] = "failed" - return False - - def receive_message(self, message_id: str) -> Optional[Dict[str, Any]]: - """Receive and process a message""" - for message in self.messages: - if message["message_id"] == message_id: - message["status"] = "received" - message["received_timestamp"] = datetime.utcnow().isoformat() - return message - return None - - def get_messages_by_agent(self, agent_id: str) -> List[Dict[str, Any]]: - """Get all messages for a specific agent""" - return [ - msg for msg in self.messages - if msg["sender_id"] == agent_id or msg["receiver_id"] == agent_id - ] - -class AgentMessageClient: - """Client for agent message communication""" - - def __init__(self, agent_id: str, protocol: MessageProtocol): - self.agent_id = agent_id - self.protocol = protocol - self.received_messages = [] - - def send_message( - self, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any] - ) -> Dict[str, Any]: - """Send a message to another agent""" - message = self.protocol.create_message( - sender_id=self.agent_id, - receiver_id=receiver_id, - message_type=message_type, - content=content - ) - self.protocol.send_message(message) - return message - - def receive_messages(self) -> List[Dict[str, Any]]: - """Receive all pending messages for this agent""" - messages = [] - for message in self.protocol.messages: - if (message["receiver_id"] == self.agent_id and - message["status"] == "sent" and - message not in self.received_messages): - self.protocol.receive_message(message["message_id"]) - self.received_messages.append(message) - messages.append(message) - return messages diff --git a/apps/agent-services_backup_20260402_121936/agent-protocols/src/task_manager.py b/apps/agent-services_backup_20260402_121936/agent-protocols/src/task_manager.py deleted file mode 100644 index af680c99..00000000 --- a/apps/agent-services_backup_20260402_121936/agent-protocols/src/task_manager.py +++ /dev/null @@ -1,128 +0,0 @@ -""" -Task Manager for AITBC Agents -Handles task creation, assignment, and tracking -""" - -import uuid -from datetime import datetime, timedelta -from typing import Dict, Any, Optional, List -from enum import Enum - -class TaskStatus(Enum): - """Task status enumeration""" - PENDING = "pending" - IN_PROGRESS = "in_progress" - COMPLETED = "completed" - FAILED = "failed" - CANCELLED = "cancelled" - -class TaskPriority(Enum): - """Task priority enumeration""" - LOW = "low" - MEDIUM = "medium" - HIGH = "high" - URGENT = "urgent" - -class Task: - """Task representation""" - - def __init__( - self, - task_id: str, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ): - self.task_id = task_id - self.title = title - self.description = description - self.assigned_to = assigned_to - self.priority = priority - self.created_by = created_by or assigned_to - self.status = TaskStatus.PENDING - self.created_at = datetime.utcnow() - self.updated_at = datetime.utcnow() - self.completed_at = None - self.result = None - self.error = None - -class TaskManager: - """Task manager for agent coordination""" - - def __init__(self): - self.tasks = {} - self.task_history = [] - - def create_task( - self, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ) -> Task: - """Create a new task""" - task_id = str(uuid.uuid4()) - task = Task( - task_id=task_id, - title=title, - description=description, - assigned_to=assigned_to, - priority=priority, - created_by=created_by - ) - - self.tasks[task_id] = task - return task - - def get_task(self, task_id: str) -> Optional[Task]: - """Get a task by ID""" - return self.tasks.get(task_id) - - def update_task_status( - self, - task_id: str, - status: TaskStatus, - result: Optional[Dict[str, Any]] = None, - error: Optional[str] = None - ) -> bool: - """Update task status""" - task = self.get_task(task_id) - if not task: - return False - - task.status = status - task.updated_at = datetime.utcnow() - - if status == TaskStatus.COMPLETED: - task.completed_at = datetime.utcnow() - task.result = result - elif status == TaskStatus.FAILED: - task.error = error - - return True - - def get_tasks_by_agent(self, agent_id: str) -> List[Task]: - """Get all tasks assigned to an agent""" - return [ - task for task in self.tasks.values() - if task.assigned_to == agent_id - ] - - def get_tasks_by_status(self, status: TaskStatus) -> List[Task]: - """Get all tasks with a specific status""" - return [ - task for task in self.tasks.values() - if task.status == status - ] - - def get_overdue_tasks(self, hours: int = 24) -> List[Task]: - """Get tasks that are overdue""" - cutoff_time = datetime.utcnow() - timedelta(hours=hours) - return [ - task for task in self.tasks.values() - if task.status in [TaskStatus.PENDING, TaskStatus.IN_PROGRESS] and - task.created_at < cutoff_time - ] diff --git a/apps/agent-services_backup_20260402_121936/agent-registry/src/app.py b/apps/agent-services_backup_20260402_121936/agent-registry/src/app.py deleted file mode 100644 index 70eb95f7..00000000 --- a/apps/agent-services_backup_20260402_121936/agent-registry/src/app.py +++ /dev/null @@ -1,151 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Registry Service -Central agent discovery and registration system -""" - -from fastapi import FastAPI, HTTPException, Depends -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import time -import uuid -from datetime import datetime, timedelta -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Registry API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_registry.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS agents ( - id TEXT PRIMARY KEY, - name TEXT NOT NULL, - type TEXT NOT NULL, - capabilities TEXT NOT NULL, - chain_id TEXT NOT NULL, - endpoint TEXT NOT NULL, - status TEXT DEFAULT 'active', - last_heartbeat TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - metadata TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP - ) - ''') - -# Models -class Agent(BaseModel): - id: str - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -class AgentRegistration(BaseModel): - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -# API Endpoints - -@app.post("/api/agents/register", response_model=Agent) -async def register_agent(agent: AgentRegistration): - """Register a new agent""" - agent_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO agents (id, name, type, capabilities, chain_id, endpoint, metadata) - VALUES (?, ?, ?, ?, ?, ?, ?) - ''', ( - agent_id, agent.name, agent.type, - json.dumps(agent.capabilities), agent.chain_id, - agent.endpoint, json.dumps(agent.metadata) - )) - conn.commit() - - return Agent( - id=agent_id, - name=agent.name, - type=agent.type, - capabilities=agent.capabilities, - chain_id=agent.chain_id, - endpoint=agent.endpoint, - metadata=agent.metadata - ) - -@app.get("/api/agents", response_model=List[Agent]) -async def list_agents( - agent_type: Optional[str] = None, - chain_id: Optional[str] = None, - capability: Optional[str] = None -): - """List registered agents with optional filters""" - with get_db_connection() as conn: - query = "SELECT * FROM agents WHERE status = 'active'" - params = [] - - if agent_type: - query += " AND type = ?" - params.append(agent_type) - - if chain_id: - query += " AND chain_id = ?" - params.append(chain_id) - - if capability: - query += " AND capabilities LIKE ?" - params.append(f'%{capability}%') - - agents = conn.execute(query, params).fetchall() - - return [ - Agent( - id=agent["id"], - name=agent["name"], - type=agent["type"], - capabilities=json.loads(agent["capabilities"]), - chain_id=agent["chain_id"], - endpoint=agent["endpoint"], - metadata=json.loads(agent["metadata"] or "{}") - ) - for agent in agents - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8013) diff --git a/apps/agent-services_backup_20260402_121936/agent-registry/src/registration.py b/apps/agent-services_backup_20260402_121936/agent-registry/src/registration.py deleted file mode 100644 index 3793139d..00000000 --- a/apps/agent-services_backup_20260402_121936/agent-registry/src/registration.py +++ /dev/null @@ -1,431 +0,0 @@ -""" -Agent Registration System -Handles AI agent registration, capability management, and discovery -""" - -import asyncio -import time -import json -import hashlib -from typing import Dict, List, Optional, Set, Tuple -from dataclasses import dataclass, asdict -from enum import Enum -from decimal import Decimal - -class AgentType(Enum): - AI_MODEL = "ai_model" - DATA_PROVIDER = "data_provider" - VALIDATOR = "validator" - MARKET_MAKER = "market_maker" - BROKER = "broker" - ORACLE = "oracle" - -class AgentStatus(Enum): - REGISTERED = "registered" - ACTIVE = "active" - INACTIVE = "inactive" - SUSPENDED = "suspended" - BANNED = "banned" - -class CapabilityType(Enum): - TEXT_GENERATION = "text_generation" - IMAGE_GENERATION = "image_generation" - DATA_ANALYSIS = "data_analysis" - PREDICTION = "prediction" - VALIDATION = "validation" - COMPUTATION = "computation" - -@dataclass -class AgentCapability: - capability_type: CapabilityType - name: str - version: str - parameters: Dict - performance_metrics: Dict - cost_per_use: Decimal - availability: float - max_concurrent_jobs: int - -@dataclass -class AgentInfo: - agent_id: str - agent_type: AgentType - name: str - owner_address: str - public_key: str - endpoint_url: str - capabilities: List[AgentCapability] - reputation_score: float - total_jobs_completed: int - total_earnings: Decimal - registration_time: float - last_active: float - status: AgentStatus - metadata: Dict - -class AgentRegistry: - """Manages AI agent registration and discovery""" - - def __init__(self): - self.agents: Dict[str, AgentInfo] = {} - self.capability_index: Dict[CapabilityType, Set[str]] = {} # capability -> agent_ids - self.type_index: Dict[AgentType, Set[str]] = {} # agent_type -> agent_ids - self.reputation_scores: Dict[str, float] = {} - self.registration_queue: List[Dict] = [] - - # Registry parameters - self.min_reputation_threshold = 0.5 - self.max_agents_per_type = 1000 - self.registration_fee = Decimal('100.0') - self.inactivity_threshold = 86400 * 7 # 7 days - - # Initialize capability index - for capability_type in CapabilityType: - self.capability_index[capability_type] = set() - - # Initialize type index - for agent_type in AgentType: - self.type_index[agent_type] = set() - - async def register_agent(self, agent_type: AgentType, name: str, owner_address: str, - public_key: str, endpoint_url: str, capabilities: List[Dict], - metadata: Dict = None) -> Tuple[bool, str, Optional[str]]: - """Register a new AI agent""" - try: - # Validate inputs - if not self._validate_registration_inputs(agent_type, name, owner_address, public_key, endpoint_url): - return False, "Invalid registration inputs", None - - # Check if agent already exists - agent_id = self._generate_agent_id(owner_address, name) - if agent_id in self.agents: - return False, "Agent already registered", None - - # Check type limits - if len(self.type_index[agent_type]) >= self.max_agents_per_type: - return False, f"Maximum agents of type {agent_type.value} reached", None - - # Convert capabilities - agent_capabilities = [] - for cap_data in capabilities: - capability = self._create_capability_from_data(cap_data) - if capability: - agent_capabilities.append(capability) - - if not agent_capabilities: - return False, "Agent must have at least one valid capability", None - - # Create agent info - agent_info = AgentInfo( - agent_id=agent_id, - agent_type=agent_type, - name=name, - owner_address=owner_address, - public_key=public_key, - endpoint_url=endpoint_url, - capabilities=agent_capabilities, - reputation_score=1.0, # Start with neutral reputation - total_jobs_completed=0, - total_earnings=Decimal('0'), - registration_time=time.time(), - last_active=time.time(), - status=AgentStatus.REGISTERED, - metadata=metadata or {} - ) - - # Add to registry - self.agents[agent_id] = agent_info - - # Update indexes - self.type_index[agent_type].add(agent_id) - for capability in agent_capabilities: - self.capability_index[capability.capability_type].add(agent_id) - - log_info(f"Agent registered: {agent_id} ({name})") - return True, "Registration successful", agent_id - - except Exception as e: - return False, f"Registration failed: {str(e)}", None - - def _validate_registration_inputs(self, agent_type: AgentType, name: str, - owner_address: str, public_key: str, endpoint_url: str) -> bool: - """Validate registration inputs""" - # Check required fields - if not all([agent_type, name, owner_address, public_key, endpoint_url]): - return False - - # Validate address format (simplified) - if not owner_address.startswith('0x') or len(owner_address) != 42: - return False - - # Validate URL format (simplified) - if not endpoint_url.startswith(('http://', 'https://')): - return False - - # Validate name - if len(name) < 3 or len(name) > 100: - return False - - return True - - def _generate_agent_id(self, owner_address: str, name: str) -> str: - """Generate unique agent ID""" - content = f"{owner_address}:{name}:{time.time()}" - return hashlib.sha256(content.encode()).hexdigest()[:16] - - def _create_capability_from_data(self, cap_data: Dict) -> Optional[AgentCapability]: - """Create capability from data dictionary""" - try: - # Validate required fields - required_fields = ['type', 'name', 'version', 'cost_per_use'] - if not all(field in cap_data for field in required_fields): - return None - - # Parse capability type - try: - capability_type = CapabilityType(cap_data['type']) - except ValueError: - return None - - # Create capability - return AgentCapability( - capability_type=capability_type, - name=cap_data['name'], - version=cap_data['version'], - parameters=cap_data.get('parameters', {}), - performance_metrics=cap_data.get('performance_metrics', {}), - cost_per_use=Decimal(str(cap_data['cost_per_use'])), - availability=cap_data.get('availability', 1.0), - max_concurrent_jobs=cap_data.get('max_concurrent_jobs', 1) - ) - - except Exception as e: - log_error(f"Error creating capability: {e}") - return None - - async def update_agent_status(self, agent_id: str, status: AgentStatus) -> Tuple[bool, str]: - """Update agent status""" - if agent_id not in self.agents: - return False, "Agent not found" - - agent = self.agents[agent_id] - old_status = agent.status - agent.status = status - agent.last_active = time.time() - - log_info(f"Agent {agent_id} status changed: {old_status.value} -> {status.value}") - return True, "Status updated successfully" - - async def update_agent_capabilities(self, agent_id: str, capabilities: List[Dict]) -> Tuple[bool, str]: - """Update agent capabilities""" - if agent_id not in self.agents: - return False, "Agent not found" - - agent = self.agents[agent_id] - - # Remove old capabilities from index - for old_capability in agent.capabilities: - self.capability_index[old_capability.capability_type].discard(agent_id) - - # Add new capabilities - new_capabilities = [] - for cap_data in capabilities: - capability = self._create_capability_from_data(cap_data) - if capability: - new_capabilities.append(capability) - self.capability_index[capability.capability_type].add(agent_id) - - if not new_capabilities: - return False, "No valid capabilities provided" - - agent.capabilities = new_capabilities - agent.last_active = time.time() - - return True, "Capabilities updated successfully" - - async def find_agents_by_capability(self, capability_type: CapabilityType, - filters: Dict = None) -> List[AgentInfo]: - """Find agents by capability type""" - agent_ids = self.capability_index.get(capability_type, set()) - - agents = [] - for agent_id in agent_ids: - agent = self.agents.get(agent_id) - if agent and agent.status == AgentStatus.ACTIVE: - if self._matches_filters(agent, filters): - agents.append(agent) - - # Sort by reputation (highest first) - agents.sort(key=lambda x: x.reputation_score, reverse=True) - return agents - - async def find_agents_by_type(self, agent_type: AgentType, filters: Dict = None) -> List[AgentInfo]: - """Find agents by type""" - agent_ids = self.type_index.get(agent_type, set()) - - agents = [] - for agent_id in agent_ids: - agent = self.agents.get(agent_id) - if agent and agent.status == AgentStatus.ACTIVE: - if self._matches_filters(agent, filters): - agents.append(agent) - - # Sort by reputation (highest first) - agents.sort(key=lambda x: x.reputation_score, reverse=True) - return agents - - def _matches_filters(self, agent: AgentInfo, filters: Dict) -> bool: - """Check if agent matches filters""" - if not filters: - return True - - # Reputation filter - if 'min_reputation' in filters: - if agent.reputation_score < filters['min_reputation']: - return False - - # Cost filter - if 'max_cost_per_use' in filters: - max_cost = Decimal(str(filters['max_cost_per_use'])) - if any(cap.cost_per_use > max_cost for cap in agent.capabilities): - return False - - # Availability filter - if 'min_availability' in filters: - min_availability = filters['min_availability'] - if any(cap.availability < min_availability for cap in agent.capabilities): - return False - - # Location filter (if implemented) - if 'location' in filters: - agent_location = agent.metadata.get('location') - if agent_location != filters['location']: - return False - - return True - - async def get_agent_info(self, agent_id: str) -> Optional[AgentInfo]: - """Get agent information""" - return self.agents.get(agent_id) - - async def search_agents(self, query: str, limit: int = 50) -> List[AgentInfo]: - """Search agents by name or capability""" - query_lower = query.lower() - results = [] - - for agent in self.agents.values(): - if agent.status != AgentStatus.ACTIVE: - continue - - # Search in name - if query_lower in agent.name.lower(): - results.append(agent) - continue - - # Search in capabilities - for capability in agent.capabilities: - if (query_lower in capability.name.lower() or - query_lower in capability.capability_type.value): - results.append(agent) - break - - # Sort by relevance (reputation) - results.sort(key=lambda x: x.reputation_score, reverse=True) - return results[:limit] - - async def get_agent_statistics(self, agent_id: str) -> Optional[Dict]: - """Get detailed statistics for an agent""" - agent = self.agents.get(agent_id) - if not agent: - return None - - # Calculate additional statistics - avg_job_earnings = agent.total_earnings / agent.total_jobs_completed if agent.total_jobs_completed > 0 else Decimal('0') - days_active = (time.time() - agent.registration_time) / 86400 - jobs_per_day = agent.total_jobs_completed / days_active if days_active > 0 else 0 - - return { - 'agent_id': agent_id, - 'name': agent.name, - 'type': agent.agent_type.value, - 'status': agent.status.value, - 'reputation_score': agent.reputation_score, - 'total_jobs_completed': agent.total_jobs_completed, - 'total_earnings': float(agent.total_earnings), - 'avg_job_earnings': float(avg_job_earnings), - 'jobs_per_day': jobs_per_day, - 'days_active': int(days_active), - 'capabilities_count': len(agent.capabilities), - 'last_active': agent.last_active, - 'registration_time': agent.registration_time - } - - async def get_registry_statistics(self) -> Dict: - """Get registry-wide statistics""" - total_agents = len(self.agents) - active_agents = len([a for a in self.agents.values() if a.status == AgentStatus.ACTIVE]) - - # Count by type - type_counts = {} - for agent_type in AgentType: - type_counts[agent_type.value] = len(self.type_index[agent_type]) - - # Count by capability - capability_counts = {} - for capability_type in CapabilityType: - capability_counts[capability_type.value] = len(self.capability_index[capability_type]) - - # Reputation statistics - reputations = [a.reputation_score for a in self.agents.values()] - avg_reputation = sum(reputations) / len(reputations) if reputations else 0 - - # Earnings statistics - total_earnings = sum(a.total_earnings for a in self.agents.values()) - - return { - 'total_agents': total_agents, - 'active_agents': active_agents, - 'inactive_agents': total_agents - active_agents, - 'agent_types': type_counts, - 'capabilities': capability_counts, - 'average_reputation': avg_reputation, - 'total_earnings': float(total_earnings), - 'registration_fee': float(self.registration_fee) - } - - async def cleanup_inactive_agents(self) -> Tuple[int, str]: - """Clean up inactive agents""" - current_time = time.time() - cleaned_count = 0 - - for agent_id, agent in list(self.agents.items()): - if (agent.status == AgentStatus.INACTIVE and - current_time - agent.last_active > self.inactivity_threshold): - - # Remove from registry - del self.agents[agent_id] - - # Update indexes - self.type_index[agent.agent_type].discard(agent_id) - for capability in agent.capabilities: - self.capability_index[capability.capability_type].discard(agent_id) - - cleaned_count += 1 - - if cleaned_count > 0: - log_info(f"Cleaned up {cleaned_count} inactive agents") - - return cleaned_count, f"Cleaned up {cleaned_count} inactive agents" - -# Global agent registry -agent_registry: Optional[AgentRegistry] = None - -def get_agent_registry() -> Optional[AgentRegistry]: - """Get global agent registry""" - return agent_registry - -def create_agent_registry() -> AgentRegistry: - """Create and set global agent registry""" - global agent_registry - agent_registry = AgentRegistry() - return agent_registry diff --git a/apps/agent-services_backup_20260402_121936/agent-trading/src/trading_agent.py b/apps/agent-services_backup_20260402_121936/agent-trading/src/trading_agent.py deleted file mode 100644 index 181d963b..00000000 --- a/apps/agent-services_backup_20260402_121936/agent-trading/src/trading_agent.py +++ /dev/null @@ -1,166 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Trading Agent -Automated trading agent for AITBC marketplace -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class TradingAgent: - """Automated trading agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.trading_strategy = config.get("strategy", "basic") - self.symbols = config.get("symbols", ["AITBC/BTC"]) - self.trade_interval = config.get("trade_interval", 60) # seconds - - async def start(self) -> bool: - """Start trading agent""" - try: - # Register with service bridge - success = await self.bridge.start_agent(self.agent_id, { - "type": "trading", - "capabilities": ["market_analysis", "trading", "risk_management"], - "endpoint": f"http://localhost:8005" - }) - - if success: - self.is_running = True - print(f"Trading agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start trading agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting trading agent: {e}") - return False - - async def stop(self) -> bool: - """Stop trading agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Trading agent {self.agent_id} stopped successfully") - return success - - async def run_trading_loop(self): - """Main trading loop""" - while self.is_running: - try: - for symbol in self.symbols: - await self._analyze_and_trade(symbol) - - await asyncio.sleep(self.trade_interval) - except Exception as e: - print(f"Error in trading loop: {e}") - await asyncio.sleep(10) # Wait before retrying - - async def _analyze_and_trade(self, symbol: str) -> None: - """Analyze market and execute trades""" - try: - # Perform market analysis - analysis_task = { - "type": "market_analysis", - "symbol": symbol, - "strategy": self.trading_strategy - } - - analysis_result = await self.bridge.execute_agent_task(self.agent_id, analysis_task) - - if analysis_result.get("status") == "success": - analysis = analysis_result["result"]["analysis"] - - # Make trading decision - if self._should_trade(analysis): - await self._execute_trade(symbol, analysis) - else: - print(f"Market analysis failed for {symbol}: {analysis_result}") - - except Exception as e: - print(f"Error in analyze_and_trade for {symbol}: {e}") - - def _should_trade(self, analysis: Dict[str, Any]) -> bool: - """Determine if should execute trade""" - recommendation = analysis.get("recommendation", "hold") - return recommendation in ["buy", "sell"] - - async def _execute_trade(self, symbol: str, analysis: Dict[str, Any]) -> None: - """Execute trade based on analysis""" - try: - recommendation = analysis.get("recommendation", "hold") - - if recommendation == "buy": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "buy", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - elif recommendation == "sell": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "sell", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - else: - return - - trade_result = await self.bridge.execute_agent_task(self.agent_id, trade_task) - - if trade_result.get("status") == "success": - print(f"Trade executed successfully: {trade_result}") - else: - print(f"Trade execution failed: {trade_result}") - - except Exception as e: - print(f"Error executing trade: {e}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - return await self.bridge.get_agent_status(self.agent_id) - -# Main execution -async def main(): - """Main trading agent execution""" - agent_id = "trading-agent-001" - config = { - "strategy": "basic", - "symbols": ["AITBC/BTC"], - "trade_interval": 30, - "trade_amount": 0.1 - } - - agent = TradingAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run trading loop - await agent.run_trading_loop() - except KeyboardInterrupt: - print("Shutting down trading agent...") - finally: - await agent.stop() - else: - print("Failed to start trading agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_122040/agent-bridge/src/integration_layer.py b/apps/agent-services_backup_20260402_122040/agent-bridge/src/integration_layer.py deleted file mode 100644 index f1be04db..00000000 --- a/apps/agent-services_backup_20260402_122040/agent-bridge/src/integration_layer.py +++ /dev/null @@ -1,229 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Integration Layer -Connects agent protocols to existing AITBC services -""" - -import asyncio -import aiohttp -import json -from typing import Dict, Any, List, Optional -from datetime import datetime - -class AITBCServiceIntegration: - """Integration layer for AITBC services""" - - def __init__(self): - self.service_endpoints = { - "coordinator_api": "http://localhost:8000", - "blockchain_rpc": "http://localhost:8006", - "exchange_service": "http://localhost:8001", - "marketplace": "http://localhost:8002", - "agent_registry": "http://localhost:8013" - } - self.session = None - - async def __aenter__(self): - self.session = aiohttp.ClientSession() - return self - - async def __aexit__(self, exc_type, exc_val, exc_tb): - if self.session: - await self.session.close() - - async def get_blockchain_info(self) -> Dict[str, Any]: - """Get blockchain information""" - try: - async with self.session.get(f"{self.service_endpoints['blockchain_rpc']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_exchange_status(self) -> Dict[str, Any]: - """Get exchange service status""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def get_coordinator_status(self) -> Dict[str, Any]: - """Get coordinator API status""" - try: - async with self.session.get(f"{self.service_endpoints['coordinator_api']}/health") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "unavailable"} - - async def submit_transaction(self, transaction_data: Dict[str, Any]) -> Dict[str, Any]: - """Submit transaction to blockchain""" - try: - async with self.session.post( - f"{self.service_endpoints['blockchain_rpc']}/rpc/submit", - json=transaction_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def get_market_data(self, symbol: str = "AITBC/BTC") -> Dict[str, Any]: - """Get market data from exchange""" - try: - async with self.session.get(f"{self.service_endpoints['exchange_service']}/api/market/{symbol}") as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - - async def register_agent_with_coordinator(self, agent_data: Dict[str, Any]) -> Dict[str, Any]: - """Register agent with coordinator""" - try: - async with self.session.post( - f"{self.service_endpoints['agent_registry']}/api/agents/register", - json=agent_data - ) as response: - return await response.json() - except Exception as e: - return {"error": str(e), "status": "failed"} - -class AgentServiceBridge: - """Bridge between agents and AITBC services""" - - def __init__(self): - self.integration = AITBCServiceIntegration() - self.active_agents = {} - - async def start_agent(self, agent_id: str, agent_config: Dict[str, Any]) -> bool: - """Start an agent with service integration""" - try: - # Register agent with coordinator - async with self.integration as integration: - registration_result = await integration.register_agent_with_coordinator({ - "name": agent_id, - "type": agent_config.get("type", "generic"), - "capabilities": agent_config.get("capabilities", []), - "chain_id": agent_config.get("chain_id", "ait-mainnet"), - "endpoint": agent_config.get("endpoint", f"http://localhost:{8000 + len(self.active_agents) + 10}") - }) - - # The registry returns the created agent dict on success, not a {"status": "ok"} wrapper - if registration_result and "id" in registration_result: - self.active_agents[agent_id] = { - "config": agent_config, - "registration": registration_result, - "started_at": datetime.utcnow() - } - return True - else: - print(f"Registration failed: {registration_result}") - return False - except Exception as e: - print(f"Failed to start agent {agent_id}: {e}") - return False - - async def stop_agent(self, agent_id: str) -> bool: - """Stop an agent""" - if agent_id in self.active_agents: - del self.active_agents[agent_id] - return True - return False - - async def get_agent_status(self, agent_id: str) -> Dict[str, Any]: - """Get agent status with service integration""" - if agent_id not in self.active_agents: - return {"status": "not_found"} - - agent_info = self.active_agents[agent_id] - - async with self.integration as integration: - # Get service statuses - blockchain_status = await integration.get_blockchain_info() - exchange_status = await integration.get_exchange_status() - coordinator_status = await integration.get_coordinator_status() - - return { - "agent_id": agent_id, - "status": "active", - "started_at": agent_info["started_at"].isoformat(), - "services": { - "blockchain": blockchain_status, - "exchange": exchange_status, - "coordinator": coordinator_status - } - } - - async def execute_agent_task(self, agent_id: str, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute agent task with service integration""" - if agent_id not in self.active_agents: - return {"status": "error", "message": "Agent not found"} - - task_type = task_data.get("type") - - if task_type == "market_analysis": - return await self._execute_market_analysis(task_data) - elif task_type == "trading": - return await self._execute_trading_task(task_data) - elif task_type == "compliance_check": - return await self._execute_compliance_check(task_data) - else: - return {"status": "error", "message": f"Unknown task type: {task_type}"} - - async def _execute_market_analysis(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute market analysis task""" - try: - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Perform basic analysis - analysis_result = { - "symbol": task_data.get("symbol", "AITBC/BTC"), - "market_data": market_data, - "analysis": { - "trend": "neutral", - "volatility": "medium", - "recommendation": "hold" - }, - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": analysis_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_trading_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute trading task""" - try: - # Get market data first - async with self.integration as integration: - market_data = await integration.get_market_data(task_data.get("symbol", "AITBC/BTC")) - - # Create transaction - transaction = { - "type": "trade", - "symbol": task_data.get("symbol", "AITBC/BTC"), - "side": task_data.get("side", "buy"), - "amount": task_data.get("amount", 0.1), - "price": task_data.get("price", market_data.get("price", 0.001)) - } - - # Submit transaction - tx_result = await integration.submit_transaction(transaction) - - return {"status": "success", "transaction": tx_result} - except Exception as e: - return {"status": "error", "message": str(e)} - - async def _execute_compliance_check(self, task_data: Dict[str, Any]) -> Dict[str, Any]: - """Execute compliance check task""" - try: - # Basic compliance check - compliance_result = { - "user_id": task_data.get("user_id"), - "check_type": task_data.get("check_type", "basic"), - "status": "passed", - "checks_performed": ["kyc", "aml", "sanctions"], - "timestamp": datetime.utcnow().isoformat() - } - - return {"status": "success", "result": compliance_result} - except Exception as e: - return {"status": "error", "message": str(e)} diff --git a/apps/agent-services_backup_20260402_122040/agent-compliance/src/compliance_agent.py b/apps/agent-services_backup_20260402_122040/agent-compliance/src/compliance_agent.py deleted file mode 100644 index a04ad5bd..00000000 --- a/apps/agent-services_backup_20260402_122040/agent-compliance/src/compliance_agent.py +++ /dev/null @@ -1,149 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Compliance Agent -Automated compliance and regulatory monitoring agent -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class ComplianceAgent: - """Automated compliance agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.check_interval = config.get("check_interval", 300) # 5 minutes - self.monitored_entities = config.get("monitored_entities", []) - - async def start(self) -> bool: - """Start compliance agent""" - try: - success = await self.bridge.start_agent(self.agent_id, { - "type": "compliance", - "capabilities": ["kyc_check", "aml_screening", "regulatory_reporting"], - "endpoint": f"http://localhost:8006" - }) - - if success: - self.is_running = True - print(f"Compliance agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start compliance agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting compliance agent: {e}") - return False - - async def stop(self) -> bool: - """Stop compliance agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Compliance agent {self.agent_id} stopped successfully") - return success - - async def run_compliance_loop(self): - """Main compliance monitoring loop""" - while self.is_running: - try: - for entity in self.monitored_entities: - await self._perform_compliance_check(entity) - - await asyncio.sleep(self.check_interval) - except Exception as e: - print(f"Error in compliance loop: {e}") - await asyncio.sleep(30) # Wait before retrying - - async def _perform_compliance_check(self, entity_id: str) -> None: - """Perform compliance check for entity""" - try: - compliance_task = { - "type": "compliance_check", - "user_id": entity_id, - "check_type": "full", - "monitored_activities": ["trading", "transfers", "wallet_creation"] - } - - result = await self.bridge.execute_agent_task(self.agent_id, compliance_task) - - if result.get("status") == "success": - compliance_result = result["result"] - await self._handle_compliance_result(entity_id, compliance_result) - else: - print(f"Compliance check failed for {entity_id}: {result}") - - except Exception as e: - print(f"Error performing compliance check for {entity_id}: {e}") - - async def _handle_compliance_result(self, entity_id: str, result: Dict[str, Any]) -> None: - """Handle compliance check result""" - status = result.get("status", "unknown") - - if status == "passed": - print(f"✅ Compliance check passed for {entity_id}") - elif status == "failed": - print(f"❌ Compliance check failed for {entity_id}") - # Trigger alert or further investigation - await self._trigger_compliance_alert(entity_id, result) - else: - print(f"⚠️ Compliance check inconclusive for {entity_id}") - - async def _trigger_compliance_alert(self, entity_id: str, result: Dict[str, Any]) -> None: - """Trigger compliance alert""" - alert_data = { - "entity_id": entity_id, - "alert_type": "compliance_failure", - "severity": "high", - "details": result, - "timestamp": datetime.utcnow().isoformat() - } - - # In a real implementation, this would send to alert system - print(f"🚨 COMPLIANCE ALERT: {json.dumps(alert_data, indent=2)}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - status = await self.bridge.get_agent_status(self.agent_id) - status["monitored_entities"] = len(self.monitored_entities) - status["check_interval"] = self.check_interval - return status - -# Main execution -async def main(): - """Main compliance agent execution""" - agent_id = "compliance-agent-001" - config = { - "check_interval": 60, # 1 minute for testing - "monitored_entities": ["user001", "user002", "user003"] - } - - agent = ComplianceAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run compliance loop - await agent.run_compliance_loop() - except KeyboardInterrupt: - print("Shutting down compliance agent...") - finally: - await agent.stop() - else: - print("Failed to start compliance agent") - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/apps/agent-services_backup_20260402_122040/agent-coordinator/src/coordinator.py b/apps/agent-services_backup_20260402_122040/agent-coordinator/src/coordinator.py deleted file mode 100644 index ce39c3cc..00000000 --- a/apps/agent-services_backup_20260402_122040/agent-coordinator/src/coordinator.py +++ /dev/null @@ -1,132 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Coordinator Service -Agent task coordination and management -""" - -from fastapi import FastAPI, HTTPException -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import uuid -from datetime import datetime -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Coordinator API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_coordinator.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS tasks ( - id TEXT PRIMARY KEY, - task_type TEXT NOT NULL, - payload TEXT NOT NULL, - required_capabilities TEXT NOT NULL, - priority TEXT NOT NULL, - status TEXT NOT NULL, - assigned_agent_id TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - result TEXT - ) - ''') - -# Models -class Task(BaseModel): - id: str - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str - status: str - assigned_agent_id: Optional[str] = None - -class TaskCreation(BaseModel): - task_type: str - payload: Dict[str, Any] - required_capabilities: List[str] - priority: str = "normal" - -# API Endpoints - -@app.post("/api/tasks", response_model=Task) -async def create_task(task: TaskCreation): - """Create a new task""" - task_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO tasks (id, task_type, payload, required_capabilities, priority, status) - VALUES (?, ?, ?, ?, ?, ?) - ''', ( - task_id, task.task_type, json.dumps(task.payload), - json.dumps(task.required_capabilities), task.priority, "pending" - )) - - return Task( - id=task_id, - task_type=task.task_type, - payload=task.payload, - required_capabilities=task.required_capabilities, - priority=task.priority, - status="pending" - ) - -@app.get("/api/tasks", response_model=List[Task]) -async def list_tasks(status: Optional[str] = None): - """List tasks with optional status filter""" - with get_db_connection() as conn: - query = "SELECT * FROM tasks" - params = [] - - if status: - query += " WHERE status = ?" - params.append(status) - - tasks = conn.execute(query, params).fetchall() - - return [ - Task( - id=task["id"], - task_type=task["task_type"], - payload=json.loads(task["payload"]), - required_capabilities=json.loads(task["required_capabilities"]), - priority=task["priority"], - status=task["status"], - assigned_agent_id=task["assigned_agent_id"] - ) - for task in tasks - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8012) diff --git a/apps/agent-services_backup_20260402_122040/agent-protocols/.env.example b/apps/agent-services_backup_20260402_122040/agent-protocols/.env.example deleted file mode 100644 index bf8ed394..00000000 --- a/apps/agent-services_backup_20260402_122040/agent-protocols/.env.example +++ /dev/null @@ -1,19 +0,0 @@ -# AITBC Agent Protocols Environment Configuration -# Copy this file to .env and update with your secure values - -# Agent Protocol Encryption Key (generate a strong, unique key) -AITBC_AGENT_PROTOCOL_KEY=your-secure-encryption-key-here - -# Agent Protocol Salt (generate a unique salt value) -AITBC_AGENT_PROTOCOL_SALT=your-unique-salt-value-here - -# Agent Registry Configuration -AGENT_REGISTRY_HOST=0.0.0.0 -AGENT_REGISTRY_PORT=8003 - -# Database Configuration -AGENT_REGISTRY_DB_PATH=agent_registry.db - -# Security Settings -AGENT_PROTOCOL_TIMEOUT=300 -AGENT_PROTOCOL_MAX_RETRIES=3 diff --git a/apps/agent-services_backup_20260402_122040/agent-protocols/src/__init__.py b/apps/agent-services_backup_20260402_122040/agent-protocols/src/__init__.py deleted file mode 100644 index 9dfeaacd..00000000 --- a/apps/agent-services_backup_20260402_122040/agent-protocols/src/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -""" -Agent Protocols Package -""" - -from .message_protocol import MessageProtocol, MessageTypes, AgentMessageClient -from .task_manager import TaskManager, TaskStatus, TaskPriority, Task - -__all__ = [ - "MessageProtocol", - "MessageTypes", - "AgentMessageClient", - "TaskManager", - "TaskStatus", - "TaskPriority", - "Task" -] diff --git a/apps/agent-services_backup_20260402_122040/agent-protocols/src/message_protocol.py b/apps/agent-services_backup_20260402_122040/agent-protocols/src/message_protocol.py deleted file mode 100644 index 48289d6b..00000000 --- a/apps/agent-services_backup_20260402_122040/agent-protocols/src/message_protocol.py +++ /dev/null @@ -1,113 +0,0 @@ -""" -Message Protocol for AITBC Agents -Handles message creation, routing, and delivery between agents -""" - -import json -import uuid -from datetime import datetime -from typing import Dict, Any, Optional, List -from enum import Enum - -class MessageTypes(Enum): - """Message type enumeration""" - TASK_REQUEST = "task_request" - TASK_RESPONSE = "task_response" - HEARTBEAT = "heartbeat" - STATUS_UPDATE = "status_update" - ERROR = "error" - DATA = "data" - -class MessageProtocol: - """Message protocol handler for agent communication""" - - def __init__(self): - self.messages = [] - self.message_handlers = {} - - def create_message( - self, - sender_id: str, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any], - message_id: Optional[str] = None - ) -> Dict[str, Any]: - """Create a new message""" - if message_id is None: - message_id = str(uuid.uuid4()) - - message = { - "message_id": message_id, - "sender_id": sender_id, - "receiver_id": receiver_id, - "message_type": message_type.value, - "content": content, - "timestamp": datetime.utcnow().isoformat(), - "status": "pending" - } - - self.messages.append(message) - return message - - def send_message(self, message: Dict[str, Any]) -> bool: - """Send a message to the receiver""" - try: - message["status"] = "sent" - message["sent_timestamp"] = datetime.utcnow().isoformat() - return True - except Exception: - message["status"] = "failed" - return False - - def receive_message(self, message_id: str) -> Optional[Dict[str, Any]]: - """Receive and process a message""" - for message in self.messages: - if message["message_id"] == message_id: - message["status"] = "received" - message["received_timestamp"] = datetime.utcnow().isoformat() - return message - return None - - def get_messages_by_agent(self, agent_id: str) -> List[Dict[str, Any]]: - """Get all messages for a specific agent""" - return [ - msg for msg in self.messages - if msg["sender_id"] == agent_id or msg["receiver_id"] == agent_id - ] - -class AgentMessageClient: - """Client for agent message communication""" - - def __init__(self, agent_id: str, protocol: MessageProtocol): - self.agent_id = agent_id - self.protocol = protocol - self.received_messages = [] - - def send_message( - self, - receiver_id: str, - message_type: MessageTypes, - content: Dict[str, Any] - ) -> Dict[str, Any]: - """Send a message to another agent""" - message = self.protocol.create_message( - sender_id=self.agent_id, - receiver_id=receiver_id, - message_type=message_type, - content=content - ) - self.protocol.send_message(message) - return message - - def receive_messages(self) -> List[Dict[str, Any]]: - """Receive all pending messages for this agent""" - messages = [] - for message in self.protocol.messages: - if (message["receiver_id"] == self.agent_id and - message["status"] == "sent" and - message not in self.received_messages): - self.protocol.receive_message(message["message_id"]) - self.received_messages.append(message) - messages.append(message) - return messages diff --git a/apps/agent-services_backup_20260402_122040/agent-protocols/src/task_manager.py b/apps/agent-services_backup_20260402_122040/agent-protocols/src/task_manager.py deleted file mode 100644 index af680c99..00000000 --- a/apps/agent-services_backup_20260402_122040/agent-protocols/src/task_manager.py +++ /dev/null @@ -1,128 +0,0 @@ -""" -Task Manager for AITBC Agents -Handles task creation, assignment, and tracking -""" - -import uuid -from datetime import datetime, timedelta -from typing import Dict, Any, Optional, List -from enum import Enum - -class TaskStatus(Enum): - """Task status enumeration""" - PENDING = "pending" - IN_PROGRESS = "in_progress" - COMPLETED = "completed" - FAILED = "failed" - CANCELLED = "cancelled" - -class TaskPriority(Enum): - """Task priority enumeration""" - LOW = "low" - MEDIUM = "medium" - HIGH = "high" - URGENT = "urgent" - -class Task: - """Task representation""" - - def __init__( - self, - task_id: str, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ): - self.task_id = task_id - self.title = title - self.description = description - self.assigned_to = assigned_to - self.priority = priority - self.created_by = created_by or assigned_to - self.status = TaskStatus.PENDING - self.created_at = datetime.utcnow() - self.updated_at = datetime.utcnow() - self.completed_at = None - self.result = None - self.error = None - -class TaskManager: - """Task manager for agent coordination""" - - def __init__(self): - self.tasks = {} - self.task_history = [] - - def create_task( - self, - title: str, - description: str, - assigned_to: str, - priority: TaskPriority = TaskPriority.MEDIUM, - created_by: Optional[str] = None - ) -> Task: - """Create a new task""" - task_id = str(uuid.uuid4()) - task = Task( - task_id=task_id, - title=title, - description=description, - assigned_to=assigned_to, - priority=priority, - created_by=created_by - ) - - self.tasks[task_id] = task - return task - - def get_task(self, task_id: str) -> Optional[Task]: - """Get a task by ID""" - return self.tasks.get(task_id) - - def update_task_status( - self, - task_id: str, - status: TaskStatus, - result: Optional[Dict[str, Any]] = None, - error: Optional[str] = None - ) -> bool: - """Update task status""" - task = self.get_task(task_id) - if not task: - return False - - task.status = status - task.updated_at = datetime.utcnow() - - if status == TaskStatus.COMPLETED: - task.completed_at = datetime.utcnow() - task.result = result - elif status == TaskStatus.FAILED: - task.error = error - - return True - - def get_tasks_by_agent(self, agent_id: str) -> List[Task]: - """Get all tasks assigned to an agent""" - return [ - task for task in self.tasks.values() - if task.assigned_to == agent_id - ] - - def get_tasks_by_status(self, status: TaskStatus) -> List[Task]: - """Get all tasks with a specific status""" - return [ - task for task in self.tasks.values() - if task.status == status - ] - - def get_overdue_tasks(self, hours: int = 24) -> List[Task]: - """Get tasks that are overdue""" - cutoff_time = datetime.utcnow() - timedelta(hours=hours) - return [ - task for task in self.tasks.values() - if task.status in [TaskStatus.PENDING, TaskStatus.IN_PROGRESS] and - task.created_at < cutoff_time - ] diff --git a/apps/agent-services_backup_20260402_122040/agent-registry/src/app.py b/apps/agent-services_backup_20260402_122040/agent-registry/src/app.py deleted file mode 100644 index 70eb95f7..00000000 --- a/apps/agent-services_backup_20260402_122040/agent-registry/src/app.py +++ /dev/null @@ -1,151 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Agent Registry Service -Central agent discovery and registration system -""" - -from fastapi import FastAPI, HTTPException, Depends -from pydantic import BaseModel -from typing import List, Optional, Dict, Any -import json -import time -import uuid -from datetime import datetime, timedelta -import sqlite3 -from contextlib import contextmanager -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup - init_db() - yield - # Shutdown (cleanup if needed) - pass - -app = FastAPI(title="AITBC Agent Registry API", version="1.0.0", lifespan=lifespan) - -# Database setup -def get_db(): - conn = sqlite3.connect('agent_registry.db') - conn.row_factory = sqlite3.Row - return conn - -@contextmanager -def get_db_connection(): - conn = get_db() - try: - yield conn - finally: - conn.close() - -# Initialize database -def init_db(): - with get_db_connection() as conn: - conn.execute(''' - CREATE TABLE IF NOT EXISTS agents ( - id TEXT PRIMARY KEY, - name TEXT NOT NULL, - type TEXT NOT NULL, - capabilities TEXT NOT NULL, - chain_id TEXT NOT NULL, - endpoint TEXT NOT NULL, - status TEXT DEFAULT 'active', - last_heartbeat TIMESTAMP DEFAULT CURRENT_TIMESTAMP, - metadata TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP - ) - ''') - -# Models -class Agent(BaseModel): - id: str - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -class AgentRegistration(BaseModel): - name: str - type: str - capabilities: List[str] - chain_id: str - endpoint: str - metadata: Optional[Dict[str, Any]] = {} - -# API Endpoints - -@app.post("/api/agents/register", response_model=Agent) -async def register_agent(agent: AgentRegistration): - """Register a new agent""" - agent_id = str(uuid.uuid4()) - - with get_db_connection() as conn: - conn.execute(''' - INSERT INTO agents (id, name, type, capabilities, chain_id, endpoint, metadata) - VALUES (?, ?, ?, ?, ?, ?, ?) - ''', ( - agent_id, agent.name, agent.type, - json.dumps(agent.capabilities), agent.chain_id, - agent.endpoint, json.dumps(agent.metadata) - )) - conn.commit() - - return Agent( - id=agent_id, - name=agent.name, - type=agent.type, - capabilities=agent.capabilities, - chain_id=agent.chain_id, - endpoint=agent.endpoint, - metadata=agent.metadata - ) - -@app.get("/api/agents", response_model=List[Agent]) -async def list_agents( - agent_type: Optional[str] = None, - chain_id: Optional[str] = None, - capability: Optional[str] = None -): - """List registered agents with optional filters""" - with get_db_connection() as conn: - query = "SELECT * FROM agents WHERE status = 'active'" - params = [] - - if agent_type: - query += " AND type = ?" - params.append(agent_type) - - if chain_id: - query += " AND chain_id = ?" - params.append(chain_id) - - if capability: - query += " AND capabilities LIKE ?" - params.append(f'%{capability}%') - - agents = conn.execute(query, params).fetchall() - - return [ - Agent( - id=agent["id"], - name=agent["name"], - type=agent["type"], - capabilities=json.loads(agent["capabilities"]), - chain_id=agent["chain_id"], - endpoint=agent["endpoint"], - metadata=json.loads(agent["metadata"] or "{}") - ) - for agent in agents - ] - -@app.get("/api/health") -async def health_check(): - """Health check endpoint""" - return {"status": "ok", "timestamp": datetime.utcnow()} - -if __name__ == "__main__": - import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8013) diff --git a/apps/agent-services_backup_20260402_122040/agent-registry/src/registration.py b/apps/agent-services_backup_20260402_122040/agent-registry/src/registration.py deleted file mode 100644 index 3793139d..00000000 --- a/apps/agent-services_backup_20260402_122040/agent-registry/src/registration.py +++ /dev/null @@ -1,431 +0,0 @@ -""" -Agent Registration System -Handles AI agent registration, capability management, and discovery -""" - -import asyncio -import time -import json -import hashlib -from typing import Dict, List, Optional, Set, Tuple -from dataclasses import dataclass, asdict -from enum import Enum -from decimal import Decimal - -class AgentType(Enum): - AI_MODEL = "ai_model" - DATA_PROVIDER = "data_provider" - VALIDATOR = "validator" - MARKET_MAKER = "market_maker" - BROKER = "broker" - ORACLE = "oracle" - -class AgentStatus(Enum): - REGISTERED = "registered" - ACTIVE = "active" - INACTIVE = "inactive" - SUSPENDED = "suspended" - BANNED = "banned" - -class CapabilityType(Enum): - TEXT_GENERATION = "text_generation" - IMAGE_GENERATION = "image_generation" - DATA_ANALYSIS = "data_analysis" - PREDICTION = "prediction" - VALIDATION = "validation" - COMPUTATION = "computation" - -@dataclass -class AgentCapability: - capability_type: CapabilityType - name: str - version: str - parameters: Dict - performance_metrics: Dict - cost_per_use: Decimal - availability: float - max_concurrent_jobs: int - -@dataclass -class AgentInfo: - agent_id: str - agent_type: AgentType - name: str - owner_address: str - public_key: str - endpoint_url: str - capabilities: List[AgentCapability] - reputation_score: float - total_jobs_completed: int - total_earnings: Decimal - registration_time: float - last_active: float - status: AgentStatus - metadata: Dict - -class AgentRegistry: - """Manages AI agent registration and discovery""" - - def __init__(self): - self.agents: Dict[str, AgentInfo] = {} - self.capability_index: Dict[CapabilityType, Set[str]] = {} # capability -> agent_ids - self.type_index: Dict[AgentType, Set[str]] = {} # agent_type -> agent_ids - self.reputation_scores: Dict[str, float] = {} - self.registration_queue: List[Dict] = [] - - # Registry parameters - self.min_reputation_threshold = 0.5 - self.max_agents_per_type = 1000 - self.registration_fee = Decimal('100.0') - self.inactivity_threshold = 86400 * 7 # 7 days - - # Initialize capability index - for capability_type in CapabilityType: - self.capability_index[capability_type] = set() - - # Initialize type index - for agent_type in AgentType: - self.type_index[agent_type] = set() - - async def register_agent(self, agent_type: AgentType, name: str, owner_address: str, - public_key: str, endpoint_url: str, capabilities: List[Dict], - metadata: Dict = None) -> Tuple[bool, str, Optional[str]]: - """Register a new AI agent""" - try: - # Validate inputs - if not self._validate_registration_inputs(agent_type, name, owner_address, public_key, endpoint_url): - return False, "Invalid registration inputs", None - - # Check if agent already exists - agent_id = self._generate_agent_id(owner_address, name) - if agent_id in self.agents: - return False, "Agent already registered", None - - # Check type limits - if len(self.type_index[agent_type]) >= self.max_agents_per_type: - return False, f"Maximum agents of type {agent_type.value} reached", None - - # Convert capabilities - agent_capabilities = [] - for cap_data in capabilities: - capability = self._create_capability_from_data(cap_data) - if capability: - agent_capabilities.append(capability) - - if not agent_capabilities: - return False, "Agent must have at least one valid capability", None - - # Create agent info - agent_info = AgentInfo( - agent_id=agent_id, - agent_type=agent_type, - name=name, - owner_address=owner_address, - public_key=public_key, - endpoint_url=endpoint_url, - capabilities=agent_capabilities, - reputation_score=1.0, # Start with neutral reputation - total_jobs_completed=0, - total_earnings=Decimal('0'), - registration_time=time.time(), - last_active=time.time(), - status=AgentStatus.REGISTERED, - metadata=metadata or {} - ) - - # Add to registry - self.agents[agent_id] = agent_info - - # Update indexes - self.type_index[agent_type].add(agent_id) - for capability in agent_capabilities: - self.capability_index[capability.capability_type].add(agent_id) - - log_info(f"Agent registered: {agent_id} ({name})") - return True, "Registration successful", agent_id - - except Exception as e: - return False, f"Registration failed: {str(e)}", None - - def _validate_registration_inputs(self, agent_type: AgentType, name: str, - owner_address: str, public_key: str, endpoint_url: str) -> bool: - """Validate registration inputs""" - # Check required fields - if not all([agent_type, name, owner_address, public_key, endpoint_url]): - return False - - # Validate address format (simplified) - if not owner_address.startswith('0x') or len(owner_address) != 42: - return False - - # Validate URL format (simplified) - if not endpoint_url.startswith(('http://', 'https://')): - return False - - # Validate name - if len(name) < 3 or len(name) > 100: - return False - - return True - - def _generate_agent_id(self, owner_address: str, name: str) -> str: - """Generate unique agent ID""" - content = f"{owner_address}:{name}:{time.time()}" - return hashlib.sha256(content.encode()).hexdigest()[:16] - - def _create_capability_from_data(self, cap_data: Dict) -> Optional[AgentCapability]: - """Create capability from data dictionary""" - try: - # Validate required fields - required_fields = ['type', 'name', 'version', 'cost_per_use'] - if not all(field in cap_data for field in required_fields): - return None - - # Parse capability type - try: - capability_type = CapabilityType(cap_data['type']) - except ValueError: - return None - - # Create capability - return AgentCapability( - capability_type=capability_type, - name=cap_data['name'], - version=cap_data['version'], - parameters=cap_data.get('parameters', {}), - performance_metrics=cap_data.get('performance_metrics', {}), - cost_per_use=Decimal(str(cap_data['cost_per_use'])), - availability=cap_data.get('availability', 1.0), - max_concurrent_jobs=cap_data.get('max_concurrent_jobs', 1) - ) - - except Exception as e: - log_error(f"Error creating capability: {e}") - return None - - async def update_agent_status(self, agent_id: str, status: AgentStatus) -> Tuple[bool, str]: - """Update agent status""" - if agent_id not in self.agents: - return False, "Agent not found" - - agent = self.agents[agent_id] - old_status = agent.status - agent.status = status - agent.last_active = time.time() - - log_info(f"Agent {agent_id} status changed: {old_status.value} -> {status.value}") - return True, "Status updated successfully" - - async def update_agent_capabilities(self, agent_id: str, capabilities: List[Dict]) -> Tuple[bool, str]: - """Update agent capabilities""" - if agent_id not in self.agents: - return False, "Agent not found" - - agent = self.agents[agent_id] - - # Remove old capabilities from index - for old_capability in agent.capabilities: - self.capability_index[old_capability.capability_type].discard(agent_id) - - # Add new capabilities - new_capabilities = [] - for cap_data in capabilities: - capability = self._create_capability_from_data(cap_data) - if capability: - new_capabilities.append(capability) - self.capability_index[capability.capability_type].add(agent_id) - - if not new_capabilities: - return False, "No valid capabilities provided" - - agent.capabilities = new_capabilities - agent.last_active = time.time() - - return True, "Capabilities updated successfully" - - async def find_agents_by_capability(self, capability_type: CapabilityType, - filters: Dict = None) -> List[AgentInfo]: - """Find agents by capability type""" - agent_ids = self.capability_index.get(capability_type, set()) - - agents = [] - for agent_id in agent_ids: - agent = self.agents.get(agent_id) - if agent and agent.status == AgentStatus.ACTIVE: - if self._matches_filters(agent, filters): - agents.append(agent) - - # Sort by reputation (highest first) - agents.sort(key=lambda x: x.reputation_score, reverse=True) - return agents - - async def find_agents_by_type(self, agent_type: AgentType, filters: Dict = None) -> List[AgentInfo]: - """Find agents by type""" - agent_ids = self.type_index.get(agent_type, set()) - - agents = [] - for agent_id in agent_ids: - agent = self.agents.get(agent_id) - if agent and agent.status == AgentStatus.ACTIVE: - if self._matches_filters(agent, filters): - agents.append(agent) - - # Sort by reputation (highest first) - agents.sort(key=lambda x: x.reputation_score, reverse=True) - return agents - - def _matches_filters(self, agent: AgentInfo, filters: Dict) -> bool: - """Check if agent matches filters""" - if not filters: - return True - - # Reputation filter - if 'min_reputation' in filters: - if agent.reputation_score < filters['min_reputation']: - return False - - # Cost filter - if 'max_cost_per_use' in filters: - max_cost = Decimal(str(filters['max_cost_per_use'])) - if any(cap.cost_per_use > max_cost for cap in agent.capabilities): - return False - - # Availability filter - if 'min_availability' in filters: - min_availability = filters['min_availability'] - if any(cap.availability < min_availability for cap in agent.capabilities): - return False - - # Location filter (if implemented) - if 'location' in filters: - agent_location = agent.metadata.get('location') - if agent_location != filters['location']: - return False - - return True - - async def get_agent_info(self, agent_id: str) -> Optional[AgentInfo]: - """Get agent information""" - return self.agents.get(agent_id) - - async def search_agents(self, query: str, limit: int = 50) -> List[AgentInfo]: - """Search agents by name or capability""" - query_lower = query.lower() - results = [] - - for agent in self.agents.values(): - if agent.status != AgentStatus.ACTIVE: - continue - - # Search in name - if query_lower in agent.name.lower(): - results.append(agent) - continue - - # Search in capabilities - for capability in agent.capabilities: - if (query_lower in capability.name.lower() or - query_lower in capability.capability_type.value): - results.append(agent) - break - - # Sort by relevance (reputation) - results.sort(key=lambda x: x.reputation_score, reverse=True) - return results[:limit] - - async def get_agent_statistics(self, agent_id: str) -> Optional[Dict]: - """Get detailed statistics for an agent""" - agent = self.agents.get(agent_id) - if not agent: - return None - - # Calculate additional statistics - avg_job_earnings = agent.total_earnings / agent.total_jobs_completed if agent.total_jobs_completed > 0 else Decimal('0') - days_active = (time.time() - agent.registration_time) / 86400 - jobs_per_day = agent.total_jobs_completed / days_active if days_active > 0 else 0 - - return { - 'agent_id': agent_id, - 'name': agent.name, - 'type': agent.agent_type.value, - 'status': agent.status.value, - 'reputation_score': agent.reputation_score, - 'total_jobs_completed': agent.total_jobs_completed, - 'total_earnings': float(agent.total_earnings), - 'avg_job_earnings': float(avg_job_earnings), - 'jobs_per_day': jobs_per_day, - 'days_active': int(days_active), - 'capabilities_count': len(agent.capabilities), - 'last_active': agent.last_active, - 'registration_time': agent.registration_time - } - - async def get_registry_statistics(self) -> Dict: - """Get registry-wide statistics""" - total_agents = len(self.agents) - active_agents = len([a for a in self.agents.values() if a.status == AgentStatus.ACTIVE]) - - # Count by type - type_counts = {} - for agent_type in AgentType: - type_counts[agent_type.value] = len(self.type_index[agent_type]) - - # Count by capability - capability_counts = {} - for capability_type in CapabilityType: - capability_counts[capability_type.value] = len(self.capability_index[capability_type]) - - # Reputation statistics - reputations = [a.reputation_score for a in self.agents.values()] - avg_reputation = sum(reputations) / len(reputations) if reputations else 0 - - # Earnings statistics - total_earnings = sum(a.total_earnings for a in self.agents.values()) - - return { - 'total_agents': total_agents, - 'active_agents': active_agents, - 'inactive_agents': total_agents - active_agents, - 'agent_types': type_counts, - 'capabilities': capability_counts, - 'average_reputation': avg_reputation, - 'total_earnings': float(total_earnings), - 'registration_fee': float(self.registration_fee) - } - - async def cleanup_inactive_agents(self) -> Tuple[int, str]: - """Clean up inactive agents""" - current_time = time.time() - cleaned_count = 0 - - for agent_id, agent in list(self.agents.items()): - if (agent.status == AgentStatus.INACTIVE and - current_time - agent.last_active > self.inactivity_threshold): - - # Remove from registry - del self.agents[agent_id] - - # Update indexes - self.type_index[agent.agent_type].discard(agent_id) - for capability in agent.capabilities: - self.capability_index[capability.capability_type].discard(agent_id) - - cleaned_count += 1 - - if cleaned_count > 0: - log_info(f"Cleaned up {cleaned_count} inactive agents") - - return cleaned_count, f"Cleaned up {cleaned_count} inactive agents" - -# Global agent registry -agent_registry: Optional[AgentRegistry] = None - -def get_agent_registry() -> Optional[AgentRegistry]: - """Get global agent registry""" - return agent_registry - -def create_agent_registry() -> AgentRegistry: - """Create and set global agent registry""" - global agent_registry - agent_registry = AgentRegistry() - return agent_registry diff --git a/apps/agent-services_backup_20260402_122040/agent-trading/src/trading_agent.py b/apps/agent-services_backup_20260402_122040/agent-trading/src/trading_agent.py deleted file mode 100644 index 181d963b..00000000 --- a/apps/agent-services_backup_20260402_122040/agent-trading/src/trading_agent.py +++ /dev/null @@ -1,166 +0,0 @@ -#!/usr/bin/env python3 -""" -AITBC Trading Agent -Automated trading agent for AITBC marketplace -""" - -import asyncio -import json -import time -from typing import Dict, Any, List -from datetime import datetime -import sys -import os - -# Add parent directory to path -sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) - -from apps.agent_services.agent_bridge.src.integration_layer import AgentServiceBridge - -class TradingAgent: - """Automated trading agent""" - - def __init__(self, agent_id: str, config: Dict[str, Any]): - self.agent_id = agent_id - self.config = config - self.bridge = AgentServiceBridge() - self.is_running = False - self.trading_strategy = config.get("strategy", "basic") - self.symbols = config.get("symbols", ["AITBC/BTC"]) - self.trade_interval = config.get("trade_interval", 60) # seconds - - async def start(self) -> bool: - """Start trading agent""" - try: - # Register with service bridge - success = await self.bridge.start_agent(self.agent_id, { - "type": "trading", - "capabilities": ["market_analysis", "trading", "risk_management"], - "endpoint": f"http://localhost:8005" - }) - - if success: - self.is_running = True - print(f"Trading agent {self.agent_id} started successfully") - return True - else: - print(f"Failed to start trading agent {self.agent_id}") - return False - except Exception as e: - print(f"Error starting trading agent: {e}") - return False - - async def stop(self) -> bool: - """Stop trading agent""" - self.is_running = False - success = await self.bridge.stop_agent(self.agent_id) - if success: - print(f"Trading agent {self.agent_id} stopped successfully") - return success - - async def run_trading_loop(self): - """Main trading loop""" - while self.is_running: - try: - for symbol in self.symbols: - await self._analyze_and_trade(symbol) - - await asyncio.sleep(self.trade_interval) - except Exception as e: - print(f"Error in trading loop: {e}") - await asyncio.sleep(10) # Wait before retrying - - async def _analyze_and_trade(self, symbol: str) -> None: - """Analyze market and execute trades""" - try: - # Perform market analysis - analysis_task = { - "type": "market_analysis", - "symbol": symbol, - "strategy": self.trading_strategy - } - - analysis_result = await self.bridge.execute_agent_task(self.agent_id, analysis_task) - - if analysis_result.get("status") == "success": - analysis = analysis_result["result"]["analysis"] - - # Make trading decision - if self._should_trade(analysis): - await self._execute_trade(symbol, analysis) - else: - print(f"Market analysis failed for {symbol}: {analysis_result}") - - except Exception as e: - print(f"Error in analyze_and_trade for {symbol}: {e}") - - def _should_trade(self, analysis: Dict[str, Any]) -> bool: - """Determine if should execute trade""" - recommendation = analysis.get("recommendation", "hold") - return recommendation in ["buy", "sell"] - - async def _execute_trade(self, symbol: str, analysis: Dict[str, Any]) -> None: - """Execute trade based on analysis""" - try: - recommendation = analysis.get("recommendation", "hold") - - if recommendation == "buy": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "buy", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - elif recommendation == "sell": - trade_task = { - "type": "trading", - "symbol": symbol, - "side": "sell", - "amount": self.config.get("trade_amount", 0.1), - "strategy": self.trading_strategy - } - else: - return - - trade_result = await self.bridge.execute_agent_task(self.agent_id, trade_task) - - if trade_result.get("status") == "success": - print(f"Trade executed successfully: {trade_result}") - else: - print(f"Trade execution failed: {trade_result}") - - except Exception as e: - print(f"Error executing trade: {e}") - - async def get_status(self) -> Dict[str, Any]: - """Get agent status""" - return await self.bridge.get_agent_status(self.agent_id) - -# Main execution -async def main(): - """Main trading agent execution""" - agent_id = "trading-agent-001" - config = { - "strategy": "basic", - "symbols": ["AITBC/BTC"], - "trade_interval": 30, - "trade_amount": 0.1 - } - - agent = TradingAgent(agent_id, config) - - # Start agent - if await agent.start(): - try: - # Run trading loop - await agent.run_trading_loop() - except KeyboardInterrupt: - print("Shutting down trading agent...") - finally: - await agent.stop() - else: - print("Failed to start trading agent") - -if __name__ == "__main__": - asyncio.run(main())