Process flow visualizer + key skills [for validation only) V2

app.py

@@ -21,6 +21,20 @@ logger = logging.getLogger(__name__)
 orchestrator = None
 orchestrator_available = False
 
+# Import Process Flow Visualization
+try:
+    from process_flow_visualizer import (
+        create_process_flow_tab,
+        update_process_flow_visualization,
+        clear_flow_history,
+        export_flow_data
+    )
+    process_flow_available = True
+    logger.info("✓ Process Flow Visualization available")
+except ImportError as e:
+    logger.warning(f"Process Flow Visualization not available: {e}")
+    process_flow_available = False
+
 try:
     logger.info("Attempting to import orchestration components...")
     import sys
@@ -30,7 +44,12 @@ try:
     from src.agents.intent_agent import create_intent_agent
     from src.agents.synthesis_agent import create_synthesis_agent
     from src.agents.safety_agent import create_safety_agent
-    from src.agents.skills_identification_agent import create_skills_identification_agent
+    try:
+        from src.agents.skills_identification_agent import create_skills_identification_agent
+    except ImportError:
+        logger.warning("Skills identification agent not available, using placeholder")
+        def create_skills_identification_agent(llm_router=None):
+            return None
     from llm_router import LLMRouter
     from orchestrator_engine import MVPOrchestrator
     from context_manager import EfficientContextManager
@@ -305,11 +324,18 @@ def create_mobile_optimized_interface():
                             show_label=False
                         )
                         interface_components['context_display'] = context_display
+                
+                # Process Flow Tab (if available)
+                if process_flow_available:
+                    process_flow_tab = create_process_flow_tab(interface_components)
+                    interface_components['process_flow_tab'] = process_flow_tab
             
             # Mobile Bottom Navigation
             with gr.Row(visible=False, elem_id="mobile_nav") as mobile_navigation:
                 chat_nav_btn = gr.Button("💬 Chat", variant="secondary", size="sm", min_width=0)
                 details_nav_btn = gr.Button("🔍 Details", variant="secondary", size="sm", min_width=0)
+                if process_flow_available:
+                    flow_nav_btn = gr.Button("🔄 Flow", variant="secondary", size="sm", min_width=0)
                 settings_nav_btn = gr.Button("⚙️ Settings", variant="secondary", size="sm", min_width=0)
         
         # Settings Panel (Modal for Mobile)
@@ -373,6 +399,21 @@ def create_mobile_optimized_interface():
                 outputs.append(interface_components['skills_tags'])
                 outputs.append(skills_display_row)  # Add visibility control for skills display row
             
+            # Add Process Flow outputs if available
+            if process_flow_available:
+                if 'flow_display' in interface_components:
+                    outputs.append(interface_components['flow_display'])
+                if 'flow_stats' in interface_components:
+                    outputs.append(interface_components['flow_stats'])
+                if 'performance_metrics' in interface_components:
+                    outputs.append(interface_components['performance_metrics'])
+                if 'intent_details' in interface_components:
+                    outputs.append(interface_components['intent_details'])
+                if 'synthesis_details' in interface_components:
+                    outputs.append(interface_components['synthesis_details'])
+                if 'safety_details' in interface_components:
+                    outputs.append(interface_components['safety_details'])
+            
             # Include session_info in inputs to pass session ID
             inputs = [interface_components['message_input'], interface_components['chatbot']]
             if 'session_info' in interface_components:
@@ -417,6 +458,36 @@ def create_mobile_optimized_interface():
                         interface_components.get('cache_enabled', None)
                     ]
                 )
+            
+            # Wire up Process Flow event handlers if available
+            if process_flow_available:
+                # Clear flow history button
+                if 'clear_flow_btn' in interface_components:
+                    interface_components['clear_flow_btn'].click(
+                        fn=clear_flow_history,
+                        outputs=[
+                            interface_components.get('flow_display'),
+                            interface_components.get('flow_stats'),
+                            interface_components.get('performance_metrics'),
+                            interface_components.get('intent_details'),
+                            interface_components.get('synthesis_details'),
+                            interface_components.get('safety_details')
+                        ]
+                    )
+                
+                # Export flow data button
+                if 'export_flow_btn' in interface_components:
+                    interface_components['export_flow_btn'].click(
+                        fn=export_flow_data,
+                        outputs=[gr.File(label="Download Flow Data")]
+                    )
+                
+                # Share flow button (placeholder)
+                if 'share_flow_btn' in interface_components:
+                    interface_components['share_flow_btn'].click(
+                        fn=lambda: gr.Info("Flow sharing feature coming soon!"),
+                        outputs=[]
+                    )
     
     return demo, interface_components
 
@@ -518,6 +589,7 @@ async def process_message_async(message: str, history: Optional[List], session_i
         reasoning_data = {}
         performance_data = {}
         context_data = {}
+        skills_html = ""  # Initialize skills_html
         
         # GUARANTEE: Always get a response
         response = "Hello! I'm processing your request..."
@@ -649,6 +721,7 @@ async def process_message_async(message: str, history: Optional[List], session_i
                 "evidence_sources": [],
                 "confidence_calibration": {"overall_confidence": 0.5, "initialization_mode": True}
             }
+            skills_html = ""  # Initialize skills_html for orchestrator not available case
         
         # Add assistant response
         new_history.append({"role": "assistant", "content": response})
@@ -758,14 +831,89 @@ if SPACES_GPU_AVAILABLE and GPU is not None:
     chat_handler_fn = gpu_chat_handler
 else:
     def chat_handler_wrapper(message, history, session_id=None):
-        """Wrapper to handle session ID"""
+        """Wrapper to handle session ID with Process Flow Visualization"""
         if not session_id:
             session_id = str(uuid.uuid4())[:8]
         result = process_message(message, history, session_id)
         # Extract skills_html from result and determine visibility
         skills_html = result[6]
         skills_content, skills_visible = _update_skills_display(skills_html)
-        return result[0], result[1], result[2], result[3], result[4], result[5], skills_content, gr.update(visible=skills_visible)
+        
+        # Prepare process flow updates if available
+        flow_updates = {}
+        if process_flow_available:
+            try:
+                # Extract data for process flow visualization
+                reasoning_data = result[2]
+                performance_data = result[3]
+                context_data = result[4]
+                
+                # Create mock agent results for visualization
+                intent_result = {
+                    "primary_intent": reasoning_data.get("chain_of_thought", {}).get("step_1", {}).get("hypothesis", "unknown"),
+                    "confidence_scores": {"overall": reasoning_data.get("confidence_calibration", {}).get("overall_confidence", 0.7)},
+                    "secondary_intents": [],
+                    "reasoning_chain": list(reasoning_data.get("chain_of_thought", {}).keys()),
+                    "context_tags": ["general"],
+                    "processing_time": performance_data.get("processing_time", 0.5),
+                    "agent_id": "INTENT_REC_001"
+                }
+                
+                synthesis_result = {
+                    "final_response": result[0][-1]["content"] if result[0] else "",
+                    "draft_response": "",
+                    "source_references": ["INTENT_REC_001"],
+                    "coherence_score": 0.85,
+                    "synthesis_method": "llm_enhanced",
+                    "intent_alignment": {"intent_detected": intent_result["primary_intent"], "alignment_score": 0.8},
+                    "processing_time": performance_data.get("processing_time", 0.5) - 0.15,
+                    "agent_id": "RESP_SYNTH_001"
+                }
+                
+                safety_result = {
+                    "original_response": result[0][-1]["content"] if result[0] else "",
+                    "safety_checked_response": result[0][-1]["content"] if result[0] else "",
+                    "warnings": [],
+                    "safety_analysis": {
+                        "toxicity_score": 0.1,
+                        "bias_indicators": [],
+                        "privacy_concerns": [],
+                        "overall_safety_score": 0.9,
+                        "confidence_scores": {"safety": 0.9}
+                    },
+                    "blocked": False,
+                    "processing_time": 0.1,
+                    "agent_id": "SAFETY_BIAS_001"
+                }
+                
+                # Update process flow visualization
+                flow_updates = update_process_flow_visualization(
+                    user_input=message,
+                    intent_result=intent_result,
+                    synthesis_result=synthesis_result,
+                    safety_result=safety_result,
+                    final_response=result[0][-1]["content"] if result[0] else "",
+                    session_id=session_id,
+                    processing_time=performance_data.get("processing_time", 1.0)
+                )
+            except Exception as e:
+                logger.error(f"Error updating process flow: {e}")
+                flow_updates = {}
+        
+        # Return all updates including process flow
+        if process_flow_available and flow_updates:
+            return (
+                result[0], result[1], result[2], result[3], result[4], result[5], 
+                skills_content, gr.update(visible=skills_visible),
+                flow_updates.get("flow_display", ""),
+                flow_updates.get("flow_stats", {}),
+                flow_updates.get("performance_metrics", {}),
+                flow_updates.get("intent_details", {}),
+                flow_updates.get("synthesis_details", {}),
+                flow_updates.get("safety_details", {})
+            )
+        else:
+            return result[0], result[1], result[2], result[3], result[4], result[5], skills_content, gr.update(visible=skills_visible)
     chat_handler_fn = chat_handler_wrapper
 
 # Initialize orchestrator on module load
@@ -798,8 +946,16 @@ def initialize_orchestrator():
             'intent_recognition': create_intent_agent(llm_router),
             'response_synthesis': create_synthesis_agent(llm_router),
             'safety_check': create_safety_agent(llm_router),
-            'skills_identification': create_skills_identification_agent(llm_router)
         }
+        
+        # Add skills identification agent if available
+        skills_agent = create_skills_identification_agent(llm_router)
+        if skills_agent is not None:
+            agents['skills_identification'] = skills_agent
+            logger.info("✓ Skills identification agent initialized")
+        else:
+            logger.info("⚠ Skills identification agent not available")
+        
         logger.info(f"✓ Initialized {len(agents)} agents")
         
         # Initialize Context Manager

test_process_flow_integration.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+Test script to verify Process Flow Visualization integration
+"""
+
+import sys
+import os
+
+def test_imports():
+    """Test if all required imports work"""
+    print("Testing imports...")
+    
+    try:
+        # Test process flow visualizer import
+        from process_flow_visualizer import (
+            create_process_flow_tab,
+            update_process_flow_visualization,
+            clear_flow_history,
+            export_flow_data
+        )
+        print("✓ Process Flow Visualizer imports successful")
+        return True
+    except ImportError as e:
+        print(f"✗ Process Flow Visualizer import failed: {e}")
+        return False
+
+def test_app_integration():
+    """Test if app.py can be imported without errors"""
+    print("Testing app.py integration...")
+    
+    try:
+        # Add current directory to path
+        sys.path.insert(0, '.')
+        
+        # Test importing app components
+        import app
+        print("✓ App.py imports successful")
+        
+        # Test if process flow is available
+        if hasattr(app, 'process_flow_available'):
+            print(f"✓ Process Flow available: {app.process_flow_available}")
+        else:
+            print("⚠ Process Flow availability not detected")
+        
+        return True
+    except Exception as e:
+        print(f"✗ App.py integration failed: {e}")
+        return False
+
+def test_process_flow_functions():
+    """Test process flow functions"""
+    print("Testing Process Flow functions...")
+    
+    try:
+        from process_flow_visualizer import update_process_flow_visualization
+        
+        # Test with mock data
+        mock_intent_result = {
+            "primary_intent": "information_request",
+            "confidence_scores": {"information_request": 0.8},
+            "secondary_intents": [],
+            "reasoning_chain": ["Step 1: Analyze user input"],
+            "context_tags": ["general"],
+            "processing_time": 0.15,
+            "agent_id": "INTENT_REC_001"
+        }
+        
+        mock_synthesis_result = {
+            "final_response": "Test response",
+            "draft_response": "",
+            "source_references": ["INTENT_REC_001"],
+            "coherence_score": 0.85,
+            "synthesis_method": "llm_enhanced",
+            "intent_alignment": {"intent_detected": "information_request", "alignment_score": 0.8},
+            "processing_time": 0.5,
+            "agent_id": "RESP_SYNTH_001"
+        }
+        
+        mock_safety_result = {
+            "original_response": "Test response",
+            "safety_checked_response": "Test response",
+            "warnings": [],
+            "safety_analysis": {
+                "toxicity_score": 0.1,
+                "bias_indicators": [],
+                "privacy_concerns": [],
+                "overall_safety_score": 0.9,
+                "confidence_scores": {"safety": 0.9}
+            },
+            "blocked": False,
+            "processing_time": 0.1,
+            "agent_id": "SAFETY_BIAS_001"
+        }
+        
+        # Test the function
+        result = update_process_flow_visualization(
+            user_input="Test message",
+            intent_result=mock_intent_result,
+            synthesis_result=mock_synthesis_result,
+            safety_result=mock_safety_result,
+            final_response="Test response",
+            session_id="test_session",
+            processing_time=1.0
+        )
+        
+        print("✓ Process Flow functions work correctly")
+        print(f"✓ Generated flow HTML length: {len(result.get('flow_display', ''))}")
+        return True
+        
+    except Exception as e:
+        print(f"✗ Process Flow functions failed: {e}")
+        return False
+
+def main():
+    """Run all tests"""
+    print("=" * 60)
+    print("PROCESS FLOW VISUALIZATION INTEGRATION TEST")
+    print("=" * 60)
+    
+    tests = [
+        test_imports,
+        test_app_integration,
+        test_process_flow_functions
+    ]
+    
+    passed = 0
+    total = len(tests)
+    
+    for test in tests:
+        try:
+            if test():
+                passed += 1
+            print()
+        except Exception as e:
+            print(f"✗ Test {test.__name__} failed with exception: {e}")
+            print()
+    
+    print("=" * 60)
+    print(f"TEST RESULTS: {passed}/{total} tests passed")
+    print("=" * 60)
+    
+    if passed == total:
+        print("🎉 All tests passed! Process Flow Visualization is ready!")
+        return True
+    else:
+        print("❌ Some tests failed. Please check the errors above.")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)