agentmesh-platform 1.0.0a1__py3-none-any.whl

agentmesh/reward/learning.py

@@ -0,0 +1,287 @@
+"""
+Adaptive Learning
+
+The platform's ability to learn and adapt from agent behavior.
+Supports tunable weights with A/B testing.
+"""
+
+from datetime import datetime, timedelta
+from typing import Optional, Callable
+from pydantic import BaseModel, Field
+from dataclasses import dataclass
+import random
+
+
+@dataclass
+class WeightExperiment:
+    """An A/B test experiment for reward weights."""
+    
+    experiment_id: str
+    name: str
+    
+    # Control weights (current production)
+    control_weights: dict[str, float]
+    
+    # Treatment weights (being tested)
+    treatment_weights: dict[str, float]
+    
+    # Split
+    treatment_percentage: float = 0.1  # 10% in treatment
+    
+    # Assignment
+    control_agents: set = None
+    treatment_agents: set = None
+    
+    # Results
+    control_scores: list = None
+    treatment_scores: list = None
+    
+    # Status
+    started_at: datetime = None
+    ended_at: datetime = None
+    
+    def __post_init__(self):
+        self.control_agents = set()
+        self.treatment_agents = set()
+        self.control_scores = []
+        self.treatment_scores = []
+        self.started_at = datetime.utcnow()
+    
+    def assign_agent(self, agent_did: str) -> str:
+        """Assign an agent to control or treatment."""
+        if agent_did in self.control_agents:
+            return "control"
+        if agent_did in self.treatment_agents:
+            return "treatment"
+        
+        # Random assignment
+        if random.random() < self.treatment_percentage:
+            self.treatment_agents.add(agent_did)
+            return "treatment"
+        else:
+            self.control_agents.add(agent_did)
+            return "control"
+    
+    def record_score(self, agent_did: str, score: int) -> None:
+        """Record a score observation."""
+        if agent_did in self.treatment_agents:
+            self.treatment_scores.append(score)
+        else:
+            self.control_scores.append(score)
+    
+    def get_results(self) -> dict:
+        """Get experiment results."""
+        control_avg = (
+            sum(self.control_scores) / len(self.control_scores)
+            if self.control_scores else 0
+        )
+        treatment_avg = (
+            sum(self.treatment_scores) / len(self.treatment_scores)
+            if self.treatment_scores else 0
+        )
+        
+        return {
+            "experiment_id": self.experiment_id,
+            "name": self.name,
+            "control_count": len(self.control_agents),
+            "treatment_count": len(self.treatment_agents),
+            "control_avg_score": control_avg,
+            "treatment_avg_score": treatment_avg,
+            "lift": treatment_avg - control_avg,
+            "lift_pct": ((treatment_avg - control_avg) / control_avg * 100) if control_avg else 0,
+        }
+
+
+class WeightOptimizer:
+    """
+    Optimizer for reward dimension weights.
+    
+    Supports:
+    - A/B testing of weight configurations
+    - Automatic weight tuning
+    - Statistical significance testing
+    """
+    
+    def __init__(self):
+        self._experiments: dict[str, WeightExperiment] = {}
+        self._active_experiment: Optional[str] = None
+    
+    def start_experiment(
+        self,
+        name: str,
+        control_weights: dict[str, float],
+        treatment_weights: dict[str, float],
+        treatment_pct: float = 0.1,
+    ) -> WeightExperiment:
+        """Start a weight A/B test."""
+        import uuid
+        exp_id = f"exp_{uuid.uuid4().hex[:12]}"
+        
+        experiment = WeightExperiment(
+            experiment_id=exp_id,
+            name=name,
+            control_weights=control_weights,
+            treatment_weights=treatment_weights,
+            treatment_percentage=treatment_pct,
+        )
+        
+        self._experiments[exp_id] = experiment
+        self._active_experiment = exp_id
+        
+        return experiment
+    
+    def get_weights_for_agent(self, agent_did: str) -> dict[str, float]:
+        """Get the appropriate weights for an agent (considering experiments)."""
+        if not self._active_experiment:
+            return {}  # Use default
+        
+        experiment = self._experiments[self._active_experiment]
+        group = experiment.assign_agent(agent_did)
+        
+        if group == "treatment":
+            return experiment.treatment_weights
+        else:
+            return experiment.control_weights
+    
+    def record_observation(self, agent_did: str, score: int) -> None:
+        """Record a score observation for active experiment."""
+        if self._active_experiment:
+            self._experiments[self._active_experiment].record_score(agent_did, score)
+    
+    def end_experiment(self, experiment_id: Optional[str] = None) -> dict:
+        """End an experiment and get results."""
+        exp_id = experiment_id or self._active_experiment
+        if not exp_id or exp_id not in self._experiments:
+            return {"error": "No experiment found"}
+        
+        experiment = self._experiments[exp_id]
+        experiment.ended_at = datetime.utcnow()
+        
+        if exp_id == self._active_experiment:
+            self._active_experiment = None
+        
+        return experiment.get_results()
+    
+    def should_adopt_treatment(self, experiment_id: str, min_lift_pct: float = 5.0) -> bool:
+        """Check if treatment should be adopted."""
+        if experiment_id not in self._experiments:
+            return False
+        
+        results = self._experiments[experiment_id].get_results()
+        
+        # Check statistical significance (simplified)
+        if results["control_count"] < 100 or results["treatment_count"] < 10:
+            return False  # Not enough data
+        
+        return results["lift_pct"] >= min_lift_pct
+
+
+class AdaptiveLearner:
+    """
+    Learns optimal policies from agent behavior.
+    
+    Features:
+    - Behavioral pattern detection
+    - Anomaly identification
+    - Policy recommendation
+    """
+    
+    def __init__(self):
+        self._patterns: dict[str, list] = {}  # agent_did -> [patterns]
+        self._anomalies: list = []
+    
+    def observe(
+        self,
+        agent_did: str,
+        action: str,
+        context: dict,
+        outcome: str,
+        score_impact: int,
+    ) -> None:
+        """Observe an agent action for learning."""
+        if agent_did not in self._patterns:
+            self._patterns[agent_did] = []
+        
+        observation = {
+            "action": action,
+            "context_keys": list(context.keys()),
+            "outcome": outcome,
+            "score_impact": score_impact,
+            "timestamp": datetime.utcnow().isoformat(),
+        }
+        
+        self._patterns[agent_did].append(observation)
+        
+        # Detect anomalies
+        if score_impact < -50:  # Large negative impact
+            self._anomalies.append({
+                "agent_did": agent_did,
+                "observation": observation,
+                "type": "large_negative_impact",
+            })
+    
+    def get_agent_patterns(self, agent_did: str) -> list:
+        """Get learned patterns for an agent."""
+        return self._patterns.get(agent_did, [])
+    
+    def get_recommendations(self, agent_did: str) -> list[str]:
+        """Get policy recommendations based on patterns."""
+        patterns = self._patterns.get(agent_did, [])
+        
+        if not patterns:
+            return []
+        
+        recommendations = []
+        
+        # Analyze patterns
+        negative_actions = [
+            p["action"] for p in patterns
+            if p["score_impact"] < 0
+        ]
+        
+        # Count frequent negative actions
+        action_counts = {}
+        for action in negative_actions:
+            action_counts[action] = action_counts.get(action, 0) + 1
+        
+        # Recommend blocking frequent negative actions
+        for action, count in action_counts.items():
+            if count >= 3:
+                recommendations.append(
+                    f"Consider blocking action '{action}' - caused {count} negative impacts"
+                )
+        
+        return recommendations
+    
+    def get_anomalies(
+        self,
+        agent_did: Optional[str] = None,
+        since: Optional[datetime] = None,
+    ) -> list:
+        """Get detected anomalies."""
+        anomalies = self._anomalies
+        
+        if agent_did:
+            anomalies = [a for a in anomalies if a["agent_did"] == agent_did]
+        
+        if since:
+            anomalies = [
+                a for a in anomalies
+                if datetime.fromisoformat(a["observation"]["timestamp"]) >= since
+            ]
+        
+        return anomalies
+    
+    def get_learning_summary(self) -> dict:
+        """Get summary of learning state."""
+        total_observations = sum(len(p) for p in self._patterns.values())
+        
+        return {
+            "agents_tracked": len(self._patterns),
+            "total_observations": total_observations,
+            "anomalies_detected": len(self._anomalies),
+            "patterns_per_agent": {
+                agent: len(patterns)
+                for agent, patterns in self._patterns.items()
+            },
+        }

agentmesh/reward/scoring.py

@@ -0,0 +1,203 @@
+"""
+Reward Scoring
+
+Multi-dimensional scoring with trust scores and reward signals.
+"""
+
+from datetime import datetime
+from typing import Optional
+from pydantic import BaseModel, Field
+from enum import Enum
+
+
+class DimensionType(str, Enum):
+    """The 5 reward dimensions."""
+    POLICY_COMPLIANCE = "policy_compliance"
+    RESOURCE_EFFICIENCY = "resource_efficiency"
+    OUTPUT_QUALITY = "output_quality"
+    SECURITY_POSTURE = "security_posture"
+    COLLABORATION_HEALTH = "collaboration_health"
+
+
+class RewardSignal(BaseModel):
+    """
+    A single reward signal.
+    
+    Signals feed into dimension scores which aggregate to trust scores.
+    """
+    
+    dimension: DimensionType
+    value: float = Field(..., ge=0.0, le=1.0, description="0=bad, 1=good")
+    
+    # Source
+    source: str = Field(..., description="Where this signal came from")
+    
+    # Context
+    details: Optional[str] = None
+    trace_id: Optional[str] = None
+    
+    # Timing
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+    
+    # Weight (for importance)
+    weight: float = Field(default=1.0, ge=0.0)
+
+
+class RewardDimension(BaseModel):
+    """Score for a single dimension."""
+    
+    name: str
+    score: float = Field(default=50.0, ge=0.0, le=100.0)
+    
+    # Signal statistics
+    signal_count: int = Field(default=0)
+    positive_signals: int = Field(default=0)
+    negative_signals: int = Field(default=0)
+    
+    # Trend
+    previous_score: Optional[float] = None
+    trend: str = "stable"  # improving, degrading, stable
+    
+    # Last update
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+    
+    def add_signal(self, signal: RewardSignal) -> None:
+        """Add a signal and update score."""
+        self.signal_count += 1
+        
+        if signal.value >= 0.5:
+            self.positive_signals += 1
+        else:
+            self.negative_signals += 1
+        
+        # Update score (exponential moving average)
+        alpha = 0.1  # Smoothing factor
+        self.previous_score = self.score
+        self.score = self.score * (1 - alpha) + (signal.value * 100) * alpha
+        
+        # Update trend
+        if self.previous_score is not None:
+            diff = self.score - self.previous_score
+            if diff > 5:
+                self.trend = "improving"
+            elif diff < -5:
+                self.trend = "degrading"
+            else:
+                self.trend = "stable"
+        
+        self.updated_at = datetime.utcnow()
+
+
+class TrustScore(BaseModel):
+    """
+    Complete trust score for an agent.
+    
+    Aggregates all dimension scores into a single 0-1000 score.
+    """
+    
+    agent_did: str
+    
+    # Total score (0-1000)
+    total_score: int = Field(default=500, ge=0, le=1000)
+    
+    # Trust tier
+    tier: str = "standard"  # verified_partner, trusted, standard, probationary, untrusted
+    
+    # Dimension breakdown
+    dimensions: dict[str, RewardDimension] = Field(default_factory=dict)
+    
+    # Timestamps
+    calculated_at: datetime = Field(default_factory=datetime.utcnow)
+    
+    # History
+    previous_score: Optional[int] = None
+    score_change: int = 0
+    
+    model_config = {"validate_assignment": True}
+    
+    def __init__(self, **data):
+        super().__init__(**data)
+        self._update_tier()
+    
+    def _update_tier(self) -> None:
+        """Update tier based on score."""
+        if self.total_score >= 900:
+            self.tier = "verified_partner"
+        elif self.total_score >= 700:
+            self.tier = "trusted"
+        elif self.total_score >= 500:
+            self.tier = "standard"
+        elif self.total_score >= 300:
+            self.tier = "probationary"
+        else:
+            self.tier = "untrusted"
+    
+    def update(self, new_score: int, dimensions: dict[str, RewardDimension]) -> None:
+        """Update the trust score."""
+        self.previous_score = self.total_score
+        self.total_score = max(0, min(1000, new_score))
+        self.score_change = self.total_score - (self.previous_score or 0)
+        self.dimensions = dimensions
+        self.calculated_at = datetime.utcnow()
+        self._update_tier()
+    
+    def meets_threshold(self, threshold: int) -> bool:
+        """Check if score meets a threshold."""
+        return self.total_score >= threshold
+    
+    def to_dict(self) -> dict:
+        """Export as dictionary."""
+        return {
+            "agent_did": self.agent_did,
+            "total_score": self.total_score,
+            "tier": self.tier,
+            "dimensions": {
+                name: {
+                    "score": dim.score,
+                    "trend": dim.trend,
+                    "signal_count": dim.signal_count,
+                }
+                for name, dim in self.dimensions.items()
+            },
+            "calculated_at": self.calculated_at.isoformat(),
+        }
+
+
+class ScoreThresholds(BaseModel):
+    """Configurable score thresholds."""
+    
+    # Tier thresholds
+    verified_partner: int = 900
+    trusted: int = 700
+    standard: int = 500
+    probationary: int = 300
+    
+    # Action thresholds
+    allow_threshold: int = 500
+    warn_threshold: int = 400
+    revocation_threshold: int = 300
+    
+    def get_tier(self, score: int) -> str:
+        """Get tier for a score."""
+        if score >= self.verified_partner:
+            return "verified_partner"
+        elif score >= self.trusted:
+            return "trusted"
+        elif score >= self.standard:
+            return "standard"
+        elif score >= self.probationary:
+            return "probationary"
+        else:
+            return "untrusted"
+    
+    def should_allow(self, score: int) -> bool:
+        """Check if score should allow actions."""
+        return score >= self.allow_threshold
+    
+    def should_warn(self, score: int) -> bool:
+        """Check if score should trigger warning."""
+        return score < self.warn_threshold
+    
+    def should_revoke(self, score: int) -> bool:
+        """Check if score should trigger revocation."""
+        return score < self.revocation_threshold

agentmesh/trust/__init__.py

@@ -0,0 +1,19 @@
+"""
+Trust & Protocol Bridge (Layer 2)
+
+Implements IATP for agent-to-agent trust handshakes.
+Native A2A and MCP support with transparent protocol translation.
+"""
+
+from .bridge import TrustBridge, ProtocolBridge
+from .handshake import TrustHandshake, HandshakeResult
+from .capability import CapabilityScope, CapabilityGrant
+
+__all__ = [
+    "TrustBridge",
+    "ProtocolBridge",
+    "TrustHandshake",
+    "HandshakeResult",
+    "CapabilityScope",
+    "CapabilityGrant",
+]