agentmesh-platform 1.0.0a1__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

agentmesh/storage/provider.py

@@ -0,0 +1,231 @@
+"""
+Abstract Storage Provider Interface.
+
+Defines the contract that all storage backends must implement.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+from pydantic import BaseModel, Field
+
+
+class StorageConfig(BaseModel):
+    """Configuration for storage provider."""
+    
+    backend: str = Field(default="memory", description="Storage backend type")
+    connection_string: Optional[str] = Field(default=None, description="Connection string")
+    pool_size: int = Field(default=10, ge=1, le=100, description="Connection pool size")
+    timeout_seconds: int = Field(default=30, ge=1, le=300, description="Operation timeout")
+    
+    # Redis-specific
+    redis_host: Optional[str] = Field(default="localhost")
+    redis_port: int = Field(default=6379, ge=1, le=65535)
+    redis_db: int = Field(default=0, ge=0)
+    redis_password: Optional[str] = None
+    redis_ssl: bool = False
+    
+    # PostgreSQL-specific
+    postgres_host: Optional[str] = Field(default="localhost")
+    postgres_port: int = Field(default=5432, ge=1, le=65535)
+    postgres_database: Optional[str] = Field(default="agentmesh")
+    postgres_user: Optional[str] = None
+    postgres_password: Optional[str] = None
+    postgres_ssl_mode: str = Field(default="prefer")
+    
+    # Cache settings
+    cache_ttl_seconds: int = Field(default=300, ge=0)
+    enable_cache: bool = True
+
+
+class AbstractStorageProvider(ABC):
+    """
+    Abstract storage provider.
+    
+    All storage backends (Redis, Postgres, etc.) must implement this interface.
+    Supports:
+    - Key-value operations
+    - Hash operations (for structured data)
+    - List operations (for audit logs, events)
+    - TTL support
+    - Async operations
+    """
+    
+    def __init__(self, config: StorageConfig):
+        """Initialize storage provider with configuration."""
+        self.config = config
+    
+    @abstractmethod
+    async def connect(self) -> None:
+        """Establish connection to storage backend."""
+        pass
+    
+    @abstractmethod
+    async def disconnect(self) -> None:
+        """Close connection to storage backend."""
+        pass
+    
+    @abstractmethod
+    async def health_check(self) -> bool:
+        """Check if storage backend is healthy."""
+        pass
+    
+    # Key-Value Operations
+    
+    @abstractmethod
+    async def get(self, key: str) -> Optional[str]:
+        """Get value by key."""
+        pass
+    
+    @abstractmethod
+    async def set(
+        self,
+        key: str,
+        value: str,
+        ttl_seconds: Optional[int] = None,
+    ) -> bool:
+        """Set value with optional TTL."""
+        pass
+    
+    @abstractmethod
+    async def delete(self, key: str) -> bool:
+        """Delete key."""
+        pass
+    
+    @abstractmethod
+    async def exists(self, key: str) -> bool:
+        """Check if key exists."""
+        pass
+    
+    # Hash Operations (for structured data)
+    
+    @abstractmethod
+    async def hget(self, key: str, field: str) -> Optional[str]:
+        """Get hash field value."""
+        pass
+    
+    @abstractmethod
+    async def hset(self, key: str, field: str, value: str) -> bool:
+        """Set hash field value."""
+        pass
+    
+    @abstractmethod
+    async def hgetall(self, key: str) -> dict[str, str]:
+        """Get all hash fields."""
+        pass
+    
+    @abstractmethod
+    async def hdel(self, key: str, field: str) -> bool:
+        """Delete hash field."""
+        pass
+    
+    @abstractmethod
+    async def hkeys(self, key: str) -> list[str]:
+        """Get all hash field names."""
+        pass
+    
+    # List Operations (for audit logs, events)
+    
+    @abstractmethod
+    async def lpush(self, key: str, value: str) -> int:
+        """Push value to head of list. Returns new list length."""
+        pass
+    
+    @abstractmethod
+    async def rpush(self, key: str, value: str) -> int:
+        """Push value to tail of list. Returns new list length."""
+        pass
+    
+    @abstractmethod
+    async def lrange(self, key: str, start: int, stop: int) -> list[str]:
+        """Get list range [start, stop]."""
+        pass
+    
+    @abstractmethod
+    async def llen(self, key: str) -> int:
+        """Get list length."""
+        pass
+    
+    # Sorted Set Operations (for trust scores)
+    
+    @abstractmethod
+    async def zadd(
+        self,
+        key: str,
+        score: float,
+        member: str,
+    ) -> bool:
+        """Add member to sorted set with score."""
+        pass
+    
+    @abstractmethod
+    async def zscore(self, key: str, member: str) -> Optional[float]:
+        """Get score of member in sorted set."""
+        pass
+    
+    @abstractmethod
+    async def zrange(
+        self,
+        key: str,
+        start: int,
+        stop: int,
+        with_scores: bool = False,
+    ) -> list[str] | list[tuple[str, float]]:
+        """Get sorted set range."""
+        pass
+    
+    @abstractmethod
+    async def zrangebyscore(
+        self,
+        key: str,
+        min_score: float,
+        max_score: float,
+        with_scores: bool = False,
+    ) -> list[str] | list[tuple[str, float]]:
+        """Get sorted set range by score."""
+        pass
+    
+    # Atomic Operations
+    
+    @abstractmethod
+    async def incr(self, key: str) -> int:
+        """Increment value atomically. Returns new value."""
+        pass
+    
+    @abstractmethod
+    async def decr(self, key: str) -> int:
+        """Decrement value atomically. Returns new value."""
+        pass
+    
+    @abstractmethod
+    async def incrby(self, key: str, amount: int) -> int:
+        """Increment value by amount. Returns new value."""
+        pass
+    
+    # Batch Operations
+    
+    @abstractmethod
+    async def mget(self, keys: list[str]) -> list[Optional[str]]:
+        """Get multiple values."""
+        pass
+    
+    @abstractmethod
+    async def mset(self, mapping: dict[str, str]) -> bool:
+        """Set multiple key-value pairs."""
+        pass
+    
+    # Pattern Operations
+    
+    @abstractmethod
+    async def keys(self, pattern: str) -> list[str]:
+        """Get keys matching pattern."""
+        pass
+    
+    @abstractmethod
+    async def scan(
+        self,
+        cursor: int = 0,
+        match: Optional[str] = None,
+        count: int = 100,
+    ) -> tuple[int, list[str]]:
+        """Scan keys with cursor. Returns (new_cursor, keys)."""
+        pass

agentmesh/storage/redis_provider.py

@@ -0,0 +1,223 @@
+"""
+Redis Storage Provider.
+
+Production-ready Redis backend with connection pooling and error handling.
+"""
+
+from typing import Optional
+import json
+
+from .provider import AbstractStorageProvider, StorageConfig
+
+
+class RedisStorageProvider(AbstractStorageProvider):
+    """
+    Redis storage provider.
+    
+    Features:
+    - Connection pooling
+    - Automatic reconnection
+    - TTL support
+    - High-performance caching
+    
+    Requires: redis[asyncio] package
+    """
+    
+    def __init__(self, config: StorageConfig):
+        """Initialize Redis storage."""
+        super().__init__(config)
+        self._client = None
+        self._pool = None
+    
+    async def connect(self) -> None:
+        """Establish connection to Redis."""
+        try:
+            import redis.asyncio as aioredis
+        except ImportError:
+            raise ImportError(
+                "redis package is required for RedisStorageProvider. "
+                "Install with: pip install redis[asyncio]"
+            )
+        
+        # Create connection pool
+        self._pool = aioredis.ConnectionPool(
+            host=self.config.redis_host,
+            port=self.config.redis_port,
+            db=self.config.redis_db,
+            password=self.config.redis_password,
+            ssl=self.config.redis_ssl,
+            max_connections=self.config.pool_size,
+            socket_timeout=self.config.timeout_seconds,
+            socket_connect_timeout=self.config.timeout_seconds,
+            decode_responses=True,
+        )
+        
+        self._client = aioredis.Redis(connection_pool=self._pool)
+        
+        # Test connection
+        await self._client.ping()
+    
+    async def disconnect(self) -> None:
+        """Close connection to Redis."""
+        if self._client:
+            await self._client.close()
+        if self._pool:
+            await self._pool.disconnect()
+    
+    async def health_check(self) -> bool:
+        """Check if Redis is healthy."""
+        try:
+            if self._client:
+                await self._client.ping()
+                return True
+        except Exception:
+            pass
+        return False
+    
+    # Key-Value Operations
+    
+    async def get(self, key: str) -> Optional[str]:
+        """Get value by key."""
+        return await self._client.get(key)
+    
+    async def set(
+        self,
+        key: str,
+        value: str,
+        ttl_seconds: Optional[int] = None,
+    ) -> bool:
+        """Set value with optional TTL."""
+        if ttl_seconds is not None:
+            return await self._client.setex(key, ttl_seconds, value)
+        return await self._client.set(key, value)
+    
+    async def delete(self, key: str) -> bool:
+        """Delete key."""
+        result = await self._client.delete(key)
+        return result > 0
+    
+    async def exists(self, key: str) -> bool:
+        """Check if key exists."""
+        result = await self._client.exists(key)
+        return result > 0
+    
+    # Hash Operations
+    
+    async def hget(self, key: str, field: str) -> Optional[str]:
+        """Get hash field value."""
+        return await self._client.hget(key, field)
+    
+    async def hset(self, key: str, field: str, value: str) -> bool:
+        """Set hash field value."""
+        result = await self._client.hset(key, field, value)
+        return result >= 0
+    
+    async def hgetall(self, key: str) -> dict[str, str]:
+        """Get all hash fields."""
+        return await self._client.hgetall(key)
+    
+    async def hdel(self, key: str, field: str) -> bool:
+        """Delete hash field."""
+        result = await self._client.hdel(key, field)
+        return result > 0
+    
+    async def hkeys(self, key: str) -> list[str]:
+        """Get all hash field names."""
+        return await self._client.hkeys(key)
+    
+    # List Operations
+    
+    async def lpush(self, key: str, value: str) -> int:
+        """Push value to head of list."""
+        return await self._client.lpush(key, value)
+    
+    async def rpush(self, key: str, value: str) -> int:
+        """Push value to tail of list."""
+        return await self._client.rpush(key, value)
+    
+    async def lrange(self, key: str, start: int, stop: int) -> list[str]:
+        """Get list range [start, stop]."""
+        return await self._client.lrange(key, start, stop)
+    
+    async def llen(self, key: str) -> int:
+        """Get list length."""
+        return await self._client.llen(key)
+    
+    # Sorted Set Operations
+    
+    async def zadd(self, key: str, score: float, member: str) -> bool:
+        """Add member to sorted set with score."""
+        result = await self._client.zadd(key, {member: score})
+        return result >= 0
+    
+    async def zscore(self, key: str, member: str) -> Optional[float]:
+        """Get score of member in sorted set."""
+        return await self._client.zscore(key, member)
+    
+    async def zrange(
+        self,
+        key: str,
+        start: int,
+        stop: int,
+        with_scores: bool = False,
+    ) -> list[str] | list[tuple[str, float]]:
+        """Get sorted set range."""
+        return await self._client.zrange(
+            key, start, stop, withscores=with_scores
+        )
+    
+    async def zrangebyscore(
+        self,
+        key: str,
+        min_score: float,
+        max_score: float,
+        with_scores: bool = False,
+    ) -> list[str] | list[tuple[str, float]]:
+        """Get sorted set range by score."""
+        return await self._client.zrangebyscore(
+            key, min_score, max_score, withscores=with_scores
+        )
+    
+    # Atomic Operations
+    
+    async def incr(self, key: str) -> int:
+        """Increment value atomically."""
+        return await self._client.incr(key)
+    
+    async def decr(self, key: str) -> int:
+        """Decrement value atomically."""
+        return await self._client.decr(key)
+    
+    async def incrby(self, key: str, amount: int) -> int:
+        """Increment value by amount."""
+        return await self._client.incrby(key, amount)
+    
+    # Batch Operations
+    
+    async def mget(self, keys: list[str]) -> list[Optional[str]]:
+        """Get multiple values."""
+        return await self._client.mget(keys)
+    
+    async def mset(self, mapping: dict[str, str]) -> bool:
+        """Set multiple key-value pairs."""
+        return await self._client.mset(mapping)
+    
+    # Pattern Operations
+    
+    async def keys(self, pattern: str) -> list[str]:
+        """Get keys matching pattern."""
+        return await self._client.keys(pattern)
+    
+    async def scan(
+        self,
+        cursor: int = 0,
+        match: Optional[str] = None,
+        count: int = 100,
+    ) -> tuple[int, list[str]]:
+        """Scan keys with cursor."""
+        new_cursor, keys = await self._client.scan(
+            cursor=cursor,
+            match=match,
+            count=count,
+        )
+        return new_cursor, keys

agentmesh/trust/__init__.py

@@ -7,7 +7,7 @@ Native A2A and MCP support with transparent protocol translation.
 
 from .bridge import TrustBridge, ProtocolBridge
 from .handshake import TrustHandshake, HandshakeResult
-from .capability import CapabilityScope, CapabilityGrant
+from .capability import CapabilityScope, CapabilityGrant, CapabilityRegistry
 
 __all__ = [
     "TrustBridge",
@@ -16,4 +16,5 @@ __all__ = [
     "HandshakeResult",
     "CapabilityScope",
     "CapabilityGrant",
+    "CapabilityRegistry",
 ]

agentmesh/trust/bridge.py

@@ -246,6 +246,43 @@ class ProtocolBridge(BaseModel):
             "parameters": params.get("arguments", {}),
         }
     
+    def add_verification_footer(
+        self,
+        content: str,
+        trust_score: int,
+        agent_did: str,
+        metadata: Optional[dict] = None
+    ) -> str:
+        """
+        Add AgentMesh verification footer to content.
+        
+        This creates the "viral" verification message that shows
+        AgentMesh is securing the interaction.
+        
+        Args:
+            content: Original content
+            trust_score: Current trust score
+            agent_did: Agent DID
+            metadata: Optional metadata to include
+            
+        Returns:
+            Content with verification footer appended
+        """
+        footer = (
+            f"\n\n> 🔒 Verified by AgentMesh (Trust Score: {trust_score}/1000)\n"
+            f"> Agent: {agent_did[:40]}...\n"
+        )
+        
+        if metadata:
+            if "policy" in metadata:
+                footer += f"> Policy: {metadata['policy']}\n"
+            if "audit" in metadata:
+                footer += f"> Audit: {metadata['audit']}\n"
+            if "view_log" in metadata:
+                footer += f"> [View Audit Log]({metadata['view_log']})\n"
+        
+        return content + footer
+    
     async def _send(self, peer_did: str, message: Any, protocol: str) -> Any:
         """Send message via protocol handler."""
         # In production, would dispatch to actual protocol handlers