nat-engine 1__py3-none-any.whl

mannf/core/agents/analyzer_agent.py

@@ -0,0 +1,224 @@
+# Copyright (C) 2026 Brad Guider
+# This file is part of NAT (Neural Agent Testing Framework).
+# Licensed under the AGPL-3.0. See LICENSE for details.
+# Commercial licensing available — see COMMERCIAL_LICENSE.md.
+
+"""Analyzer Agent – processes results, updates beliefs, detects anomalies.
+
+The AnalyzerAgent is the "learning hub" of the NAT framework.  It receives
+test results from ExecutorAgents, runs its Oracle network for anomaly
+detection, updates its BDI beliefs accordingly, and broadcasts BELIEF_UPDATE
+messages to keep other agents informed (Thesis §4.2, §3.2).
+
+Oracle Network:
+  An autoencoder-style anomaly detector trained on *passing* execution traces.
+  High reconstruction error on a new trace signals an anomaly.
+
+Coverage tracking:
+  The analyzer maintains per-service execution counts and detects coverage
+  plateaus, triggering desire-weight adjustments to encourage exploration.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections import defaultdict, deque
+from typing import Any, Deque, Dict, List, Optional, Set
+
+import numpy as np
+
+from mannf.core.agents.bdi_agent import BDIAgent
+from mannf.core.messaging.bus import MessageBus
+from mannf.core.messaging.messages import Message, MessageType
+from mannf.core.testing.models import TestResult
+
+logger = logging.getLogger(__name__)
+
+_ORACLE_IN = 6          # trace feature dimensions (matches BDIAgent oracle_net)
+_HISTORY = 50           # sliding window for anomaly baseline
+
+
+class AnalyzerAgent(BDIAgent):
+    """Processes test execution data, maintains beliefs, detects anomalies."""
+
+    def __init__(
+        self,
+        agent_id: str,
+        bus: MessageBus,
+        service_names: List[str],
+        broadcast_interval: int = 5,
+    ) -> None:
+        super().__init__(agent_id, bus, service_names)
+        self._broadcast_interval = broadcast_interval
+
+        # Anomaly detection state
+        self._trace_history: Deque[np.ndarray] = deque(maxlen=_HISTORY)
+        self._anomaly_threshold: float = 1.0
+
+        # Coverage and statistics
+        self._service_counts: Dict[str, int] = defaultdict(int)
+        self._service_failures: Dict[str, int] = defaultdict(int)
+        self._total_results = 0
+        self._results_since_broadcast = 0
+
+    @property
+    def subscribed_types(self) -> Set[MessageType]:
+        return {
+            MessageType.TEST_RESULT,
+            MessageType.CONTRACT_RESULT,
+            MessageType.BELIEF_UPDATE,
+        }
+
+    # ------------------------------------------------------------------
+    # Message handling
+    # ------------------------------------------------------------------
+
+    async def _handle_message(self, message: Message) -> None:
+        if message.type in (MessageType.TEST_RESULT, MessageType.CONTRACT_RESULT):
+            payload = message.payload
+            result: Optional[TestResult] = (
+                payload.get("result") if isinstance(payload, dict) else
+                payload if isinstance(payload, TestResult) else None
+            )
+            if result:
+                await self._process_result(result)
+
+        elif message.type == MessageType.BELIEF_UPDATE:
+            self._absorb_peer_beliefs(
+                message.sender_id,
+                message.payload.get("beliefs", {}),
+            )
+
+    # ------------------------------------------------------------------
+    # Result processing
+    # ------------------------------------------------------------------
+
+    async def _process_result(self, result: TestResult) -> None:
+        """Update beliefs and detect anomalies from a test result."""
+        # Determine target service from result metadata
+        target = self._infer_target(result)
+
+        # Update service statistics
+        self._total_results += 1
+        if target:
+            self._service_counts[target] += 1
+            if not result.passed or result.error:
+                self._service_failures[target] += 1
+
+            # Update fault-likelihood belief (Thesis §3.3 bounded revision)
+            evidence = 0.0 if (result.passed and not result.error) else 1.0
+            old_belief = self.beliefs.fault_likelihood.get(target, 0.5)
+            self._update_belief_from_result(target, evidence)
+            new_belief = self.beliefs.fault_likelihood.get(target, 0.5)
+
+            # Broadcast belief update telemetry (fail-safe)
+            try:
+                from mannf.dashboard import telemetry as _tel
+                await _tel.broadcast_belief_update(
+                    agent_id=self.agent_id,
+                    endpoint=target,
+                    old_value=old_belief,
+                    new_value=new_belief,
+                    evidence=evidence,
+                )
+            except Exception:  # noqa: BLE001
+                pass
+
+        # Anomaly detection via Oracle network
+        trace_vec = self._result_to_trace(result)
+        self._trace_history.append(trace_vec)
+
+        if result.passed and not result.error:
+            # Train Oracle on normal traces
+            self.oracle_net.train_step(
+                trace_vec,
+                np.array([0.0])  # label = not anomalous
+            )
+
+        if len(self._trace_history) >= 10:
+            await self._check_anomaly(result, trace_vec)
+
+        # Periodically broadcast updated beliefs
+        self._results_since_broadcast += 1
+        if self._results_since_broadcast >= self._broadcast_interval:
+            self._results_since_broadcast = 0
+            await self._broadcast_beliefs()
+
+    def _infer_target(self, result: TestResult) -> Optional[str]:
+        """Best-effort extraction of target service from a TestResult."""
+        output = result.actual_output
+        if isinstance(output, dict):
+            return output.get("service")
+        return None
+
+    def _result_to_trace(self, result: TestResult) -> np.ndarray:
+        """Encode a TestResult into a 6-D execution trace vector."""
+        vec = np.zeros(_ORACLE_IN)
+        vec[0] = 1.0 if result.passed else 0.0
+        vec[1] = 1.0 if result.error else 0.0
+        vec[2] = min(result.execution_time_ms / 1000.0, 5.0)
+        total = self._total_results or 1
+        all_failures = sum(self._service_failures.values())
+        vec[3] = all_failures / total
+        vec[4] = min(total / 500.0, 1.0)
+        vec[5] = self.beliefs.entropy()
+        return vec
+
+    # ------------------------------------------------------------------
+    # Anomaly detection
+    # ------------------------------------------------------------------
+
+    async def _check_anomaly(self, result: TestResult, vec: np.ndarray) -> None:
+        """Run Oracle network; publish ANOMALY_DETECTED if threshold exceeded."""
+        anomaly_score = float(self.oracle_net.predict(vec)[0])
+
+        # Update dynamic threshold as 95th percentile of recent scores
+        recent_scores = [
+            float(self.oracle_net.predict(v)[0])
+            for v in list(self._trace_history)[-20:]
+        ]
+        if recent_scores:
+            self._anomaly_threshold = float(np.percentile(recent_scores, 95)) + 0.1
+
+        if anomaly_score > self._anomaly_threshold and anomaly_score > 0.2:
+            logger.info(
+                "AnalyzerAgent %s: anomaly detected (score=%.4f > threshold=%.4f)",
+                self.agent_id, anomaly_score, self._anomaly_threshold,
+            )
+            await self._publish(
+                Message(
+                    MessageType.ANOMALY_DETECTED,
+                    sender_id=self.agent_id,
+                    payload={
+                        "test_case_id": result.test_case_id,
+                        "anomaly_score": anomaly_score,
+                        "threshold": self._anomaly_threshold,
+                    },
+                )
+            )
+
+    # ------------------------------------------------------------------
+    # Diagnostics
+    # ------------------------------------------------------------------
+
+    @property
+    def total_results(self) -> int:
+        return self._total_results
+
+    @property
+    def service_failure_counts(self) -> Dict[str, int]:
+        return dict(self._service_failures)
+
+    @property
+    def service_execution_counts(self) -> Dict[str, int]:
+        return dict(self._service_counts)
+
+    def metrics(self) -> Dict[str, Any]:
+        total = max(self._total_results, 1)
+        return {
+            "agent_id": self.agent_id,
+            "total_results": self._total_results,
+            "failure_rate": sum(self._service_failures.values()) / total,
+            "belief_entropy": round(self.beliefs.entropy(), 4),
+            "anomaly_threshold": round(self._anomaly_threshold, 6),
+        }