workflow errors debugging v6

app.py

@@ -212,18 +212,21 @@ def create_mobile_optimized_interface():
                             label="",
                             show_label=False
                         )
+                        interface_components['reasoning_display'] = reasoning_display
                     
                     with gr.Accordion("Agent Performance", open=False):
                         performance_display = gr.JSON(
                             label="",
                             show_label=False
                         )
+                        interface_components['performance_display'] = performance_display
                     
                     with gr.Accordion("Session Context", open=False):
                         context_display = gr.JSON(
                             label="",
                             show_label=False
                         )
+                        interface_components['context_display'] = context_display
             
             # Mobile Bottom Navigation
             with gr.Row(visible=False, elem_id="mobile_nav") as mobile_navigation:
@@ -270,10 +273,19 @@ def create_mobile_optimized_interface():
         # Wire up the submit handler INSIDE the gr.Blocks context
         if 'send_btn' in interface_components and 'message_input' in interface_components and 'chatbot' in interface_components:
             # Connect the submit handler with the GPU-decorated function
+            # Include Details tab components as outputs
+            outputs = [interface_components['chatbot'], interface_components['message_input']]
+            if 'reasoning_display' in interface_components:
+                outputs.append(interface_components['reasoning_display'])
+            if 'performance_display' in interface_components:
+                outputs.append(interface_components['performance_display'])
+            if 'context_display' in interface_components:
+                outputs.append(interface_components['context_display'])
+            
             interface_components['send_btn'].click(
                 fn=chat_handler_fn,
                 inputs=[interface_components['message_input'], interface_components['chatbot']],
-                outputs=[interface_components['chatbot'], interface_components['message_input']]
+                outputs=outputs
             )
     
     return demo, interface_components
@@ -305,15 +317,16 @@ def setup_event_handlers(demo, event_handlers):
     
     return demo
 
-async def process_message_async(message: str, history: Optional[List], session_id: str) -> Tuple[List, str]:
+async def process_message_async(message: str, history: Optional[List], session_id: str) -> Tuple[List, str, dict, dict, dict]:
     """
     Process message with full orchestration system
-    Returns (updated_history, empty_string)
+    Returns (updated_history, empty_string, reasoning_data, performance_data, context_data)
     
     GUARANTEES:
     - Always returns a response (never None or empty)
     - Handles all error cases gracefully
     - Provides fallback responses at every level
+    - Returns metadata for Details tab
     """
     global orchestrator
     
@@ -324,7 +337,7 @@ async def process_message_async(message: str, history: Optional[List], session_i
         
         if not message or not message.strip():
             logger.debug("Empty message received")
-            return history if history else [], ""
+            return history if history else [], "", {}, {}, {}
         
         if history is None:
             history = []
@@ -334,6 +347,11 @@ async def process_message_async(message: str, history: Optional[List], session_i
         # Add user message
         new_history.append({"role": "user", "content": message.strip()})
         
+        # Initialize Details tab data
+        reasoning_data = {}
+        performance_data = {}
+        context_data = {}
+        
         # GUARANTEE: Always get a response
         response = "Hello! I'm processing your request..."
         
@@ -349,6 +367,7 @@ async def process_message_async(message: str, history: Optional[List], session_i
                 
                 # Extract response from result with multiple fallback checks
                 if isinstance(result, dict):
+                    # Extract the text response (not the dict)
                     response = (
                         result.get('response') or 
                         result.get('final_response') or 
@@ -356,6 +375,28 @@ async def process_message_async(message: str, history: Optional[List], session_i
                         result.get('original_response') or
                         str(result.get('result', ''))
                     )
+                    
+                    # Extract metadata for Details tab
+                    reasoning_data = {
+                        "intent": result.get('metadata', {}).get('intent', 'unknown'),
+                        "execution_plan": result.get('metadata', {}).get('execution_plan', {}),
+                        "processing_steps": result.get('metadata', {}).get('processing_steps', [])
+                    }
+                    
+                    performance_data = {
+                        "agent_trace": result.get('agent_trace', []),
+                        "processing_time": result.get('metadata', {}).get('processing_time', 0),
+                        "token_count": result.get('metadata', {}).get('token_count', 0),
+                        "confidence_score": result.get('confidence_score', 0.7),
+                        "agents_used": result.get('metadata', {}).get('agents_used', [])
+                    }
+                    
+                    context_data = {
+                        "interaction_id": result.get('interaction_id', 'unknown'),
+                        "session_id": session_id,
+                        "timestamp": result.get('timestamp', ''),
+                        "warnings": result.get('metadata', {}).get('warnings', [])
+                    }
                 else:
                     response = str(result) if result else "Processing complete."
                 
@@ -372,16 +413,18 @@ async def process_message_async(message: str, history: Optional[List], session_i
                 logger.error(f"Orchestrator error: {orch_error}", exc_info=True)
                 # Fallback response with error info
                 response = f"I'm experiencing some technical difficulties. Your message was: '{message[:100]}...' Please try again or rephrase your question."
+                reasoning_data = {"error": str(orch_error)}
         else:
             # Fallback placeholder - always informative
             logger.info("Using placeholder response (orchestrator unavailable)")
             response = f"Hello! I received your message: '{message}'.\n\nThe full AI orchestration system is {'available but not loaded' if orchestrator_available else 'not available'}."
+            reasoning_data = {"status": "orchestrator_unavailable"}
         
         # Add assistant response
         new_history.append({"role": "assistant", "content": response})
         logger.info("✓ Message processing complete")
         
-        return new_history, ""
+        return new_history, "", reasoning_data, performance_data, context_data
         
     except Exception as e:
         # FINAL FALLBACK: Always return something to user
@@ -398,11 +441,12 @@ async def process_message_async(message: str, history: Optional[List], session_i
         )
         error_history.append({"role": "assistant", "content": error_message})
         
-        return error_history, ""
+        return error_history, "", {"error": str(e)}, {}, {}
 
-def process_message(message: str, history: Optional[List]) -> Tuple[List, str]:
+def process_message(message: str, history: Optional[List]) -> Tuple[List, str, dict, dict, dict]:
     """
     Synchronous wrapper for async processing
+    Returns (history, empty_string, reasoning_data, performance_data, context_data)
     """
     import asyncio
     
@@ -420,7 +464,7 @@ def process_message(message: str, history: Optional[List]) -> Tuple[List, str]:
         error_history = list(history) if history else []
         error_history.append({"role": "user", "content": message})
         error_history.append({"role": "assistant", "content": f"Error: {str(e)}"})
-        return error_history, ""
+        return error_history, "", {"error": str(e)}, {}, {}
 
 # Decorate the chat handler with GPU if available
 if SPACES_GPU_AVAILABLE and GPU is not None:

orchestrator_engine.py

@@ -1,6 +1,7 @@
 # orchestrator_engine.py
 import uuid
 import logging
+import time
 from datetime import datetime
 
 logger = logging.getLogger(__name__)
@@ -20,6 +21,8 @@ class MVPOrchestrator:
         logger.info(f"Processing request for session {session_id}")
         logger.info(f"User input: {user_input[:100]}")
         
+        start_time = time.time()
+        
         try:
             # Step 1: Generate unique interaction ID
             interaction_id = self._generate_interaction_id(session_id)
@@ -62,16 +65,40 @@ class MVPOrchestrator:
                 context=context
             )
             
-            result = self._format_final_output(safety_checked, interaction_id)
+            processing_time = time.time() - start_time
+            
+            result = self._format_final_output(safety_checked, interaction_id, {
+                'intent': intent_result.get('primary_intent', 'unknown'),
+                'execution_plan': execution_plan,
+                'processing_steps': [
+                    'Context management',
+                    'Intent recognition',
+                    'Execution planning',
+                    'Agent execution',
+                    'Response synthesis',
+                    'Safety check'
+                ],
+                'processing_time': processing_time,
+                'agents_used': list(self.agents.keys())
+            })
             logger.info(f"Request processing complete. Response length: {len(str(result.get('response', '')))}")
             return result
             
         except Exception as e:
             logger.error(f"Error in process_request: {e}", exc_info=True)
+            processing_time = time.time() - start_time
             return {
                 "response": f"Error processing request: {str(e)}",
                 "error": str(e),
-                "interaction_id": str(uuid.uuid4())[:8]
+                "interaction_id": str(uuid.uuid4())[:8],
+                "agent_trace": [],
+                "timestamp": datetime.now().isoformat(),
+                "metadata": {
+                    "agents_used": [],
+                    "processing_time": processing_time,
+                    "token_count": 0,
+                    "warnings": []
+                }
             }
     
     def _generate_interaction_id(self, session_id: str) -> str:
@@ -100,7 +127,7 @@ class MVPOrchestrator:
         # TODO: Implement parallel/sequential agent execution
         return {}
     
-    def _format_final_output(self, response: dict, interaction_id: str) -> dict:
+    def _format_final_output(self, response: dict, interaction_id: str, additional_metadata: dict = None) -> dict:
         """
         Format final output with tracing and metadata
         """
@@ -116,6 +143,23 @@ class MVPOrchestrator:
         if not response_text:
             response_text = "I apologize, but I'm having trouble generating a response right now. Please try again."
         
+        # Extract warnings from safety check result
+        warnings = []
+        if "warnings" in response:
+            warnings = response["warnings"] if isinstance(response["warnings"], list) else []
+        
+        # Build metadata dict
+        metadata = {
+            "agents_used": response.get("agents_used", []),
+            "processing_time": response.get("processing_time", 0),
+            "token_count": response.get("token_count", 0),
+            "warnings": warnings
+        }
+        
+        # Merge in any additional metadata
+        if additional_metadata:
+            metadata.update(additional_metadata)
+        
         return {
             "interaction_id": interaction_id,
             "response": response_text,
@@ -123,12 +167,7 @@ class MVPOrchestrator:
             "confidence_score": response.get("confidence_score", 0.7),
             "agent_trace": self.execution_trace,
             "timestamp": datetime.now().isoformat(),
-            "metadata": {
-                "agents_used": response.get("agents_used", []),
-                "processing_time": response.get("processing_time", 0),
-                "token_count": response.get("token_count", 0),
-                "warnings": response.get("warnings", [])
-            }
+            "metadata": metadata
         }
     
     def get_execution_trace(self) -> list: