Update stt/stt_lifecycle_manager.py

stt/stt_lifecycle_manager.py

@@ -176,6 +176,11 @@ class STTLifecycleManager:
                 error=str(e)
             )
 
+    async def _handle_session_ended(self, event: Event):
+        """Clean up STT resources when session ends"""
+        session_id = event.session_id
+        await self._cleanup_session(session_id)
+    
     async def _handle_stt_stop(self, event: Event):
         """Handle STT stop request and perform transcription"""
         session_id = event.session_id
@@ -232,4 +237,108 @@ class STTLifecycleManager:
                 f"❌ Error stopping STT",
                 session_id=session_id,
                 error=str(e)
-            )
+            )
+
+    async def _cleanup_session(self, session_id: str):
+        """Clean up STT session"""
+        stt_session = self.stt_sessions.pop(session_id, None)
+        if not stt_session:
+            return
+    
+        try:
+            # Mark as inactive
+            stt_session.is_active = False
+    
+            # Release resource
+            resource_id = f"stt_{session_id}"
+            await self.resource_manager.release(resource_id, delay_seconds=60)
+    
+            log_info(
+                f"🧹 STT session cleaned up",
+                session_id=session_id,
+                total_chunks=stt_session.total_chunks,
+                total_bytes=stt_session.total_bytes
+            )
+    
+        except Exception as e:
+            log_error(
+                f"❌ Error cleaning up STT session",
+                session_id=session_id,
+                error=str(e)
+            )
+    
+    async def _cleanup_stt_instance(self, stt_instance: STTInterface):
+        """Cleanup callback for STT instance"""
+        try:
+            log_debug("🧹 STT instance cleaned up")
+        except Exception as e:
+            log_error(f"❌ Error cleaning up STT instance", error=str(e))
+    
+    def _setup_resource_pool(self):
+        """Setup STT instance pool"""
+        self.resource_manager.register_pool(
+            resource_type=ResourceType.STT_INSTANCE,
+            factory=self._create_stt_instance,
+            max_idle=5,
+            max_age_seconds=300  # 5 minutes
+        )
+    
+    async def _create_stt_instance(self) -> STTInterface:
+        """Factory for creating STT instances"""
+        try:
+            stt_instance = STTFactory.create_provider()
+            if not stt_instance:
+                raise ValueError("Failed to create STT instance")
+    
+            log_debug("🎤 Created new STT instance")
+            return stt_instance
+    
+        except Exception as e:
+            log_error(f"❌ Failed to create STT instance", error=str(e))
+            raise
+    
+    def _get_language_code(self, locale: str) -> str:
+        """Convert locale to STT language code"""
+        # Map common locales to STT language codes
+        locale_map = {
+            "tr": "tr-TR",
+            "en": "en-US",
+            "de": "de-DE",
+            "fr": "fr-FR",
+            "es": "es-ES",
+            "it": "it-IT",
+            "pt": "pt-BR",
+            "ru": "ru-RU",
+            "ja": "ja-JP",
+            "ko": "ko-KR",
+            "zh": "zh-CN",
+            "ar": "ar-SA"
+        }
+    
+        # Check direct match
+        if locale in locale_map:
+            return locale_map[locale]
+    
+        # Check if it's already a full code
+        if "-" in locale and len(locale) == 5:
+            return locale
+    
+        # Default to locale-LOCALE format
+        return f"{locale}-{locale.upper()}"
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get STT manager statistics"""
+        session_stats = {}
+        for session_id, stt_session in self.stt_sessions.items():
+            session_stats[session_id] = {
+                "is_active": stt_session.is_active,
+                "total_chunks": stt_session.total_chunks,
+                "total_bytes": stt_session.total_bytes,
+                "vad_stats": stt_session.vad.get_stats() if stt_session.vad else {}
+            }
+    
+        return {
+            "active_sessions": len(self.stt_sessions),
+            "active_streaming": sum(1 for s in self.stt_sessions.values() if s.is_active),
+            "sessions": session_stats
+        }