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

agentmesh/observability/tracing.py

@@ -0,0 +1,203 @@
+"""
+OpenTelemetry Tracing Integration.
+
+Provides distributed tracing for AgentMesh operations.
+"""
+
+from typing import Optional, Any
+from functools import wraps
+import os
+
+
+def setup_tracing(
+    service_name: str = "agentmesh",
+    endpoint: Optional[str] = None,
+    insecure: bool = False,
+) -> None:
+    """
+    Setup OpenTelemetry tracing.
+    
+    Args:
+        service_name: Service name for traces
+        endpoint: OTLP endpoint (default: from OTEL_EXPORTER_OTLP_ENDPOINT env)
+        insecure: Whether to use insecure connection (default: False, use TLS)
+    """
+    try:
+        from opentelemetry import trace
+        from opentelemetry.sdk.trace import TracerProvider
+        from opentelemetry.sdk.trace.export import BatchSpanProcessor
+        from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+        from opentelemetry.sdk.resources import Resource
+    except ImportError:
+        # OpenTelemetry not installed, skip setup
+        return
+    
+    # Get endpoint from env or parameter
+    endpoint = endpoint or os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
+    if not endpoint:
+        # No endpoint configured, skip
+        return
+    
+    # Create resource
+    resource = Resource.create({
+        "service.name": service_name,
+        "service.namespace": "agentmesh",
+        "deployment.environment": os.getenv("AGENTMESH_ENV", "development"),
+    })
+    
+    # Create tracer provider
+    provider = TracerProvider(resource=resource)
+    
+    # Create OTLP exporter
+    otlp_exporter = OTLPSpanExporter(endpoint=endpoint, insecure=insecure)
+    
+    # Add span processor
+    provider.add_span_processor(BatchSpanProcessor(otlp_exporter))
+    
+    # Set global tracer provider
+    trace.set_tracer_provider(provider)
+
+
+def get_tracer(name: str = "agentmesh"):
+    """Get tracer instance."""
+    try:
+        from opentelemetry import trace
+        return trace.get_tracer(name)
+    except ImportError:
+        return None
+
+
+def trace_operation(
+    operation_name: str,
+    agent_did: Optional[str] = None,
+    trust_score: Optional[int] = None,
+    policy_result: Optional[str] = None,
+):
+    """
+    Decorator to trace an operation.
+    
+    Args:
+        operation_name: Name of the operation
+        agent_did: Optional agent DID
+        trust_score: Optional trust score
+        policy_result: Optional policy result (ALLOW/DENY)
+    """
+    def decorator(func):
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            tracer = get_tracer()
+            if tracer is None:
+                # Tracing not available
+                return await func(*args, **kwargs)
+            
+            with tracer.start_as_current_span(operation_name) as span:
+                # Set attributes
+                if agent_did:
+                    span.set_attribute("agent.did", agent_did)
+                if trust_score is not None:
+                    span.set_attribute("agent.trust_score", trust_score)
+                if policy_result:
+                    span.set_attribute("policy.result", policy_result)
+                
+                # Set standard attributes
+                span.set_attribute("operation.name", operation_name)
+                
+                try:
+                    result = await func(*args, **kwargs)
+                    span.set_attribute("operation.status", "success")
+                    return result
+                except Exception as e:
+                    span.set_attribute("operation.status", "error")
+                    span.set_attribute("error.type", type(e).__name__)
+                    span.set_attribute("error.message", str(e))
+                    span.record_exception(e)
+                    raise
+        
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            tracer = get_tracer()
+            if tracer is None:
+                return func(*args, **kwargs)
+            
+            with tracer.start_as_current_span(operation_name) as span:
+                if agent_did:
+                    span.set_attribute("agent.did", agent_did)
+                if trust_score is not None:
+                    span.set_attribute("agent.trust_score", trust_score)
+                if policy_result:
+                    span.set_attribute("policy.result", policy_result)
+                
+                span.set_attribute("operation.name", operation_name)
+                
+                try:
+                    result = func(*args, **kwargs)
+                    span.set_attribute("operation.status", "success")
+                    return result
+                except Exception as e:
+                    span.set_attribute("operation.status", "error")
+                    span.set_attribute("error.type", type(e).__name__)
+                    span.set_attribute("error.message", str(e))
+                    span.record_exception(e)
+                    raise
+        
+        # Return appropriate wrapper based on function type
+        import inspect
+        if inspect.iscoroutinefunction(func):
+            return async_wrapper
+        return sync_wrapper
+    
+    return decorator
+
+
+class TraceContext:
+    """Context manager for manual tracing."""
+    
+    def __init__(
+        self,
+        operation_name: str,
+        agent_did: Optional[str] = None,
+        **attributes: Any,
+    ):
+        self.operation_name = operation_name
+        self.agent_did = agent_did
+        self.attributes = attributes
+        self.span = None
+    
+    def __enter__(self):
+        tracer = get_tracer()
+        if tracer is None:
+            return self
+        
+        self.span = tracer.start_span(self.operation_name)
+        self.span.__enter__()
+        
+        # Set attributes
+        if self.agent_did:
+            self.span.set_attribute("agent.did", self.agent_did)
+        
+        for key, value in self.attributes.items():
+            self.span.set_attribute(key, value)
+        
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.span:
+            if exc_type:
+                self.span.set_attribute("operation.status", "error")
+                self.span.set_attribute("error.type", exc_type.__name__)
+                self.span.set_attribute("error.message", str(exc_val))
+                self.span.record_exception(exc_val)
+            else:
+                self.span.set_attribute("operation.status", "success")
+            
+            self.span.__exit__(exc_type, exc_val, exc_tb)
+    
+    def set_attribute(self, key: str, value: Any):
+        """Set attribute on current span."""
+        if self.span:
+            self.span.set_attribute(key, value)
+    
+    def add_event(self, name: str, attributes: Optional[dict] = None):
+        """Add event to current span."""
+        if self.span:
+            self.span.add_event(name, attributes or {})

agentmesh/services/__init__.py

@@ -0,0 +1,10 @@
+"""
+Services Module
+
+High-level services for AgentMesh:
+- registry: Agent registry (Yellow Pages)
+- reward_engine: Trust score processor
+- audit: Merkle-chain logger
+"""
+
+__all__ = []

agentmesh/services/audit/__init__.py

@@ -0,0 +1,14 @@
+"""
+Audit Service
+
+Merkle-chained logger for tamper-evident audit trails.
+
+This service wraps the core audit logging to provide:
+- Immutable event history
+- Cryptographic verification
+- Compliance audit trails
+- Query and export capabilities
+"""
+
+# TODO: Implement service wrapper around governance.audit
+# The core audit module is in src/agentmesh/governance/

agentmesh/services/registry/__init__.py

@@ -0,0 +1,12 @@
+"""
+Agent Registry Service
+
+The "Yellow Pages" of agents with DIDs and reputation scores.
+"""
+
+from .agent_registry import AgentRegistry, AgentRegistryEntry
+
+__all__ = [
+    "AgentRegistry",
+    "AgentRegistryEntry",
+]

agentmesh/services/registry/agent_registry.py

@@ -0,0 +1,249 @@
+"""
+Agent Registry Service
+
+The "Yellow Pages" of agents. Stores:
+- Agent DIDs and identities
+- Reputation scores
+- Current status (active, suspended, revoked)
+- Capabilities and protocols
+"""
+
+import asyncio
+from datetime import datetime, timezone
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class AgentRegistryEntry(BaseModel):
+    """Entry in the agent registry."""
+
+    # Identity
+    did: str
+    name: str
+    description: str | None = None
+    organization: str | None = None
+
+    # Sponsor
+    sponsor_email: str
+    sponsor_verified: bool = False
+
+    # Status
+    status: Literal["active", "suspended", "revoked"] = "active"
+    revocation_reason: str | None = None
+
+    # Capabilities
+    capabilities: list[str] = Field(default_factory=list)
+    supported_protocols: list[str] = Field(default_factory=list)
+
+    # Trust
+    trust_score: int = Field(default=500, ge=0, le=1000)
+    trust_tier: Literal[
+        "verified_partner",
+        "trusted",
+        "standard",
+        "probationary",
+        "untrusted"
+    ] = "standard"
+
+    # Credentials
+    public_key_fingerprint: str
+    svid_serial_number: str
+    current_credential_expires_at: datetime
+
+    # Timestamps
+    registered_at: datetime = Field(default_factory=datetime.utcnow)
+    last_seen_at: datetime | None = None
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+
+    # Delegation
+    parent_did: str | None = None
+    delegation_depth: int = 0
+
+    # Metadata
+    metadata: dict[str, str] = Field(default_factory=dict)
+
+
+class AgentRegistry:
+    """
+    Agent Registry Service.
+    
+    Maintains a registry of all agents in the mesh with their:
+    - Identity and credentials
+    - Trust scores and reputation
+    - Status and capabilities
+    """
+
+    def __init__(self):
+        """Initialize the agent registry."""
+        self._agents: dict[str, AgentRegistryEntry] = {}
+        self._lock = asyncio.Lock()
+
+    async def register(self, entry: AgentRegistryEntry) -> None:
+        """
+        Register a new agent.
+        
+        Args:
+            entry: Agent registry entry
+            
+        Raises:
+            ValueError: If agent is already registered
+        """
+        async with self._lock:
+            if entry.did in self._agents:
+                raise ValueError(f"Agent {entry.did} is already registered")
+
+            self._agents[entry.did] = entry
+
+    async def get(self, did: str) -> AgentRegistryEntry | None:
+        """
+        Get an agent by DID.
+        
+        Args:
+            did: Agent's DID
+            
+        Returns:
+            Agent entry or None if not found
+        """
+        return self._agents.get(did)
+
+    async def update_trust_score(self, did: str, new_score: int) -> None:
+        """
+        Update an agent's trust score.
+        
+        Args:
+            did: Agent's DID
+            new_score: New trust score (0-1000)
+            
+        Raises:
+            ValueError: If agent not found
+        """
+        async with self._lock:
+            entry = self._agents.get(did)
+            if entry is None:
+                raise ValueError(f"Agent {did} not found")
+
+            entry.trust_score = new_score
+            entry.updated_at = datetime.now(timezone.utc)
+
+            # Update trust tier based on score
+            if new_score >= 900:
+                entry.trust_tier = "verified_partner"
+            elif new_score >= 700:
+                entry.trust_tier = "trusted"
+            elif new_score >= 400:
+                entry.trust_tier = "standard"
+            elif new_score >= 200:
+                entry.trust_tier = "probationary"
+            else:
+                entry.trust_tier = "untrusted"
+
+    async def update_status(
+        self,
+        did: str,
+        status: Literal["active", "suspended", "revoked"],
+        reason: str | None = None,
+    ) -> None:
+        """
+        Update an agent's status.
+        
+        Args:
+            did: Agent's DID
+            status: New status
+            reason: Optional reason for status change
+            
+        Raises:
+            ValueError: If agent not found
+        """
+        async with self._lock:
+            entry = self._agents.get(did)
+            if entry is None:
+                raise ValueError(f"Agent {did} not found")
+
+            entry.status = status
+            entry.revocation_reason = reason
+            entry.updated_at = datetime.now(timezone.utc)
+
+    async def record_activity(self, did: str) -> None:
+        """
+        Record that an agent was seen (heartbeat).
+        
+        Args:
+            did: Agent's DID
+        """
+        async with self._lock:
+            entry = self._agents.get(did)
+            if entry:
+                entry.last_seen_at = datetime.now(timezone.utc)
+
+    async def list_agents(
+        self,
+        status: Literal["active", "suspended", "revoked"] | None = None,
+        min_trust_score: int | None = None,
+    ) -> list[AgentRegistryEntry]:
+        """
+        List agents with optional filters.
+        
+        Args:
+            status: Filter by status
+            min_trust_score: Filter by minimum trust score
+            
+        Returns:
+            List of matching agent entries
+        """
+        agents = list(self._agents.values())
+
+        if status:
+            agents = [a for a in agents if a.status == status]
+
+        if min_trust_score is not None:
+            agents = [a for a in agents if a.trust_score >= min_trust_score]
+
+        return agents
+
+    async def count_agents(
+        self,
+        status: Literal["active", "suspended", "revoked"] | None = None,
+    ) -> int:
+        """
+        Count agents with optional status filter.
+        
+        Args:
+            status: Filter by status
+            
+        Returns:
+            Number of matching agents
+        """
+        if status is None:
+            return len(self._agents)
+
+        return sum(1 for a in self._agents.values() if a.status == status)
+
+    async def get_trust_statistics(self) -> dict:
+        """
+        Get aggregate trust statistics.
+        
+        Returns:
+            Dictionary of trust statistics
+        """
+        if not self._agents:
+            return {
+                "total_agents": 0,
+                "average_trust_score": 0,
+                "tier_distribution": {},
+            }
+
+        scores = [a.trust_score for a in self._agents.values()]
+        tiers = {}
+
+        for agent in self._agents.values():
+            tier = agent.trust_tier
+            tiers[tier] = tiers.get(tier, 0) + 1
+
+        return {
+            "total_agents": len(self._agents),
+            "average_trust_score": sum(scores) / len(scores),
+            "min_trust_score": min(scores),
+            "max_trust_score": max(scores),
+            "tier_distribution": tiers,
+        }

agentmesh/services/reward_engine/__init__.py

@@ -0,0 +1,14 @@
+"""
+Reward Engine Service
+
+Async worker that processes Flight Recorder logs and updates trust scores.
+
+This service wraps the core reward engine to provide:
+- Continuous trust score updates
+- Multi-dimensional scoring
+- Auto-revocation triggers
+- Behavioral pattern detection
+"""
+
+# TODO: Implement service wrapper around reward.engine
+# The core reward engine is in src/agentmesh/reward/

agentmesh/storage/__init__.py

@@ -0,0 +1,18 @@
+"""
+Storage providers for AgentMesh.
+
+Provides abstract interfaces and implementations for scalable storage backends.
+"""
+
+from .provider import AbstractStorageProvider, StorageConfig
+from .memory_provider import MemoryStorageProvider
+from .redis_provider import RedisStorageProvider
+from .postgres_provider import PostgresStorageProvider
+
+__all__ = [
+    "AbstractStorageProvider",
+    "StorageConfig",
+    "MemoryStorageProvider",
+    "RedisStorageProvider",
+    "PostgresStorageProvider",
+]