Update main.py

main.py

@@ -1,22 +1,39 @@
 import asyncio
+
 import json
+
 import os
+
 import re
+
 import statistics
+
 import time
+
 import uuid
+
 from dataclasses import dataclass
+
 from typing import Any, Optional
+
 import httpx
+
 from dotenv import load_dotenv
+
 from fastapi import FastAPI, HTTPException
+
 from fastapi.middleware.cors import CORSMiddleware
+
 from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
+
+from pydantic import BaseModel, Field
 
 
 
 load_dotenv()
+
+
+
 app = FastAPI(title="CortexFlow Backend", version="1.0.0")
 
 app.add_middleware(
@@ -36,8 +53,11 @@ app.add_middleware(
 
 
 GROQ_API_KEY = os.getenv("GROQ_API_KEY", "").strip()
+
 GROQ_API_BASE = os.getenv("GROQ_API_BASE", "https://api.groq.com/openai/v1").rstrip("/")
+
 GROQ_TIMEOUT_SECONDS = float(os.getenv("GROQ_TIMEOUT_SECONDS", "40"))
+
 MODEL_DISCOVERY_TTL_SECONDS = int(os.getenv("MODEL_DISCOVERY_TTL_SECONDS", "900"))
 
 
@@ -77,8 +97,10 @@ PREFERRED_SAFETY_MODELS = [
 
 
 OVERRIDE_REASONING_MODEL = os.getenv("GROQ_REASONING_MODEL", "").strip()
+
 OVERRIDE_SAFETY_MODEL = os.getenv("GROQ_SAFETY_MODEL", "").strip()
-GROQ_TRANSCRIBE_MODEL = os.getenv("GROQ_TRANSCRIBE_MODEL", "whisper-large-v3-turbo").strip() or "whisper-large-v3-turbo"
+
+
 
 MIN_WORDS_REQUIRED = int(os.getenv("MIN_WORDS_REQUIRED", "25"))
 
@@ -131,14 +153,6 @@ STOPWORDS = {
     "not", "no", "yes", "so", "because", "about", "into", "out", "up", "down", "can", "could", "would",
 
     "should", "will", "just", "very", "really", "also",
-    # Common Romanized Hindi stopwords for code-mixed speech.
-    "hai", "hain", "tha", "thi", "the", "ho", "hoga", "hogi", "honge", "main", "mein", "mera", "meri", "mere",
-    "hum", "tum", "aap", "ye", "yeh", "wo", "woh", "is", "iss", "us", "uss", "ko", "se", "ka", "ki", "ke",
-    "par", "aur", "lekin", "magar", "kyunki", "kyonki", "agar", "jab", "tab", "tak", "ya", "nahi", "nahin", "haan",
-    # Common Devanagari stopwords for native Hindi transcripts.
-    "है", "हैं", "था", "थी", "थे", "हो", "होगा", "होगी", "होंगे", "मैं", "में", "मेरा", "मेरी", "मेरे", "हम",
-    "तुम", "आप", "ये", "यह", "वो", "वह", "इस", "उस", "को", "से", "का", "की", "के", "पर", "और", "लेकिन",
-    "मगर", "क्योंकि", "अगर", "जब", "तब", "तक", "या", "नहीं", "हाँ",
 
 }
 
@@ -146,8 +160,7 @@ STOPWORDS = {
 
 FILLERS = {
 
-    "um", "uh", "erm", "hmm", "like", "actually", "basically", "literally",
-    "matlab", "achha", "accha", "toh", "na", "yaar", "dekho", "samjho", "मतलब", "अच्छा", "तो", "ना",
+    "um", "uh", "erm", "hmm", "like", "you", "know", "actually", "basically", "literally", "sort", "kind", "maybe",
 
 }
 
@@ -156,61 +169,31 @@ FILLERS = {
 POSITIVE_WORDS = {
 
     "good", "better", "great", "calm", "confident", "clear", "focused", "stable", "happy", "optimistic", "safe", "steady",
-    "accha", "badhiya", "shaant", "khush", "सुरक्षित", "शांत", "खुश", "अच्छा",
 
 }
 
 NEGATIVE_WORDS = {
 
     "bad", "worse", "anxious", "scared", "panic", "panicked", "confused", "sad", "depressed", "angry", "overwhelmed", "stressed",
-    "bura", "ghabrahat", "darr", "pareshan", "dukhi", "चिंतित", "डरा", "उलझन", "दुखी", "तनाव",
 
 }
 
 AROUSAL_WORDS = {
 
     "urgent", "immediately", "intense", "extreme", "critical", "afraid", "panic", "terrified", "racing", "shaking", "worried",
-    "jaldi", "turant", "tez", "bahut", "घबराहट", "तुरंत", "जल्दी", "तेज", "चिंता",
 
 }
 
 HEDGE_WORDS = {
 
     "maybe", "perhaps", "possibly", "probably", "sort", "kind", "might", "could", "guess", "unsure", "not sure",
-    "shayad", "lagta", "shayad", "pata", "कदाचित", "शायद", "लगता", "पता",
 
 }
 
-FILLER_PHRASES = {
-    "you know",
-    "i mean",
-    "sort of",
-    "kind of",
-    "pata hai",
-    "you know what",
-}
-
-HEDGE_PHRASES = {
-    "not sure",
-    "i guess",
-    "sort of",
-    "kind of",
-    "pata nahi",
-    "mujhe lagta",
-}
-
 SUBORDINATORS = {
 
     "because", "although", "though", "while", "unless", "until", "since", "whereas", "however", "therefore", "moreover", "which", "that",
-    "kyunki", "kyonki", "agar", "jab", "jabki", "lekin", "magar", "isliye", "jo", "कि", "क्योंकि", "अगर", "जब", "जबकि", "लेकिन", "मगर", "इसलिए", "जो",
-
-}
 
-ROMAN_HINDI_MARKERS = {
-    "hai", "hain", "tha", "thi", "the", "main", "mein", "mera", "meri", "mere", "hum", "tum", "aap", "ye", "yeh",
-    "wo", "woh", "ko", "se", "ka", "ki", "ke", "par", "aur", "lekin", "magar", "kyunki", "kyonki", "agar", "jab",
-    "tab", "tak", "ya", "nahi", "nahin", "haan", "accha", "achha", "matlab", "yaar", "jaldi", "turant", "shayad",
-    "pata", "samjho", "dekho", "bahut", "thoda", "zyada", "abhi", "kal", "kar", "karna", "kiya", "karo", "raha", "rahi",
 }
 
 
@@ -227,10 +210,6 @@ class AnalyzeRequest(BaseModel):
 
     audio_duration: Optional[float] = None
 
-    detected_language: Optional[str] = None
-
-    language_profile: Optional[dict[str, Any]] = None
-
     session_id: Optional[str] = None
 
 
@@ -259,8 +238,6 @@ class AnalysisState:
 
     quality_notes: list[str]
 
-    language_profile: dict[str, Any]
-
     metrics: dict[str, Any]
 
 
@@ -271,10 +248,6 @@ _MODEL_CACHE: dict[str, Any] = {"updated": 0.0, "models": []}
 
 _MODEL_CACHE_LOCK = asyncio.Lock()
 
-LATIN_TOKEN_RE = re.compile(r"[A-Za-z]+(?:'[A-Za-z]+)?")
-DEVANAGARI_TOKEN_RE = re.compile(r"[\u0900-\u097F]+")
-WORD_TOKEN_RE = re.compile(r"[A-Za-z]+(?:'[A-Za-z]+)?|[\u0900-\u097F]+")
-
 
 
 def clamp01(v: float) -> float:
@@ -295,7 +268,7 @@ def mean(values: list[float], default: float = 0.0) -> float:
 
 def tokenize_words(text: str) -> list[str]:
 
-    return [tok.lower() for tok in WORD_TOKEN_RE.findall(text)]
+    return re.findall(r"[A-Za-z']+", text.lower())
 
 
 
@@ -303,7 +276,7 @@ def tokenize_words(text: str) -> list[str]:
 
 def split_sentences(text: str) -> list[str]:
 
-    parts = [p.strip() for p in re.split(r"(?<=[.!?।])\s+", text) if p.strip()]
+    parts = [p.strip() for p in re.split(r"(?<=[.!?])\s+", text) if p.strip()]
 
     return parts if parts else ([text.strip()] if text.strip() else [])
 
@@ -316,154 +289,6 @@ def content_words(tokens: list[str]) -> list[str]:
     return [t for t in tokens if len(t) > 2 and t not in STOPWORDS]
 
 
-def read_profile_ratio(profile: Optional[dict[str, Any]], snake_key: str, camel_key: str) -> Optional[float]:
-
-    if not profile or not isinstance(profile, dict):
-
-        return None
-
-    raw = profile.get(snake_key)
-
-    if raw is None:
-
-        raw = profile.get(camel_key)
-
-    if raw is None:
-
-        return None
-
-    try:
-
-        return clamp01(float(raw))
-
-    except (TypeError, ValueError):
-
-        return None
-
-
-def detect_language_profile(
-
-    text: str,
-
-    hinted_language: Optional[str] = None,
-
-    hinted_profile: Optional[dict[str, Any]] = None,
-
-) -> dict[str, Any]:
-
-    latin_tokens = [tok.lower() for tok in LATIN_TOKEN_RE.findall(text)]
-
-    devanagari_tokens = DEVANAGARI_TOKEN_RE.findall(text)
-
-    roman_hindi_hits = sum(1 for tok in latin_tokens if tok in ROMAN_HINDI_MARKERS)
-
-    hindi_tokens = len(devanagari_tokens) + roman_hindi_hits
-
-    english_tokens = max(len(latin_tokens) - roman_hindi_hits, 0)
-
-    total = max(hindi_tokens + english_tokens, 1)
-
-
-
-    hindi_ratio = hindi_tokens / total
-
-    english_ratio = english_tokens / total
-
-    devanagari_ratio = len(devanagari_tokens) / total
-
-
-
-    hinted_english_ratio = read_profile_ratio(hinted_profile, "english_ratio", "englishRatio")
-
-    hinted_hindi_ratio = read_profile_ratio(hinted_profile, "hindi_ratio", "hindiRatio")
-
-    if hinted_english_ratio is not None and hinted_hindi_ratio is not None and (hinted_english_ratio + hinted_hindi_ratio) > 0:
-
-        hinted_total = hinted_english_ratio + hinted_hindi_ratio
-
-        hinted_english_ratio /= hinted_total
-
-        hinted_hindi_ratio /= hinted_total
-
-        english_ratio = (0.75 * english_ratio) + (0.25 * hinted_english_ratio)
-
-        hindi_ratio = (0.75 * hindi_ratio) + (0.25 * hinted_hindi_ratio)
-
-        ratio_total = max(english_ratio + hindi_ratio, 1e-6)
-
-        english_ratio = english_ratio / ratio_total
-
-        hindi_ratio = hindi_ratio / ratio_total
-
-
-
-    label = "multilingual"
-
-    if hindi_ratio >= 0.2 and english_ratio >= 0.2:
-
-        label = "hinglish"
-
-    elif hindi_ratio >= 0.68:
-
-        label = "hindi"
-
-    elif english_ratio >= 0.68:
-
-        label = "english"
-
-
-
-    hint = (hinted_language or "").strip().lower()
-
-    if hint in {"hi", "hindi"}:
-
-        if english_ratio >= 0.2:
-
-            label = "hinglish"
-
-        elif label == "multilingual":
-
-            label = "hindi"
-
-    elif hint in {"en", "english"}:
-
-        if hindi_ratio >= 0.2:
-
-            label = "hinglish"
-
-        elif label == "multilingual":
-
-            label = "english"
-
-
-
-    if hinted_profile and isinstance(hinted_profile, dict):
-
-        hinted_label = str(hinted_profile.get("label", "")).strip().lower()
-
-        if hinted_label in {"hinglish", "hindi", "english", "multilingual"} and (
-
-            label == "multilingual" or abs(hindi_ratio - english_ratio) < 0.12
-
-        ):
-
-            label = hinted_label
-
-
-
-    return {
-
-        "label": label,
-
-        "english_ratio": round(english_ratio, 4),
-
-        "hindi_ratio": round(hindi_ratio, 4),
-
-        "devanagari_ratio": round(devanagari_ratio, 4),
-
-    }
-
-
 
 
 
@@ -504,148 +329,6 @@ def scale_inverse(value: float, good: float, poor: float) -> float:
     return clamp01((good - value) / (good - poor))
 
 
-def pick_language_target(
-
-    language_profile: dict[str, Any],
-
-    english: float,
-
-    hinglish: float,
-
-    hindi: float,
-
-    multilingual: Optional[float] = None,
-
-) -> float:
-
-    try:
-
-        english_ratio = clamp01(float(language_profile.get("english_ratio", 0.0)))
-
-    except (TypeError, ValueError):
-
-        english_ratio = 0.0
-
-    try:
-
-        hindi_ratio = clamp01(float(language_profile.get("hindi_ratio", 0.0)))
-
-    except (TypeError, ValueError):
-
-        hindi_ratio = 0.0
-
-    ratio_total = english_ratio + hindi_ratio
-
-
-
-    if ratio_total > 1e-6:
-
-        english_weight = english_ratio / ratio_total
-
-        hindi_weight = hindi_ratio / ratio_total
-
-        base_target = (english_weight * english) + (hindi_weight * hindi)
-
-        code_mix_strength = clamp01(2.0 * min(english_weight, hindi_weight))
-
-        blended_target = ((1.0 - code_mix_strength) * base_target) + (code_mix_strength * hinglish)
-
-        if multilingual is not None:
-
-            blended_target = (0.9 * blended_target) + (0.1 * multilingual)
-
-        return blended_target
-
-
-
-    label = str(language_profile.get("label", "english")).lower()
-
-    if label == "hinglish":
-
-        return hinglish
-
-    if label == "hindi":
-
-        return hindi
-
-    if label == "multilingual":
-
-        return multilingual if multilingual is not None else (english + hindi) / 2.0
-
-    return english
-
-
-def transcription_model_capabilities(model_name: str) -> dict[str, Any]:
-
-    normalized = model_name.strip().lower()
-
-    if not normalized:
-
-        return {
-
-            "model": "unknown",
-
-            "multilingual": False,
-
-            "hindi_supported": False,
-
-            "hinglish_supported": False,
-
-            "notes": "No transcription model configured.",
-
-        }
-
-
-
-    english_only = normalized.endswith("-en") or normalized in {
-
-        "distil-whisper-large-v3-en",
-
-        "whisper-large-v3-en",
-
-    }
-
-    multilingual = (
-
-        ("whisper" in normalized and not english_only)
-
-        or ("gpt-4o-mini-transcribe" in normalized)
-
-        or ("gpt-4o-transcribe" in normalized)
-
-    )
-
-
-
-    if english_only:
-
-        notes = "Configured model appears English-only. Use a multilingual Whisper model for Hindi/Hinglish."
-
-    elif multilingual:
-
-        notes = "Configured model supports multilingual transcription, including Hindi and code-mixed Hinglish."
-
-    else:
-
-        notes = "Model capability is unknown; verify multilingual Hindi support in provider documentation."
-
-
-
-    return {
-
-        "model": model_name,
-
-        "multilingual": multilingual,
-
-        "hindi_supported": multilingual,
-
-        "hinglish_supported": multilingual,
-
-        "notes": notes,
-
-    }
-
-
 
 def safe_step_event(name: str, status: str, detail: Optional[str] = None) -> bytes:
 
@@ -658,31 +341,6 @@ def safe_step_event(name: str, status: str, detail: Optional[str] = None) -> byt
     return (json.dumps(payload) + "\n").encode()
 
 
-def count_phrase_hits(text: str, phrases: set[str]) -> int:
-
-    lowered = text.lower()
-
-    return sum(lowered.count(phrase) for phrase in phrases if phrase)
-
-
-def estimate_filler_hits(tokens: list[str], text: str) -> int:
-
-    token_hits = sum(1 for t in tokens if t in FILLERS)
-
-    phrase_hits = count_phrase_hits(text, FILLER_PHRASES)
-
-    return token_hits + phrase_hits
-
-
-def estimate_hedge_hits(tokens: list[str], text: str) -> int:
-
-    token_hits = sum(1 for t in tokens if t in HEDGE_WORDS)
-
-    phrase_hits = count_phrase_hits(text, HEDGE_PHRASES)
-
-    return token_hits + phrase_hits
-
-
 
 
 
@@ -712,23 +370,13 @@ def ensure_nonempty_text(req: AnalyzeRequest) -> str:
 
 
 
-def lexical_domain(
-
-    tokens: list[str],
-
-    text: str,
-
-    content: list[str],
-
-    language_profile: dict[str, Any],
-
-) -> tuple[DomainScore, dict[str, float]]:
+def lexical_domain(tokens: list[str], content: list[str]) -> tuple[DomainScore, dict[str, float]]:
 
     total = max(len(tokens), 1)
 
     unique = len(set(tokens))
 
-    filler_hits = estimate_filler_hits(tokens, text)
+    filler_hits = sum(1 for t in tokens if t in FILLERS)
 
 
 
@@ -740,21 +388,11 @@ def lexical_domain(
 
 
 
-    ttr_target = pick_language_target(language_profile, english=0.52, hinglish=0.57, hindi=0.56, multilingual=0.55)
-
-    density_target = pick_language_target(language_profile, english=0.58, hinglish=0.63, hindi=0.61, multilingual=0.60)
-
-    filler_low = pick_language_target(language_profile, english=2.0, hinglish=3.5, hindi=3.5, multilingual=3.0)
-
-    filler_high = pick_language_target(language_profile, english=12.0, hinglish=20.0, hindi=17.0, multilingual=17.0)
-
-
+    s_ttr = clamp01(abs(ttr - 0.52) / 0.30)
 
-    s_ttr = clamp01(abs(ttr - ttr_target) / 0.30)
+    s_density = clamp01(abs(density - 0.58) / 0.25)
 
-    s_density = clamp01(abs(density - density_target) / 0.25)
-
-    s_filler = scale_linear(filler_rate, filler_low, filler_high)
+    s_filler = scale_linear(filler_rate, 2.0, 14.0)
 
 
 
@@ -852,15 +490,7 @@ def semantic_domain(sentences: list[str]) -> tuple[DomainScore, dict[str, float]
 
 def prosody_domain(
 
-    tokens: list[str],
-
-    text: str,
-
-    pause_map: Optional[list[float]],
-
-    audio_duration: Optional[float],
-
-    language_profile: dict[str, Any],
+    tokens: list[str], text: str, pause_map: Optional[list[float]], audio_duration: Optional[float]
 
 ) -> tuple[DomainScore, dict[str, float], bool]:
 
@@ -894,11 +524,7 @@ def prosody_domain(
 
         pause_freq = len(pauses) / duration_minutes
 
-        pause_hesitation = sum(1 for p in pauses if p >= 0.8) / len(pauses)
-
-        lexical_hesitation = clamp01(estimate_filler_hits(tokens, text) / max(word_count, 1))
-
-        hesitation_ratio = clamp01((0.7 * pause_hesitation) + (0.3 * lexical_hesitation))
+        hesitation_ratio = sum(1 for p in pauses if p >= 0.8) / len(pauses)
 
     else:
 
@@ -906,13 +532,11 @@ def prosody_domain(
 
         pause_freq = (punctuation_pauses / max(word_count, 1)) * 100
 
-        hesitation_ratio = clamp01(estimate_filler_hits(tokens, text) / max(word_count, 1))
-
+        hesitation_ratio = sum(1 for t in tokens if t in FILLERS) / max(word_count, 1)
 
 
-    speech_rate_target = pick_language_target(language_profile, english=140.0, hinglish=132.0, hindi=126.0, multilingual=133.0)
 
-    s_rate = clamp01(abs(speech_rate - speech_rate_target) / 95.0)
+    s_rate = clamp01(abs(speech_rate - 140.0) / 95.0)
 
     s_pause = scale_linear(pause_freq, low=8.0, high=30.0)
 
@@ -950,17 +574,7 @@ def prosody_domain(
 
 
 
-def syntax_domain(
-
-    tokens: list[str],
-
-    sentences: list[str],
-
-    text: str,
-
-    language_profile: dict[str, Any],
-
-) -> tuple[DomainScore, dict[str, float]]:
+def syntax_domain(tokens: list[str], sentences: list[str], text: str) -> tuple[DomainScore, dict[str, float]]:
 
     sentence_count = max(len(sentences), 1)
 
@@ -990,31 +604,15 @@ def syntax_domain(
 
 
 
-    mlu_target = pick_language_target(language_profile, english=17.0, hinglish=15.0, hindi=14.5, multilingual=15.5)
-
-    depth_low = pick_language_target(language_profile, english=2.0, hinglish=1.5, hindi=1.4, multilingual=1.6)
+    s_mlu = clamp01(abs(mlu - 17.0) / 12.0)
 
-    depth_high = pick_language_target(language_profile, english=6.5, hinglish=5.7, hindi=5.3, multilingual=5.8)
-
-
-
-    s_mlu = clamp01(abs(mlu - mlu_target) / 12.0)
-
-    s_depth = scale_linear(clause_depth, low=depth_low, high=depth_high)
+    s_depth = scale_linear(clause_depth, low=2.0, high=6.5)
 
     s_passive = scale_linear(passive_ratio, low=0.15, high=1.2)
 
 
 
-    passive_weight = pick_language_target(language_profile, english=0.20, hinglish=0.12, hindi=0.05, multilingual=0.10)
-
-    mlu_weight = 0.45 + ((0.20 - passive_weight) * 0.55)
-
-    depth_weight = 1.0 - mlu_weight - passive_weight
-
-
-
-    overall = clamp01((mlu_weight * s_mlu) + (depth_weight * s_depth) + (passive_weight * s_passive))
+    overall = clamp01((0.45 * s_mlu) + (0.35 * s_depth) + (0.20 * s_passive))
 
 
 
@@ -1044,7 +642,7 @@ def syntax_domain(
 
 
 
-def affective_domain(tokens: list[str], text: str) -> tuple[DomainScore, dict[str, float]]:
+def affective_domain(tokens: list[str]) -> tuple[DomainScore, dict[str, float]]:
 
     total = max(len(tokens), 1)
 
@@ -1054,7 +652,7 @@ def affective_domain(tokens: list[str], text: str) -> tuple[DomainScore, dict[st
 
     arousal = sum(1 for t in tokens if t in AROUSAL_WORDS)
 
-    hedge = estimate_hedge_hits(tokens, text)
+    hedge = sum(1 for t in tokens if t in HEDGE_WORDS)
 
 
 
@@ -1154,10 +752,6 @@ def compute_analysis_state(
 
     audio_duration: Optional[float],
 
-    detected_language: Optional[str] = None,
-
-    hinted_profile: Optional[dict[str, Any]] = None,
-
 ) -> AnalysisState:
 
     tokens = tokenize_words(text)
@@ -1166,31 +760,21 @@ def compute_analysis_state(
 
     cwords = content_words(tokens)
 
-    language_profile = detect_language_profile(
-
-        text,
-
-        hinted_language=detected_language,
-
-        hinted_profile=hinted_profile,
-
-    )
-
 
 
     repeat_ratio = 1.0 - (len(set(tokens)) / max(len(tokens), 1))
 
 
 
-    lexical, lexical_raw = lexical_domain(tokens, text, cwords, language_profile)
+    lexical, lexical_raw = lexical_domain(tokens, cwords)
 
     semantic, semantic_raw = semantic_domain(sentences)
 
-    prosody, prosody_raw, has_audio = prosody_domain(tokens, text, pause_map, audio_duration, language_profile)
+    prosody, prosody_raw, has_audio = prosody_domain(tokens, text, pause_map, audio_duration)
 
-    syntax, syntax_raw = syntax_domain(tokens, sentences, text, language_profile)
+    syntax, syntax_raw = syntax_domain(tokens, sentences, text)
 
-    affective, affective_raw = affective_domain(tokens, text)
+    affective, affective_raw = affective_domain(tokens)
 
     confidence, quality_notes = compute_confidence(
 
@@ -1204,18 +788,6 @@ def compute_analysis_state(
 
     )
 
-    quality_notes.append(
-
-        "Detected language mode: "
-
-        + str(language_profile.get("label", "multilingual")).title()
-
-        + f" (Hindi {round(float(language_profile.get('hindi_ratio', 0.0)) * 100)}%, "
-
-        + f"English {round(float(language_profile.get('english_ratio', 0.0)) * 100)}%)."
-
-    )
-
 
 
     scores = {
@@ -1264,8 +836,6 @@ def compute_analysis_state(
 
         "repeat_ratio": round(repeat_ratio, 4),
 
-        "language_profile": language_profile,
-
         "lexical": lexical_raw,
 
         "semantic": semantic_raw,
@@ -1290,8 +860,6 @@ def compute_analysis_state(
 
         quality_notes=quality_notes,
 
-        language_profile=language_profile,
-
         metrics=metrics,
 
     )
@@ -1348,11 +916,9 @@ def summary_fallback(state: AnalysisState, risk_level: str) -> str:
 
     confidence_pct = round(state.confidence * 100)
 
-    language_mode = str(state.language_profile.get("label", "multilingual"))
-
     return (
 
-        f"This {language_mode} speech analysis found a {risk_level} overall cognitive load signal based on linguistic and timing features. "
+        f"This analysis found a {risk_level} overall cognitive load signal based on linguistic and timing features. "
 
         f"The strongest deviation appeared in {top_domain} markers (score {top_value:.2f}). "
 
@@ -1638,8 +1204,6 @@ async def compose_safe_summary(state: AnalysisState, risk_level: str) -> tuple[s
 
         "confidence": state.confidence,
 
-        "language_profile": state.language_profile,
-
         "scores": {k: v.overall for k, v in state.scores.items()},
 
         "quality_notes": state.quality_notes,
@@ -1652,8 +1216,6 @@ async def compose_safe_summary(state: AnalysisState, risk_level: str) -> tuple[s
 
         "You summarize computational language-screening outputs. "
 
-        "English, Hindi, and code-mixed Hinglish samples are all valid and should be interpreted fairly. "
-
         "Never diagnose disease, never use alarming wording, and always state uncertainty when confidence is limited. "
 
         "Output exactly 2-3 sentences in plain text."
@@ -1716,8 +1278,6 @@ async def health() -> dict[str, Any]:
 
     available = await fetch_available_models()
 
-    transcribe_caps = transcription_model_capabilities(GROQ_TRANSCRIBE_MODEL)
-
     return {
 
         "ok": True,
@@ -1728,10 +1288,6 @@ async def health() -> dict[str, Any]:
 
         "model_count": len(available),
 
-        "transcription_model": GROQ_TRANSCRIBE_MODEL,
-
-        "transcription_capabilities": transcribe_caps,
-
     }
 
 
@@ -1744,8 +1300,6 @@ async def models_recommended() -> dict[str, Any]:
 
     available = await fetch_available_models()
 
-    transcribe_caps = transcription_model_capabilities(GROQ_TRANSCRIBE_MODEL)
-
     return {
 
         "available_models": available,
@@ -1756,12 +1310,10 @@ async def models_recommended() -> dict[str, Any]:
 
             "safety": pick_model(available, OVERRIDE_SAFETY_MODEL, PREFERRED_SAFETY_MODELS),
 
-            "transcription": GROQ_TRANSCRIBE_MODEL,
+            "transcription": "whisper-large-v3-turbo",
 
         },
 
-        "transcription_capabilities": transcribe_caps,
-
         "notes": {
 
             "production_primary": "openai/gpt-oss-120b",
@@ -1770,12 +1322,6 @@ async def models_recommended() -> dict[str, Any]:
 
             "fast_fallback": "openai/gpt-oss-20b",
 
-            "transcription_accuracy_primary": "whisper-large-v3",
-
-            "transcription_speed_price_primary": "whisper-large-v3-turbo",
-
-            "transcription_language_note": "Both Whisper models are multilingual and suitable for Hindi/Hinglish speech.",
-
         },
 
     }
@@ -1802,19 +1348,7 @@ async def analyze(req: AnalyzeRequest):
 
         try:
 
-            state = compute_analysis_state(
-
-                text,
-
-                req.pause_map,
-
-                req.audio_duration,
-
-                detected_language=req.detected_language,
-
-                hinted_profile=req.language_profile,
-
-            )
+            state = compute_analysis_state(text, req.pause_map, req.audio_duration)
 
             yield safe_step_event("STT preprocessor", "done", "Input normalized and validated")
 
@@ -1906,8 +1440,6 @@ async def analyze(req: AnalyzeRequest):
 
                 },
 
-                "language_profile": state.language_profile,
-
                 "model_info": model_meta,
 
             }