Delete providers

providers/chroma_provider.py

@@ -1,125 +0,0 @@
-import os
-from langchain_chroma import Chroma
-from langchain_ollama import OllamaEmbeddings
-from langchain_community.retrievers import BM25Retriever
-from langchain_classic.retrievers import EnsembleRetriever
-
-class ChromaVectorStore:
-    """
-    Concrete implementation of the VectorStore protocol using ChromaDB.
-    Handles semantic embedding generation and hybrid retrieval (BM25 + MMR)
-    for pulling clinical context during background analysis.
-    """
-    def __init__(self, host: str, embedding_model: str, persist_dir: str, collection_name: str):
-        self.embeddings = OllamaEmbeddings(
-            model=embedding_model,
-            base_url=host,
-        )
-
-        self.vectorstore = Chroma(
-            collection_name=collection_name,
-            embedding_function=self.embeddings,
-            persist_directory=persist_dir,
-        )
-        count = self.vectorstore._collection.count()
-        if count == 0:
-            print(
-                "[RAG WARNING] ChromaDB collection is empty. "
-                "Run `python build_vectorDB.py` to populate it before starting a session."
-            )
-            self.ensemble_retriever = None
-        else:
-            print("[RAG] Building BM25 index for Hybrid Retrieval...")
-            import pickle
-            bm25_cache_path = os.path.join(persist_dir, "bm25_index.pkl")
-            
-            bm25_retriever = None
-            if os.path.exists(bm25_cache_path):
-                print("[RAG] Loading BM25 index from local cache...")
-                try:
-                    with open(bm25_cache_path, "rb") as f:
-                        bm25_retriever = pickle.load(f)
-                except Exception as e:
-                    print(f"[RAG] Failed to load BM25 cache: {e}. Rebuilding...")
-                    bm25_retriever = None
-
-            if bm25_retriever is None:
-                print("[RAG] Building BM25 index from ChromaDB (this may take a moment for large databases)...")
-                # Extract all stored documents in batches to avoid SQLite 'too many SQL variables' error
-                documents = []
-                batch_size = 5000
-                offset = 0
-                while True:
-                    batch = self.vectorstore.get(limit=batch_size, offset=offset)
-                    batch_docs = batch.get("documents", [])
-                    if not batch_docs:
-                        break
-                    documents.extend(batch_docs)
-                    offset += batch_size
-                
-                if documents:
-                    bm25_retriever = BM25Retriever.from_texts(documents)
-                    bm25_retriever.k = min(8, len(documents))
-                    
-                    # Save to cache for future restarts
-                    try:
-                        with open(bm25_cache_path, "wb") as f:
-                            pickle.dump(bm25_retriever, f)
-                        print("[RAG] BM25 index cached successfully.")
-                    except Exception as e:
-                        print(f"[RAG WARNING] Failed to cache BM25 index: {e}")
-            
-            if bm25_retriever:
-                # 2. Semantic Retriever (Chroma MMR)
-                mmr_retriever = self.vectorstore.as_retriever(
-                    search_type="mmr",
-                    search_kwargs={
-                        "k": bm25_retriever.k,
-                        "fetch_k": max(20, bm25_retriever.k * 3),
-                        "lambda_mult": 0.7
-                    }
-                )
-                
-                # 3. Hybrid Ensemble (50% Lexical, 50% Semantic)
-                self.ensemble_retriever = EnsembleRetriever(
-                    retrievers=[bm25_retriever, mmr_retriever],
-                    weights=[0.5, 0.5]
-                )
-            else:
-                self.ensemble_retriever = None
-
-    def retrieve(self, query: str, k: int = 8) -> str:
-        if not query or not query.strip():
-            return ""
-
-        try:
-            if self.ensemble_retriever:
-                results = self.ensemble_retriever.invoke(query)
-                # EnsembleRetriever returns a list of Document objects
-                # We limit the final combined output to the top k matches
-                return "\n\n".join([doc.page_content for doc in results[:k]])
-            
-            # Fallback if ensemble isn't ready (e.g. empty DB)
-            count = self.vectorstore._collection.count()
-            if count == 0:
-                return ""
-            
-            actual_fetch_k = min(30, count)
-            actual_k = min(k, actual_fetch_k)
-
-            results = self.vectorstore.max_marginal_relevance_search(
-                query,
-                k=actual_k,
-                fetch_k=actual_fetch_k,
-                lambda_mult=0.7,
-            )
-            return "\n\n".join([doc.page_content for doc in results])
-
-        except Exception as e:
-            print(f"[RAG ERROR] Hybrid search failed: {e}. Attempting similarity fallback.")
-            try:
-                results = self.vectorstore.similarity_search(query, k=k)
-                return "\n\n".join([doc.page_content for doc in results])
-            except Exception as e2:
-                print(f"[RAG ERROR] Similarity fallback also failed: {e2}")
-                return ""

providers/llms/fallback_llm_provider.py

@@ -1,128 +0,0 @@
-from core.ports import LLM1Output, LLM2Output, LLM3Output
-
-
-def _is_rate_limit(exc: Exception) -> bool:
-    """Return True if the exception looks like a quota / rate-limit error."""
-    msg = str(exc).lower()
-    return any(k in msg for k in (
-        "429", "rate limit", "ratelimit", "too many requests",
-        "quota", "exceeded", "tokens exhausted", "credits"
-    ))
-
-
-class FallbackLLMProvider:
-    """
-    Composite LLM Provider that loops through a list of other providers.
-    If a provider throws an exception (e.g. rate limit / 429), it tries the next.
-
-    For LLM1 and LLM2 calls:
-      - If all providers fail with a rate-limit/quota error, the exception is
-        re-raised so the route can return HTTP 429 and the frontend shows a popup.
-      - If all providers fail for any other reason, a safe fallback string is returned.
-
-    For non-conversational calls (query, LLM3, summarize), the fallback string is
-    always returned to avoid breaking secondary features.
-    """
-    def __init__(self, providers: list):
-        self.providers = providers
-
-    def generate_opening_context(self, profile_recap: str | None) -> list:
-        return self.providers[0].generate_opening_context(profile_recap)
-
-    def psychiatrist_response(
-        self, context: list, patient_info: dict = None, medium_term_memory: str | None = None
-    ) -> LLM1Output:
-        last_error = None
-        for provider in self.providers:
-            try:
-                return provider.psychiatrist_response(context, patient_info, medium_term_memory)
-            except Exception as e:
-                last_error = e
-                print(f"[FallbackRouter] Provider {type(provider).__name__} failed for LLM1: {e}")
-                continue
-
-        # Surface rate-limit errors so the frontend can show a popup
-        if last_error and _is_rate_limit(last_error):
-            print("[FallbackRouter] Rate limit detected — re-raising for LLM1.")
-            raise RuntimeError(f"Tokens Exhausted: {last_error}") from last_error
-
-        print("[FallbackRouter] ALL providers failed for LLM1!")
-        return LLM1Output(
-            assistant_message="I'm here, and I'm listening. Please take your time. && Would you like to tell me more about what's on your mind?",
-            intent="CONTINUE",
-            risk_flag=False,
-            clinical_summary=None
-        )
-
-    def internal_reasoning(
-        self, context: list, stable_prefix: str | None = None
-    ) -> LLM2Output:
-        last_error = None
-        for provider in self.providers:
-            try:
-                return provider.internal_reasoning(context, stable_prefix)
-            except Exception as e:
-                last_error = e
-                print(f"[FallbackRouter] Provider {type(provider).__name__} failed for LLM2: {e}")
-                continue
-
-        # Surface rate-limit errors so the orchestrator can propagate them
-        if last_error and _is_rate_limit(last_error):
-            print("[FallbackRouter] Rate limit detected — re-raising for LLM2.")
-            raise RuntimeError(f"Tokens Exhausted: {last_error}") from last_error
-
-        print("[FallbackRouter] ALL providers failed for LLM2!")
-        return LLM2Output(
-            assistant_message="I'm here, taking everything in. Please go on.",
-            emotional_themes=[],
-            thinking_patterns=[],
-            behavioral_patterns=[],
-            interpersonal_dynamics=[],
-            stressors=[],
-            unclear_areas=[],
-            risk_assessment="Unable to complete risk assessment due to analysis error.",
-            protective_factors=[]
-        )
-
-    def psychiatrist_query_response(self, context: list, retrieved_context: str) -> str:
-        for provider in self.providers:
-            try:
-                return provider.psychiatrist_query_response(context, retrieved_context)
-            except Exception as e:
-                print(f"[FallbackRouter] Provider {type(provider).__name__} failed for Query: {e}")
-                continue
-
-        return "I hear you, and we will find a way through this together. Let's keep exploring what might help."
-
-    def generate_end_of_session_profile(
-        self, old_profile: dict, session_history: list, patient_info: dict = None
-    ) -> LLM3Output:
-        for provider in self.providers:
-            try:
-                return provider.generate_end_of_session_profile(old_profile, session_history, patient_info)
-            except Exception as e:
-                print(f"[FallbackRouter] Provider {type(provider).__name__} failed for LLM3: {e}")
-                continue
-
-        return LLM3Output(
-            session_summary="Error generating session summary.",
-            update_profile=False,
-            emotional_themes=[],
-            thinking_patterns=[],
-            behavioral_patterns=[],
-            interpersonal_dynamics=[],
-            stressors=[],
-            unclear_areas=[],
-            risk_assessment="Error.",
-            protective_factors=[]
-        )
-
-    def summarize_history(self, turns: list) -> str:
-        for provider in self.providers:
-            try:
-                return provider.summarize_history(turns)
-            except Exception as e:
-                print(f"[FallbackRouter] Provider {type(provider).__name__} failed for Summarize: {e}")
-                continue
-
-        return "[Summary unavailable]"

providers/llms/groq_llm_provider.py

@@ -1,283 +0,0 @@
-import os
-import json
-from groq import Groq
-from core.ports import LLM1Output, LLM2Output, LLM3Output
-from core.prompts import LLM1_SYSTEM_PROMPT, LLM2_SYSTEM_PROMPT, LLM3_SYSTEM_PROMPT
-
-# ---------------------------------------------------------------------------
-# Groq prompt-caching helpers
-#
-# Groq (beta) caches any prefix up to the LAST message that contains a
-# cache_control marker. Multiple markers create cascading cache levels.
-#
-# Cache levels we exploit:
-#   Level 1 (all calls): system prompt — constant across all patients/sessions
-#   Level 2 (LLM1+LLM2): demographics + medium-term memory — constant within
-#     a session; only changes when LLM2 fires and updates long_term_memory
-#   Level 3 (dynamic): conversation history + RAG context — changes every turn
-# ---------------------------------------------------------------------------
-
-def _cached_msg(role: str, content: str) -> dict:
-    """Message with Groq beta cache_control breakpoint."""
-    return {
-        "role": role,
-        "content": [
-            {
-                "type": "text",
-                "text": content,
-                "cache_control": {"type": "ephemeral"},
-            }
-        ],
-    }
-
-
-def _msg(role: str, content: str) -> dict:
-    """Plain message (no cache marker)."""
-    return {"role": role, "content": content}
-
-
-class GroqLLMProvider:
-    """
-    Concrete implementation of the LLMProvider protocol using the Groq API.
-
-    Prompt caching strategy (Groq beta cache_control):
-
-    LLM1 psychiatrist_response — two cache levels:
-      [1] system, cached  LLM1_SYSTEM_PROMPT           (~700 tokens, never changes)
-      [2] system, cached  demographics + medium-term    (~200-400 tokens, stable per session)
-          memory (long_term_memory recap)
-      [3] dynamic         conversation history          (changes every turn)
-
-    LLM2 internal_reasoning — two cache levels:
-      [1] system, cached  LLM2_SYSTEM_PROMPT           (~600 tokens, never changes)
-      [2] user,   cached  demographics + profile_recap  (~200-400 tokens, stable between
-          (medium-term memory)                          LLM2 calls within a session)
-      [3] dynamic         history[-6:] + analysis ctx   (changes every turn)
-
-    Savings estimate vs. baseline (no caching):
-      - LLM1: ~1,000-1,100 cached tokens per turn after warm-up
-      - LLM2: ~1,200-1,400 cached tokens per ANALYZE call
-    """
-    def __init__(self, model1: str, model2: str):
-        self.model1 = model1
-        self.model2 = model2
-        self.client = Groq()
-
-    def generate_opening_context(self, profile_recap: str | None) -> list:
-        if profile_recap:
-            return [
-                {
-                    "role": "user",
-                    "content": (
-                        f"{profile_recap}\n\n"
-                        "Start the psychiatric session. Greet the patient warmly, "
-                        "briefly acknowledge continuity if it feels right, then use && "
-                        "to add an open question at the end — e.g. "
-                        "'Welcome back, it's good to see you. && How have things been for you since we last spoke?'"
-                    ),
-                }
-            ]
-        else:
-            return [
-                {
-                    "role": "user",
-                    "content": (
-                        "Start the psychiatric session. Greet the patient warmly and naturally, "
-                        "then use && to add an open question at the end — e.g. "
-                        "'Hello, I'm Dr. Aiden. I'm here to listen. && What brings you here today?'"
-                    ),
-                }
-            ]
-
-    def psychiatrist_response(
-        self,
-        context: list,
-        patient_info: dict = None,
-        medium_term_memory: str | None = None,
-    ) -> LLM1Output:
-        """
-        LLM1 fast path. Message order:
-          [1] system, CACHED  LLM1_SYSTEM_PROMPT         (constant)
-          [2] system, CACHED  demographics + MTM recap    (stable within session)
-          [3] dynamic         conversation history        (changes every turn)
-
-        `medium_term_memory` is the long_term_memory recap string built by
-        the orchestrator from profile_store. It is constant between LLM2 updates.
-        """
-        try:
-            # Level 1: constant system prompt — cached across all patients
-            messages = [_cached_msg("system", LLM1_SYSTEM_PROMPT)]
-
-            # Level 2: stable patient context — cached within a session
-            stable_parts = []
-            if patient_info:
-                stable_parts.append(
-                    f"PATIENT DEMOGRAPHICS:\n"
-                    f"- Name: {patient_info.get('name', 'Unknown')}\n"
-                    f"- Age: {patient_info.get('age', 'Unknown')}\n"
-                    f"- Gender: {patient_info.get('gender', 'Unknown')}\n"
-                    f"- Nationality: {patient_info.get('nationality', 'Unknown')}\n"
-                    f"- Primary Concern: {patient_info.get('primary_concern', 'Unknown')}"
-                )
-            if medium_term_memory:
-                stable_parts.append(
-                    f"PATIENT MEDIUM-TERM MEMORY (prior sessions & patterns — do not quote verbatim):\n"
-                    f"{medium_term_memory}"
-                )
-            if stable_parts:
-                messages.append(_cached_msg("system", "\n\n".join(stable_parts)))
-
-            # Level 3: dynamic conversation history
-            for m in context:
-                messages.append(_msg(m["role"], m["content"]))
-
-            response = self.client.chat.completions.create(
-                model=self.model1,
-                messages=messages,
-                response_format={"type": "json_object"},
-                temperature=0.6,
-                max_completion_tokens=1024,
-            )
-            raw = response.choices[0].message.content
-            return LLM1Output.model_validate_json(raw)
-        except Exception as e:
-            print(f"[Groq LLM1 ERROR] {e}")
-            raise e
-
-    def internal_reasoning(
-        self,
-        context: list,
-        stable_prefix: str | None = None,
-    ) -> LLM2Output:
-        """
-        LLM2 analysis path. Message order:
-          [1] system, CACHED  LLM2_SYSTEM_PROMPT         (constant)
-          [2] user,   CACHED  stable_prefix              (demographics + profile_recap,
-                                                          stable between LLM2 calls)
-          [3] dynamic         history[-6:] + analysis ctx (changes every ANALYZE trigger)
-
-        `stable_prefix` is built by the orchestrator and contains demographics +
-        medium-term memory (profile_recap). It is constant for the lifetime of a
-        session between LLM2 updates — giving a solid cache hit on the 70b model.
-        """
-        try:
-            # Level 1: constant system prompt
-            messages = [_cached_msg("system", LLM2_SYSTEM_PROMPT)]
-
-            # Level 2: stable patient context (demographics + profile recap)
-            if stable_prefix:
-                messages.append(_cached_msg("user", stable_prefix))
-
-            # Level 3: dynamic history + analysis context
-            for m in context:
-                messages.append(_msg(m["role"], m["content"]))
-
-            response = self.client.chat.completions.create(
-                model=self.model2,
-                messages=messages,
-                response_format={"type": "json_object"},
-                temperature=0.1,
-                max_completion_tokens=1024,
-            )
-            raw = response.choices[0].message.content
-            return LLM2Output.model_validate_json(raw)
-        except Exception as e:
-            print(f"[Groq LLM2 ERROR] {e}")
-            raise e
-
-    def psychiatrist_query_response(self, context: list, retrieved_context: str) -> str:
-        try:
-            sys_prompt = (
-                "You are a compassionate AI psychiatrist. The patient has asked for advice. "
-                "Synthesize a thoughtful response using the following clinical guidelines:\n\n"
-                f"{retrieved_context}\n\n"
-                "Keep your response empathetic, natural, and under 4 sentences. Do not use markdown."
-            )
-            messages = [_msg("system", sys_prompt)]
-            for m in context:
-                messages.append(_msg(m["role"], m["content"]))
-
-            response = self.client.chat.completions.create(
-                model=self.model1,
-                messages=messages,
-                temperature=0.5,
-                max_completion_tokens=512,
-            )
-            return response.choices[0].message.content.strip()
-        except Exception as e:
-            print(f"[Groq QUERY ERROR] {e}")
-            raise e
-
-    def generate_end_of_session_profile(
-        self, old_profile: dict, session_history: list, patient_info: dict = None
-    ) -> LLM3Output:
-        try:
-            # Level 1: constant system prompt — cached across all patients
-            messages = [_cached_msg("system", LLM3_SYSTEM_PROMPT)]
-
-            # Level 2: patient demographics — small, per-patient, no cache needed
-            if patient_info:
-                demographics = (
-                    f"PATIENT DEMOGRAPHICS:\n"
-                    f"- Name: {patient_info.get('name', 'Unknown')}\n"
-                    f"- Age: {patient_info.get('age', 'Unknown')}\n"
-                    f"- Gender: {patient_info.get('gender', 'Unknown')}\n"
-                    f"- Nationality: {patient_info.get('nationality', 'Unknown')}\n"
-                    f"- Primary Concern: {patient_info.get('primary_concern', 'Unknown')}"
-                )
-                messages.append(_msg("system", demographics))
-
-            # Level 3: dynamic content — old profile + session transcript
-            formatted_history = "\n".join(
-                f"{t['role'].upper()}: {t['content']}" for t in session_history
-            )
-            user_prompt = (
-                f"EXISTING PROFILE:\n{old_profile}\n\n"
-                f"RECENT SESSION TRANSCRIPT:\n{formatted_history}\n\n"
-                "Please generate the 100-200 word session_summary and the merged, deduplicated clinical profile."
-            )
-            messages.append(_msg("user", user_prompt))
-
-            response = self.client.chat.completions.create(
-                model=self.model1,
-                messages=messages,
-                response_format={"type": "json_object"},
-                temperature=0.2,
-                max_completion_tokens=1500,
-            )
-            raw = response.choices[0].message.content
-            return LLM3Output.model_validate_json(raw)
-        except Exception as e:
-            print(f"[Groq LLM3 ERROR] {e}")
-            raise e
-
-
-    def summarize_history(self, turns: list) -> str:
-        if not turns:
-            return ""
-        try:
-            formatted = "\n".join(
-                f"{t['role'].upper()}: {t['content']}" for t in turns
-            )
-            messages = [
-                {
-                    "role": "system",
-                    "content": (
-                        "You are a clinical note-taker. Summarize the following "
-                        "patient-psychiatrist conversation excerpt in 3-5 sentences, "
-                        "third-person clinical register. Capture key symptoms, "
-                        "themes, and any safety concerns. Be concise."
-                    ),
-                },
-                {"role": "user", "content": formatted},
-            ]
-            response = self.client.chat.completions.create(
-                model=self.model1,
-                messages=messages,
-                temperature=0.3,
-                max_completion_tokens=300,
-            )
-            return response.choices[0].message.content.strip()
-        except Exception as e:
-            print(f"[Groq SUMMARIZE ERROR] {e}")
-            raise e

providers/llms/huggingface_llm_provider.py

@@ -1,260 +0,0 @@
-import os
-import json
-from huggingface_hub import InferenceClient
-from core.ports import LLM1Output, LLM2Output, LLM3Output
-from core.prompts import LLM1_SYSTEM_PROMPT, LLM2_SYSTEM_PROMPT, LLM3_SYSTEM_PROMPT
-
-
-def _msg(role: str, content: str) -> dict:
-    return {"role": role, "content": content}
-
-
-class HuggingFaceLLMProvider:
-    """
-    Concrete implementation of the LLMProvider protocol using the HuggingFace
-    Serverless Inference API (api-inference.huggingface.co).
-
-    Requires HF_TOKEN set as a Space Secret. Models used:
-      LLM1 / LLM3 : meta-llama/Llama-3.1-8B-Instruct  (fast, free tier)
-      LLM2         : meta-llama/Llama-3.3-70B-Instruct (deep analysis)
-
-    NOTE: HF Inference API does NOT support prompt caching, so the
-    stable_prefix and medium_term_memory params are merged into regular
-    system messages instead.
-    """
-
-    def __init__(self, model1: str, model2: str):
-        token = os.environ.get("HF_TOKEN")
-        if not token:
-            raise RuntimeError(
-                "HF_TOKEN is not set. Add it as a Space Secret on HuggingFace."
-            )
-        self.model1 = model1
-        self.model2 = model2
-        # Single client — the model is passed per-call so one client is enough
-        self.client = InferenceClient(api_key=token)
-
-    # ------------------------------------------------------------------
-    # Internal helpers
-    # ------------------------------------------------------------------
-    def _build_stable_system(
-        self, patient_info: dict | None, medium_term_memory: str | None
-    ) -> str | None:
-        """Build the demographics + MTM system block (replaces Groq's cache_control)."""
-        parts = []
-        if patient_info:
-            parts.append(
-                f"PATIENT DEMOGRAPHICS:\n"
-                f"- Name: {patient_info.get('name', 'Unknown')}\n"
-                f"- Age: {patient_info.get('age', 'Unknown')}\n"
-                f"- Gender: {patient_info.get('gender', 'Unknown')}\n"
-                f"- Nationality: {patient_info.get('nationality', 'Unknown')}\n"
-                f"- Primary Concern: {patient_info.get('primary_concern', 'Unknown')}"
-            )
-        if medium_term_memory:
-            parts.append(
-                f"PATIENT MEDIUM-TERM MEMORY (prior sessions & patterns — do not quote verbatim):\n"
-                f"{medium_term_memory}"
-            )
-        return "\n\n".join(parts) if parts else None
-
-    def _call(self, model: str, messages: list, temperature: float, max_tokens: int) -> str:
-        response = self.client.chat.completions.create(
-            model=model,
-            messages=messages,
-            response_format={"type": "json_object"},
-            temperature=temperature,
-            max_tokens=max_tokens,
-        )
-        return response.choices[0].message.content
-
-    # ------------------------------------------------------------------
-    # Schema repair helpers — HF models sometimes omit fields from the
-    # JSON schema. We inject sensible defaults before Pydantic validates.
-    # ------------------------------------------------------------------
-    @staticmethod
-    def _parse_llm1(raw: str) -> LLM1Output:
-        d = json.loads(raw)
-        d.setdefault("intent", "CONTINUE")
-        d.setdefault("risk_flag", False)
-        d.setdefault("clinical_summary", None)
-        d.setdefault("search_query", None)
-        return LLM1Output.model_validate(d)
-
-    @staticmethod
-    def _parse_llm2(raw: str) -> LLM2Output:
-        d = json.loads(raw)
-        d.setdefault("assistant_message", "I'm here with you. Please continue.")
-        d.setdefault("emotional_themes", [])
-        d.setdefault("thinking_patterns", [])
-        d.setdefault("behavioral_patterns", [])
-        d.setdefault("interpersonal_dynamics", [])
-        d.setdefault("stressors", [])
-        d.setdefault("unclear_areas", [])
-        d.setdefault("risk_assessment", "No immediate risk identified.")
-        d.setdefault("protective_factors", [])
-        return LLM2Output.model_validate(d)
-
-    @staticmethod
-    def _parse_llm3(raw: str) -> LLM3Output:
-        d = json.loads(raw)
-        d.setdefault("session_summary", "Session completed.")
-        d.setdefault("update_profile", True)
-        d.setdefault("emotional_themes", [])
-        d.setdefault("thinking_patterns", [])
-        d.setdefault("behavioral_patterns", [])
-        d.setdefault("interpersonal_dynamics", [])
-        d.setdefault("stressors", [])
-        d.setdefault("unclear_areas", [])
-        d.setdefault("risk_assessment", "No immediate risk identified.")
-        d.setdefault("protective_factors", [])
-        d.setdefault("updated_primary_concern", None)
-        return LLM3Output.model_validate(d)
-
-    def generate_opening_context(self, profile_recap: str | None) -> list:
-        if profile_recap:
-            return [
-                {
-                    "role": "user",
-                    "content": (
-                        f"{profile_recap}\n\n"
-                        "Start the psychiatric session. Greet the patient warmly, "
-                        "briefly acknowledge continuity if it feels right, then use && "
-                        "to add an open question at the end — e.g. "
-                        "'Welcome back, it's good to see you. && How have things been for you since we last spoke?'"
-                    ),
-                }
-            ]
-        else:
-            return [
-                {
-                    "role": "user",
-                    "content": (
-                        "Start the psychiatric session. Greet the patient warmly and naturally, "
-                        "then use && to add an open question at the end — e.g. "
-                        "'Hello, I'm Dr. Aiden. I'm here to listen. && What brings you here today?'"
-                    ),
-                }
-            ]
-
-    def psychiatrist_response(
-        self,
-        context: list,
-        patient_info: dict = None,
-        medium_term_memory: str | None = None,
-    ) -> LLM1Output:
-        try:
-            messages = [_msg("system", LLM1_SYSTEM_PROMPT)]
-            stable = self._build_stable_system(patient_info, medium_term_memory)
-            if stable:
-                messages.append(_msg("system", stable))
-            for m in context:
-                messages.append(_msg(m["role"], m["content"]))
-
-            raw = self._call(self.model1, messages, temperature=0.6, max_tokens=1024)
-            return self._parse_llm1(raw)
-        except Exception as e:
-            print(f"[HF LLM1 ERROR] {e}")
-            raise e
-
-    def internal_reasoning(
-        self,
-        context: list,
-        stable_prefix: str | None = None,
-    ) -> LLM2Output:
-        try:
-            messages = [_msg("system", LLM2_SYSTEM_PROMPT)]
-            # stable_prefix = demographics + profile recap (built by orchestrator)
-            if stable_prefix:
-                messages.append(_msg("user", stable_prefix))
-            for m in context:
-                messages.append(_msg(m["role"], m["content"]))
-
-            raw = self._call(self.model2, messages, temperature=0.1, max_tokens=1024)
-            return self._parse_llm2(raw)
-        except Exception as e:
-            print(f"[HF LLM2 ERROR] {e}")
-            raise e
-
-    def psychiatrist_query_response(self, context: list, retrieved_context: str) -> str:
-        try:
-            sys_prompt = (
-                "You are a compassionate AI psychiatrist. The patient has asked for advice. "
-                "Synthesize a thoughtful response using the following clinical guidelines:\n\n"
-                f"{retrieved_context}\n\n"
-                "Keep your response empathetic, natural, and under 4 sentences. Do not use markdown."
-            )
-            messages = [_msg("system", sys_prompt)]
-            for m in context:
-                messages.append(_msg(m["role"], m["content"]))
-
-            response = self.client.chat.completions.create(
-                model=self.model1,
-                messages=messages,
-                temperature=0.5,
-                max_tokens=512,
-            )
-            return response.choices[0].message.content.strip()
-        except Exception as e:
-            print(f"[HF QUERY ERROR] {e}")
-            raise e
-
-    def generate_end_of_session_profile(
-        self, old_profile: dict, session_history: list, patient_info: dict = None
-    ) -> LLM3Output:
-        try:
-            messages = [_msg("system", LLM3_SYSTEM_PROMPT)]
-            if patient_info:
-                demographics = (
-                    f"PATIENT DEMOGRAPHICS:\n"
-                    f"- Name: {patient_info.get('name', 'Unknown')}\n"
-                    f"- Age: {patient_info.get('age', 'Unknown')}\n"
-                    f"- Gender: {patient_info.get('gender', 'Unknown')}\n"
-                    f"- Nationality: {patient_info.get('nationality', 'Unknown')}\n"
-                    f"- Primary Concern: {patient_info.get('primary_concern', 'Unknown')}"
-                )
-                messages.append(_msg("system", demographics))
-
-            formatted_history = "\n".join(
-                f"{t['role'].upper()}: {t['content']}" for t in session_history
-            )
-            user_prompt = (
-                f"EXISTING PROFILE:\n{old_profile}\n\n"
-                f"RECENT SESSION TRANSCRIPT:\n{formatted_history}\n\n"
-                "Please generate the 100-200 word session_summary and the merged, deduplicated clinical profile."
-            )
-            messages.append(_msg("user", user_prompt))
-
-            raw = self._call(self.model1, messages, temperature=0.2, max_tokens=1500)
-            return self._parse_llm3(raw)
-        except Exception as e:
-            print(f"[HF LLM3 ERROR] {e}")
-            raise e
-
-    def summarize_history(self, turns: list) -> str:
-        if not turns:
-            return ""
-        try:
-            formatted = "\n".join(
-                f"{t['role'].upper()}: {t['content']}" for t in turns
-            )
-            messages = [
-                _msg(
-                    "system",
-                    "You are a clinical note-taker. Summarize the following "
-                    "patient-psychiatrist conversation excerpt in 3-5 sentences, "
-                    "third-person clinical register. Capture key symptoms, "
-                    "themes, and any safety concerns. Be concise.",
-                ),
-                _msg("user", formatted),
-            ]
-            response = self.client.chat.completions.create(
-                model=self.model1,
-                messages=messages,
-                temperature=0.3,
-                max_tokens=300,
-            )
-            return response.choices[0].message.content.strip()
-        except Exception as e:
-            print(f"[HF SUMMARIZE ERROR] {e}")
-            raise e

providers/llms/ollama_llm_provider.py

@@ -1,224 +0,0 @@
-import os
-import threading
-import ollama
-from core.ports import LLM1Output, LLM2Output, LLM3Output
-from core.prompts import LLM1_SYSTEM_PROMPT, LLM2_SYSTEM_PROMPT, LLM3_SYSTEM_PROMPT
-
-class OllamaLLMProvider:
-    """
-    Concrete implementation of the LLMProvider protocol using local Ollama models.
-    Provides the engine for both the fast conversational responses (LLM1) 
-    and the deep background pattern analysis (LLM2).
-    """
-    def __init__(self, host: str, model1: str, model2: str):
-        self.host = host
-        self.model1 = model1
-        self.model2 = model2
-        # Global lock to queue requests and prevent CUDA out-of-memory errors
-        self._llm_lock = threading.Lock()
-        
-    def _client(self):
-        return ollama.Client(host=self.host)
-        
-    def generate_opening_context(self, profile_recap: str | None) -> list:
-        if profile_recap:
-            return [
-                {
-                    "role": "user",
-                    "content": (
-                        f"{profile_recap}\n\n"
-                        "Start the psychiatric session. Greet the patient warmly, "
-                        "briefly acknowledge continuity if it feels right, then use && "
-                        "to add an open question at the end — e.g. "
-                        "'Welcome back, it's good to see you. && How have things been for you since we last spoke?'"
-                    ),
-                }
-            ]
-        else:
-            return [
-                {
-                    "role": "user",
-                    "content": (
-                        "Start the psychiatric session. Greet the patient warmly and naturally, "
-                        "then use && to add an open question at the end — e.g. "
-                        "'Hello, I'm Dr. Aiden. I'm here to listen. && What brings you here today?'"
-                    ),
-                }
-            ]
-        
-    def psychiatrist_response(self, context: list, patient_info: dict = None, medium_term_memory: str | None = None) -> LLM1Output:
-        try:
-            sys_prompt = LLM1_SYSTEM_PROMPT
-            stable_parts = []
-            if patient_info:
-                stable_parts.append(
-                    f"PATIENT DEMOGRAPHICS:\n"
-                    f"- Name: {patient_info.get('name', 'Unknown')}\n"
-                    f"- Age: {patient_info.get('age', 'Unknown')}\n"
-                    f"- Gender: {patient_info.get('gender', 'Unknown')}\n"
-                    f"- Nationality: {patient_info.get('nationality', 'Unknown')}\n"
-                    f"- Primary Concern: {patient_info.get('primary_concern', 'Unknown')}"
-                )
-            if medium_term_memory:
-                stable_parts.append(
-                    f"PATIENT MEDIUM-TERM MEMORY (prior sessions & patterns — do not quote verbatim):\n"
-                    f"{medium_term_memory}"
-                )
-            if stable_parts:
-                sys_prompt = "\n\n".join(stable_parts) + "\n\n" + sys_prompt
-
-            messages = [{"role": "system", "content": sys_prompt}]
-            for m in context:
-                messages.append({"role": m["role"], "content": m["content"]})
-
-            with self._llm_lock:
-                response = self._client().chat(
-                    model=self.model1,
-                    messages=messages,
-                    format=LLM1Output.model_json_schema(),
-                    options={"temperature": 0.6, "num_predict": 1024, "num_ctx": 8192},
-                )
-            raw = response.message.content
-            return LLM1Output.model_validate_json(raw)
-        except Exception as e:
-            print(f"[LLM1 ERROR] {e}")
-            return LLM1Output(
-                assistant_message="I'm here, and I'm listening. Please take your time. && Would you like to tell me more about what's on your mind?",
-                intent="CONTINUE",
-                risk_flag=False,
-                clinical_summary=None
-            )
-
-    def internal_reasoning(self, context: list, stable_prefix: str | None = None) -> LLM2Output:
-        try:
-            messages = [{"role": "system", "content": LLM2_SYSTEM_PROMPT}]
-            # For Ollama there is no caching concept; merge stable_prefix as a user message
-            if stable_prefix:
-                messages.append({"role": "user", "content": stable_prefix})
-            for m in context:
-                messages.append({"role": m["role"], "content": m["content"]})
-
-            with self._llm_lock:
-                response = self._client().chat(
-                    model=self.model2,
-                    messages=messages,
-                    format=LLM2Output.model_json_schema(),
-                    options={"temperature": 0.1, "num_predict": 1024, "num_ctx": 8192},
-                    keep_alive=0,
-                )
-            raw = response.message.content
-            return LLM2Output.model_validate_json(raw)
-        except Exception as e:
-            print(f"[LLM2 ERROR] {e}")
-            return LLM2Output(
-                assistant_message="I'm here, taking everything in. Please go on.",
-                emotional_themes=[],
-                thinking_patterns=[],
-                behavioral_patterns=[],
-                interpersonal_dynamics=[],
-                stressors=[],
-                unclear_areas=[],
-                risk_assessment="Unable to complete risk assessment due to analysis error.",
-                protective_factors=[]
-            )
-
-    def psychiatrist_query_response(self, context: list, retrieved_context: str) -> str:
-        try:
-            sys_prompt = (
-                "You are a compassionate AI psychiatrist. The patient has asked for advice. "
-                "Synthesize a thoughtful response using the following clinical guidelines:\n\n"
-                f"{retrieved_context}\n\n"
-                "Keep your response empathetic, natural, and under 4 sentences. Do not use markdown."
-            )
-            messages = [{"role": "system", "content": sys_prompt}]
-            for m in context:
-                messages.append({"role": m["role"], "content": m["content"]})
-
-            with self._llm_lock:
-                response = self._client().chat(
-                    model=self.model1,
-                    messages=messages,
-                    options={"temperature": 0.5, "num_predict": 512, "num_ctx": 8192},
-                )
-            return response.message.content.strip()
-        except Exception as e:
-            print(f"[QUERY ERROR] {e}")
-            return "I hear you, and we will find a way through this together. Let's keep exploring what might help."
-
-    def generate_end_of_session_profile(self, old_profile: dict, session_history: list, patient_info: dict = None) -> LLM3Output:
-        try:
-            sys_prompt = LLM3_SYSTEM_PROMPT
-            if patient_info:
-                demographics = (
-                    f"PATIENT DEMOGRAPHICS:\n"
-                    f"- Name: {patient_info.get('name', 'Unknown')}\n"
-                    f"- Age: {patient_info.get('age', 'Unknown')}\n"
-                    f"- Gender: {patient_info.get('gender', 'Unknown')}\n"
-                    f"- Nationality: {patient_info.get('nationality', 'Unknown')}\n"
-                    f"- Primary Concern: {patient_info.get('primary_concern', 'Unknown')}\n\n"
-                )
-                sys_prompt = demographics + sys_prompt
-            
-            formatted_history = "\n".join(f"{t['role'].upper()}: {t['content']}" for t in session_history)
-            user_prompt = (
-                f"EXISTING PROFILE:\n{old_profile}\n\n"
-                f"RECENT SESSION TRANSCRIPT:\n{formatted_history}\n\n"
-                "Please generate the 100-200 word session_summary and the merged, deduplicated clinical profile."
-            )
-            messages = [
-                {"role": "system", "content": sys_prompt},
-                {"role": "user", "content": user_prompt}
-            ]
-
-            with self._llm_lock:
-                response = self._client().chat(
-                    model=self.model1,
-                    messages=messages,
-                    format=LLM3Output.model_json_schema(),
-                    options={"temperature": 0.2, "num_predict": 1500, "num_ctx": 8192},
-                )
-            raw = response.message.content
-            return LLM3Output.model_validate_json(raw)
-        except Exception as e:
-            print(f"[LLM3 ERROR] {e}")
-            return LLM3Output(
-                session_summary="Error generating session summary.",
-                emotional_themes=[],
-                thinking_patterns=[],
-                behavioral_patterns=[],
-                interpersonal_dynamics=[],
-                stressors=[],
-                unclear_areas=[],
-                risk_assessment="Error.",
-                protective_factors=[]
-            )
-
-    def summarize_history(self, turns: list) -> str:
-        if not turns:
-            return ""
-        try:
-            formatted = "\n".join(
-                f"{t['role'].upper()}: {t['content']}" for t in turns
-            )
-            messages = [
-                {
-                    "role": "system",
-                    "content": (
-                        "You are a clinical note-taker. Summarize the following "
-                        "patient-psychiatrist conversation excerpt in 3-5 sentences, "
-                        "third-person clinical register. Capture key symptoms, "
-                        "themes, and any safety concerns. Be concise."
-                    ),
-                },
-                {"role": "user", "content": formatted},
-            ]
-            with self._llm_lock:
-                response = self._client().chat(
-                    model=self.model1,
-                    messages=messages,
-                    options={"temperature": 0.3, "num_predict": 300, "num_ctx": 8192},
-                )
-            return response.message.content.strip()
-        except Exception as e:
-            print(f"[SUMMARIZE ERROR] {e}")
-            return "[Summary unavailable]"

providers/pinecone_provider.py

@@ -1,54 +0,0 @@
-import os
-from langchain_pinecone import PineconeVectorStore as LangchainPinecone
-from langchain_ollama import OllamaEmbeddings
-from pinecone import Pinecone
-
-class PineconeVectorStore:
-    """
-    Concrete implementation of the VectorStore protocol using Pinecone.
-    Handles semantic embedding generation and retrieval for pulling clinical context.
-    """
-    def __init__(self, host: str, embedding_model: str, index_name: str, api_key: str):
-        self.embeddings = OllamaEmbeddings(
-            model=embedding_model,
-            base_url=host,
-        )
-        
-        # Initialize the Pinecone SDK client
-        self.pc = Pinecone(api_key=api_key)
-        
-        # We assume the index already exists. 
-        # If it doesn't, this will throw an error when accessed.
-        self.index = self.pc.Index(index_name)
-
-        self.vectorstore = LangchainPinecone(
-            index=self.index,
-            embedding=self.embeddings,
-            text_key="text" # The default text metadata key used by langchain
-        )
-        
-        # Note: Pinecone doesn't naturally support local BM25/hybrid search 
-        # in the exact same way as local Chroma without serverless Pinecone BM25 integrations.
-        # We will use pure semantic search (Max Marginal Relevance or Similarity).
-
-    def retrieve(self, query: str, k: int = 8) -> str:
-        if not query or not query.strip():
-            return ""
-
-        try:
-            # First try Max Marginal Relevance search for diverse results
-            results = self.vectorstore.max_marginal_relevance_search(
-                query,
-                k=k,
-                fetch_k=max(20, k * 3),
-                lambda_mult=0.7,
-            )
-            return "\n\n".join([doc.page_content for doc in results])
-        except Exception as e:
-            print(f"[RAG ERROR] MMR search failed in Pinecone: {e}. Attempting standard similarity fallback.")
-            try:
-                results = self.vectorstore.similarity_search(query, k=k)
-                return "\n\n".join([doc.page_content for doc in results])
-            except Exception as e2:
-                print(f"[RAG ERROR] Similarity fallback also failed in Pinecone: {e2}")
-                return ""

providers/safety/bert.py

@@ -1,58 +0,0 @@
-from typing import Optional
-from transformers import pipeline
-import logging
-
-from core.ports import LLM1Output, LLM2Output
-
-logger = logging.getLogger(__name__)
-
-class BertRiskSignal:
-    """
-    NLP-based risk signal using a fine-tuned BERT model.
-    Downloads and caches the model on initial run to the HF_HOME directory.
-    Checks the patient's raw message for suicidal/self-harm ideation 
-    with much higher contextual accuracy than regex keywords.
-    """
-    def __init__(self, model_name: str = "Akashpaul123/bert-suicide-detection"):
-        logger.info(f"Loading BertRiskSignal with model: {model_name}.")
-        # Use local_files_only=True to skip HuggingFace's network version-check on startup.
-        # This prevents 504 timeouts when the hub is unreachable or slow.
-        # On first run (no cache), this will fail and fall back to downloading automatically.
-        try:
-            self.classifier = pipeline(
-                "text-classification",
-                model=model_name,
-                truncation=True,
-                max_length=512,
-                local_files_only=True,
-            )
-            logger.info("BertRiskSignal loaded from local cache.")
-        except Exception:
-            logger.info("Local cache not found. Downloading BERT model from HuggingFace (first-time setup)...")
-            self.classifier = pipeline(
-                "text-classification",
-                model=model_name,
-                truncation=True,
-                max_length=512,
-            )
-            logger.info("BertRiskSignal downloaded and loaded successfully.")
-
-    def check(self, message: str, llm1_output: LLM1Output, llm2_output: Optional[LLM2Output] = None) -> bool:
-        if not message or not message.strip():
-            return False
-            
-        try:
-            result = self.classifier(message)
-            label = result[0]['label'].lower()
-            score = result[0]['score']
-            
-            logger.info(f"BERT raw output for '{message}': {label} (score: {score:.3f})")
-            
-            # Outputs 'label_1' for suicide/risk & 'label_0' for non-suicide
-            if "label_1" in label:
-                return True
-                
-            return False
-        except Exception as e:
-            logger.error(f"Error in BertRiskSignal: {e}")
-            return False

providers/safety/cascade.py

@@ -1,25 +0,0 @@
-from typing import Optional
-from core.ports import RiskSignal, LLM1Output, LLM2Output
-import logging
-
-logger = logging.getLogger(__name__)
-
-class CascadeRiskSignal:
-    """
-    Implements a Filter-Verify (Cascade) architecture for risk signals.
-    Passes the message through a high-speed, high-recall filter first. 
-    Only if the filter triggers does it pass the message to a slower, high-precision verifier.
-    """
-    def __init__(self, filter_signal: RiskSignal, verify_signal: RiskSignal):
-        self.filter_signal = filter_signal
-        self.verify_signal = verify_signal
-
-    def check(self, message: str, llm1_output: LLM1Output, llm2_output: Optional[LLM2Output] = None) -> bool:
-        # 1. FAST PASS
-        if not self.filter_signal.check(message, llm1_output, llm2_output):
-            return False
-            
-        logger.info("Fast-pass filter triggered. Verifying with secondary signal...")
-        
-        # 2. SLOW PASS (Verification)
-        return self.verify_signal.check(message, llm1_output, llm2_output)

providers/safety/clinical.py

@@ -1,17 +0,0 @@
-from typing import Optional
-from core.ports import LLM1Output, LLM2Output
-
-class ClinicalRiskSignal:
-    """
-    Risk signal that triggers based on the 'risk_assessment' output from the 
-    background LLM2 pattern analysis.
-    """
-    def check(self, message: str, llm1_output: LLM1Output, llm2_output: Optional[LLM2Output] = None) -> bool:
-        if llm2_output is None:
-            return False
-        assessment = llm2_output.risk_assessment.strip().lower()
-        if assessment.startswith("no safety concerns identified"):
-            return False
-        if assessment == "":
-            return False
-        return True

providers/safety/keyword.py

@@ -1,102 +0,0 @@
-import re
-from typing import Optional
-from core.ports import LLM1Output, LLM2Output
-
-# ---------------------------------------------------------------------------
-# Deterministic, LLM-independent risk patterns.
-# Biased toward false positives — the cost of over-triggering (showing crisis
-# resources unnecessarily) is low; the cost of missing a real signal is high.
-#
-# This list was built and tested against a real conversation log where the
-# LLM-only signal (risk_flag) missed several explicit statements across
-# consecutive turns. Keeping this signal independent of any LLM call means
-# it can't fail for the same reason the model failed.
-# ---------------------------------------------------------------------------
-_RISK_PATTERNS = [
-    # --- Direct desire to die / end one's life ---
-    r"\b(want|wanted|wanna|going to|gonna|thinking about|think about|thought about|considering|considered|planning to|plan to)\b.{0,40}\b(kill|end|take)\b.{0,20}\b(myself|my life|it all)\b",
-    r"\b(want|wanted|wanna|going to|gonna)\b.{0,15}\b(die|death)\b",   # "wanna die", "going to die"
-    r"\b(end(ing)? it all)\b",
-    r"\b(suicid(e|al)|self.harm|self-harm|selfharm)\b",
-    r"\b(don'?t want to (be here|live|exist|wake up))\b",
-    r"\b(no (reason|point|purpose) (to|in) (live|living|go on|continue))\b",
-    r"\b(better off (dead|without me|if i (were|was) gone))\b",
-    r"\b(end (my life|everything|my pain|my suffering))\b",
-    r"\b(can'?t (go on|take it|do this) anymore)\b",
-    r"\b(wish(ing)? (i was|i were|to be) dead\b)",
-    r"\b(plan(ning)? to (die|kill|hurt) (myself|my self))\b",
-
-    # --- Specific means / methods, standalone — do NOT require a lead-in verb
-    #     since people phrase these many ways ---
-    r"\b(kill(ing)?|hang(ing)?|hung)\b.{0,10}\bmyself\b",
-    r"\bjump(ing)?\s+(off|from)\b",
-    r"\b(cut(ting)?|burn(ing)?|starv(e|ing)|hitt?ing|punch(ing)?)\b.{0,10}\b(myself|my self)\b",
-    r"\bhurt(ing)?\s+(myself|my self)\b",
-    r"\boverdose|od'?ing\b",
-    r"\bswallow(ing)?\s+(all\s+)?(the\s+)?pills\b",
-
-    # --- Passive ideation / hopelessness ---
-    r"\bwhat(’|'|)s?\s+the point( of (living|anything|life))?\b",
-    r"\b(no (hope|future|reason to (stay|continue|keep going)))\b",
-    r"\b(life (is|isn'?t) worth (living|it))\b",
-    r"\b(just want (to disappear|it to end|to stop existing))\b",
-    r"\b(everyone (would be|is) better off without me)\b",
-    r"\b(giving|given|gave|give)\s+up\s+on\s+(life|everything)\b",  # any tense, requires "on life/everything" to cut false positives like "gave up my seat"
-    r"\b(too (tired|exhausted) to (go on|continue|fight))\b",
-
-    # --- Self-harm urges ---
-    r"\b(urge(s)? to (hurt|harm|cut|burn))\b",
-
-    # --- Explicit direct statements ---
-    r"\bi (don'?t|do not) (want|deserve) to (live|be alive)\b",
-    r"\b(thinking about|thought about) (dying|death|not being here|ending it)\b",
-
-    # --- Farewell / final-arrangement language — a distinct warning-sign
-    #     category in clinical suicide-risk screening (alongside direct
-    #     ideation), not just another phrasing of "I want to die" ---
-    r"\b(this is (my )?goodbye|saying goodbye|say my goodbyes)\b",
-    r"\b(won'?t|wont) be (around|here) (much longer|for long|anymore)\b",
-    r"\b(take care of|look after) (my|the) (dog|cat|kids|children|family)\b.{0,40}\b(when|after) i'?m gone\b",
-    r"\bnot (going to|gonna) be (a problem|around) (for )?much longer\b",
-    r"\bwon'?t (have to|need to) worry about me (much longer|soon|anymore)\b",
-
-    # --- Burden language — very common phrasing in real disclosures ---
-    r"\b(such a |such)?burden (to|on) (everyone|my family|everybody|people)\b",
-    r"\btired of being a burden\b",
-
-    # --- Evasive slang / obfuscated spellings, used specifically to get
-    #     past literal-word filters — worth matching for exactly that reason ---
-    r"\b(kms|kys)\b",
-    r"\bunaliv(e|ing|ed)\b",
-    r"\bsewerslide\b",                    # documented deliberate misspelling of "suicide"
-
-    # --- Planning / preparation and access to means, kept at the level of
-    #     intent-language rather than naming specific objects, so this adds
-    #     coverage without turning into a methods list ---
-    r"\b(have a plan|got a plan)\b",
-    r"\b(pills|gun|rope|knife)\s+ready\b",
-    r"\b(have|got|access to) (the means|a way) to (do it|end (it|things|my life))\b",
-]
-
-_COMPILED = [re.compile(p, re.IGNORECASE | re.DOTALL) for p in _RISK_PATTERNS]
-
-
-class KeywordRiskSignal:
-    """
-    Deterministic, regex-based risk signal. Runs independently of any LLM —
-    checks only the raw patient message text. This is intentionally the
-    fastest and most "dumb" signal in the RiskAssessmentService: it can't be
-    talked out of firing, doesn't depend on model quality or prompt
-    adherence, and doesn't require a network call.
-
-    Known limitation (accepted, not a bug): purely contextual pleas — e.g.
-    "don't you think you should stop me by helping me?" — carry no risk
-    vocabulary in isolation and won't match here. That class of statement is
-    exactly what LLMRiskSignal (which sees conversation history) is for.
-    Treat the two signals as complementary, not redundant.
-    """
-
-    def check(self, message: str, llm1_output: LLM1Output, llm2_output: Optional[LLM2Output] = None) -> bool:
-        if not message or not message.strip():
-            return False
-        return any(pattern.search(message) for pattern in _COMPILED)

providers/safety/llm.py

@@ -1,10 +0,0 @@
-from typing import Optional
-from core.ports import LLM1Output, LLM2Output
-
-class LLMRiskSignal:
-    """
-    Risk signal that triggers based on the 'risk_flag' explicitly set by LLM1 
-    during its generation of the conversational response.
-    """
-    def check(self, message: str, llm1_output: LLM1Output, llm2_output: Optional[LLM2Output] = None) -> bool:
-        return llm1_output.risk_flag

providers/speech_to_text_provider.py

@@ -1,106 +0,0 @@
-import io
-import re
-import tempfile
-from typing import Dict, Any
-
-_EMOTION_MAP = {
-    "HAPPY":     "happy",
-    "SAD":       "sad",
-    "ANGRY":     "angry",
-    "NEUTRAL":   "neutral",
-    "FEARFUL":   "fearful",
-    "DISGUSTED": "disgusted",
-    "SURPRISED": "surprised",
-}
-_KNOWN_EVENTS = {"Speech", "Laughter", "Cry", "Cough", "Sneeze", "Breath", "Noise"}
-_TAG_RE = re.compile(r"<\|([^|]+)\|>")
-
-def _parse_sensevoice_output(raw_text: str) -> tuple[str, str, str | None]:
-    tags = _TAG_RE.findall(raw_text)
-    clean = _TAG_RE.sub("", raw_text).strip()
-
-    emotion = "neutral"
-    event: str | None = None
-
-    for tag in tags:
-        upper = tag.upper()
-        if upper in _EMOTION_MAP:
-            emotion = _EMOTION_MAP[upper]
-        if tag in _KNOWN_EVENTS:
-            event = tag
-
-    return clean, emotion, event
-
-class SenseVoiceSTTProvider:
-    """
-    Concrete implementation of the STTProvider protocol using FunASR's SenseVoiceSmall model.
-    Transcribes audio into text while simultaneously extracting vocal emotional tone 
-    (e.g., happy, sad, angry) and acoustic events (e.g., laughter, crying).
-    """
-    def __init__(self):
-        self._sense_voice = None
-        self._init_stt()
-
-    def _init_stt(self):
-        try:
-            from funasr import AutoModel
-            from funasr.utils.postprocess_utils import rich_transcription_postprocess
-
-            self._sense_voice = AutoModel(
-                model="iic/SenseVoiceSmall",
-                trust_remote_code=True,
-                vad_model="fsmn-vad",
-                vad_kwargs={"max_single_segment_time": 30000},
-                device="cpu",
-                disable_update=True
-            )
-            print("[STARTUP] SenseVoice-Small loaded successfully.")
-        except Exception as e:
-            print(f"[WARNING] Failed to load SenseVoice: {e}")
-            self._sense_voice = None
-
-    def transcribe(self, audio_bytes: bytes) -> Dict[str, Any]:
-        """
-        Takes raw webm/ogg bytes, runs them through SenseVoice,
-        and returns {text, emotion, event}.
-        """
-        if not self._sense_voice:
-            print("[WARNING] STT requested but SenseVoice is not loaded.")
-            return {"text": "", "emotion": "unknown", "event": None}
-
-        # funasr expects a file path
-        with tempfile.NamedTemporaryFile(suffix=".webm", delete=False) as tf:
-            tf.write(audio_bytes)
-            tf.flush()
-            temp_path = tf.name
-
-        try:
-            res = self._sense_voice.generate(
-                input=temp_path,
-                cache={},
-                language="auto", 
-                use_itn=True,
-                batch_size_s=60,
-                merge_vad=True, 
-                merge_length_s=15,
-            )
-            if not res or len(res) == 0:
-                return {"text": "", "emotion": "neutral", "event": None}
-
-            raw_text = res[0].get("text", "")
-            clean, emotion, event = _parse_sensevoice_output(raw_text)
-
-            return {
-                "text": clean,
-                "emotion": emotion,
-                "event": event
-            }
-        except Exception as e:
-            print(f"[ERROR] SenseVoice transcription failed: {e}")
-            return {"text": "", "emotion": "unknown", "event": None}
-        finally:
-            import os
-            try:
-                os.remove(temp_path)
-            except OSError:
-                pass