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,94 +0,0 @@
-from core.ports import LLM1Output, LLM2Output, LLM3Output
-
-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.
-    Returns safe fallback strings if all providers fail.
-    """
-    def __init__(self, providers: list):
-        self.providers = providers
-
-    def generate_opening_context(self, profile_recap: str | None) -> list:
-        # This doesn't call an LLM directly, so we just use the first provider's logic
-        return self.providers[0].generate_opening_context(profile_recap)
-
-    def psychiatrist_response(self, context: list, patient_info: dict = None) -> LLM1Output:
-        for provider in self.providers:
-            try:
-                return provider.psychiatrist_response(context, patient_info)
-            except Exception as e:
-                print(f"[FallbackRouter] Provider {type(provider).__name__} failed for LLM1: {e}")
-                continue
-        
-        # All failed
-        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) -> LLM2Output:
-        for provider in self.providers:
-            try:
-                return provider.internal_reasoning(context)
-            except Exception as e:
-                print(f"[FallbackRouter] Provider {type(provider).__name__} failed for LLM2: {e}")
-                continue
-
-        # All failed
-        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,183 +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
-
-class GroqLLMProvider:
-    """
-    Concrete implementation of the LLMProvider protocol using the Groq API.
-    Provides true asynchronous concurrency (no local GPU threading lock required).
-    """
-    def __init__(self, model1: str, model2: str):
-        self.model1 = model1
-        self.model2 = model2
-        # Relies on the GROQ_API_KEY environment variable being set
-        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) -> LLM1Output:
-        try:
-            sys_prompt = LLM1_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
-                
-            messages = [{"role": "system", "content": sys_prompt}]
-            for m in context:
-                messages.append({"role": m["role"], "content": 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) -> LLM2Output:
-        try:
-            messages = [{"role": "system", "content": LLM2_SYSTEM_PROMPT}]
-            for m in context:
-                messages.append({"role": m["role"], "content": 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 = [{"role": "system", "content": sys_prompt}]
-            for m in context:
-                messages.append({"role": m["role"], "content": 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:
-            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}
-            ]
-
-            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/ollama_llm_provider.py

@@ -1,214 +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) -> LLM1Output:
-        try:
-            sys_prompt = LLM1_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
-                
-            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) -> LLM2Output:
-        try:
-            messages = [{"role": "system", "content": LLM2_SYSTEM_PROMPT}]
-            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,107 +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="./SenseVoiceSmall",
-                trust_remote_code=True,
-                remote_code="./model.py",
-                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