Update demo/orchestrator.py

demo/orchestrator.py

@@ -1,62 +1,89 @@
-# demo/orchestrator.py
+# demo/orchestrator.py - FIXED VERSION
 from __future__ import annotations
 
 import logging
-from typing import Any, Dict, Optional
+import asyncio
+from typing import Any, Dict, Optional, List
+import time
 
 logger = logging.getLogger(__name__)
 
-# --- Optional Streamlit import (SAFE) ---
+# Import mock ARF functions
 try:
-    import streamlit as st  # type: ignore
-except Exception:
-    st = None
-    logger.info("Streamlit not available; running in non-Streamlit mode.")
+    from demo.mock_arf import (
+        simulate_arf_analysis,
+        run_rag_similarity_search,
+        create_mock_healing_intent,
+        calculate_pattern_confidence
+    )
+    MOCK_ARF_AVAILABLE = True
+except ImportError:
+    logger.warning("Mock ARF functions not available")
+    MOCK_ARF_AVAILABLE = False
 
 
 class DemoOrchestrator:
     """
-    Orchestrates demo scenarios.
-
-    Streamlit is OPTIONAL and never required at import time.
-    This prevents Hugging Face Spaces from crashing.
+    Orchestrates demo scenarios with proper agent workflow.
     """
 
     def __init__(self, enable_streamlit: bool = False):
-        self.enable_streamlit = enable_streamlit and st is not None
-
-        if enable_streamlit and st is None:
-            logger.warning(
-                "Streamlit requested but not installed. "
-                "Proceeding without Streamlit UI."
-            )
-
-    def render_streamlit(self) -> None:
+        self.enable_streamlit = enable_streamlit
+    
+    async def analyze_incident(self, scenario_name: str, scenario_data: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Render Streamlit UI if available.
-        Safe no-op otherwise.
+        Analyze an incident using the ARF agent workflow.
+        This is the method called by app.py
         """
-        if not self.enable_streamlit or st is None:
-            logger.debug("Streamlit UI disabled or unavailable.")
-            return
-
-        st.title("Agentic Reliability Framework Demo")
-        st.markdown("Interactive demo running inside Streamlit.")
-
+        logger.info(f"Analyzing incident: {scenario_name}")
+        
+        if not MOCK_ARF_AVAILABLE:
+            return {
+                "status": "error",
+                "message": "Mock ARF functions not available",
+                "scenario": scenario_name
+            }
+        
+        try:
+            # Step 1: Detection Agent
+            detection_result = simulate_arf_analysis(scenario_data)
+            
+            # Step 2: Recall Agent  
+            similar_incidents = run_rag_similarity_search(scenario_data)
+            
+            # Step 3: Decision Agent
+            confidence = calculate_pattern_confidence(scenario_data, similar_incidents)
+            healing_intent = create_mock_healing_intent(scenario_data, similar_incidents, confidence)
+            
+            # Simulate processing time
+            await asyncio.sleep(0.5)
+            
+            return {
+                "status": "success",
+                "scenario": scenario_name,
+                "detection": detection_result,
+                "recall": similar_incidents,
+                "decision": healing_intent,
+                "confidence": confidence,
+                "processing_time_ms": 450
+            }
+            
+        except Exception as e:
+            logger.error(f"Error analyzing incident: {e}")
+            return {
+                "status": "error",
+                "message": str(e),
+                "scenario": scenario_name
+            }
+    
     def run_scenario(self, scenario: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Run a demo scenario without any UI dependency.
+        Run a demo scenario (legacy method).
         """
         logger.info("Running scenario: %s", scenario.get("name", "unknown"))
 
-        result = {
+        return {
             "scenario": scenario.get("name"),
             "status": "completed",
             "output": scenario,
-        }
-
-        # Optional Streamlit visualization
-        if self.enable_streamlit and st is not None:
-            st.json(result)
-
-        return result
+        }