Update app.py

app.py

@@ -2,9 +2,9 @@
 import logging
 import uuid
 from datetime import datetime, timezone
-from typing import Dict, Optional
+from typing import Dict, Optional, List
 
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
 from fastapi.responses import RedirectResponse
@@ -16,6 +16,21 @@ 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
+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,
+)
+
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
@@ -35,7 +50,20 @@ risk_engine = RiskEngine()
 faiss_index = create_faiss_index(dim=MemoryConstants.VECTOR_DIM)
 memory = RAGGraphMemory(faiss_index)
 
-# In‑memory storage for demo purposes (replace with a real DB later)
+# Create policy engine and cost estimator (use default implementations)
+policy_engine = PolicyEngine()      # Will need policies loaded if any
+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 = []
 
 # ========================= PYDANTIC MODELS =========================
@@ -107,21 +135,105 @@ async def get_history():
     """Return the last 10 decisions."""
     return decision_history[-10:]
 
-@fastapi_app.post("/v1/incidents/evaluate", response_model=EvaluateResponse)
+@fastapi_app.post("/v1/incidents/evaluate")
 async def evaluate_incident(request: EvaluateRequest):
     """
-    Evaluate an incident and return a risk score with explainability.
-    This is a placeholder – replace with actual call to your risk engine.
+    Evaluate an incident by converting it into an infrastructure intent
+    and running it through the full governance loop. Returns a complete
+    HealingIntent with risk assessment, similar incidents, and recommended actions.
     """
-    # For now, return a dummy response
-    return EvaluateResponse(
-        risk_score=0.23,
-        base_risk=0.15,
-        memory_risk=0.3,
-        weight=0.5,
-        similar_events=[],
-        confidence=0.9
-    )
+    try:
+        # Map the incident to a DeployConfigurationIntent (as an example)
+        # You can change the mapping logic based on your needs
+        intent = DeployConfigurationIntent(
+            service_name=request.service_name,
+            change_scope="single_instance",  # default
+            deployment_target=Environment.DEV,  # assume dev for now
+            configuration=request.metrics,
+            requester="system",
+            provenance={"source": "incident_evaluation", "event_type": request.event_type, "severity": request.severity},
+        )
+
+        # Run through governance loop
+        healing_intent: HealingIntent = governance_loop.run(
+            intent=intent,
+            context={
+                "incident_metadata": {
+                    "service_name": request.service_name,
+                    "event_type": request.event_type,
+                    "severity": request.severity,
+                    "metrics": request.metrics,
+                }
+            },
+        )
+
+        # Serialize the healing intent to a dictionary suitable for JSON response
+        # We'll use the full dict (including OSS context) for the frontend.
+        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),
+            ]
+
+        # 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
+
+    except Exception as e:
+        logger.exception("Error in evaluate_incident")
+        raise HTTPException(status_code=500, detail=str(e))
 
 @fastapi_app.post("/v1/feedback")
 async def record_outcome(decision_id: str, success: bool):
@@ -225,10 +337,9 @@ with gr.Blocks(title="ARF v4 Demo") as demo:
     history_btn.click(fn=lambda: decision_history[-10:], outputs=decision_output)
 
 # ========================= Mount Gradio and Add Documentation Routes =========================
-# Mount Gradio at "/api" – this means Gradio will handle all requests starting with "/api".
 app = gr.mount_gradio_app(fastapi_app, demo, path="/api")
 
-# Add documentation routes at "/docs" (outside the Gradio mount path) to avoid conflict.
+# Add documentation routes at "/docs"
 @app.get("/docs", include_in_schema=False)
 async def swagger_ui():
     return get_swagger_ui_html(
@@ -247,7 +358,6 @@ async def redoc_ui():
 async def openapi():
     return fastapi_app.openapi()
 
-# Optional redirect from /api/docs to /docs for backward compatibility.
 @app.get("/api/docs", include_in_schema=False)
 async def redirect_docs():
     return RedirectResponse(url="/docs")