Delete services

services/auth_service.py

@@ -1,43 +0,0 @@
-"""
-Authentication Service
-Handles JWT token generation, validation, and password hashing.
-"""
-
-import os
-from datetime import datetime, timedelta, timezone
-from jose import JWTError, jwt
-import bcrypt
-from dotenv import load_dotenv
-
-load_dotenv()
-
-SECRET_KEY = os.environ.get("JWT_SECRET_KEY")
-if not SECRET_KEY:
-    raise ValueError("JWT_SECRET_KEY is not set in environment")
-
-ALGORITHM = os.environ.get("JWT_ALGORITHM")
-ACCESS_TOKEN_EXPIRE_MINUTES = int(os.environ.get("JWT_ACCESS_TOKEN_EXPIRE_MINUTES"))
-
-def verify_password(plain_password: str, hashed_password: str) -> bool:
-    return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8'))
-
-def get_password_hash(password: str) -> str:
-    salt = bcrypt.gensalt()
-    return bcrypt.hashpw(password.encode('utf-8'), salt).decode('utf-8')
-
-def create_access_token(data: dict, expires_delta: timedelta | None = None) -> str:
-    to_encode = data.copy()
-    if expires_delta:
-        expire = datetime.now(timezone.utc) + expires_delta
-    else:
-        expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
-    to_encode.update({"exp": expire})
-    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
-    return encoded_jwt
-
-def decode_access_token(token: str) -> dict | None:
-    try:
-        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
-        return payload
-    except JWTError:
-        return None

services/conversation_orchestrator.py

@@ -1,181 +0,0 @@
-"""
-Conversation Orchestrator Service
-Coordinates the conversation logic, manages LLM calls, and interfaces with the risk assessment service.
-"""
-
-import time
-from typing import Optional
-from core.ports import LLMProvider, VectorStore, SessionStore, ProfileStore, LLM1Output
-from core.schemas import ChatResult
-from services.risk_assessment_service import RiskAssessmentService
-from core.logger import get_logger, serinity_logger
-
-class ConversationOrchestrator:
-    """
-    Central coordinator for the application's core logic.
-    Implements a 'Sync 3-Pipeline' architecture.
-    """
-    def __init__(
-        self,
-        llm_provider: LLMProvider,
-        vector_store: VectorStore,
-        session_store: SessionStore,
-        profile_store: ProfileStore,
-        risk_service: RiskAssessmentService
-    ):
-        self.llm_provider = llm_provider
-        self.vector_store = vector_store
-        self.session_store = session_store
-        self.profile_store = profile_store
-        self.risk_service = risk_service
-
-    def _format_list(self, items: list) -> str:
-        if not items:
-            return "None identified yet"
-        return "\n  • " + "\n  • ".join(items)
-
-    def handle_message(self, session_id: str, message: str, emotion: Optional[str], default_patient_id: Optional[str]) -> ChatResult:
-        start_time = time.time()
-        
-        patient_id = self.session_store.get_patient_id(session_id) or default_patient_id
-        patient_info = self.profile_store.get_patient(patient_id) if patient_id else None
-        user_name = patient_info.get("name", "Guest Patient") if patient_info else "Guest Patient"
-        
-        session_number = self.session_store.get_session_count(patient_id) if patient_id else 1
-        log = get_logger(session_id, user_name, session_number)
-        
-        emotion = (emotion or "").lower().strip()
-        user_message = message
-        if emotion and emotion not in ("neutral", "unknown", ""):
-            user_message = f"[vocal tone: {emotion}] {user_message}"
-            
-        log.user_message(message, emotion=emotion or None)
-        
-        self.session_store.append_message(session_id, "user", user_message)
-        
-        history = self.session_store.get_working_context(session_id, llm_engine=self.llm_provider)
-        
-        try:
-            llm1_response = self.llm_provider.psychiatrist_response(history, patient_info)
-            log.llm1_decision(llm1_response)
-            
-            base_risk = self.risk_service.assess(message, llm1_response, None)
-            
-            intent = llm1_response.intent
-            if base_risk and intent != "ANALYZE":
-                intent = "ANALYZE"
-                
-            final_message = llm1_response.assistant_message
-
-            # Sync fast-path for user queries
-            if intent == "QUERY" and llm1_response.search_query:
-                retrieved_context = self.vector_store.retrieve(llm1_response.search_query, k=5)
-                log.analyze_triggered(llm1_response.search_query, "query")
-                log.retrieved_context(retrieved_context)
-                final_message = self.llm_provider.psychiatrist_query_response(history, retrieved_context)
-                
-            # Synchronous execution of LLM2 pipeline
-            if intent == "ANALYZE" and patient_id:
-                llm2_message = self._run_sync_analysis(session_id, patient_id, llm1_response.clinical_summary, llm1_response.assistant_message)
-                if llm2_message:
-                    final_message = llm2_message
-
-            self.session_store.append_message(session_id, "assistant", final_message)
-            latency_ms = int((time.time() - start_time) * 1000)
-            log.assistant_reply(final_message, risk_injected=base_risk, latency_ms=latency_ms)
-            
-            chat_result = ChatResult(
-                assistant_message=final_message,
-                intent=intent,
-                risk_flagged=base_risk,
-                job_id=None,
-                clinical_summary=llm1_response.clinical_summary
-            )
-                
-            return chat_result
-        except Exception as e:
-            log.error("handle_message_failed", e)
-            serinity_logger.error(f"Error in handle_message: {str(e)}")
-            fallback_message = "I'm having a little trouble connecting my thoughts right now. Could you repeat that?"
-            self.session_store.append_message(session_id, "assistant", fallback_message)
-            return ChatResult(
-                assistant_message=fallback_message,
-                intent="UNKNOWN",
-                risk_flagged=False,
-                job_id=None,
-                clinical_summary=None
-            )
-
-    def _run_sync_analysis(self, session_id: str, patient_id: str, clinical_summary: Optional[str] = None, llm1_draft: Optional[str] = None) -> Optional[str]:
-        """
-        Executes the heavy LLM2 pattern analysis synchronously and returns the LLM2 generated response.
-        """
-        session_number = self.session_store.get_session_count(patient_id) if patient_id else 1
-        log = get_logger(session_id, "Sync Analysis Task", session_number)
-        try:
-            history = self.session_store.get_working_context(session_id, llm_engine=self.llm_provider)
-            if clinical_summary and clinical_summary.strip():
-                retrieval_query = clinical_summary
-                query_source = "clinical_summary"
-            else:
-                retrieval_query = "\n".join(
-                    msg["content"]
-                    for msg in history[-10:]
-                    if msg.get("role") == "user"
-                )
-                query_source = "user_messages_fallback"
-            
-            log.analyze_triggered(retrieval_query, query_source)
-            retrieved_context = self.vector_store.retrieve(retrieval_query)
-            log.retrieved_context(retrieved_context)
-            
-            existing_profile_recap = self.profile_store.build_profile_recap(patient_id) or "No previous clinical profile exists for this patient."
-            
-            patient_info = self.profile_store.get_patient(patient_id) if patient_id else None
-            demographics = ""
-            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"
-                )
-            
-            context_prompt = (
-                f"{demographics}"
-                f"Existing Clinical Profile:\n{existing_profile_recap}\n\n"
-            )
-            if clinical_summary and clinical_summary.strip():
-                context_prompt += f"Current Session Clinical Summary:\n{clinical_summary}\n\n"
-                
-            context_prompt += (
-                f"Retrieved Clinical Reference (Sims' Symptoms in the Mind):\n{retrieved_context}\n\n"
-            )
-
-            if llm1_draft:
-                context_prompt += (
-                    f"Intern's Draft Response:\n{llm1_draft}\n\n"
-                )
-
-            context_prompt += (
-                "Please perform pattern analysis across all eight domains. Evaluate how the user is behaving now (based on the current session messages and summary) compared to their existing profile, and output the updated patterns. "
-                "You must also review the Intern's Draft Response, refine and amplify it using your deeper clinical insights, and provide the final polished conversational response."
-            )
-            
-            llm2_input = history[-10:] + [{
-                "role": "user",
-                "content": context_prompt
-            }]
-            llm2_response = self.llm_provider.internal_reasoning(llm2_input)
-            log.llm2_output(llm2_response)
-            
-            self.profile_store.update_long_term_memory(patient_id, llm2_response)
-            serinity_logger.info(f"Synchronous analysis completed for patient {patient_id}.")
-            return llm2_response.assistant_message
-            
-        except Exception as e:
-            log.error("sync_analysis_failed", e)
-            serinity_logger.error(f"Synchronous analysis failed: {e}")
-            return None

services/email_service.py

@@ -1,65 +0,0 @@
-import os
-import requests
-from typing import Optional
-from core.logger import serinity_logger as logger
-
-def send_otp_email(to_email: str, subject: str, otp_code: str, body_text: Optional[str] = None):
-    """
-    Sends an OTP email either via Brevo (if CLOUD_MODE=true) or to the terminal (if CLOUD_MODE=false).
-    """
-    cloud_mode = os.getenv("CLOUD_MODE", "false").lower() == "true"
-    
-    # Format the body message
-    if not body_text:
-        body_text = f"Your verification code is: {otp_code}"
-    else:
-        body_text = body_text.replace("{otp_code}", otp_code)
-
-    if not cloud_mode:
-        # Local Mode: Print to terminal
-        print(f"\n" + "="*40)
-        print(f"[LOCAL EMAIL SIMULATION]")
-        print(f"To: {to_email}")
-        print(f"Subject: {subject}")
-        print(f"Body:\n{body_text}")
-        print(f"="*40 + "\n")
-        logger.info(f"Local email simulated for {to_email} (Subject: {subject})")
-        return True
-
-    # Cloud Mode: Send via Brevo
-    brevo_api_key = os.getenv("BREVO_API_KEY")
-    if not brevo_api_key:
-        logger.error("BREVO_API_KEY is not set in environment variables.")
-        return False
-
-    url = "https://api.brevo.com/v3/smtp/email"
-    headers = {
-        "accept": "application/json",
-        "api-key": brevo_api_key,
-        "content-type": "application/json"
-    }
-    
-    payload = {
-        "sender": {
-            "name": "Serinity AI",
-            "email": os.getenv("BREVO_SENDER_EMAIL")
-        },
-        "to": [
-            {
-                "email": to_email
-            }
-        ],
-        "subject": subject,
-        "htmlContent": f"<html><body><p>{body_text}</p></body></html>"
-    }
-
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=10)
-        response.raise_for_status()
-        logger.info(f"Email sent successfully via Brevo to {to_email}")
-        return True
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Failed to send email via Brevo: {str(e)}")
-        if hasattr(e, 'response') and e.response is not None:
-            logger.error(f"Brevo API Response: {e.response.text}")
-        return False

services/patient_service.py

@@ -1,121 +0,0 @@
-"""
-Patient Service
-Manages high-level lifecycle of patient sessions including creation, summarization, and abandoned session sweeping.
-"""
-
-from typing import Optional, Tuple
-from core.ports import ProfileStore, SessionStore, LLMProvider
-from core.logger import get_logger, close_logger, serinity_logger
-
-class PatientService:
-    """
-    Service responsible for managing the high-level lifecycle of patient sessions.
-    Handles session initialization, profile recap generation, and session termination/summarization.
-    """
-    def __init__(self, profile_store: ProfileStore, session_store: SessionStore, llm_provider: LLMProvider):
-        self.profile_store = profile_store
-        self.session_store = session_store
-        self.llm_provider = llm_provider
-
-    def create_new_session(self, default_patient_id: Optional[str] = None) -> Tuple[str, str, str]:
-        session_id = self.session_store.create_session(patient_id=default_patient_id)
-        resolved_patient_id = self.session_store.get_patient_id(session_id)
-
-        recap = self.profile_store.build_profile_recap(resolved_patient_id) if resolved_patient_id else None
-        opening_context = self.llm_provider.generate_opening_context(recap)
-        llm1_response   = self.llm_provider.psychiatrist_response(opening_context)
-
-        self.session_store.append_message(session_id, "assistant", llm1_response.assistant_message)
-
-        patient_info = self.profile_store.get_patient(resolved_patient_id) if resolved_patient_id else None
-        user_name = patient_info.get("name", "Guest Patient") if patient_info else "Guest Patient"
-        session_number = self.session_store.get_session_count(resolved_patient_id) if resolved_patient_id else 1
-        log = get_logger(session_id, user_name, session_number)
-        log.session_start(resolved_patient_id)
-        log.assistant_reply(llm1_response.assistant_message, risk_injected=False)
-
-        return session_id, llm1_response.assistant_message, resolved_patient_id
-
-    def end_session(self, session_id: str, default_patient_id: Optional[str] = None) -> None:
-        """
-        Synchronously ends the session.
-        Immediate teardown logic goes here.
-        """
-        self.session_store.end_session(session_id)
-
-    def get_active_session(self, patient_id: str) -> Optional[str]:
-        """Check if the patient currently has an active session."""
-        return self.session_store.get_active_session(patient_id)
-
-    def get_session_messages(self, session_id: str) -> list[dict]:
-        """Retrieve all raw messages for a given session."""
-        return self.session_store.get_all_messages(session_id)
-    def reset_patient_data(self, patient_id: str) -> None:
-        """
-        Resets the patient's data, including sessions, messages, and profile.
-        """
-        self.profile_store.reset_patient_data(patient_id)
-
-    def delete_patient(self, patient_id: str) -> None:
-        """
-        Deletes a patient and all their associated data completely.
-        """
-        self.profile_store.delete_patient(patient_id)
-
-    def generate_session_summary(self, session_id: str, default_patient_id: Optional[str] = None) -> None:
-        """
-        Asynchronously generates and saves a clinical summary of the session and updates the profile via LLM3.
-        """
-        patient_id = self.session_store.get_patient_id(session_id) or default_patient_id
-
-        history = self.session_store.get_working_context(session_id)
-        
-        # Check if the user actually sent any messages
-        has_user_messages = any(msg.get("role") == "user" for msg in history)
-        
-        summary = "No conversation occurred."
-        llm3_output = None
-        if has_user_messages and patient_id:
-            try:
-                patient_info = self.profile_store.get_patient(patient_id)
-                old_profile = self.profile_store.get_patient_profile(patient_id)
-                llm3_output = self.llm_provider.generate_end_of_session_profile(old_profile, history, patient_info)
-                
-                if not llm3_output.update_profile:
-                    summary = "Not enough conversation to generate a meaningful summary."
-                else:
-                    summary = llm3_output.session_summary
-                    self.profile_store.update_patient_profile(patient_id, llm3_output)
-                    self.profile_store.update_long_term_memory(patient_id, llm3_output)
-                    
-                    if llm3_output.updated_primary_concern:
-                        self.profile_store.update_primary_concern(patient_id, llm3_output.updated_primary_concern)
-                        
-            except Exception as e:
-                summary = f"Summary generation failed: {e}"
-
-        self.session_store.save_session_summary(session_id, summary)
-
-        patient_info = self.profile_store.get_patient(patient_id) if patient_id else None
-        user_name = patient_info.get("name", "Guest Patient") if patient_info else "Guest Patient"
-        
-        session_number = self.session_store.get_session_count(patient_id) if patient_id else 1
-        log = get_logger(session_id, user_name, session_number)
-        if llm3_output:
-            log.llm3_output(llm3_output)
-        else:
-            log._log_event("session_summary", {"summary": summary})
-        close_logger(session_id)
-
-    def sweep_abandoned_sessions(self, timeout_minutes: int = 30) -> None:
-        """
-        Finds sessions inactive for `timeout_minutes` and generates summaries for them, then closes them.
-        """
-        abandoned_ids = self.session_store.get_abandoned_sessions(timeout_minutes)
-        for session_id in abandoned_ids:
-            try:
-                serinity_logger.info(f"Sweeping abandoned session {session_id}...")
-                self.generate_session_summary(session_id)
-                self.end_session(session_id)
-            except Exception as e:
-                serinity_logger.error(f"Failed to sweep session {session_id}: {e}")

services/risk_assessment_service.py

@@ -1,17 +0,0 @@
-from typing import List, Optional
-from core.ports import RiskSignal, LLM1Output, LLM2Output
-
-class RiskAssessmentService:
-    """
-    Evaluates patient messages and LLM responses against a suite of RiskSignals.
-    Ensures patient safety by identifying crisis or self-harm intents in real-time.
-    """
-    def __init__(self, signals: List[RiskSignal]):
-        self._signals = signals
-
-    def assess(self, message: str, llm1_output: LLM1Output, llm2_output: Optional[LLM2Output] = None) -> bool:
-        """Evaluate all risk signals and return True if any indicate a risk."""
-        return any(
-            signal.check(message, llm1_output, llm2_output)
-            for signal in self._signals
-        )