Log Process Flow as JSON for review v1

app.py

@@ -21,19 +21,10 @@ 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
+# Process Flow Visualization - DISABLED
+# Moving functionality to container logs instead of UI
+process_flow_available = False
+logger.info("Process Flow Visualization disabled - functionality moved to container logs")
 
 try:
     logger.info("Attempting to import orchestration components...")
@@ -320,17 +311,13 @@ def create_mobile_optimized_interface():
                         )
                         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
+                # Process Flow Tab - DISABLED
+                # Process flow information is now logged to container logs instead of UI
             
             # 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)
@@ -384,7 +371,7 @@ def create_mobile_optimized_interface():
             _interface_components = interface_components
             
             # Build outputs list dynamically
-            outputs = _build_outputs_list(interface_components, process_flow_available)
+            outputs = _build_outputs_list(interface_components)
             
             # Include session_info in inputs to pass session ID
             inputs = [interface_components['message_input'], interface_components['chatbot']]
@@ -431,35 +418,8 @@ def create_mobile_optimized_interface():
                     ]
                 )
             
-            # 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=[]
-                    )
+            # Process Flow event handlers - DISABLED
+            # Process flow information is now logged to container logs instead of UI
     
     return demo, interface_components
 
@@ -743,7 +703,7 @@ async def process_message_async(message: str, history: Optional[List], session_i
 # Global variable to store interface components for dynamic return values
 _interface_components = {}
 
-def _build_outputs_list(interface_components: dict, process_flow_available: bool) -> list:
+def _build_outputs_list(interface_components: dict) -> list:
     """
     Build outputs list dynamically based on available interface components
     """
@@ -761,24 +721,12 @@ def _build_outputs_list(interface_components: dict, process_flow_available: bool
     if 'skills_tags' in interface_components:
         outputs.append(interface_components['skills_tags'])
     
-    # 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'])
+    # Process Flow outputs - DISABLED
+    # Process flow information is now logged to container logs instead of UI
     
     return outputs
 
-def _build_dynamic_return_values(result: tuple, skills_content: str, interface_components: dict, process_flow_available: bool = False, flow_updates: dict = None) -> tuple:
+def _build_dynamic_return_values(result: tuple, skills_content: str, interface_components: dict) -> tuple:
     """
     Build return values dynamically based on available interface components
     This ensures the return values match the outputs list exactly
@@ -803,20 +751,8 @@ def _build_dynamic_return_values(result: tuple, skills_content: str, interface_c
     if 'skills_tags' in interface_components:
         return_values.append(skills_content)  # skills_content
     
-    # Add Process Flow outputs if available
-    if process_flow_available:
-        if 'flow_display' in interface_components:
-            return_values.append(flow_updates.get("flow_display", "") if flow_updates else "")
-        if 'flow_stats' in interface_components:
-            return_values.append(flow_updates.get("flow_stats", {}) if flow_updates else {})
-        if 'performance_metrics' in interface_components:
-            return_values.append(flow_updates.get("performance_metrics", {}) if flow_updates else {})
-        if 'intent_details' in interface_components:
-            return_values.append(flow_updates.get("intent_details", {}) if flow_updates else {})
-        if 'synthesis_details' in interface_components:
-            return_values.append(flow_updates.get("synthesis_details", {}) if flow_updates else {})
-        if 'safety_details' in interface_components:
-            return_values.append(flow_updates.get("safety_details", {}) if flow_updates else {})
+    # Process Flow outputs - DISABLED
+    # Process flow information is now logged to container logs instead of UI
     
     return tuple(return_values)
 
@@ -842,7 +778,7 @@ def process_message(message: str, history: Optional[List], session_id: Optional[
         skills_content, skills_visible = _update_skills_display(skills_html)
         
         # Return dynamic values based on available components
-        return _build_dynamic_return_values(result, skills_content, _interface_components, process_flow_available)
+        return _build_dynamic_return_values(result, skills_content, _interface_components)
     except Exception as e:
         logger.error(f"Error in process_message: {e}", exc_info=True)
         error_history = list(history) if history else []
@@ -873,7 +809,7 @@ def process_message(message: str, history: Optional[List], session_id: Optional[
         
         # Return dynamic values for error case
         error_result = (error_history, "", reasoning_data, {}, {}, session_id, "")
-        return _build_dynamic_return_values(error_result, "", _interface_components, process_flow_available)
+        return _build_dynamic_return_values(error_result, "", _interface_components)
 
 # Decorate the chat handler with GPU if available
 if SPACES_GPU_AVAILABLE and GPU is not None:
@@ -889,7 +825,7 @@ 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 with Process Flow Visualization"""
+        """Wrapper to handle session ID - Process Flow functionality moved to logs"""
         if not session_id:
             session_id = str(uuid.uuid4())[:8]
         result = process_message(message, history, session_id)
@@ -897,85 +833,54 @@ else:
         skills_html = result[6]
         skills_content, skills_visible = _update_skills_display(skills_html)
         
-        # 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 dynamic agent results for visualization
-                step_results = {}
-                
-                # Intent result
-                step_results["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"
-                }
-                
-                # Skills result (if available)
-                if "skills_result" in reasoning_data:  # Check if skills data is in reasoning_data
-                    step_results["skills_result"] = reasoning_data["skills_result"]
-                else:
-                    step_results["skills_result"] = {
-                        "identified_skills": [],
-                        "confidence_score": 0.7,
-                        "processing_time": performance_data.get("processing_time", 0.5) * 0.2,
-                        "agent_id": "SKILLS_ID_001"
-                    }
-                
-                # Synthesis result
-                step_results["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": step_results["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
-                step_results["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"
-                }
-                
-                # Final response
-                step_results["final_response"] = result[0][-1]["content"] if result[0] else ""
-                
-                # Update process flow visualization dynamically
-                flow_updates = update_process_flow_visualization(
-                    user_input=message,
-                    session_id=session_id,
-                    processing_time=performance_data.get("processing_time", 1.0),
-                    **step_results
-                )
-            except Exception as e:
-                logger.error(f"Error updating process flow: {e}")
-                flow_updates = {}
+        # Log process flow information to container logs instead of UI
+        try:
+            # Extract data for process flow logging
+            reasoning_data = result[2]
+            performance_data = result[3]
+            context_data = result[4]
+            
+            # Log comprehensive process flow information
+            logger.info("=" * 60)
+            logger.info("PROCESS FLOW LOGGING")
+            logger.info("=" * 60)
+            logger.info(f"Session ID: {session_id}")
+            logger.info(f"User Input: {message[:100]}...")
+            logger.info(f"Processing Time: {performance_data.get('processing_time', 0):.2f}s")
+            
+            # Log intent recognition details
+            if reasoning_data.get("chain_of_thought"):
+                logger.info("Intent Recognition:")
+                logger.info(f"  - Primary Intent: {reasoning_data.get('chain_of_thought', {}).get('step_1', {}).get('hypothesis', 'unknown')}")
+                logger.info(f"  - Confidence: {reasoning_data.get('confidence_calibration', {}).get('overall_confidence', 0.7):.2f}")
+            
+            # Log performance metrics
+            logger.info("Performance Metrics:")
+            logger.info(f"  - Agent Trace: {performance_data.get('agent_trace', [])}")
+            logger.info(f"  - Token Count: {performance_data.get('token_count', 0)}")
+            logger.info(f"  - Confidence Score: {performance_data.get('confidence_score', 0.7):.2f}")
+            logger.info(f"  - Agents Used: {performance_data.get('agents_used', [])}")
+            
+            # Log context information
+            logger.info("Context Information:")
+            logger.info(f"  - Interaction ID: {context_data.get('interaction_id', 'unknown')}")
+            logger.info(f"  - Timestamp: {context_data.get('timestamp', '')}")
+            logger.info(f"  - Warnings: {context_data.get('warnings', [])}")
+            
+            # Log skills identification if available
+            if skills_html and len(skills_html.strip()) > 0:
+                logger.info("Skills Identification:")
+                logger.info(f"  - Skills HTML: {skills_html}")
+            
+            logger.info("=" * 60)
+            logger.info("END PROCESS FLOW LOGGING")
+            logger.info("=" * 60)
+            
+        except Exception as e:
+            logger.error(f"Error logging process flow: {e}")
         
-        # Return dynamic values including process flow
-        return _build_dynamic_return_values(result, skills_content, _interface_components, process_flow_available, flow_updates)
+        # Return dynamic values without process flow
+        return _build_dynamic_return_values(result, skills_content, _interface_components)
     chat_handler_fn = chat_handler_wrapper
 
 # Initialize orchestrator on module load