Fix monitoring for agent-bridge configuration changes

Author: kPatch

coffee_ws/src/coffee_voice_agent_ui/coffee_voice_agent_ui/voice_agent_monitor.py

@@ -10,6 +10,7 @@
 import rclpy
 from rclpy.node import Node
 from rclpy.executors import MultiThreadedExecutor
+from rclpy.parameter import Parameter
 import threading
 from datetime import datetime
 
@@ -185,6 +186,96 @@ def _init_ros(self):
         self.ros_executor.add_node(self.ros_node)
         self.ros_thread = threading.Thread(target=self.ros_executor.spin, daemon=True)
         self.ros_thread.start()
+        
+        # Query and distribute initial configuration (with delay for bridge startup)
+        QTimer.singleShot(2000, self._query_and_distribute_config)  # Wait 2 seconds for bridge to initialize
+        
+        # Set up periodic config refresh in case bridge connects later
+        self.config_refresh_timer = QTimer()
+        self.config_refresh_timer.timeout.connect(self._retry_config_if_fallback)
+        self.config_refresh_timer.start(10000)  # Check every 10 seconds
+    
+    def _query_and_distribute_config(self):
+        """Query configuration parameters from bridge and distribute to widgets"""
+        try:
+            # Query parameters from the voice agent bridge
+            config_data = {}
+            config_source = "fallback"
+            
+            # Try to get parameters from bridge using parameter client
+            try:
+                from rclpy.parameter_client import AsyncParameterClient
+                
+                # Create parameter client to query bridge node
+                param_client = AsyncParameterClient(self.ros_node, 'voice_agent_bridge')
+                
+                # Wait for bridge node to be available (timeout after 5 seconds)
+                if param_client.wait_for_services(timeout_sec=5.0):
+                    # Query timeout parameters from bridge
+                    parameter_names = ['user_response_timeout', 'max_conversation_time', 'config_received']
+                    
+                    # Use async parameter client - get future and wait for result
+                    future = param_client.get_parameters(parameter_names)
+                    
+                    # Spin until the future is complete (with timeout)
+                    import time
+                    start_time = time.time()
+                    timeout = 5.0
+                    
+                    while not future.done() and (time.time() - start_time) < timeout:
+                        rclpy.spin_once(self.ros_node, timeout_sec=0.1)
+                    
+                    if future.done():
+                        parameters = future.result().values
+                        
+                        config_data = {
+                            'user_response_timeout': parameters[0].double_value if parameters[0].type == 3 else 15.0,  # PARAMETER_DOUBLE = 3
+                            'max_conversation_time': parameters[1].double_value if parameters[1].type == 3 else 180.0
+                        }
+                        
+                        # Check if we got real configuration from agent using config_received flag
+                        config_received = parameters[2].bool_value if parameters[2].type == 1 else False  # PARAMETER_BOOL = 1
+                        
+                        if config_received:
+                            config_source = "agent"  # Bridge has received agent configuration
+                        else:
+                            config_source = "fallback"  # Bridge still using defaults
+                        
+                        self.ros_node.get_logger().info(f"Retrieved configuration from bridge: {config_data} (source: {config_source})")
+                    else:
+                        raise Exception("Parameter query timed out")
+                else:
+                    raise Exception("Bridge node not available")
+                
+            except Exception as e:
+                # Parameters not available, use fallback values
+                self.ros_node.get_logger().warn(f"Could not query bridge parameters: {e}, using fallback configuration")
+                config_data = {
+                    'user_response_timeout': 15.0,
+                    'max_conversation_time': 180.0
+                }
+                config_source = "fallback"
+            
+            # Distribute configuration to widgets
+            if hasattr(self, 'conversation_widget'):
+                self.conversation_widget.update_configuration(config_data, config_source)
+                self.ros_node.get_logger().info("Updated conversation widget configuration")
+            
+            # Add configuration info to analytics data
+            self.last_config_update = {
+                'config_data': config_data,
+                'config_source': config_source,
+                'timestamp': datetime.now()
+            }
+            
+        except Exception as e:
+            self.ros_node.get_logger().error(f"Error in configuration query and distribution: {e}")
+    
+    def _retry_config_if_fallback(self):
+        """Retry configuration query if still using fallback values"""
+        if (hasattr(self, 'last_config_update') and 
+            self.last_config_update.get('config_source') == 'fallback'):
+            self._query_and_distribute_config()
 
     def _setup_timers(self):
         """Set up update timers for the UI"""

coffee_ws/src/coffee_voice_agent_ui/coffee_voice_agent_ui/voice_agent_monitor_app.py

@@ -18,6 +18,7 @@
 import rclpy
 from rclpy.node import Node
 from rclpy.executors import MultiThreadedExecutor
+from rclpy.parameter import Parameter
 import threading
 from datetime import datetime
 
@@ -231,6 +232,14 @@ def _init_ros(self):
         self.ros_executor.add_node(self.ros_node)
         self.ros_thread = threading.Thread(target=self.ros_executor.spin, daemon=True)
         self.ros_thread.start()
+        
+        # Query and distribute initial configuration (with delay for bridge startup)
+        QTimer.singleShot(2000, self._query_and_distribute_config)  # Wait 2 seconds for bridge to initialize
+        
+        # Set up periodic config refresh in case bridge connects later
+        self.config_refresh_timer = QTimer()
+        self.config_refresh_timer.timeout.connect(self._retry_config_if_fallback)
+        self.config_refresh_timer.start(10000)  # Check every 10 seconds
 
     def _setup_timers(self):
         """Set up update timers for the UI"""
@@ -244,6 +253,87 @@ def _setup_timers(self):
         self.analytics_timer.timeout.connect(self._update_analytics)
         self.analytics_timer.start(1000)  # 1 FPS for analytics
 
+    def _query_and_distribute_config(self):
+        """Query configuration parameters from bridge and distribute to widgets"""
+        try:
+            # Query parameters from the voice agent bridge
+            config_data = {}
+            config_source = "fallback"
+            
+            # Try to get parameters from bridge using parameter client
+            try:
+                from rclpy.parameter_client import AsyncParameterClient
+                
+                # Create parameter client to query bridge node
+                param_client = AsyncParameterClient(self.ros_node, 'voice_agent_bridge')
+                
+                # Wait for bridge node to be available (timeout after 5 seconds)
+                if param_client.wait_for_services(timeout_sec=5.0):
+                    # Query timeout parameters from bridge
+                    parameter_names = ['user_response_timeout', 'max_conversation_time', 'config_received']
+                    
+                    # Use async parameter client - get future and wait for result
+                    future = param_client.get_parameters(parameter_names)
+                    
+                    # Spin until the future is complete (with timeout)
+                    import time
+                    start_time = time.time()
+                    timeout = 5.0
+                    
+                    while not future.done() and (time.time() - start_time) < timeout:
+                        rclpy.spin_once(self.ros_node, timeout_sec=0.1)
+                    
+                    if future.done():
+                        parameters = future.result().values
+                        
+                        config_data = {
+                            'user_response_timeout': parameters[0].double_value if parameters[0].type == 3 else 15.0,  # PARAMETER_DOUBLE = 3
+                            'max_conversation_time': parameters[1].double_value if parameters[1].type == 3 else 180.0
+                        }
+                        
+                        # Check if we got real configuration from agent using config_received flag
+                        config_received = parameters[2].bool_value if parameters[2].type == 1 else False  # PARAMETER_BOOL = 1
+                        if config_received:
+                            config_source = "agent"  # Bridge has received agent configuration
+                        else:
+                            config_source = "fallback"  # Bridge still using defaults
+                        
+                        self.ros_node.get_logger().info(f"Retrieved configuration from bridge: {config_data} (source: {config_source})")
+                    else:
+                        raise Exception("Parameter query timed out")
+                else:
+                    raise Exception("Bridge node not available")
+                
+            except Exception as e:
+                # Parameters not available, use fallback values
+                self.ros_node.get_logger().warn(f"Could not query bridge parameters: {e}, using fallback configuration")
+                config_data = {
+                    'user_response_timeout': 15.0,
+                    'max_conversation_time': 180.0
+                }
+                config_source = "fallback"
+            
+            # Distribute configuration to widgets
+            if hasattr(self, 'conversation_widget'):
+                self.conversation_widget.update_configuration(config_data, config_source)
+                self.ros_node.get_logger().info("Updated conversation widget configuration")
+            
+            # Add configuration info to analytics data
+            self.last_config_update = {
+                'config_data': config_data,
+                'config_source': config_source,
+                'timestamp': datetime.now()
+            }
+            
+        except Exception as e:
+            self.ros_node.get_logger().error(f"Error in configuration query and distribution: {e}")
+    
+    def _retry_config_if_fallback(self):
+        """Retry configuration query if still using fallback values"""
+        if (hasattr(self, 'last_config_update') and 
+            self.last_config_update.get('config_source') == 'fallback'):
+            self._query_and_distribute_config()
+    
     @pyqtSlot(AgentStatus)
     def _update_agent_status(self, status):
         """Update UI with new agent status"""
@@ -312,6 +402,8 @@ def closeEvent(self, event):
             self.update_timer.stop()
         if hasattr(self, 'analytics_timer'):
             self.analytics_timer.stop()
+        if hasattr(self, 'config_refresh_timer'):
+            self.config_refresh_timer.stop()
 
         # Clean up ROS
         if hasattr(self, 'ros_executor'):

coffee_ws/src/coffee_voice_agent_ui/coffee_voice_agent_ui/widgets/analytics_widget.py

@@ -414,34 +414,50 @@ def _process_conversation_data(self, conversation_data):
                 # Session ended - determine outcome type
                 duration = datetime.now() - self.current_session_start
 
-                # Analyze conversation outcome (this could be enhanced with more data from conversation_data)
-                # For now, we use heuristics based on duration and available data
+                # Analyze conversation outcome using enhanced timeout information
                 outcome_type = 'completed'  # Default assumption
+                timeout_category = 'none'   # Track which timeout caused ending
 
-                # Check for timeout indicators
-                if conversation_data.get('timeout_reached', False):
-                    outcome_type = 'timeout'
+                # Check for timeout indicators from conversation widget
+                if conversation_data.get('max_timeout_reached', False):
+                    outcome_type = 'max_timeout'
+                    timeout_category = 'max_conversation'
+                elif conversation_data.get('timeout_reached', False):
+                    outcome_type = 'user_timeout'
+                    timeout_category = 'user_response'
                 elif conversation_data.get('user_disconnected', False):
                     outcome_type = 'user_disconnect'
                 elif conversation_data.get('natural_ending', False):
                     outcome_type = 'natural'
                 elif duration.total_seconds() < 30:  # Very short conversations might be failures
                     outcome_type = 'failed'
 
+                # Check warning states for analytics
+                approaching_max_timeout = conversation_data.get('approaching_max_timeout', False)
+                approaching_user_timeout = conversation_data.get('approaching_user_timeout', False)
+                
                 session_record = {
                     'start': self.current_session_start,
                     'duration': duration,
                     'outcome': outcome_type,
+                    'timeout_category': timeout_category,
                     'turn_count': conversation_data.get('turn_count', 0),
-                    'successful': outcome_type in ['completed', 'natural']
+                    'successful': outcome_type in ['completed', 'natural'],
+                    'user_response_timeout': conversation_data.get('user_response_timeout', 15.0),
+                    'max_conversation_time': conversation_data.get('max_conversation_time', 180.0),
+                    'config_source': conversation_data.get('config_source', 'unknown'),
+                    'approaching_max_timeout': approaching_max_timeout,
+                    'approaching_user_timeout': approaching_user_timeout
                 }
 
                 self.conversation_sessions.append(session_record)
                 self.conversation_outcomes.append({
                     'timestamp': datetime.now(),
                     'outcome': outcome_type,
+                    'timeout_category': timeout_category,
                     'duration': duration,
-                    'successful': outcome_type in ['completed', 'natural']
+                    'successful': outcome_type in ['completed', 'natural'],
+                    'config_source': conversation_data.get('config_source', 'unknown')
                 })
 
                 self.current_session_start = None
@@ -671,6 +687,38 @@ def _calculate_emotion_trends(self):
         else:
             self.peak_happiness_label.setText("Peak happiness: --")
             self.most_curious_label.setText("Most curious: --")
+        
+        # Add timeout analytics to emotion trends section
+        self._update_timeout_analytics()
+    
+    def _update_timeout_analytics(self):
+        """Update timeout analytics in the existing emotion trend labels"""
+        # Calculate timeout statistics from recent outcomes
+        recent_outcomes = [outcome for outcome in self.conversation_outcomes 
+                          if (datetime.now() - outcome['timestamp']).total_seconds() < 3600]
+        
+        if recent_outcomes:
+            # Count different timeout types
+            max_timeout_count = sum(1 for o in recent_outcomes if o.get('timeout_category') == 'max_conversation')
+            user_timeout_count = sum(1 for o in recent_outcomes if o.get('timeout_category') == 'user_response')
+            natural_count = sum(1 for o in recent_outcomes if o.get('outcome') == 'natural')
+            total_conversations = len(recent_outcomes)
+            
+            # Update peak happiness label with timeout completion info
+            if total_conversations > 0:
+                natural_percentage = (natural_count / total_conversations) * 100
+                self.peak_happiness_label.setText(f"Natural endings: {natural_count}/{total_conversations} ({natural_percentage:.0f}%)")
+            else:
+                self.peak_happiness_label.setText("Natural endings: --")
+            
+            # Update curious label with timeout breakdown
+            if max_timeout_count > 0 or user_timeout_count > 0:
+                self.most_curious_label.setText(f"Timeouts: {max_timeout_count} max, {user_timeout_count} user")
+            else:
+                self.most_curious_label.setText("Timeouts: None recently")
+        else:
+            self.peak_happiness_label.setText("Natural endings: --")
+            self.most_curious_label.setText("Timeouts: --")
 
     def _calculate_system_metrics(self):
         """Calculate and update system metrics from real data"""