Update state_orchestrator.py

state_orchestrator.py

@@ -81,6 +81,7 @@ class StateOrchestrator:
 
         # Conversation events
         self.event_bus.subscribe(EventType.CONVERSATION_STARTED, self._handle_conversation_started)
+        self.event_bus.subscribe(EventType.CONVERSATION_ENDED, self._handle_conversation_ended)  
 
         # Session lifecycle
         self.event_bus.subscribe(EventType.SESSION_STARTED, self._handle_session_started)
@@ -116,23 +117,65 @@ class StateOrchestrator:
         
         log_info(f"🎤 Conversation started | session_id={session_id}")
         
-        # Welcome mesajını şimdi başlat
-        if context.project_config and context.project_config.get("welcome_enabled", True):
+        # İlk olarak IDLE'dan INITIALIZING'e geç
+        await self.transition_to(session_id, ConversationState.INITIALIZING)
+        
+        # Welcome mesajı varsa
+        if context.metadata.get("has_welcome") and context.metadata.get("welcome_text"):
             await self.transition_to(session_id, ConversationState.PREPARING_WELCOME)
-            await self._prepare_welcome_message(session_id)
+            
+            # Request TTS for welcome message
+            await self.event_bus.publish(Event(
+                type=EventType.TTS_STARTED,
+                session_id=session_id,
+                data={
+                    "text": context.metadata.get("welcome_text", ""),
+                    "is_welcome": True
+                }
+            ))
         else:
-            # Welcome yoksa direkt listening'e geç
+            # Welcome yoksa direkt LISTENING'e geç
             await self.transition_to(session_id, ConversationState.LISTENING)
             
             # Start STT
-            await self._event_bus.publish(
+            await self.event_bus.publish(
                 Event(
-                    type=EventType.START_STT,
-                    data={"session_id": session_id},
+                    type=EventType.STT_STARTED,
+                    data={},
                     session_id=session_id
                 )
             )
-            
+
+    async def _handle_conversation_ended(self, event: Event) -> None:
+        """Handle conversation end - but keep session alive"""
+        session_id = event.session_id
+        context = self.sessions.get(session_id)
+        
+        if not context:
+            log_warning(f"⚠️ Session not found for conversation end | session_id={session_id}")
+            return
+        
+        log_info(f"🔚 Conversation ended | session_id={session_id}")
+        
+        # Stop STT if running
+        await self.event_bus.publish(Event(
+            type=EventType.STT_STOPPED,
+            session_id=session_id,
+            data={"reason": "conversation_ended"}
+        ))
+        
+        # Stop any ongoing TTS
+        await self.event_bus.publish(Event(
+            type=EventType.TTS_STOPPED,
+            session_id=session_id,
+            data={"reason": "conversation_ended"}
+        ))
+        
+        # Transition back to IDLE - session still alive!
+        await self.transition_to(session_id, ConversationState.IDLE)
+        
+        log_info(f"💤 Session back to IDLE, ready for new conversation | session_id={session_id}")
+        
     async def _handle_session_started(self, event: Event):
         """Handle session start"""
         session_id = event.session_id
@@ -152,62 +195,51 @@ class StateOrchestrator:
         
         self.sessions[session_id] = context
         
-        # Transition to INITIALIZING
-        await self.transition_to(session_id, ConversationState.INITIALIZING)
+        # Session başladığında IDLE state'te kalmalı
+        # Conversation başlayana kadar bekleyeceğiz
+        # Zaten SessionContext default state'i IDLE
+        log_info(f"📍 Session created in IDLE state | session_id={session_id}")
+            
+    async def _handle_session_ended(self, event: Event):
+        """Handle session end - complete cleanup"""
+        session_id = event.session_id
         
-        # Check if welcome prompt exists
-        if session_data.get("has_welcome"):
-            await self.transition_to(session_id, ConversationState.PREPARING_WELCOME)
+        log_info(f"🏁 Session ended | session_id={session_id}")
+        
+        # Get context for cleanup
+        context = self.sessions.get(session_id)
+        
+        if context:
+            # Try to transition to ENDED if possible
+            try:
+                await self.transition_to(session_id, ConversationState.ENDED)
+            except Exception as e:
+                log_warning(f"Could not transition to ENDED state: {e}")
             
-            # Request TTS for welcome message
+            # Stop all components
             await self.event_bus.publish(Event(
-                type=EventType.TTS_STARTED,
+                type=EventType.STT_STOPPED,
                 session_id=session_id,
-                data={
-                    "text": session_data.get("welcome_text", ""),
-                    "is_welcome": True
-                }
+                data={"reason": "session_ended"}
             ))
-        else:
-            # No welcome, go straight to listening
-            await self.transition_to(session_id, ConversationState.LISTENING)
             
-            # Request STT start
             await self.event_bus.publish(Event(
-                type=EventType.STT_STARTED,
+                type=EventType.TTS_STOPPED,
                 session_id=session_id,
-                data={}
+                data={"reason": "session_ended"}
             ))
             
-    async def _handle_session_ended(self, event: Event):
-        """Handle session end"""
-        session_id = event.session_id
-        
-        log_info(f"🏁 Session ended", session_id=session_id)
-        
-        # Get context for cleanup
-        context = self.sessions.get(session_id)
-        
-        # Transition to ended
-        await self.transition_to(session_id, ConversationState.ENDED)
-        
-        # Stop all components
-        await self.event_bus.publish(Event(
-            type=EventType.STT_STOPPED,
-            session_id=session_id,
-            data={"reason": "session_ended"}
-        ))
-        
-        # Cleanup session context
-        if context:
+            # Cleanup session context
             await context.cleanup()
-            
+        
         # Remove session
         self.sessions.pop(session_id, None)
         
         # Clear event bus session data
         self.event_bus.clear_session_data(session_id)
         
+        log_info(f"✅ Session fully cleaned up | session_id={session_id}")
+        
     async def _handle_stt_ready(self, event: Event):
         """Handle STT ready signal"""
         session_id = event.session_id