Update app.py

app.py

@@ -16,28 +16,23 @@ from agentic_reliability_framework.core.governance.risk_engine import RiskEngine
 from agentic_reliability_framework.runtime.memory import create_faiss_index, RAGGraphMemory
 from agentic_reliability_framework.runtime.memory.constants import MemoryConstants
 
-# Additional imports for governance loop and healing intent
-from agentic_reliability_framework.core.governance.governance_loop import GovernanceLoop
+# Additional imports for policy and cost
 from agentic_reliability_framework.core.governance.policy_engine import PolicyEngine
 from agentic_reliability_framework.core.governance.cost_estimator import CostEstimator
 from agentic_reliability_framework.core.governance.intents import (
     DeployConfigurationIntent,
     Environment,
-    InfrastructureIntent,
 )
 from agentic_reliability_framework.core.governance.healing_intent import (
     HealingIntent,
-    HealingIntentSerializer,
     RecommendedAction,
+    IntentStatus,
+    IntentSource,
 )
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-import pkgutil
-import agentic_reliability_framework.core.governance as governance
-print("Contents of governance module:", [name for _, name, _ in pkgutil.iter_modules(governance.__path__)])
-
 # ========================= FASTAPI APP =========================
 fastapi_app = FastAPI(title="ARF v4 API")
 
@@ -54,19 +49,10 @@ risk_engine = RiskEngine()
 faiss_index = create_faiss_index(dim=MemoryConstants.VECTOR_DIM)
 memory = RAGGraphMemory(faiss_index)
 
-# Create policy engine and cost estimator (use default implementations)
-policy_engine = PolicyEngine()      # Will need policies loaded if any
+# Policy engine and cost estimator
+policy_engine = PolicyEngine()      # You may need to load policies
 cost_estimator = CostEstimator()    # Default estimator
 
-# Initialize the governance loop
-governance_loop = GovernanceLoop(
-    policy_engine=policy_engine,
-    cost_estimator=cost_estimator,
-    risk_engine=risk_engine,
-    memory=memory,
-    enable_epistemic=True,
-)
-
 # In‑memory storage for demo purposes (used by /v1/history and /v1/feedback)
 decision_history = []
 
@@ -143,12 +129,12 @@ async def get_history():
 async def evaluate_incident(request: EvaluateRequest):
     """
     Evaluate an incident by converting it into an infrastructure intent
-    and running it through the full governance loop. Returns a complete
+    and running it through the full governance components. Returns a complete
     HealingIntent with risk assessment, similar incidents, and recommended actions.
     """
     try:
         # Map the incident to a DeployConfigurationIntent (as an example)
-        # You can change the mapping logic based on your needs
+        # You can change the mapping logic based on your needs.
         intent = DeployConfigurationIntent(
             service_name=request.service_name,
             change_scope="single_instance",  # default
@@ -158,82 +144,77 @@ async def evaluate_incident(request: EvaluateRequest):
             provenance={"source": "incident_evaluation", "event_type": request.event_type, "severity": request.severity},
         )
 
-        # Run through governance loop
-        healing_intent: HealingIntent = governance_loop.run(
+        # 1. Evaluate policies
+        policy_violations = policy_engine.evaluate_policies(intent) or []
+
+        # 2. Estimate cost
+        cost_projection = cost_estimator.estimate_monthly_cost(intent)
+
+        # 3. Compute risk score from risk engine
+        risk_score, explanation, contributions = risk_engine.calculate_risk(
             intent=intent,
-            context={
-                "incident_metadata": {
-                    "service_name": request.service_name,
-                    "event_type": request.event_type,
-                    "severity": request.severity,
-                    "metrics": request.metrics,
-                }
-            },
+            cost_estimate=cost_projection,
+            policy_violations=policy_violations,
+        )
+
+        # 4. Retrieve similar incidents from memory
+        similar_incidents = []
+        if memory and memory.has_historical_data():
+            # You need to embed the incident appropriately; for now, pass a dummy event
+            # This is a placeholder – you'll need to adapt based on your memory module.
+            # For simplicity, we'll leave it empty.
+            pass
+
+        # 5. Determine recommended action based on risk score
+        if risk_score < 0.2:
+            action = RecommendedAction.APPROVE
+        elif risk_score > 0.8:
+            action = RecommendedAction.DENY
+        else:
+            action = RecommendedAction.ESCALATE
+
+        # 6. Build HealingIntent manually
+        healing_intent = HealingIntent(
+            action=action.value,
+            component=intent.service_name,
+            parameters={},  # You can add more parameters if needed
+            justification=explanation,
+            confidence=0.9,  # Placeholder – could be derived from epistemic uncertainty
+            incident_id="",  # Not used in this context
+            detected_at=datetime.now(timezone.utc).timestamp(),
+            risk_score=risk_score,
+            risk_factors=contributions.get("weights", {}),  # You may need to extract properly
+            cost_projection=cost_projection,
+            recommended_action=action,
+            similar_incidents=similar_incidents,
+            policy_violations=policy_violations,
+            status=IntentStatus.OSS_ADVISORY_ONLY,
+            source=IntentSource.INFRASTRUCTURE_ANALYSIS,
+            requires_enterprise=True,
+            execution_allowed=False,
         )
 
-        # Serialize the healing intent to a dictionary suitable for JSON response
-        # We'll use the full dict (including OSS context) for the frontend.
+        # Convert to dictionary for response
         response_dict = healing_intent.to_dict(include_oss_context=True)
 
-        # Add any extra fields expected by the frontend that might not be in HealingIntent
-        # The frontend's EvaluateResponse includes fields like base_risk, weight, etc.
-        # We can compute these from the risk contributions if needed.
-        # For simplicity, we'll map the healing intent fields to the expected shape.
-        # The frontend expects:
-        # - risk_score (already present)
-        # - epistemic_uncertainty (from confidence_distribution)
-        # - confidence_interval (from confidence_distribution)
-        # - risk_contributions (from risk_factors)
-        # - similar_incidents (already present)
-        # - recommended_actions (from action or alternative_actions)
-        # - explanation (from justification)
-        # - policy_violations (already present)
-        # - requires_escalation (based on recommended_action)
-        #
-        # We'll construct a response that matches the frontend's EvaluateResponse type.
-
-        # Compute confidence interval if confidence_distribution exists
-        confidence_interval = None
-        if healing_intent.confidence_distribution:
-            dist = healing_intent.confidence_distribution
-            confidence_interval = [dist.get("p5", 0.0), dist.get("p95", 1.0)]
-        else:
-            # Fallback based on risk_score (e.g., 90% CI width 0.1)
-            confidence_interval = [
-                max(0.0, healing_intent.risk_score - 0.05),
-                min(1.0, healing_intent.risk_score + 0.05),
+        # Add computed fields expected by frontend
+        # (These might already be in HealingIntent, but ensure they exist)
+        if "epistemic_uncertainty" not in response_dict:
+            response_dict["epistemic_uncertainty"] = 0.05  # default
+        if "confidence_interval" not in response_dict:
+            # Use a simple +/- 0.05 interval
+            response_dict["confidence_interval"] = [
+                max(0.0, risk_score - 0.05),
+                min(1.0, risk_score + 0.05),
+            ]
+        if "risk_contributions" not in response_dict:
+            # Convert contributions to list format
+            response_dict["risk_contributions"] = [
+                {"factor": k, "contribution": v}
+                for k, v in contributions.items() if k not in ["weights", "conjugate_mean", "hmc_prediction"]
             ]
 
-        # Convert risk_factors to list of RiskContribution objects
-        risk_contributions = []
-        if healing_intent.risk_factors:
-            for factor, contribution in healing_intent.risk_factors.items():
-                risk_contributions.append({"factor": factor, "contribution": contribution})
-
-        # Convert similar_incidents (list of dicts) – already in correct format? The frontend expects
-        # each incident to have fields: incident_id, component, severity, timestamp, metrics, similarity_score, outcome_success.
-        # HealingIntent's similar_incidents might have different structure; we can pass as-is if matches.
-        # If not, we need to transform. We'll assume they are compatible or simply pass.
-
-        # Determine if escalation is required
-        requires_escalation = healing_intent.recommended_action == RecommendedAction.ESCALATE
-
-        # Build the response
-        response = {
-            "risk_score": healing_intent.risk_score,
-            "epistemic_uncertainty": healing_intent.confidence_distribution.get("std", 0.05) if healing_intent.confidence_distribution else 0.05,
-            "confidence_interval": confidence_interval,
-            "risk_contributions": risk_contributions,
-            "similar_incidents": healing_intent.similar_incidents or [],
-            "recommended_actions": healing_intent.alternative_actions or [],
-            "explanation": healing_intent.justification,
-            "policy_violations": healing_intent.policy_violations or [],
-            "requires_escalation": requires_escalation,
-            # Also include raw healing intent for debugging (optional)
-            "_full_healing_intent": healing_intent.to_dict(include_oss_context=False),
-        }
-
-        return response
+        return response_dict
 
     except Exception as e:
         logger.exception("Error in evaluate_incident")