Update way we handle ending conversation and add VIP support

Author: kPatch

coffee_ws/src/coffee_voice_agent/scripts/agents/coffee_barista_agent.py

@@ -23,7 +23,8 @@
 from state.state_manager import StateManager, AgentState
 from tools.coffee_tools import (
     get_current_time_impl, get_current_date_impl, get_coffee_menu_impl,
-    get_ordering_instructions_impl, recommend_drink_impl, set_agent_instance
+    get_ordering_instructions_impl, recommend_drink_impl, set_agent_instance,
+    manage_conversation_time_impl, check_user_status_impl
 )
 
 logger = logging.getLogger(__name__)
@@ -62,6 +63,16 @@ def __init__(self):
                     name="recommend_drink",
                     description="Recommend a drink based on user preference."
                 ),
+                function_tool(
+                    manage_conversation_time_impl,
+                    name="manage_conversation_time",
+                    description="Intelligent conversation time management. Use this when you receive admin messages about time limits or need to make decisions about continuing or ending the conversation."
+                ),
+                function_tool(
+                    check_user_status_impl,
+                    name="check_user_status",
+                    description="Check if a user has special status (VIP, staff, important guest) based on what they tell you about themselves."
+                ),
             ]
         )
 
@@ -192,6 +203,41 @@ async def process_text_stream():
 
         logger.info("🔍 DEBUG: tts_node processing complete")
 
+    async def on_user_turn_completed(self, turn_ctx, new_message):
+        """Handle user turn completion - inject admin messages for time management"""
+        if not self.state_manager.conversation_start_time:
+            return
+            
+        import time
+        elapsed = time.time() - self.state_manager.conversation_start_time
+        
+        # 5 minute warning
+        if elapsed > 300 and not self.state_manager.five_minute_warning_sent:
+            logger.info("Injecting 5-minute conversation warning via callback")
+            turn_ctx.add_message(
+                role="system",
+                content="ADMIN: You've been chatting for 5 minutes. The user seems engaged. Consider mentioning you have time for 1-2 more questions, but be natural about it based on the conversation flow."
+            )
+            self.state_manager.five_minute_warning_sent = True
+            
+        # 6 minute warning  
+        elif elapsed > 360 and not self.state_manager.six_minute_warning_sent:
+            logger.info("Injecting 6-minute conversation warning via callback")
+            turn_ctx.add_message(
+                role="system", 
+                content="ADMIN: You've been chatting for 6 minutes. Suggest wrapping up soon to help other visitors, but use your judgment. Call the manage_conversation_time tool to make a decision."
+            )
+            self.state_manager.six_minute_warning_sent = True
+            
+        # 7 minute limit
+        elif elapsed > 420 and not self.state_manager.seven_minute_warning_sent:
+            logger.info("Injecting 7-minute conversation limit via callback")
+            turn_ctx.add_message(
+                role="system",
+                content="ADMIN: You've been chatting for 7 minutes - time limit reached. Call the manage_conversation_time tool with action='end' to wrap up gracefully, unless there are special circumstances."
+            )
+            self.state_manager.seven_minute_warning_sent = True
+
     async def start_wake_word_detection(self, room):
         """Start wake word detection in a separate thread"""
         if not self.porcupine_access_key:

coffee_ws/src/coffee_voice_agent/scripts/config/instructions.py

@@ -16,6 +16,17 @@
 
 Available emotions: excited, friendly, helpful, curious, enthusiastic, warm, professional, cheerful
 
+ADMIN MESSAGE HANDLING:
+You may receive ADMIN messages about conversation timing and management. These are system notifications to help you manage your time effectively:
+
+- When you see "ADMIN: You've been chatting for 5 minutes..." - Acknowledge naturally and consider mentioning you have time for more questions
+- When you see "ADMIN: You've been chatting for 6 minutes..." - Use the manage_conversation_time tool to make a decision about wrapping up
+- When you see "ADMIN: You've been chatting for 7 minutes..." - Use the manage_conversation_time tool with action='end' to wrap up gracefully
+
+IMPORTANT: If a user mentions they are VIP, staff, or important guests (like "I'm Alice from Sui Foundation"), use the check_user_status tool to verify and potentially extend the conversation.
+
+Always respond naturally to admin messages - incorporate them into your conversation flow rather than mentioning them directly to the user.
+
 Your personality:
 - Enthusiastic about coffee and the blockchain conference
 - Knowledgeable about coffee drinks and brewing

coffee_ws/src/coffee_voice_agent/scripts/config/settings.py

@@ -9,7 +9,9 @@
 # Configurable timeout settings
 USER_RESPONSE_TIMEOUT = int(os.getenv("USER_RESPONSE_TIMEOUT", "15"))  # seconds
 FINAL_TIMEOUT = int(os.getenv("FINAL_TIMEOUT", "10"))  # seconds after prompt
-MAX_CONVERSATION_TIME = int(os.getenv("MAX_CONVERSATION_TIME", "180"))  # 3 minutes total
+MAX_CONVERSATION_TIME = int(os.getenv("MAX_CONVERSATION_TIME", "420"))  # 7 minutes total
+CONVERSATION_WARNING_TIME = int(os.getenv("CONVERSATION_WARNING_TIME", "300"))  # 5 minutes - first warning
+FINAL_WARNING_TIME = int(os.getenv("FINAL_WARNING_TIME", "360"))  # 6 minutes - final warning
 
 # WebSocket server settings
 WEBSOCKET_HOST = os.getenv("WEBSOCKET_HOST", "localhost")

coffee_ws/src/coffee_voice_agent/scripts/state/state_manager.py

@@ -16,7 +16,7 @@
 
 from config.settings import (
     USER_RESPONSE_TIMEOUT, FINAL_TIMEOUT, MAX_CONVERSATION_TIME,
-    VALID_EMOTIONS
+    CONVERSATION_WARNING_TIME, FINAL_WARNING_TIME, VALID_EMOTIONS
 )
 
 logger = logging.getLogger(__name__)
@@ -58,6 +58,12 @@ def __init__(self, agent=None):
         # Goodbye coordination flag
         self.goodbye_pending = False  # Flag to coordinate goodbye handling between user and assistant handlers
 
+        # Conversation timing tracking for admin message injection
+        self.conversation_start_time = None
+        self.five_minute_warning_sent = False
+        self.six_minute_warning_sent = False
+        self.seven_minute_warning_sent = False
+        
         # Phase 4: Mutual exclusion for virtual request processing
         self.virtual_request_processing_lock = asyncio.Lock()
         # Removed batching complexity - no longer needed
@@ -111,26 +117,37 @@ async def _exit_current_state(self):
     async def _enter_new_state(self):
         """Initialize new state"""
         if self.current_state == AgentState.ACTIVE:
+            # Start conversation timing tracking
+            import time
+            self.conversation_start_time = time.time()
+            self.five_minute_warning_sent = False
+            self.six_minute_warning_sent = False
+            self.seven_minute_warning_sent = False
+            
             # Start max conversation timer (absolute limit)
             self.conversation_timer = asyncio.create_task(self._max_conversation_timeout())
         elif self.current_state == AgentState.DORMANT:
+            # Reset conversation timing
+            self.conversation_start_time = None
+            
             # Resume wake word detection when returning to dormant
             if self.agent:
                 self.agent.wake_word_paused = False
                 logger.info("Resumed wake word detection")
 
     async def _max_conversation_timeout(self):
-        """Handle maximum conversation time limit"""
+        """Handle absolute maximum conversation time limit (fallback)"""
         try:
-            await asyncio.sleep(MAX_CONVERSATION_TIME)  # 5 minute absolute limit
+            # Wait for absolute maximum time (7 minutes)
+            await asyncio.sleep(MAX_CONVERSATION_TIME)
             if self.session and self.current_state == AgentState.ACTIVE:
-                logger.info("Maximum conversation time reached - ending session")
+                logger.info("Absolute maximum conversation time reached - ending conversation")
 
                 # Set ending flag to prevent timer conflicts
                 self.ending_conversation = True
 
-                # Timeout message with sleepy emotion using delimiter format
-                timeout_response = "sleepy:We've been chatting for a while! I'm getting a bit sleepy. Thanks for the conversation. Say 'hey barista' if you need me again."
+                # Fallback timeout message if callback system didn't handle it
+                timeout_response = "friendly:I've really enjoyed our conversation! To help other visitors, I'll need to wrap up here. Say 'hey barista' if you need me again."
                 emotion, text = self.process_emotional_response(timeout_response)
                 await self.say_with_emotion(text, emotion)
 

coffee_ws/src/coffee_voice_agent/scripts/tools/coffee_tools.py

@@ -120,4 +120,93 @@ async def recommend_drink_impl(context: RunContext, preference: str = "energizin
     logger.info(f"Drink recommendation for '{preference}': {base_recommendation}")
 
     await send_tool_event("recommend_drink", "completed", [preference], full_recommendation)
-    return full_recommendation 
+    return full_recommendation
+
+
+async def manage_conversation_time_impl(
+    context: RunContext,
+    action: str,
+    reason: str,
+    user_importance: str = "normal",
+    extension_minutes: int = 0
+) -> str:
+    """
+    Intelligent conversation time management based on context.
+    
+    Args:
+        action: What to do - "continue", "warn", "extend", "end"
+        reason: LLM's reasoning for the decision
+        user_importance: Assessment of user importance/engagement - "vip", "engaged", "normal"
+        extension_minutes: How much to extend if action is 'extend'
+    """
+    await send_tool_event("manage_conversation_time", "started", [action, reason, user_importance])
+    
+    logger.info(f"LLM conversation decision: {action} - {reason} (user_importance: {user_importance})")
+    
+    result = ""
+    
+    if action == "end":
+        # Signal the state manager to end conversation gracefully
+        if _agent_instance and hasattr(_agent_instance, 'state_manager'):
+            _agent_instance.state_manager.ending_conversation = True
+            # Schedule conversation end after a brief delay
+            asyncio.create_task(_delayed_conversation_end())
+        result = f"Conversation ending initiated: {reason}"
+        
+    elif action == "extend":
+        logger.info(f"Conversation extended by {extension_minutes} minutes: {reason}")
+        result = f"Conversation extended by {extension_minutes} minutes: {reason}"
+        
+    elif action == "warn":
+        logger.info(f"Conversation warning acknowledged: {reason}")
+        result = f"Time warning acknowledged: {reason}"
+        
+    elif action == "continue":
+        logger.info(f"Conversation continues normally: {reason}")
+        result = f"Conversation continues: {reason}"
+        
+    else:
+        result = f"Unknown action '{action}': {reason}"
+        logger.warning(result)
+    
+    await send_tool_event("manage_conversation_time", "completed", [action, reason, user_importance], result)
+    return result
+
+
+async def check_user_status_impl(
+    context: RunContext,
+    user_identifier: str = ""
+) -> str:
+    """
+    Check if user has special status (VIP, staff, important guest).
+    
+    Args:
+        user_identifier: Any identifier mentioned by the user (name, title, etc.)
+    """
+    await send_tool_event("check_user_status", "started", [user_identifier])
+    
+    # VIP keywords to check for
+    vip_keywords = [
+        "alice", "bob", "sui foundation", "event organizer", "staff", "organizer",
+        "speaker", "sponsor", "mysten labs", "team", "developer", "builder"
+    ]
+    
+    user_lower = user_identifier.lower()
+    is_vip = any(keyword in user_lower for keyword in vip_keywords)
+    
+    if is_vip:
+        result = f"VIP user detected: {user_identifier}. Recommended extension: 3 minutes. Enhanced service advised."
+        logger.info(f"VIP user identified: {user_identifier}")
+    else:
+        result = f"Standard user: {user_identifier}. Normal time limits apply."
+        logger.info(f"Standard user: {user_identifier}")
+    
+    await send_tool_event("check_user_status", "completed", [user_identifier], result)
+    return result
+
+
+async def _delayed_conversation_end():
+    """Helper function to end conversation after a brief delay"""
+    await asyncio.sleep(2)  # Allow current response to complete
+    if _agent_instance and hasattr(_agent_instance, 'state_manager'):
+        await _agent_instance.state_manager.end_conversation()