Upload folder using huggingface_hub

Dockerfile

@@ -2,24 +2,12 @@ FROM python:3.10-slim
 
 WORKDIR /app
 
-# System dependencies for audio processing + git for torch.hub
-RUN apt-get update && apt-get install -y \
-    libsndfile1 \
-    ffmpeg \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
 COPY requirements.txt .
-
-# Install CPU-only torch first (prevents CUDA downloads)
-RUN pip install --no-cache-dir torch==2.1.0+cpu torchvision==0.16.0+cpu torchaudio==2.1.0+cpu \
-    --extra-index-url https://download.pytorch.org/whl/cpu
-
-# Install other dependencies
+RUN pip install --no-cache-dir torch==2.1.0 --index-url https://download.pytorch.org/whl/cpu
 RUN pip install -r requirements.txt
 
 COPY . .
 
 EXPOSE 7860
 
-CMD ["uvicorn", "handler:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["python", "handler.py"]

README.md

@@ -1,41 +1,26 @@
 ---
-title: Busy Module Audio Features
-emoji: 🎤
-colorFrom: indigo
-colorTo: purple
+title: Busy Module Text Features
+emoji: 💬
+colorFrom: blue
+colorTo: green
 sdk: docker
 app_port: 7860
 pinned: false
 ---
 
-# Audio Feature Extraction API
+# Text Feature Extraction API
 
-Extracts 17 voice features from audio: SNR, noise classification, speech rate, pitch, energy, pause analysis, and emotion features.
+Extracts 9 text features from conversation transcripts: explicit intent, response patterns, cognitive load, time pressure, deflection, sentiment (RoBERTa), coherence (Sentence Transformer), and latency.
 
 ## API
 
-**POST** `/extract-audio-features-base64`
+**POST** `/extract-text-features`
 ```json
 {
-  "audio_base64": "<base64-encoded-wav>",
-  "transcript": "I'm driving right now"
+  "transcript": "I'm driving right now, can't talk",
+  "utterances": ["I'm driving right now", "can't talk"],
+  "question": "How are you doing?"
 }
 ```
 
-**POST** `/extract-audio-features` (multipart form)
-- `audio`: audio file upload
-- `transcript`: text transcript
-
-**POST** `/extract-audio-features` (multipart form)
-- `audio`: audio file upload
-- `transcript`: text transcript
-
 **GET** `/health`
-
-## Authentication
-
-This Space requires access to private models. You must add your Hugging Face token as a secret:
-1. Go to **Settings** -> **Variables and secrets**.
-2. Click **New secret**.
-3. Name: `HF_TOKEN`
-4. Value: Your Hugging Face Access Token (with read permissions).

handler.py

@@ -1,91 +1,53 @@
 """
-Audio Feature Extraction — Hugging Face Inference Endpoint Handler
+Text Feature Extraction — Hugging Face Inference Endpoint Handler
 
-Extracts all 17 voice features from uploaded audio:
-  v1_snr, v2_noise_* (5), v3_speech_rate, v4/v5_pitch, v6/v7_energy,
-  v8/v9/v10_pause, v11/v12/v13_emotion
+Extracts all 9 text features from conversation transcript:
+  t0_explicit_free, t1_explicit_busy, t2_avg_resp_len, t3_short_ratio,
+  t4_cognitive_load, t5_time_pressure, t6_deflection, t7_sentiment,
+  t8_coherence, t9_latency
 
-Derived from: src/audio_features.py, src/emotion_features.py
+Derived from: src/text_features.py
 """
 
-import io
-import numpy as np
-import librosa
-from scipy import signal as scipy_signal
-from typing import Dict
-import torch
-import torch.nn as nn
-from torchvision import models
-import warnings
-
-warnings.filterwarnings("ignore")
-
-
 # ──────────────────────────────────────────────────────────────────────── #
 # Imports from standardized modules
 # ──────────────────────────────────────────────────────────────────────── #
 try:
-    from audio_features import AudioFeatureExtractor
+    from text_features import TextFeatureExtractor
 except ImportError:
-    # Fallback if running from a different context
     import sys
     sys.path.append('.')
-    from audio_features import AudioFeatureExtractor
+    from text_features import TextFeatureExtractor
 
 # Initialize global extractor
-# We use a global instance to cache models (VAD, Emotion)
-print("[INFO] Initializing Global AudioFeatureExtractor...")
-extractor = AudioFeatureExtractor(
-    sample_rate=16000,
-    use_emotion=True,
-    emotion_models_dir="/app/models" # Absolute path in Docker container
-)
-
-# Ensure models are downloaded/ready
-if extractor.use_emotion and extractor.emotion_extractor:
-    print("[INFO] Checking for emotion models...")
-    # Trigger download if needed/possible
-    try:
-        if len(extractor.emotion_extractor.models) == 0:
-             print("[INFO] Models not found, attempting download...")
-             extractor.emotion_extractor.download_models()
-             # Re-init manually to load them
-             extractor.emotion_extractor.__init__(models_dir=extractor.emotion_extractor.models_dir)
-    except Exception as e:
-        print(f"[WARN] Failed to download emotion models: {e}")
-
-# ──────────────────────────────────────────────────────────────────────── #
-# Helper to handle NaN/Inf for JSON
-# ──────────────────────────────────────────────────────────────────────── #
-def sanitize_features(features: Dict[str, float]) -> Dict[str, float]:
-    sanitized = {}
-    for key, val in features.items():
-        if isinstance(val, (float, np.floating)):
-            if np.isnan(val) or np.isinf(val):
-                sanitized[key] = 0.0
-            else:
-                sanitized[key] = float(val)
-        elif isinstance(val, (int, np.integer)):
-            sanitized[key] = int(val)
-        else:
-            sanitized[key] = val # keep string/other as is
-    return sanitized
-
+print("[INFO] Initializing Global TextFeatureExtractor...")
+extractor = TextFeatureExtractor(use_intent_model=True)
 
 
 # ──────────────────────────────────────────────────────────────────────── #
-# FastAPI handler for deployment (HF Spaces / Cloud Run / Lambda)
+# FastAPI handler for deployment
 # ──────────────────────────────────────────────────────────────────────── #
 
-from fastapi import FastAPI, File, UploadFile, Form, Request
+from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
-from typing import Optional
-import base64
+from typing import Optional, List, Dict
 import traceback
 
-app = FastAPI(title="Audio Feature Extraction API", version="1.0.0")
+# ──────────────────────────────────────────────────────────────────────── #
+# Constants & Defaults
+# ──────────────────────────────────────────────────────────────────────── #
+
+DEFAULT_TEXT_FEATURES = {
+    "t0_explicit_free": 0.0, "t1_explicit_busy": 0.0,
+    "t2_avg_resp_len": 0.0, "t3_short_ratio": 0.0,
+    "t4_cognitive_load": 0.0, "t5_time_pressure": 0.0,
+    "t6_deflection": 0.0, "t7_sentiment": 0.0,
+    "t8_coherence": 0.5, "t9_latency": 0.0,
+}
+
+app = FastAPI(title="Text Feature Extraction API", version="1.0.0")
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"], allow_credentials=True,
@@ -95,110 +57,65 @@ app.add_middleware(
 
 @app.exception_handler(Exception)
 async def global_exception_handler(request: Request, exc: Exception):
-    """Catch any unhandled exceptions and return defaults instead of 500."""
     print(f"[GLOBAL ERROR] {request.url}: {exc}")
     traceback.print_exc()
     return JSONResponse(
         status_code=200,
-        content={**DEFAULT_AUDIO_FEATURES, "_error": str(exc), "_handler": "global"},
+        content={**DEFAULT_TEXT_FEATURES, "_error": str(exc), "_handler": "global"},
     )
 
-# Extractor is already initialized globally above
-
-# ──────────────────────────────────────────────────────────────────────── #
-# Constants & Defaults
-# ──────────────────────────────────────────────────────────────────────── #
-
-class AudioBase64Request(BaseModel):
-    audio_base64: str = ""
+class TextRequest(BaseModel):
     transcript: str = ""
+    # Optional list of extra utterances if available
+    utterances: List[str] = []
+    question: str = ""
+    events: Optional[List[Dict]] = None
 
 
 @app.get("/")
 async def root():
     return {
-        "service": "Audio Feature Extraction API",
+        "service": "Text Feature Extraction API",
         "version": "1.0.0",
-        "endpoints": ["/health", "/extract-audio-features", "/extract-audio-features-base64"],
+        "endpoints": ["/health", "/extract-text-features"],
     }
 
 
 @app.get("/health")
 async def health():
-    vad_status = extractor.vad_model is not None
-    emotion_status = extractor.emotion_extractor is not None if extractor.use_emotion else False
     return {
-        "status": "healthy", 
-        "vad_loaded": vad_status,
-        "emotion_loaded": emotion_status
+        "status": "healthy",
+        "intent_model_loaded": extractor.use_intent_model,
+        "sentiment_loaded": extractor.sentiment_model is not None,
     }
 
 
-@app.post("/extract-audio-features")
-async def extract_audio_features(audio: UploadFile = File(...), transcript: str = Form("")):
-    """Extract all 17 voice features from uploaded audio file."""
-    try:
-        audio_bytes = await audio.read()
-        # librosa.load returns (audio, sr)
-        y, sr = librosa.load(io.BytesIO(audio_bytes), sr=16000, mono=True)
-        
-        # AudioFeatureExtractor.extract_all expects numpy array and optional transcript
-        features = extractor.extract_all(y, transcript)
-        
-        return sanitize_features(features)
-    except Exception as e:
-        print(f"[ERROR] extract_audio_features: {e}")
-        traceback.print_exc()
-        return {**DEFAULT_AUDIO_FEATURES, "_error": str(e)}
-
-
-@app.post("/extract-audio-features-base64")
-async def extract_audio_features_base64(data: AudioBase64Request):
-    """Extract features from base64-encoded audio (for Vercel serverless calls)."""
-    import soundfile as sf
-
-    audio_b64 = data.audio_base64
-    transcript = data.transcript
-
-    # Handle empty / missing audio — return default features
-    if not audio_b64 or len(audio_b64) < 100:
-        print("[INFO] Empty or too-short audio_base64, returning defaults")
-        return {**DEFAULT_AUDIO_FEATURES}
-
-    try:
-        # Strip data URL prefix if present (e.g. "data:audio/wav;base64,...")
-        if "," in audio_b64[:80]:
-            audio_b64 = audio_b64.split(",", 1)[1]
-
-        audio_bytes = base64.b64decode(audio_b64)
-        print(f"[INFO] Decoded {len(audio_bytes)} bytes of audio")
-
-        # Try soundfile first, fall back to librosa
-        try:
-            y, sr = sf.read(io.BytesIO(audio_bytes))
-        except Exception as sf_err:
-            print(f"[WARN] soundfile failed ({sf_err}), trying librosa...")
-            y, sr = librosa.load(io.BytesIO(audio_bytes), sr=16000, mono=True)
-
-        if hasattr(y, 'shape') and len(y.shape) > 1:
-            y = np.mean(y, axis=1)
-        y = np.asarray(y, dtype=np.float32)
-        if sr != 16000:
-            y = librosa.resample(y, orig_sr=sr, target_sr=16000)
-        y = y.astype(np.float32)
-
-        if len(y) < 100:
-            print("[WARN] Audio too short after decode, returning defaults")
-            return {**DEFAULT_AUDIO_FEATURES}
-
-        features = extractor.extract_all(y, transcript)
-        print(f"[OK] Extracted {len(features)} audio features")
-        return sanitize_features(features)
-    except Exception as e:
-        print(f"[ERROR] extract_audio_features_base64: {e}")
-        traceback.print_exc()
-        # Return defaults rather than 500
-        return {**DEFAULT_AUDIO_FEATURES, "_error": str(e)}
+@app.post("/extract-text-features")
+async def extract_text_features(data: TextRequest):
+    """Extract all 9 text features from transcript."""
+    # Prepare inputs for TextFeatureExtractor.extract_all
+    # It expects: transcript_list, full_transcript, question, events
+    
+    transcript_list = data.utterances
+    if not transcript_list and data.transcript:
+        transcript_list = [data.transcript]
+    
+    features = extractor.extract_all(
+        transcript_list=transcript_list,
+        full_transcript=data.transcript,
+        question=data.question,
+        events=data.events,
+    )
+    
+    # Sanitize inputs to ensure floats
+    sanitized = {}
+    for k, v in features.items():
+        if isinstance(v, float):
+             sanitized[k] = 0.0 if np.isnan(v) or np.isinf(v) else v
+        else:
+             sanitized[k] = v
+             
+    return sanitized
 
 
 if __name__ == "__main__":
@@ -206,4 +123,3 @@ if __name__ == "__main__":
     import os
     port = int(os.environ.get("PORT", 7860))
     uvicorn.run(app, host="0.0.0.0", port=port)
-

requirements.txt

@@ -1,22 +1,11 @@
-# Core audio processing
-librosa==0.10.1
-soundfile==0.12.1
-numpy==1.24.3
-scipy==1.11.2
-
-# ML - CPU-only versions (HF Spaces friendly)
-# Torch for Silero VAD
---extra-index-url https://download.pytorch.org/whl/cpu
-torch==2.1.0+cpu
-torchaudio==2.1.0+cpu
+# NLP
+transformers==4.35.0
+sentence-transformers==2.2.2
 
-# TensorFlow for Emotion Models
-tensorflow-cpu==2.15.0
+numpy==1.24.3
+scikit-learn==1.3.2
 
 # API
 fastapi==0.95.2
 uvicorn==0.22.0
-python-multipart==0.0.6
-huggingface_hub>=0.19.0
-noisereduce>=3.0.0
-scikit-image>=0.21.0
+pydantic==1.10.13

text_features.py

@@ -0,0 +1,431 @@
+"""
+Text Feature Extractor - IMPROVED VERSION
+Extracts 9 text features from conversation transcripts to detect busy/distracted states.
+
+KEY IMPROVEMENTS:
+1. Uses NLI model for intent classification (understands "not busy" properly)
+2. Handles negation, context, and sarcasm
+3. Removes useless t9_latency for single-side audio
+"""
+
+import numpy as np
+from typing import List, Dict, Tuple
+from transformers import pipeline
+from sentence_transformers import SentenceTransformer
+import re
+
+
+class TextFeatureExtractor:
+    """Extract 9 text features for busy detection"""
+    
+    def __init__(self, use_intent_model: bool = True):
+        """
+        Initialize NLP models
+        
+        Args:
+            use_intent_model: If True, use BART-MNLI for intent classification
+                            If False, fall back to pattern matching
+        """
+        self.use_intent_model = use_intent_model
+
+        print("Loading NLP models...")
+
+        # Sentiment model
+        model_name = "cardiffnlp/twitter-roberta-base-sentiment-latest"
+        self.sentiment_model = pipeline(
+            "sentiment-analysis",
+            model=model_name,
+            device=-1
+        )
+        print("[OK] Sentiment model loaded")
+
+        # Coherence model
+        self.coherence_model = SentenceTransformer('all-MiniLM-L6-v2')
+        print("[OK] Coherence model loaded")
+
+        # Always setup patterns — busy_keywords is needed by extract_marker_counts()
+        self._setup_patterns()
+
+        # Intent classification model (NEW - understands context!)
+        if self.use_intent_model:
+            try:
+                self.intent_classifier = pipeline(
+                    "zero-shot-classification",
+                    model="facebook/bart-large-mnli",
+                    device=-1
+                )
+                print("[OK] Intent classifier loaded (BART-MNLI)")
+            except Exception as e:
+                print(f"[WARN] Intent classifier failed to load: {e}")
+                print("  Falling back to pattern matching")
+                self.use_intent_model = False
+
+    def _setup_patterns(self):
+        """Setup pattern-based matching as fallback"""
+        # Negation pattern
+        self.negation_pattern = re.compile(
+            r'\b(not|no|never|neither|n\'t|dont|don\'t|cannot|can\'t|wont|won\'t)\s+\w*\s*(busy|free|available|talk|rush)',
+            re.IGNORECASE
+        )
+        
+        # Busy patterns (positive assertions)
+        self.busy_patterns = [
+            r'\b(i\'m|i am|im)\s+(busy|driving|working|cooking|rushing)\b',
+            r'\bin a (meeting|call|hurry)\b',
+            r'\bcan\'t talk\b',
+            r'\bcall (you|me) back\b',
+            r'\bnot a good time\b',
+            r'\bbad time\b'
+        ]
+        
+        # Free patterns (positive assertions)
+        self.free_patterns = [
+            r'\b(i\'m|i am|im)\s+(free|available)\b',
+            r'\bcan talk\b',
+            r'\bhave time\b',
+            r'\bnot busy\b',
+            r'\bgood time\b',
+            r'\bnow works\b'
+        ]
+        
+        # Compile patterns
+        self.busy_patterns = [re.compile(p, re.IGNORECASE) for p in self.busy_patterns]
+        self.free_patterns = [re.compile(p, re.IGNORECASE) for p in self.free_patterns]
+
+        # Legacy keywords for other features
+        self.busy_keywords = {
+            'cognitive_load': [
+                'um', 'uh', 'like', 'you know', 'i mean', 'kind of', 
+                'sort of', 'basically', 'actually'
+            ],
+            'time_pressure': [
+                'quickly', 'hurry', 'fast', 'urgent', 'asap', 'right now',
+                'immediately', 'short', 'brief'
+            ],
+            'deflection': [
+                'later', 'another time', 'not now', 'maybe', 'i don\'t know',
+                'whatever', 'sure sure', 'yeah yeah'
+            ]
+        }
+    
+    def extract_explicit_busy(self, transcript: str) -> float:
+        """
+        T1: Explicit Busy Indicators (binary: 0 or 1)
+        
+        IMPROVED: Uses NLI model to understand context and negation
+        - "I'm busy" → 1.0
+        - "I'm not busy" → 0.0
+        - "Can't talk right now" → 1.0
+        - "I can talk" → 0.0
+        """
+        if not transcript or len(transcript.strip()) < 3:
+            return 0.0
+        
+        # Method 1: Use intent classification model (best)
+        if self.use_intent_model:
+            try:
+                result = self.intent_classifier(
+                    transcript,
+                    candidate_labels=["person is busy or occupied", 
+                                    "person is free and available", 
+                                    "unclear or neutral"],
+                    hypothesis_template="This {}."
+                )
+                
+                top_label = result['labels'][0]
+                top_score = result['scores'][0]
+                
+                # Require high confidence (>0.6) to avoid false positives
+                if top_score > 0.6:
+                    if "busy" in top_label:
+                        return 1.0
+                    elif "free" in top_label:
+                        return 0.0
+                
+                return 0.0  # Neutral or low confidence
+                
+            except Exception as e:
+                print(f"Intent classification failed: {e}")
+                # Fall through to pattern matching
+        
+        # Method 2: Pattern-based with negation handling (fallback)
+        return self._extract_busy_patterns(transcript)
+    
+    def _extract_busy_patterns(self, transcript: str) -> float:
+        """Pattern-based busy detection with negation handling"""
+        transcript_lower = transcript.lower()
+        
+        # Check for negated busy/free statements
+        negation_match = self.negation_pattern.search(transcript_lower)
+        if negation_match:
+            matched_text = negation_match.group(0)
+            # "not busy" or "can't be free" etc.
+            if any(word in matched_text for word in ['busy', 'rush']):
+                return 0.0  # "not busy" = available
+            elif any(word in matched_text for word in ['free', 'available', 'talk']):
+                return 1.0  # "can't talk" or "not free" = busy
+        
+        # Check free patterns first (higher priority)
+        for pattern in self.free_patterns:
+            if pattern.search(transcript_lower):
+                return 0.0
+        
+        # Then check busy patterns
+        for pattern in self.busy_patterns:
+            if pattern.search(transcript_lower):
+                return 1.0
+        
+        return 0.0
+
+    def extract_explicit_free(self, transcript: str) -> float:
+        """
+        T0: Explicit Free Indicators (binary: 0 or 1)
+        
+        IMPROVED: Uses same context-aware approach as busy detection
+        """
+        if not transcript or len(transcript.strip()) < 3:
+            return 0.0
+        
+        # Use intent model
+        if self.use_intent_model:
+            try:
+                result = self.intent_classifier(
+                    transcript,
+                    candidate_labels=["person is free and available",
+                                    "person is busy or occupied",
+                                    "unclear or neutral"],
+                    hypothesis_template="This {}."
+                )
+                
+                top_label = result['labels'][0]
+                top_score = result['scores'][0]
+                
+                if top_score > 0.6 and "free" in top_label:
+                    return 1.0
+                
+                return 0.0
+                
+            except Exception as e:
+                print(f"Intent classification failed: {e}")
+        
+        # Fallback to patterns
+        transcript_lower = transcript.lower()
+        
+        for pattern in self.free_patterns:
+            if pattern.search(transcript_lower):
+                return 1.0
+        
+        return 0.0
+    
+    def extract_response_patterns(self, transcript_list: List[str]) -> Tuple[float, float]:
+        """
+        T2-T3: Average Response Length and Short Response Ratio
+        
+        Returns:
+            - avg_response_len: Average words per response
+            - short_ratio: Fraction of responses with ≤3 words
+        """
+        if not transcript_list:
+            return 0.0, 0.0
+        
+        word_counts = [len(response.split()) for response in transcript_list]
+        
+        avg_response_len = np.mean(word_counts)
+        short_count = sum(1 for wc in word_counts if wc <= 3)
+        short_ratio = short_count / len(word_counts)
+        
+        return float(avg_response_len), float(short_ratio)
+    
+    def extract_marker_counts(self, transcript: str) -> Tuple[float, float, float]:
+        """
+        T4-T6: Cognitive Load, Time Pressure, Deflection markers
+        
+        Returns:
+            - cognitive_load: Count of filler words / total words
+            - time_pressure: Count of urgency markers / total words
+            - deflection: Count of deflection phrases / total words
+        """
+        transcript_lower = transcript.lower()
+        words = transcript.split()
+        total_words = len(words)
+        
+        if total_words == 0:
+            return 0.0, 0.0, 0.0
+        
+        # Count markers
+        cognitive_load_count = sum(
+            1 for keyword in self.busy_keywords['cognitive_load']
+            if keyword in transcript_lower
+        )
+        
+        time_pressure_count = sum(
+            1 for keyword in self.busy_keywords['time_pressure']
+            if keyword in transcript_lower
+        )
+        
+        deflection_count = sum(
+            1 for keyword in self.busy_keywords['deflection']
+            if keyword in transcript_lower
+        )
+        
+        # Normalize by total words
+        cognitive_load = cognitive_load_count / total_words
+        time_pressure = time_pressure_count / total_words
+        deflection = deflection_count / total_words
+        
+        return float(cognitive_load), float(time_pressure), float(deflection)
+    
+    def extract_sentiment(self, transcript: str) -> float:
+        """
+        T7: Sentiment Polarity (-1 to +1)
+        Negative sentiment often indicates stress/frustration
+        """
+        if not transcript or len(transcript.strip()) == 0:
+            return 0.0
+
+        try:
+            result = self.sentiment_model(transcript[:512])[0]
+            label = result['label'].lower()
+            score = result['score']
+
+            if 'positive' in label:
+                return float(score)
+            elif 'negative' in label:
+                return float(-score)
+            else:
+                return 0.0
+
+        except Exception as e:
+            print(f"Sentiment extraction error: {e}")
+            return 0.0
+    
+    def extract_coherence(self, question: str, responses: List[str]) -> float:
+        """
+        T8: Coherence Score (0 to 1)
+        Measures how relevant responses are to the question
+        Low coherence = distracted/not paying attention
+        """
+        if not question or not responses:
+            return 0.5  # Neutral if no data (changed from 1.0 to be more conservative)
+        
+        try:
+            # Encode question and responses
+            question_embedding = self.coherence_model.encode(question, convert_to_tensor=True)
+            response_embeddings = self.coherence_model.encode(responses, convert_to_tensor=True)
+            
+            # Calculate cosine similarity
+            from sentence_transformers import util
+            similarities = util.cos_sim(question_embedding, response_embeddings)[0]
+            
+            # Average similarity as coherence score
+            coherence = float(np.mean(similarities.cpu().numpy()))
+            
+            return max(0.0, min(1.0, coherence))  # Clamp to [0, 1]
+        except Exception as e:
+            print(f"Coherence extraction error: {e}")
+            return 0.5
+    
+    def extract_latency(self, events: List[Dict]) -> float:
+        """
+        T9: Average Response Latency (seconds)
+        
+        ⚠️ WARNING: This feature is USELESS for single-side audio!
+        Always returns 0.0 since we don't have agent questions.
+        Kept for compatibility with existing models.
+        
+        events: List of dicts with 'timestamp' and 'speaker' keys
+        """
+        # Always return 0 for single-side audio
+        return 0.0
+    
+    def extract_all(
+        self, 
+        transcript_list: List[str], 
+        full_transcript: str = "",
+        question: str = "",
+        events: List[Dict] = None
+    ) -> Dict[str, float]:
+        """
+        Extract all 9 text features
+        
+        Args:
+            transcript_list: List of individual responses (can be single item for one-turn)
+            full_transcript: Complete conversation text
+            question: The question/prompt from agent (for coherence)
+            events: List of timestamped events (unused for single-side audio)
+        
+        Returns:
+            Dict with keys: t0_explicit_free, t1_explicit_busy,
+                           t2_avg_resp_len, t3_short_ratio,
+                           t4_cognitive_load, t5_time_pressure, t6_deflection,
+                           t7_sentiment, t8_coherence, t9_latency
+        """
+        features = {}
+        
+        # Use full transcript if not provided separately
+        if not full_transcript:
+            full_transcript = " ".join(transcript_list)
+        
+        # T0-T1: Explicit indicators (IMPROVED with NLI)
+        features['t0_explicit_free'] = self.extract_explicit_free(full_transcript)
+        features['t1_explicit_busy'] = self.extract_explicit_busy(full_transcript)
+        
+        # T2-T3: Response patterns
+        avg_len, short_ratio = self.extract_response_patterns(transcript_list)
+        features['t2_avg_resp_len'] = avg_len
+        features['t3_short_ratio'] = short_ratio
+        
+        # T4-T6: Markers
+        cog_load, time_press, deflect = self.extract_marker_counts(full_transcript)
+        features['t4_cognitive_load'] = cog_load
+        features['t5_time_pressure'] = time_press
+        features['t6_deflection'] = deflect
+        
+        # T7: Sentiment
+        features['t7_sentiment'] = self.extract_sentiment(full_transcript)
+        
+        # T8: Coherence (default to 0.5 if no question provided)
+        if question:
+            features['t8_coherence'] = self.extract_coherence(question, transcript_list)
+        else:
+            features['t8_coherence'] = 0.5  # Neutral
+        
+        # T9: Latency (ALWAYS 0 for single-side audio)
+        features['t9_latency'] = 0.0
+        
+        return features
+
+
+if __name__ == "__main__":
+    # Test the extractor
+    print("Initializing Text Feature Extractor...")
+    extractor = TextFeatureExtractor(use_intent_model=True)
+    
+    # Test cases for intent classification
+    test_cases = [
+        "I'm driving right now",
+        "I'm not busy at all",
+        "Can't talk, in a meeting",
+        "I can talk now",
+        "Not a good time",
+        "I have time to chat"
+    ]
+    
+    print("\nTesting intent classification:")
+    for test in test_cases:
+        busy_score = extractor.extract_explicit_busy(test)
+        free_score = extractor.extract_explicit_free(test)
+        print(f"  '{test}'")
+        print(f"    → Busy: {busy_score:.1f}, Free: {free_score:.1f}")
+    
+    # Full feature extraction
+    print("\nFull feature extraction:")
+    features = extractor.extract_all(
+        transcript_list=["I'm not busy", "I can talk now"],
+        full_transcript="I'm not busy. I can talk now.",
+        question="How are you doing today?"
+    )
+    
+    print("\nExtracted features:")
+    for key, value in features.items():
+        print(f"  {key}: {value:.3f}")