Update QA_result/check.txt.txt

QA_result/check.txt.txt

@@ -1,620 +1,683 @@
-"""
-Emotion Detection Service Module
-
-Provides async emotion detection from audio with:
-- Concurrent request handling via semaphores
-- Audio chunking for multi-emotion detection
-- Temporary file management
-- Thread-safe model inference
-"""
-
-import asyncio
-import os
-import uuid
-import threading
-import numpy as np
-import soundfile as sf
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Any
-from datetime import datetime
-from collections import defaultdict
-
-from .config import EmotionConfig, get_emotion_config
-from .history import EmotionHistory, EmotionTurn, build_emotion_prompt_context
-
-
-def _ensure_mono_1d(audio: np.ndarray) -> np.ndarray:
-    """
-    Ensure audio is a 1D mono array.
-
-    Handles various audio formats:
-    - Already 1D: return as-is
-    - (samples, channels): transpose and average channels
-    - (channels, samples): average channels
-    - (1, samples) or (samples, 1): squeeze to 1D
-
-    Args:
-        audio: Audio data as numpy array (1D or 2D)
-
-    Returns:
-        1D mono audio array
-    """
-    if audio.ndim == 1:
-        return audio
-
-    if audio.ndim != 2:
-        # For higher dimensional arrays, try to flatten
-        print(f"[EMOTION] Warning: unexpected audio shape {audio.shape}, attempting to flatten")
-        return audio.flatten()
-
-    # 2D array - determine format and convert to mono
-    rows, cols = audio.shape
-
-    # Check if one dimension is small (likely channels: 1 or 2)
-    if rows <= 2 and cols > 2:
-        # Shape is (channels, samples) - average across axis 0
-        if rows == 1:
-            return audio.squeeze(axis=0)
-        else:
-            return np.mean(audio, axis=0)
-
-    elif cols <= 2 and rows > 2:
-        # Shape is (samples, channels) - average across axis 1
-        if cols == 1:
-            return audio.squeeze(axis=1)
-        else:
-            return np.mean(audio, axis=1)
-
-    else:
-        # Both dimensions are large or both are small
-        # Heuristic: if rows > cols, assume (samples, channels)
-        if rows > cols:
-            if cols == 1:
-                return audio.squeeze(axis=1)
-            return np.mean(audio, axis=1)
-        else:
-            if rows == 1:
-                return audio.squeeze(axis=0)
-            return np.mean(audio, axis=0)
-
-
-class EmotionDetectionService:
-    """
-    Async-safe emotion detection service.
-
-    Handles:
-    - Audio preprocessing and chunking
-    - Concurrent request management via semaphores
-    - Temporary file lifecycle
-    - Model inference with thread safety
-    """
-
-    def __init__(self, config: Optional[EmotionConfig] = None):
-        """
-        Initialize the emotion detection service.
-
-        Args:
-            config: Optional EmotionConfig. If not provided, loads from .env
-        """
-        self.config = config or get_emotion_config()
-        self._model = None
-        self._model_lock = threading.Lock()
-        self._semaphore: Optional[asyncio.Semaphore] = None
-        self._history = EmotionHistory()
-        self._initialized = False
-
-        # Track active requests for debugging
-        self._active_requests: Dict[str, datetime] = {}
-        self._request_lock = threading.Lock()
-
-        if self.config.enabled:
-            self._initialize()
-
-    def _initialize(self):
-        """Initialize the service (load model, create directories)."""
-        if self._initialized:
-            return
-
-        try:
-            # Create temp directory
-            Path(self.config.temp_audio_dir).mkdir(parents=True, exist_ok=True)
-            print(f"[EMOTION] Temp audio directory: {self.config.temp_audio_dir}")
-
-            # Create semaphore for concurrent task limiting
-            self._semaphore = asyncio.Semaphore(self.config.max_concurrent_tasks)
-            print(f"[EMOTION] Max concurrent tasks: {self.config.max_concurrent_tasks}")
-
-            # Lazy load model on first use
-            self._initialized = True
-            print(f"[EMOTION] Service initialized successfully")
-
-        except Exception as e:
-            print(f"[EMOTION] Failed to initialize service: {e}")
-            self.config.enabled = False
-
-    def _ensure_model(self):
-        """Ensure model is loaded (lazy loading with thread safety)."""
-        if self._model is not None:
-            return
-
-        with self._model_lock:
-            if self._model is not None:
-                return
-
-            try:
-                import onnxruntime as ort
-
-                # Check available providers
-                available = ort.get_available_providers()
-                providers = []
-                if "CUDAExecutionProvider" in available:
-                    providers.append("CUDAExecutionProvider")
-                    print(f"[EMOTION] CUDA available, using GPU acceleration")
-                providers.append("CPUExecutionProvider")
-
-                # Load model
-                self._model = ort.InferenceSession(
-                    self.config.model_path,
-                    providers=providers
-                )
-
-                # Log model info
-                actual_provider = self._model.get_providers()[0]
-                print(f"[EMOTION] Model loaded from: {self.config.model_path}")
-                print(f"[EMOTION] Running on: {actual_provider}")
-
-            except Exception as e:
-                print(f"[EMOTION] Failed to load model: {e}")
-                self.config.enabled = False
-                raise
-
-    def _generate_request_id(self) -> str:
-        """Generate unique request ID for tracking."""
-        return f"emo_{uuid.uuid4().hex[:12]}_{int(datetime.now().timestamp() * 1000)}"
-
-    def _get_temp_audio_path(self, request_id: str, chunk_idx: int = 0) -> str:
-        """
-        Generate temporary audio file path.
-
-        Args:
-            request_id: Unique request identifier
-            chunk_idx: Index of audio chunk (for multi-emotion)
-
-        Returns:
-            Full path to temporary audio file
-        """
-        filename = f"{request_id}_chunk{chunk_idx}{self.config.audio_extension}"
-        return os.path.join(self.config.temp_audio_dir, filename)
-
-    def _split_audio_into_chunks(
-        self,
-        audio: np.ndarray,
-        sample_rate: int,
-        chunk_duration: int
-    ) -> List[np.ndarray]:
-        """
-        Split audio into fixed-duration chunks.
-
-        Args:
-            audio: Audio data as numpy array (1D or 2D)
-            sample_rate: Sample rate of audio
-            chunk_duration: Duration of each chunk in seconds
-
-        Returns:
-            List of audio chunks as numpy arrays (1D mono)
-        """
-        # Ensure audio is 1D mono before processing
-        audio = _ensure_mono_1d(audio)
-
-        chunk_samples = chunk_duration * sample_rate
-        total_samples = len(audio)
-
-        if total_samples <= chunk_samples:
-            # Single chunk, pad if needed
-            if total_samples < chunk_samples:
-                audio = np.pad(audio, (0, chunk_samples - total_samples), mode='constant')
-            return [audio]
-
-        # Split into multiple chunks
-        chunks = []
-        for start in range(0, total_samples, chunk_samples):
-            end = start + chunk_samples
-            chunk = audio[start:end]
-
-            # Pad last chunk if needed
-            if len(chunk) < chunk_samples:
-                chunk = np.pad(chunk, (0, chunk_samples - len(chunk)), mode='constant')
-
-            chunks.append(chunk)
-
-        return chunks
-
-    async def _save_audio_chunk(
-        self,
-        audio: np.ndarray,
-        sample_rate: int,
-        path: str
-    ) -> bool:
-        """
-        Save audio chunk to file asynchronously.
-
-        Args:
-            audio: Audio data
-            sample_rate: Sample rate
-            path: Output file path
-
-        Returns:
-            True if successful
-        """
-        try:
-            # Run file I/O in thread pool
-            await asyncio.get_event_loop().run_in_executor(
-                None,
-                lambda: sf.write(path, audio.astype(np.float32), sample_rate)
-            )
-            return True
-        except Exception as e:
-            print(f"[EMOTION] Failed to save audio chunk: {e}")
-            return False
-
-    def _cleanup_temp_file(self, path: str):
-        """Remove temporary audio file."""
-        if self.config.cleanup_temp_files:
-            try:
-                if os.path.exists(path):
-                    os.remove(path)
-            except Exception as e:
-                print(f"[EMOTION] Failed to cleanup temp file {path}: {e}")
-
-    def _run_inference(self, audio_path: str) -> Dict[str, float]:
-        """
-        Run emotion inference on audio file.
-
-        Args:
-            audio_path: Path to audio file
-
-        Returns:
-            Dict mapping emotion class to confidence score
-        """
-        self._ensure_model()
-
-        try:
-            import librosa
-            from audio_emotion_detection.preprocessing import MelSTFT
-
-            # Get model input/output info
-            input_name = self._model.get_inputs()[0].name
-            output_name = self._model.get_outputs()[0].name
-
-            # Preprocess audio
-            mel = MelSTFT(n_mels=128, sr=32000, win_length=800, hopsize=320)
-            waveform, _ = librosa.core.load(audio_path, sr=32000, mono=True)
-            waveform = np.stack([waveform])
-            spec = mel(waveform)
-
-            # Ensure correct temporal dimension (400 frames for ~4s audio)
-            if spec.shape[-1] > 400:
-                spec = spec[:, :, :400]
-            else:
-                spec = np.pad(spec, ((0, 0), (0, 0), (0, 400 - spec.shape[-1])), mode='constant')
-
-            spec = np.expand_dims(spec, axis=0).astype(np.float32)
-
-            # Run inference
-            output = self._model.run([output_name], {input_name: spec})
-
-            # Softmax
-            logits = output[0][0]
-            exp_logits = np.exp(logits - np.max(logits))
-            probs = exp_logits / np.sum(exp_logits)
-
-            # Map to emotion classes
-            results = {}
-            for i, class_name in enumerate(self.config.class_labels):
-                results[class_name] = float(probs[i])
-
-            return results
-
-        except Exception as e:
-            print(f"[EMOTION] Inference failed: {e}")
-            import traceback
-            traceback.print_exc()
-            return {}
-
-    async def detect_emotion(
-        self,
-        audio: np.ndarray,
-        sample_rate: int,
-        request_id: Optional[str] = None
-    ) -> Dict[str, float]:
-        """
-        Detect emotion from single audio segment.
-
-        Args:
-            audio: Audio data as numpy array (1D or 2D)
-            sample_rate: Sample rate of audio
-            request_id: Optional request ID for tracking
-
-        Returns:
-            Dict mapping emotion class to confidence score
-        """
-        if not self.config.enabled:
-            return {}
-
-        request_id = request_id or self._generate_request_id()
-
-        # Ensure audio is 1D mono before processing
-        audio = _ensure_mono_1d(audio)
-
-        # Track request
-        with self._request_lock:
-            self._active_requests[request_id] = datetime.now()
-
-        try:
-            # Acquire semaphore for concurrency control
-            async with self._semaphore:
-                # Resample if needed
-                if sample_rate != self.config.sample_rate:
-                    try:
-                        import librosa
-                        audio = librosa.resample(
-                            audio.astype(np.float32),
-                            orig_sr=sample_rate,
-                            target_sr=self.config.sample_rate
-                        )
-                        sample_rate = self.config.sample_rate
-                    except Exception as e:
-                        print(f"[EMOTION] Resampling failed: {e}")
-
-                # Ensure correct duration
-                target_samples = self.config.audio_duration * sample_rate
-                if len(audio) > target_samples:
-                    audio = audio[:target_samples]
-                elif len(audio) < target_samples:
-                    audio = np.pad(audio, (0, target_samples - len(audio)), mode='constant')
-
-                # Save to temp file
-                temp_path = self._get_temp_audio_path(request_id)
-                if not await self._save_audio_chunk(audio, sample_rate, temp_path):
-                    return {}
-
-                try:
-                    # Run inference in thread pool
-                    result = await asyncio.wait_for(
-                        asyncio.get_event_loop().run_in_executor(
-                            None,
-                            self._run_inference,
-                            temp_path
-                        ),
-                        timeout=self.config.detection_timeout
-                    )
-                    return result
-                finally:
-                    # Cleanup temp file
-                    self._cleanup_temp_file(temp_path)
-
-        except asyncio.TimeoutError:
-            print(f"[EMOTION] Detection timeout for request {request_id}")
-            return {}
-        except Exception as e:
-            print(f"[EMOTION] Detection failed for request {request_id}: {e}")
-            return {}
-        finally:
-            # Remove from active requests
-            with self._request_lock:
-                self._active_requests.pop(request_id, None)
-
-    async def detect_emotions_multi(
-        self,
-        audio: np.ndarray,
-        sample_rate: int,
-        request_id: Optional[str] = None
-    ) -> List[Dict[str, float]]:
-        """
-        Detect emotions from audio with multiple chunks.
-
-        If multi_emotion_per_conversation is enabled, splits audio into
-        chunks and detects emotion for each. Otherwise, uses first chunk only.
-
-        Args:
-            audio: Audio data as numpy array (1D or 2D)
-            sample_rate: Sample rate of audio
-            request_id: Optional request ID for tracking
-
-        Returns:
-            List of dicts, each mapping emotion class to confidence score
-        """
-        if not self.config.enabled:
-            return []
-
-        request_id = request_id or self._generate_request_id()
-
-        # Ensure audio is 1D mono before processing
-        audio = _ensure_mono_1d(audio)
-
-        # Resample if needed
-        if sample_rate != self.config.sample_rate:
-            try:
-                import librosa
-                audio = librosa.resample(
-                    audio.astype(np.float32),
-                    orig_sr=sample_rate,
-                    target_sr=self.config.sample_rate
-                )
-                sample_rate = self.config.sample_rate
-            except Exception as e:
-                print(f"[EMOTION] Resampling failed: {e}")
-                return []
-
-        if not self.config.multi_emotion_per_conversation:
-            # Single chunk mode
-            result = await self.detect_emotion(audio, sample_rate, request_id)
-            return [result] if result else []
-
-        # Multi-chunk mode
-        chunks = self._split_audio_into_chunks(
-            audio, sample_rate, self.config.audio_duration
-        )
-
-        print(f"[EMOTION] Processing {len(chunks)} audio chunks for request {request_id}")
-
-        # Process chunks concurrently
-        tasks = []
-        for i, chunk in enumerate(chunks):
-            chunk_request_id = f"{request_id}_c{i}"
-            tasks.append(self.detect_emotion(chunk, sample_rate, chunk_request_id))
-
-        results = await asyncio.gather(*tasks, return_exceptions=True)
-
-        # Filter out failures
-        valid_results = []
-        for result in results:
-            if isinstance(result, dict) and result:
-                valid_results.append(result)
-            elif isinstance(result, Exception):
-                print(f"[EMOTION] Chunk detection failed: {result}")
-
-        return valid_results
-
-    def aggregate_emotions(
-        self,
-        emotion_results: List[Dict[str, float]]
-    ) -> Dict[str, float]:
-        """
-        Aggregate emotions from multiple chunks into single result.
-
-        Uses average confidence across all chunks.
-
-        Args:
-            emotion_results: List of emotion dicts from each chunk
-
-        Returns:
-            Aggregated emotion dict with average confidences
-        """
-        if not emotion_results:
-            return {}
-
-        if len(emotion_results) == 1:
-            return emotion_results[0]
-
-        # Average across all results
-        aggregated = defaultdict(float)
-        for result in emotion_results:
-            for emotion, confidence in result.items():
-                aggregated[emotion] += confidence
-
-        n = len(emotion_results)
-        return {k: v / n for k, v in aggregated.items()}
-
-    async def process_conversation_turn(
-        self,
-        user_id: str,
-        text: str,
-        audio: np.ndarray,
-        sample_rate: int
-    ) -> Tuple[EmotionTurn, bool, str]:
-        """
-        Process a full conversation turn with emotion tracking.
-
-        This is the main entry point for integrating emotion detection
-        into the conversation pipeline.
-
-        Args:
-            user_id: User identifier for tracking
-            text: Transcribed text from STT
-            audio: Audio data (1D or 2D)
-            sample_rate: Sample rate
-
-        Returns:
-            Tuple of:
-            - EmotionTurn object
-            - bool: Whether empathy should be triggered
-            - str: Emotion prompt context (empty if no empathy needed)
-        """
-        if not self.config.enabled or not text.strip():
-            return None, False, ""
-
-        request_id = self._generate_request_id()
-
-        # Log audio shape for debugging
-        print(f"[EMOTION] Processing turn for user {user_id}, request {request_id}, audio shape: {audio.shape}")
-
-        # Detect emotions (multi-chunk if enabled)
-        emotion_results = await self.detect_emotions_multi(audio, sample_rate, request_id)
-
-        if not emotion_results:
-            print(f"[EMOTION] No emotions detected for request {request_id}")
-            return None, False, ""
-
-        # Aggregate results
-        aggregated = self.aggregate_emotions(emotion_results)
-
-        print(f"[EMOTION] Detected emotions: {aggregated}")
-
-        # Record in history
-        turn = self._history.add_turn(
-            user_id=user_id,
-            text=text,
-            emotions=aggregated,
-            negative_classes=self.config.negative_classes,
-            min_confidence_scores=self.config.min_confidence_scores
-        )
-
-        print(f"[EMOTION] Turn recorded - negative majority: {turn.is_negative_majority}")
-
-        # Check if empathy should be triggered
-        should_empathize, negative_turns = self._history.should_trigger_empathy(
-            user_id=user_id,
-            consecutive_threshold=self.config.consecutive_count
-        )
-
-        emotion_prompt = ""
-        if should_empathize:
-            print(f"[EMOTION] Triggering empathetic response for user {user_id}")
-            emotion_prompt = build_emotion_prompt_context(negative_turns)
-
-        return turn, should_empathize, emotion_prompt
-
-    def get_user_emotion_summary(self, user_id: str) -> Dict:
-        """Get emotion summary for a user."""
-        return self._history.get_emotion_summary(user_id)
-
-    def reset_user_emotions(self, user_id: str):
-        """Reset emotion history for a user."""
-        self._history.reset_user_history(user_id)
-
-    def get_active_request_count(self) -> int:
-        """Get count of currently active emotion detection requests."""
-        with self._request_lock:
-            return len(self._active_requests)
-
-
-# Global service instance (lazy loaded)
-_GLOBAL_SERVICE: Optional[EmotionDetectionService] = None
-_SERVICE_LOCK = threading.Lock()
-
-
-def get_emotion_service() -> EmotionDetectionService:
-    """Get the global emotion detection service instance."""
-    global _GLOBAL_SERVICE
-    if _GLOBAL_SERVICE is None:
-        with _SERVICE_LOCK:
-            if _GLOBAL_SERVICE is None:
-                _GLOBAL_SERVICE = EmotionDetectionService()
-    return _GLOBAL_SERVICE
-
-
-def initialize_emotion_service(config: Optional[EmotionConfig] = None) -> EmotionDetectionService:
-    """
-    Initialize or reinitialize the global emotion service.
-
-    Args:
-        config: Optional config. If not provided, loads from .env
-
-    Returns:
-        The initialized service instance
-    """
-    global _GLOBAL_SERVICE
-    with _SERVICE_LOCK:
-        _GLOBAL_SERVICE = EmotionDetectionService(config)
+"""
+Emotion Detection Service Module
+
+Provides async emotion detection from audio with:
+- Concurrent request handling via semaphores
+- Audio chunking for multi-emotion detection
+- Temporary file management
+- Thread-safe model inference
+"""
+
+import asyncio
+import os
+import uuid
+import threading
+import numpy as np
+import soundfile as sf
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Any
+from datetime import datetime
+from collections import defaultdict
+
+from .config import EmotionConfig, get_emotion_config
+from .history import EmotionHistory, EmotionTurn, build_emotion_prompt_context
+
+
+def _normalize_audio_to_float32(audio: np.ndarray) -> np.ndarray:
+    """
+    Normalize audio to float32 in range [-1, 1].
+
+    This is critical for soundfile.write which expects float32 audio
+    to be in the [-1, 1] range. Without normalization, audio gets
+    clipped and distorted.
+
+    Args:
+        audio: Audio data as numpy array (int16, int32, float32, float64)
+
+    Returns:
+        float32 audio normalized to [-1, 1] range
+    """
+    if audio.dtype == np.int16:
+        # int16 range: -32768 to 32767
+        return audio.astype(np.float32) / 32768.0
+    elif audio.dtype == np.int32:
+        # int32 range: -2147483648 to 2147483647
+        return audio.astype(np.float32) / 2147483648.0
+    elif audio.dtype in (np.float32, np.float64):
+        audio = audio.astype(np.float32)
+        # Check if already normalized (values in [-1, 1])
+        max_val = np.max(np.abs(audio))
+        if max_val > 1.0:
+            # Likely int16 values stored as float, normalize
+            if max_val > 32767:
+                # Likely int32 range
+                return audio / 2147483648.0
+            else:
+                # Likely int16 range
+                return audio / 32768.0
+        return audio
+    else:
+        # For other types, convert to float32 and check range
+        audio = audio.astype(np.float32)
+        max_val = np.max(np.abs(audio))
+        if max_val > 1.0:
+            # Normalize by max value to prevent clipping
+            return audio / max_val
+        return audio
+
+
+def _ensure_mono_1d(audio: np.ndarray) -> np.ndarray:
+    """
+    Ensure audio is a 1D mono array, normalized to float32 [-1, 1].
+
+    Handles various audio formats:
+    - Already 1D: normalize and return
+    - (samples, channels): average channels and normalize
+    - (channels, samples): average channels and normalize
+    - (1, samples) or (samples, 1): squeeze to 1D and normalize
+
+    Args:
+        audio: Audio data as numpy array (1D or 2D, any dtype)
+
+    Returns:
+        1D mono audio array as float32 in [-1, 1] range
+    """
+    # First normalize to float32 to avoid issues with integer overflow in np.mean
+    audio = _normalize_audio_to_float32(audio)
+
+    if audio.ndim == 1:
+        return audio
+
+    if audio.ndim != 2:
+        # For higher dimensional arrays, try to flatten
+        print(f"[EMOTION] Warning: unexpected audio shape {audio.shape}, attempting to flatten")
+        return audio.flatten()
+
+    # 2D array - determine format and convert to mono
+    rows, cols = audio.shape
+
+    # Check if one dimension is small (likely channels: 1 or 2)
+    if rows <= 2 and cols > 2:
+        # Shape is (channels, samples) - average across axis 0
+        if rows == 1:
+            return audio.squeeze(axis=0)
+        else:
+            return np.mean(audio, axis=0).astype(np.float32)
+
+    elif cols <= 2 and rows > 2:
+        # Shape is (samples, channels) - average across axis 1
+        if cols == 1:
+            return audio.squeeze(axis=1)
+        else:
+            return np.mean(audio, axis=1).astype(np.float32)
+
+    else:
+        # Both dimensions are large or both are small
+        # Heuristic: if rows > cols, assume (samples, channels)
+        if rows > cols:
+            if cols == 1:
+                return audio.squeeze(axis=1)
+            return np.mean(audio, axis=1).astype(np.float32)
+        else:
+            if rows == 1:
+                return audio.squeeze(axis=0)
+            return np.mean(audio, axis=0).astype(np.float32)
+
+
+class EmotionDetectionService:
+    """
+    Async-safe emotion detection service.
+
+    Handles:
+    - Audio preprocessing and chunking
+    - Concurrent request management via semaphores
+    - Temporary file lifecycle
+    - Model inference with thread safety
+    """
+
+    def __init__(self, config: Optional[EmotionConfig] = None):
+        """
+        Initialize the emotion detection service.
+
+        Args:
+            config: Optional EmotionConfig. If not provided, loads from .env
+        """
+        self.config = config or get_emotion_config()
+        self._model = None
+        self._model_lock = threading.Lock()
+        self._semaphore: Optional[asyncio.Semaphore] = None
+        self._history = EmotionHistory()
+        self._initialized = False
+
+        # Track active requests for debugging
+        self._active_requests: Dict[str, datetime] = {}
+        self._request_lock = threading.Lock()
+
+        if self.config.enabled:
+            self._initialize()
+
+    def _initialize(self):
+        """Initialize the service (load model, create directories)."""
+        if self._initialized:
+            return
+
+        try:
+            # Create temp directory
+            Path(self.config.temp_audio_dir).mkdir(parents=True, exist_ok=True)
+            print(f"[EMOTION] Temp audio directory: {self.config.temp_audio_dir}")
+
+            # Create semaphore for concurrent task limiting
+            self._semaphore = asyncio.Semaphore(self.config.max_concurrent_tasks)
+            print(f"[EMOTION] Max concurrent tasks: {self.config.max_concurrent_tasks}")
+
+            # Lazy load model on first use
+            self._initialized = True
+            print(f"[EMOTION] Service initialized successfully")
+
+        except Exception as e:
+            print(f"[EMOTION] Failed to initialize service: {e}")
+            self.config.enabled = False
+
+    def _ensure_model(self):
+        """Ensure model is loaded (lazy loading with thread safety)."""
+        if self._model is not None:
+            return
+
+        with self._model_lock:
+            if self._model is not None:
+                return
+
+            try:
+                import onnxruntime as ort
+
+                # Check available providers
+                available = ort.get_available_providers()
+                providers = []
+                if "CUDAExecutionProvider" in available:
+                    providers.append("CUDAExecutionProvider")
+                    print(f"[EMOTION] CUDA available, using GPU acceleration")
+                providers.append("CPUExecutionProvider")
+
+                # Load model
+                self._model = ort.InferenceSession(
+                    self.config.model_path,
+                    providers=providers
+                )
+
+                # Log model info
+                actual_provider = self._model.get_providers()[0]
+                print(f"[EMOTION] Model loaded from: {self.config.model_path}")
+                print(f"[EMOTION] Running on: {actual_provider}")
+
+            except Exception as e:
+                print(f"[EMOTION] Failed to load model: {e}")
+                self.config.enabled = False
+                raise
+
+    def _generate_request_id(self) -> str:
+        """Generate unique request ID for tracking."""
+        return f"emo_{uuid.uuid4().hex[:12]}_{int(datetime.now().timestamp() * 1000)}"
+
+    def _get_temp_audio_path(self, request_id: str, chunk_idx: int = 0) -> str:
+        """
+        Generate temporary audio file path.
+
+        Args:
+            request_id: Unique request identifier
+            chunk_idx: Index of audio chunk (for multi-emotion)
+
+        Returns:
+            Full path to temporary audio file
+        """
+        filename = f"{request_id}_chunk{chunk_idx}{self.config.audio_extension}"
+        return os.path.join(self.config.temp_audio_dir, filename)
+
+    def _split_audio_into_chunks(
+        self,
+        audio: np.ndarray,
+        sample_rate: int,
+        chunk_duration: int
+    ) -> List[np.ndarray]:
+        """
+        Split audio into fixed-duration chunks.
+
+        Args:
+            audio: Audio data as numpy array (1D or 2D)
+            sample_rate: Sample rate of audio
+            chunk_duration: Duration of each chunk in seconds
+
+        Returns:
+            List of audio chunks as numpy arrays (1D mono)
+        """
+        # Ensure audio is 1D mono before processing
+        audio = _ensure_mono_1d(audio)
+
+        chunk_samples = chunk_duration * sample_rate
+        total_samples = len(audio)
+
+        if total_samples <= chunk_samples:
+            # Single chunk, pad if needed
+            if total_samples < chunk_samples:
+                audio = np.pad(audio, (0, chunk_samples - total_samples), mode='constant')
+            return [audio]
+
+        # Split into multiple chunks
+        chunks = []
+        for start in range(0, total_samples, chunk_samples):
+            end = start + chunk_samples
+            chunk = audio[start:end]
+
+            # Pad last chunk if needed
+            if len(chunk) < chunk_samples:
+                chunk = np.pad(chunk, (0, chunk_samples - len(chunk)), mode='constant')
+
+            chunks.append(chunk)
+
+        return chunks
+
+    async def _save_audio_chunk(
+        self,
+        audio: np.ndarray,
+        sample_rate: int,
+        path: str
+    ) -> bool:
+        """
+        Save audio chunk to file asynchronously.
+
+        Audio should already be normalized to float32 [-1, 1] by _ensure_mono_1d.
+        This method adds a safety check and clips to prevent distortion.
+
+        Args:
+            audio: Audio data (should be float32 in [-1, 1])
+            sample_rate: Sample rate
+            path: Output file path
+
+        Returns:
+            True if successful
+        """
+        try:
+            # Ensure audio is float32 and normalized
+            audio_to_save = _normalize_audio_to_float32(audio)
+
+            # Safety clip to prevent any distortion from edge cases
+            audio_to_save = np.clip(audio_to_save, -1.0, 1.0)
+
+            # Log audio stats for debugging
+            max_val = np.max(np.abs(audio_to_save))
+            print(f"[EMOTION] Saving audio: shape={audio_to_save.shape}, dtype={audio_to_save.dtype}, max_abs={max_val:.4f}")
+
+            # Run file I/O in thread pool
+            await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: sf.write(path, audio_to_save, sample_rate)
+            )
+            return True
+        except Exception as e:
+            print(f"[EMOTION] Failed to save audio chunk: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+
+    def _cleanup_temp_file(self, path: str):
+        """Remove temporary audio file."""
+        if self.config.cleanup_temp_files:
+            try:
+                if os.path.exists(path):
+                    os.remove(path)
+            except Exception as e:
+                print(f"[EMOTION] Failed to cleanup temp file {path}: {e}")
+
+    def _run_inference(self, audio_path: str) -> Dict[str, float]:
+        """
+        Run emotion inference on audio file.
+
+        Args:
+            audio_path: Path to audio file
+
+        Returns:
+            Dict mapping emotion class to confidence score
+        """
+        self._ensure_model()
+
+        try:
+            import librosa
+            from audio_emotion_detection.preprocessing import MelSTFT
+
+            # Get model input/output info
+            input_name = self._model.get_inputs()[0].name
+            output_name = self._model.get_outputs()[0].name
+
+            # Preprocess audio
+            mel = MelSTFT(n_mels=128, sr=32000, win_length=800, hopsize=320)
+            waveform, _ = librosa.core.load(audio_path, sr=32000, mono=True)
+            waveform = np.stack([waveform])
+            spec = mel(waveform)
+
+            # Ensure correct temporal dimension (400 frames for ~4s audio)
+            if spec.shape[-1] > 400:
+                spec = spec[:, :, :400]
+            else:
+                spec = np.pad(spec, ((0, 0), (0, 0), (0, 400 - spec.shape[-1])), mode='constant')
+
+            spec = np.expand_dims(spec, axis=0).astype(np.float32)
+
+            # Run inference
+            output = self._model.run([output_name], {input_name: spec})
+
+            # Softmax
+            logits = output[0][0]
+            exp_logits = np.exp(logits - np.max(logits))
+            probs = exp_logits / np.sum(exp_logits)
+
+            # Map to emotion classes
+            results = {}
+            for i, class_name in enumerate(self.config.class_labels):
+                results[class_name] = float(probs[i])
+
+            return results
+
+        except Exception as e:
+            print(f"[EMOTION] Inference failed: {e}")
+            import traceback
+            traceback.print_exc()
+            return {}
+
+    async def detect_emotion(
+        self,
+        audio: np.ndarray,
+        sample_rate: int,
+        request_id: Optional[str] = None
+    ) -> Dict[str, float]:
+        """
+        Detect emotion from single audio segment.
+
+        Args:
+            audio: Audio data as numpy array (1D or 2D)
+            sample_rate: Sample rate of audio
+            request_id: Optional request ID for tracking
+
+        Returns:
+            Dict mapping emotion class to confidence score
+        """
+        if not self.config.enabled:
+            return {}
+
+        request_id = request_id or self._generate_request_id()
+
+        # Ensure audio is 1D mono before processing
+        audio = _ensure_mono_1d(audio)
+
+        # Track request
+        with self._request_lock:
+            self._active_requests[request_id] = datetime.now()
+
+        try:
+            # Acquire semaphore for concurrency control
+            async with self._semaphore:
+                # Resample if needed
+                if sample_rate != self.config.sample_rate:
+                    try:
+                        import librosa
+                        audio = librosa.resample(
+                            audio.astype(np.float32),
+                            orig_sr=sample_rate,
+                            target_sr=self.config.sample_rate
+                        )
+                        sample_rate = self.config.sample_rate
+                    except Exception as e:
+                        print(f"[EMOTION] Resampling failed: {e}")
+
+                # Ensure correct duration
+                target_samples = self.config.audio_duration * sample_rate
+                if len(audio) > target_samples:
+                    audio = audio[:target_samples]
+                elif len(audio) < target_samples:
+                    audio = np.pad(audio, (0, target_samples - len(audio)), mode='constant')
+
+                # Save to temp file
+                temp_path = self._get_temp_audio_path(request_id)
+                if not await self._save_audio_chunk(audio, sample_rate, temp_path):
+                    return {}
+
+                try:
+                    # Run inference in thread pool
+                    result = await asyncio.wait_for(
+                        asyncio.get_event_loop().run_in_executor(
+                            None,
+                            self._run_inference,
+                            temp_path
+                        ),
+                        timeout=self.config.detection_timeout
+                    )
+                    return result
+                finally:
+                    # Cleanup temp file
+                    self._cleanup_temp_file(temp_path)
+
+        except asyncio.TimeoutError:
+            print(f"[EMOTION] Detection timeout for request {request_id}")
+            return {}
+        except Exception as e:
+            print(f"[EMOTION] Detection failed for request {request_id}: {e}")
+            return {}
+        finally:
+            # Remove from active requests
+            with self._request_lock:
+                self._active_requests.pop(request_id, None)
+
+    async def detect_emotions_multi(
+        self,
+        audio: np.ndarray,
+        sample_rate: int,
+        request_id: Optional[str] = None
+    ) -> List[Dict[str, float]]:
+        """
+        Detect emotions from audio with multiple chunks.
+
+        If multi_emotion_per_conversation is enabled, splits audio into
+        chunks and detects emotion for each. Otherwise, uses first chunk only.
+
+        Args:
+            audio: Audio data as numpy array (1D or 2D)
+            sample_rate: Sample rate of audio
+            request_id: Optional request ID for tracking
+
+        Returns:
+            List of dicts, each mapping emotion class to confidence score
+        """
+        if not self.config.enabled:
+            return []
+
+        request_id = request_id or self._generate_request_id()
+
+        # Ensure audio is 1D mono before processing
+        audio = _ensure_mono_1d(audio)
+
+        # Resample if needed
+        if sample_rate != self.config.sample_rate:
+            try:
+                import librosa
+                audio = librosa.resample(
+                    audio.astype(np.float32),
+                    orig_sr=sample_rate,
+                    target_sr=self.config.sample_rate
+                )
+                sample_rate = self.config.sample_rate
+            except Exception as e:
+                print(f"[EMOTION] Resampling failed: {e}")
+                return []
+
+        if not self.config.multi_emotion_per_conversation:
+            # Single chunk mode
+            result = await self.detect_emotion(audio, sample_rate, request_id)
+            return [result] if result else []
+
+        # Multi-chunk mode
+        chunks = self._split_audio_into_chunks(
+            audio, sample_rate, self.config.audio_duration
+        )
+
+        print(f"[EMOTION] Processing {len(chunks)} audio chunks for request {request_id}")
+
+        # Process chunks concurrently
+        tasks = []
+        for i, chunk in enumerate(chunks):
+            chunk_request_id = f"{request_id}_c{i}"
+            tasks.append(self.detect_emotion(chunk, sample_rate, chunk_request_id))
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # Filter out failures
+        valid_results = []
+        for result in results:
+            if isinstance(result, dict) and result:
+                valid_results.append(result)
+            elif isinstance(result, Exception):
+                print(f"[EMOTION] Chunk detection failed: {result}")
+
+        return valid_results
+
+    def aggregate_emotions(
+        self,
+        emotion_results: List[Dict[str, float]]
+    ) -> Dict[str, float]:
+        """
+        Aggregate emotions from multiple chunks into single result.
+
+        Uses average confidence across all chunks.
+
+        Args:
+            emotion_results: List of emotion dicts from each chunk
+
+        Returns:
+            Aggregated emotion dict with average confidences
+        """
+        if not emotion_results:
+            return {}
+
+        if len(emotion_results) == 1:
+            return emotion_results[0]
+
+        # Average across all results
+        aggregated = defaultdict(float)
+        for result in emotion_results:
+            for emotion, confidence in result.items():
+                aggregated[emotion] += confidence
+
+        n = len(emotion_results)
+        return {k: v / n for k, v in aggregated.items()}
+
+    async def process_conversation_turn(
+        self,
+        user_id: str,
+        text: str,
+        audio: np.ndarray,
+        sample_rate: int
+    ) -> Tuple[EmotionTurn, bool, str]:
+        """
+        Process a full conversation turn with emotion tracking.
+
+        This is the main entry point for integrating emotion detection
+        into the conversation pipeline.
+
+        Args:
+            user_id: User identifier for tracking
+            text: Transcribed text from STT
+            audio: Audio data (1D or 2D)
+            sample_rate: Sample rate
+
+        Returns:
+            Tuple of:
+            - EmotionTurn object
+            - bool: Whether empathy should be triggered
+            - str: Emotion prompt context (empty if no empathy needed)
+        """
+        if not self.config.enabled or not text.strip():
+            return None, False, ""
+
+        request_id = self._generate_request_id()
+
+        # Log audio stats for debugging
+        max_abs = np.max(np.abs(audio)) if audio.size > 0 else 0
+        print(f"[EMOTION] Processing turn for user {user_id}, request {request_id}")
+        print(f"[EMOTION] Input audio: shape={audio.shape}, dtype={audio.dtype}, max_abs={max_abs:.4f}")
+
+        # Detect emotions (multi-chunk if enabled)
+        emotion_results = await self.detect_emotions_multi(audio, sample_rate, request_id)
+
+        if not emotion_results:
+            print(f"[EMOTION] No emotions detected for request {request_id}")
+            return None, False, ""
+
+        # Aggregate results
+        aggregated = self.aggregate_emotions(emotion_results)
+
+        print(f"[EMOTION] Detected emotions: {aggregated}")
+
+        # Record in history
+        turn = self._history.add_turn(
+            user_id=user_id,
+            text=text,
+            emotions=aggregated,
+            negative_classes=self.config.negative_classes,
+            min_confidence_scores=self.config.min_confidence_scores
+        )
+
+        print(f"[EMOTION] Turn recorded - negative majority: {turn.is_negative_majority}")
+
+        # Check if empathy should be triggered
+        should_empathize, negative_turns = self._history.should_trigger_empathy(
+            user_id=user_id,
+            consecutive_threshold=self.config.consecutive_count
+        )
+
+        emotion_prompt = ""
+        if should_empathize:
+            print(f"[EMOTION] Triggering empathetic response for user {user_id}")
+            emotion_prompt = build_emotion_prompt_context(negative_turns)
+
+        return turn, should_empathize, emotion_prompt
+
+    def get_user_emotion_summary(self, user_id: str) -> Dict:
+        """Get emotion summary for a user."""
+        return self._history.get_emotion_summary(user_id)
+
+    def reset_user_emotions(self, user_id: str):
+        """Reset emotion history for a user."""
+        self._history.reset_user_history(user_id)
+
+    def get_active_request_count(self) -> int:
+        """Get count of currently active emotion detection requests."""
+        with self._request_lock:
+            return len(self._active_requests)
+
+
+# Global service instance (lazy loaded)
+_GLOBAL_SERVICE: Optional[EmotionDetectionService] = None
+_SERVICE_LOCK = threading.Lock()
+
+
+def get_emotion_service() -> EmotionDetectionService:
+    """Get the global emotion detection service instance."""
+    global _GLOBAL_SERVICE
+    if _GLOBAL_SERVICE is None:
+        with _SERVICE_LOCK:
+            if _GLOBAL_SERVICE is None:
+                _GLOBAL_SERVICE = EmotionDetectionService()
+    return _GLOBAL_SERVICE
+
+
+def initialize_emotion_service(config: Optional[EmotionConfig] = None) -> EmotionDetectionService:
+    """
+    Initialize or reinitialize the global emotion service.
+
+    Args:
+        config: Optional config. If not provided, loads from .env
+
+    Returns:
+        The initialized service instance
+    """
+    global _GLOBAL_SERVICE
+    with _SERVICE_LOCK:
+        _GLOBAL_SERVICE = EmotionDetectionService(config)
     return _GLOBAL_SERVICE