[FEATURE] Error Handling

app/assistants.py

@@ -13,6 +13,7 @@ import psycopg2
 from psycopg2 import sql
 import pytz
 
+from app.exceptions import AssistantError, BaseOurcoachException, OpenAIRequestError
 from app.utils import get_growth_guide_summary, get_users_mementos, print_log
 from app.flows import FOLLOW_UP_STATE, GENERAL_COACHING_STATE, MICRO_ACTION_STATE, REFLECTION_STATE
 
@@ -304,13 +305,42 @@ def get_current_datetime(user_id):
     return datetime.now().astimezone(pytz.timezone(user_timezone))
 
 class Assistant:
+    def catch_error(func):
+        def wrapper(self, *args, **kwargs):
+            try:
+                return func(self, *args, **kwargs)
+            except (BaseOurcoachException) as e:
+                raise e
+            except openai.BadRequestError as e:
+                raise OpenAIRequestError(user_id=self.cm.user.user_id, message="Error getting response from OpenAI", e=str(e), run_id=self.recent_run.id)
+            except Exception as e:
+                # Handle other exceptions
+                logger.error(f"An unexpected error occurred in Assistant: {e}")
+                raise AssistantError(user_id=self.cm.user.user_id, message="Unexpected error in Assistant", e=str(e))
+        return wrapper
+
     def __init__(self, id, cm):
         self.id = id
         self.cm = cm
         self.recent_run = None
 
+    @catch_error
     def cancel_run(self, run, thread):
+        logger.info(f"(asst) Attempting to cancel run: {run} for thread: {thread}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
+        if isinstance(run, str):
+            try:
+                run = self.cm.client.beta.threads.runs.retrieve(
+                    thread_id=thread,
+                    run_id=run
+                )
+                thread = self.cm.client.beta.threads.retrieve(thread_id=thread)
+            except openai.NotFoundError:
+                logger.warning(f"Thread {thread} already deleted: {run}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
+                return True
+        if isinstance(run, PseudoRun):
+            return True
         try:
+            logger.info(f"Attempting to cancel run: {run}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
             if run.status != 'completed':
                 cancel = self.cm.client.beta.threads.runs.cancel(thread_id=thread.id, run_id=run.id)
                 while cancel.status != 'cancelled':
@@ -319,7 +349,7 @@ class Assistant:
                         thread_id=thread.id,
                         run_id=cancel.id
                     )
-                logger.info(f"Cancelled run: {run.id}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
+                logger.info(f"Succesfully cancelled run: {run.id}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
                 return True
             else:
                 logger.info(f"Run already completed: {run.id}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
@@ -328,14 +358,13 @@ class Assistant:
             # check if run has expired. run has a field 'expires_at' like run.expires_at = 1735008568
             # if expired, return True and log run already expired
             if run.expires_at < get_current_datetime().timestamp():
-                logger.error(f"Run already expired: {run.id}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
+                logger.warning(f"Run already expired: {run.id}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
                 return True
             else:
-                logger.error(f"Error cancelling run: {run.id}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
+                logger.warning(f"Error cancelling run: {run.id}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
                 return False
 
-
-        
+    @catch_error 
     def process(self, thread, text):
         # template_search = self.cm.add_message_to_thread(thread.id, "assistant", f"Pay attention to the current state you are in and the flow template to respond to the users query:") 
         message = self.cm.add_message_to_thread(thread.id, "user", text)
@@ -348,24 +377,39 @@ class Assistant:
         just_finished_intro = False
         try:
             if run.status == 'completed': 
-                logger.info(f"Run Completed: {run.status}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})       
+                logger.info(f"Run Completed: {run.status}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})
+                self.recent_run = run
                 return run, just_finished_intro, message
             
-            reccursion = 0
-            logger.info(f"[Run Pending] Status: {run.status}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})
-            while run.status == 'requires_action':
-                logger.info(f"Run Calling tool [{reccursion}]: {run.status}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})       
-                run, just_finished_intro = self.call_tool(run, thread)
-                reccursion += 1
-                if run == "cancelled" or run == "change_goal":
-                    break
-
-            if run in ['cancelled', 'change_goal'] or run.status != 'completed':
-                logger.error(f"RUN NOT COMPLETED: {run}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})
-        finally:
-            self.recent_run = run 
-            return run, just_finished_intro, message
-
+            elif run.status == 'failed':
+                raise OpenAIRequestError(user_id=self.cm.user.id, message="Run failed", run_id=run.id)
+
+            elif run.status == 'requires_action':
+                reccursion = 0
+                logger.info(f"[Run Pending] Status: {run.status}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})
+                while run.status == 'requires_action':
+                    logger.info(f"Run Calling tool [{reccursion}]: {run.status}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})       
+                    run, just_finished_intro = self.call_tool(run, thread)
+                    reccursion += 1
+                    if reccursion > 10:
+                        logger.warning(f"Run has exceeded maximum recussrion depth({10}) for function_call: {run}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})
+                        self.cancel_run(run, thread)
+                        raise OpenAIRequestError(user_id=self.cm.id, message="Tool Call Reccursion Depth Reached")
+                    if run.status == 'cancelled':
+                        logger.warning(f"RUN NOT COMPLETED: {run}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})
+                        self.cancel_run(run, thread)
+                        break
+                    elif run.status == 'completed':
+                        logger.info(f"Run Completed: {run.status}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})
+                        self.recent_run = run
+                        return run, just_finished_intro, message
+                    elif run.status == 'failed':
+                        raise OpenAIRequestError(user_id=self.cm.id, message="Run failed")
+                return run, just_finished_intro, message 
+        except openai.BadRequestError as e:
+            raise OpenAIRequestError(user_id=self.cm.user, message="Error getting response from OpenAI", e=str(e))
+    
+    @catch_error
     def call_tool(self, run, thread):
         tool_outputs = []
         logger.info(f"Required actions: {list(map(lambda x: f'{x.function.name}({x.function.arguments})', run.required_action.submit_tool_outputs.tool_calls))}", 
@@ -566,9 +610,8 @@ class Assistant:
 
                 # cancel current run
                 run = self.cancel_run(run, thread)
-                logger.info(f"Successfully cancelled run", 
-                    extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_start_now"})
-                return "cancelled", just_finish_intro
+                run = PseudoRun(status="cancelled", metadata={"message": "start_now"})
+                return run, just_finish_intro
             elif tool.function.name == "change_goal":
                 logger.info(f"Changing user goal...", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_change_goal"})
                 
@@ -577,9 +620,8 @@ class Assistant:
                 
                 # cancel current run
                 run = self.cancel_run(run, thread)
-                logger.info(f"Successfully cancelled run", 
-                    extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_change_goal"})
-                return "change_goal", just_finish_intro 
+                run = PseudoRun(status="cancelled", metadata={"message": "change_goal"})
+                return run, just_finish_intro 
             elif tool.function.name == "complete_goal":
                 logger.info(f"Completing user goal...", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_complete_goal"})
                 goal = self.cm.user.update_goal(None, 'COMPLETED')
@@ -670,17 +712,20 @@ class Assistant:
                 )
                 logger.info("Tool outputs submitted successfully", 
                         extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_submit_tools"})
-            except Exception as e:
-                logger.error(f"Failed to submit tool outputs: {str(e)}", 
-                        extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_submit_tools"})
-            finally:
                 return run, just_finish_intro
+            except Exception as e:
+                raise OpenAIRequestError(user_id=self.cm.user.id, message="Error submitting tool outputs", e=str(e), run_id=run.id)                
         else:
             logger.warning("No tool outputs to submit", 
                         extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_submit_tools"})
-            return {"status": "No tool outputs to submit"}
-        
-        
+            run = PseudoRun(status="completed", metadata={"message": "No tool outputs to submit"})
+            return run, just_finish_intro
+
+class PseudoRun:
+    def __init__(self, status, metadata=None):
+        self.id = "pseudo_run"
+        self.status = status
+        self.metadata = metadata or {}
 
 
 class GeneralAssistant(Assistant):

app/cache.py

@@ -8,6 +8,8 @@ import re
 
 from dotenv import load_dotenv
 
+from app.exceptions import DBError
+
 logger = logging.getLogger(__name__)
 
 load_dotenv()
@@ -41,7 +43,7 @@ def upload_file_to_s3(filename):
         return True
     except (FileNotFoundError, NoCredentialsError, PartialCredentialsError) as e:
         logger.error(f"S3 upload failed for {filename}: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-        return False
+        raise DBError(user_id, "S3Error", f"Failed to upload file {filename} to S3", e)
 
 class CustomTTLCache:
     def __init__(self, ttl=60, cleanup_interval=10):

app/conversation_manager.py

@@ -0,0 +1,287 @@
+import os
+import openai
+import pandas as pd
+from datetime import datetime, timezone
+from app.assistants import Assistant 
+import random
+import logging
+from app.exceptions import BaseOurcoachException, ConversationManagerError, OpenAIRequestError
+from datetime import datetime
+
+import dotenv
+dotenv.load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+def get_current_datetime():
+    return datetime.now(timezone.utc)
+
+class ConversationManager:
+    def __init__(self, client, user, asst_id, intro_done=False):
+        self.user = user
+        self.intro_done = intro_done
+        self.assistants = {'general': Assistant('asst_vnucWWELJlCWadfAARwyKkCW', self), 'intro': Assistant('asst_baczEK65KKvPWIUONSzdYH8j', self)}
+
+        self.client = client
+        self.state = {'date': pd.Timestamp.now(tz='UTC').strftime("%d-%m-%Y %a %H:%M:%S")}
+
+        self.current_thread = self.create_thread()
+        self.daily_thread = None
+
+        logger.info("Initializing conversation state", extra={"user_id": self.user.user_id, "endpoint": "conversation_init"})
+    
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        # Remove unpicklable or unnecessary attributes
+        if 'client' in state:
+            del state['client']
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        # Re-initialize attributes that were not pickled
+        self.client = None
+
+    def catch_error(func):
+        def wrapper(self, *args, **kwargs):
+            try:
+                return func(self, *args, **kwargs)
+            except BaseOurcoachException as e:
+                raise e
+            except openai.BadRequestError as e:
+                raise OpenAIRequestError(user_id=self.user.user_id, message="OpenAI Request Error", e=str(e))
+            except Exception as e:
+                # Handle other exceptions
+                logger.error(f"An unexpected error occurred: {e}")
+                raise ConversationManagerError(user_id=self.user.user_id, message="Unexpected error in ConversationManager", e=str(e))
+        return wrapper
+
+    @catch_error
+    def create_thread(self):
+        user_interaction_guidelines =self.user.user_interaction_guidelines
+        thread = self.client.beta.threads.create()
+        self.system_message = self.add_message_to_thread(thread.id, "assistant", 
+                                f"""
+                                You are coaching:
+                                \n\n{user_interaction_guidelines}\n\n\
+                                Be mindful of this information at all times in order to
+                                be as personalised as possible when conversing. Ensure to
+                                follow the conversation guidelines and flow templates. Use the
+                                current state of the conversation to adhere to the flow. Do not let the user know about any transitions.\n\n
+                                ** Today is {self.state['date']}.\n\n **
+                                ** You are now in the INTRODUCTION STATE. **
+                                """)
+        return thread
+
+    @catch_error
+    def _get_current_thread_history(self, remove_system_message=True, _msg=None, thread=None):
+        if thread is None:
+            thread = self.current_thread
+        if not remove_system_message:
+            return [{"role": msg.role, "content": msg.content[0].text.value} for msg in self.client.beta.threads.messages.list(thread.id, order="asc")]
+        if _msg:
+            return [{"role": msg.role, "content": msg.content[0].text.value} for msg in self.client.beta.threads.messages.list(thread.id, order="asc", after=_msg.id)][1:]
+        return [{"role": msg.role, "content": msg.content[0].text.value} for msg in self.client.beta.threads.messages.list(thread.id, order="asc")][1:] # remove the system message
+
+    @catch_error
+    def add_message_to_thread(self, thread_id, role, content):
+        message = self.client.beta.threads.messages.create(
+            thread_id=thread_id,
+            role=role,
+            content=content
+        )
+        return message
+    
+    @catch_error
+    def _run_current_thread(self, text, thread=None, hidden=False):
+        if thread is None:
+            thread = self.current_thread
+        logger.warning(f"{self}", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
+        logger.info(f"User Message: {text}", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
+
+        # need to select assistant
+        if self.intro_done:
+            logger.info(f"Running general assistant", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
+            run, just_finished_intro, message = self.assistants['general'].process(thread, text)
+        else:
+            logger.info(f"Running intro assistant", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
+            run, just_finished_intro, message = self.assistants['intro'].process(thread, text) 
+        
+        logger.info(f"Run {run.id} {run.status} just finished intro: {just_finished_intro}", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
+        
+        if 'message' in run.metadata:
+            message = run.metadata['message']
+
+            if message == 'start_now':
+                self.intro_done = True
+                logger.info(f"Start now", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
+            elif message == 'change_goal':
+                self.intro_done = False
+                logger.info(f"Changing goal, reset to intro assistant", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
+
+
+        if hidden:
+            self.client.beta.threads.messages.delete(message_id=message.id, thread_id=thread.id)
+            logger.info(f"Deleted hidden message: {message}", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
+        
+        return self._get_current_thread_history(remove_system_message=False)[-1], run 
+    
+    @catch_error
+    def _send_and_replace_message(self, text, replacement_msg=None):
+        logger.info(f"Sending hidden message: {text}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
+        response, _ = self._run_current_thread(text, hidden=True)
+
+        # check if there is a replacement message
+        if replacement_msg:
+            logger.info(f"Adding replacement message: {replacement_msg}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
+            # get the last message
+            last_msg = list(self.client.beta.threads.messages.list(self.current_thread.id, order="asc"))[-1]
+            logger.info(f"Last message: {last_msg}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
+            response = last_msg.content[0].text.value
+
+            # delete the last message
+            self.client.beta.threads.messages.delete(message_id=last_msg.id, thread_id=self.current_thread.id)
+            self.add_message_to_thread(self.current_thread.id, "user", replacement_msg)
+            self.add_message_to_thread(self.current_thread.id, "assistant", response)
+
+        logger.info(f"Hidden message response: {response}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
+        # NOTE: this is a hack, should get the response straight from the run
+        return {'content': response, 'role': 'assistant'}
+    
+    @catch_error
+    def _add_ai_message(self, text):
+        return self.add_message_to_thread(self.current_thread.id, "assistant", text)
+
+    @catch_error
+    def get_daily_thread(self):
+        if self.daily_thread is None:
+            messages = self._get_current_thread_history(remove_system_message=False)
+
+            self.daily_thread = self.client.beta.threads.create(
+            messages=messages[:30]
+            )
+
+            # Add remaining messages one by one if there are more than 30
+            for msg in messages[30:]:
+                self.add_message_to_thread(
+                    self.daily_thread.id,
+                    msg['role'],
+                    msg['content']
+                )
+            self.last_daily_message = list(self.client.beta.threads.messages.list(self.daily_thread.id, order="asc"))[-1]
+        else:
+            messages = self._get_current_thread_history(remove_system_message=False, _msg=self.last_daily_message)
+            self.client.beta.threads.delete(self.daily_thread.id)
+            self.daily_thread = self.client.beta.threads.create(messages=messages)
+            self.last_daily_message = list(self.client.beta.threads.messages.list(self.daily_thread.id, order="asc"))[-1]
+        logger.info(f"Daily Thread: {self._get_current_thread_history(thread=self.daily_thread)}", extra={"user_id": self.user.user_id, "endpoint": "send_morning_message"})
+        logger.info(f"Last Daily Message: {self.last_daily_message}", extra={"user_id": self.user.user_id, "endpoint": "send_morning_message"})
+        return self._get_current_thread_history(thread=self.daily_thread)
+        # [{"role":, "content":}, ....]
+
+    @catch_error
+    def _send_morning_message(self, text, add_to_main=False):
+        # create a new thread
+        # OPENAI LIMITATION: Can only attach a maximum of 32 messages when creating a new thread
+        messages = self._get_current_thread_history(remove_system_message=False)
+        if len(messages) >= 29:
+            messages = [{"content": """ Remember who you are coaching.
+                        Be mindful of this information at all times in order to
+                        be as personalised as possible when conversing. Ensure to
+                        follow the conversation guidelines and flow provided.""", "role":"assistant"}] + messages[-29:]
+        logger.info(f"Current Thread Messages: {messages}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
+        
+        temp_thread = self.client.beta.threads.create(messages=messages)
+        logger.info(f"Created Temp Thread: {temp_thread}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
+        
+        if add_to_main:
+            logger.info(f"Adding message to main thread: {text}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
+            self.add_message_to_thread(self.current_thread.id, "assistant", text)
+
+        self.add_message_to_thread(temp_thread.id, "user", text)
+
+        self._run_current_thread(text, thread=temp_thread)
+        response = self._get_current_thread_history(thread=temp_thread)[-1]
+        logger.info(f"Hidden Response: {response}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
+
+        # delete temp thread
+        self.client.beta.threads.delete(temp_thread.id)
+        logger.info(f"Deleted Temp Thread: {temp_thread}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
+
+        return response
+    
+    @catch_error
+    def delete_hidden_messages(self, old_thread=None):
+        if old_thread is None:
+            old_thread = self.current_thread
+
+        # create a new thread
+        messages = [msg for msg in self._get_current_thread_history(remove_system_message=False) if not msg['content'].startswith("[hidden]")]
+        if len(messages) >= 29:
+            messages = messages[-29:]
+        logger.info(f"Current Thread Messages: {messages}", extra={"user_id": self.user.user_id, "endpoint": "delete_hidden_messages"})
+
+        new_thread = self.client.beta.threads.create(messages=messages)
+
+        # delete old thread
+        self.client.beta.threads.delete(old_thread.id)
+
+        # set current thread
+        self.current_thread = new_thread
+    
+    @catch_error
+    def cancel_run(self, run, thread = None):
+        # Cancels and recreates a thread
+        logger.info(f"(CM) Cancelling run {run} for thread {thread}", extra={"user_id": self.user.user_id, "endpoint": "cancel_run"})
+        if thread is None:
+            thread = self.current_thread.id
+
+        if self.intro_done:
+            self.assistants['general'].cancel_run(run, thread)
+        else:
+            self.assistants['intro'].cancel_run(run, thread)
+
+        logger.info(f"Run cancelled", extra={"user_id": self.user.user_id, "endpoint": "cancel_run"})    
+        return True
+
+    @catch_error
+    def clone(self, client):
+        """Creates a new ConversationManager with copied thread messages."""
+        # Create new instance with same init parameters
+        new_cm = ConversationManager(
+            client,
+            self.user,
+            self.assistants['general'].id,
+            intro_done=True
+        )
+
+        # Get all messages from current thread
+        messages = self._get_current_thread_history(remove_system_message=False)
+        
+        # Delete the automatically created thread from constructor
+        new_cm.client.beta.threads.delete(new_cm.current_thread.id)
+        
+        # Create new thread with first 30 messages
+        new_cm.current_thread = new_cm.client.beta.threads.create(
+            messages=messages[:30]
+        )
+
+        # Add remaining messages one by one if there are more than 30
+        for msg in messages[30:]:
+            new_cm.add_message_to_thread(
+                new_cm.current_thread.id,
+                msg['role'],
+                msg['content']
+            )
+
+        # Copy other relevant state
+        new_cm.state = self.state
+
+        return new_cm
+    
+    def __str__(self):
+        return f"ConversationManager(intro_done={self.intro_done}, assistants={self.assistants}, current_thread={self.current_thread})"
+    
+    def __repr__(self):
+        return (f"ConversationManager("
+                f"intro_done={self.intro_done}, current_thread={self.current_thread})")

app/exceptions.py

@@ -0,0 +1,113 @@
+from enum import Enum
+from typing import Optional, Dict, Any
+import traceback
+import logging
+import json
+import re
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+import re
+
+class BaseOurcoachException(Exception):
+    def __init__(self, **kwargs):
+        self.user_id = kwargs.get('user_id', 'no-user')
+        self.code = kwargs.get('code', 'UnknownError')
+        self.message = kwargs.get('message', 'An unknown error occurred')
+        self.e = kwargs.get('e', None)
+
+        # Initialize the parent Exception with the message
+        Exception.__init__(self, self.message)
+
+        # Capture the full traceback
+        self.stack_trace = traceback.format_exc()
+        self.timestamp = datetime.utcnow()
+
+        logger.exception(f"Error raised with code={self.code}, message={self.message}, user_id={self.user_id}", exc_info=self.e)
+    
+    def get_formatted_details(self) -> dict:
+        def format_traceback(traceback_str: str) -> str:
+            # Extract error type and message
+            error_pattern = r"(\w+Error): (.+?)(?=\n|$)"
+            error_match = re.search(error_pattern, traceback_str)
+            error_type = error_match.group(1) if error_match else "Unknown Error"
+            error_msg = error_match.group(2) if error_match else ""
+
+            # Extract file paths and line numbers
+            file_pattern = r"File \"(.+?)\", line (\d+), in (\w+)"
+            matches = re.findall(file_pattern, traceback_str)
+            
+            # Build formatted output
+            formatted_lines = [f"Error: {error_type} - {error_msg}\n"]
+            
+            for filepath, line_num, func_name in matches:
+                if func_name == "wrapper":
+                    continue
+                # Convert to relative path
+                rel_path = filepath.split('app/')[-1] if 'app/' in filepath else filepath.split('\\')[-1]
+                formatted_lines.append(f"at {rel_path}:{func_name} (line {line_num})")
+            
+            return "\n".join(formatted_lines)
+        """Returns pinpointed error details."""
+        return {
+            "type": f"{self.__class__.__name__}{'.' + self.code if self.code != self.__class__.__name__ else ''}",
+            "message": self.message,
+            "stack_trace": format_traceback(self.stack_trace),
+            "user_id": self.user_id,
+            "at": self.timestamp.isoformat(),
+        }
+
+    def to_json(self) -> Dict[str, Any]:
+        """Convert exception to JSON-serializable dictionary"""
+        return self.get_formatted_details()
+
+    def __str__(self) -> str:
+        return json.dumps(self.to_json(), indent=2)
+    
+class DBError(BaseOurcoachException):
+    ALLOWED_CODES = ['S3Error', 'SQLError', 'NoOnboardingError', 'NoPickleError', 'NoBookingError']
+    def __init__(self, **kwargs):
+        if kwargs.get('code') not in self.ALLOWED_CODES:
+            raise ValueError(f"Invalid code for DBError: {kwargs.get('code')}")
+        super().__init__(**kwargs)
+
+    def to_json(self) -> Dict[str, Any]:
+        base_json = super().to_json()
+        base_json["allowed_codes"] = self.ALLOWED_CODES
+        return base_json
+    
+class OpenAIRequestError(BaseOurcoachException):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.run_id = kwargs.get('run_id', None)
+
+    def to_json(self) -> Dict[str, Any]:
+        base_json = super().to_json()
+        base_json["run_id"] = self.run_id
+        return base_json
+
+class AssistantError(BaseOurcoachException):
+    def __init__(self, **kwargs):
+        kwargs['code'] = "AssistantError"
+        super().__init__(**kwargs)
+
+class UserError(BaseOurcoachException):
+    def __init__(self, **kwargs):
+        kwargs['code'] = "UserError"
+        super().__init__(**kwargs)
+
+class ConversationManagerError(BaseOurcoachException):
+    def __init__(self, **kwargs):
+        kwargs['code'] = "ConversationManagerError"
+        super().__init__(**kwargs)
+
+class FastAPIError(BaseOurcoachException):
+    def __init__(self, **kwargs):
+        kwargs['code'] = "FastAPIError"
+        super().__init__(**kwargs)
+
+class UtilsError(BaseOurcoachException):
+    def __init__(self, **kwargs):
+        kwargs['code'] = "UtilsError"
+        super().__init__(**kwargs)

app/main.py

@@ -1,5 +1,5 @@
-from fastapi import FastAPI, HTTPException, Security, Query, status, Request
-from fastapi.responses import FileResponse, StreamingResponse
+from fastapi import FastAPI, HTTPException, Security, Query, status, Request, Depends
+from fastapi.responses import FileResponse, StreamingResponse, JSONResponse
 from fastapi.security import APIKeyHeader
 import openai
 from pydantic import BaseModel
@@ -11,11 +11,13 @@ import regex as re
 from datetime import datetime, timezone
 from app.user import User
 from typing import List, Optional, Callable
+from functools import wraps
+
 from openai import OpenAI
 import psycopg2
 from psycopg2 import sql
 import os
-from app.utils import add_to_cache, get_api_key, get_user_info, get_growth_guide_session, pop_cache, print_log, get_user, upload_mementos_to_db, get_user_summary, get_user_life_status, create_pre_gg_report
+from app.utils import add_to_cache, download_file_from_s3, get_api_key, get_user_info, get_growth_guide_session, pop_cache, print_log, get_user, upload_mementos_to_db, get_user_summary, get_user_life_status, create_pre_gg_report
 from dotenv import load_dotenv
 import logging.config
 import time
@@ -23,6 +25,8 @@ from starlette.middleware.base import BaseHTTPMiddleware
 import sys
 import boto3
 import pickle
+from app.exceptions import *
+import re
 
 load_dotenv()
 AWS_ACCESS_KEY = os.getenv('AWS_ACCESS_KEY')
@@ -254,229 +258,280 @@ class ChatItem(BaseModel):
     user_id: str
     message: str
 
-class AssistantItem(BaseModel):
-    user_id: str
-    assistant_id: str
-
-class ChangeDateItem(BaseModel):
-    user_id: str
-    date: str
-
 class PersonaItem(BaseModel):
     user_id: str
     persona: str
 
 class GGItem(BaseModel):
+    user_id: str
     gg_session_id: str
+
+class AssistantItem(BaseModel):
     user_id: str
+    assistant_id: str
 
-class ErrorResponse(BaseModel):
-    status: str = "error"
-    code: int
-    message: str
-    timestamp: datetime = datetime.now(timezone.utc)
+class ChangeDateItem(BaseModel):
+    user_id: str
+    date: str
 
 class BookingItem(BaseModel):
     booking_id: str
 
+def catch_endpoint_error(func):
+    """Decorator to handle errors in FastAPI endpoints"""
+    @wraps(func)  # Add this to preserve endpoint metadata
+    async def wrapper(*args, **kwargs):
+        try:
+            # Extract api_key from kwargs if present and pass it to the wrapped function
+            api_key = kwargs.pop('api_key', None)
+            return await func(*args, **kwargs)
+        except OpenAIRequestError as e:
+            # OpenAI service error
+            # Try to cancel the run so we dont get "Cannot add message to thread with active run"
+            # if e.run_id:
+            #     user_id = e.user_id
+            #     if user_id != 'no-user':
+            #         user = get_user(user_id)
+            #         user.cancel_run(e.run_id)
+            logger.error(f"OpenAI service error in {func.__name__}(...): {str(e)}", 
+                        extra={
+                            'user_id': e.user_id,
+                            'endpoint': func.__name__
+                        })
+            # Extract thread_id and run_id from error message
+            thread_match = re.search(r'thread_(\w+)', str(e))
+            run_match = re.search(r'run_(\w+)', str(e))
+            if thread_match and run_match:
+                thread_id = f"thread_{thread_match.group(1)}"
+                run_id = f"run_{run_match.group(1)}"
+                user = get_user(e.user_id)
+                logger.info(f"Cancelling run {run_id} for thread {thread_id}", extra={"user_id": e.user_id, "endpoint": func.__name__})
+                user.cancel_run(run_id, thread_id)
+                logger.info(f"Run {run_id} cancelled for thread {thread_id}", extra={"user_id": e.user_id, "endpoint": func.__name__})
 
-@app.get("/ok")
-def ok_endpoint():
-    print_log("INFO", "health check endpoint")
-    logger.info("Health check endpoint called", extra={"endpoint": "/ok"})
-    return {"message": "ok"}
-
+            raise HTTPException(
+                status_code=status.HTTP_502_BAD_GATEWAY,
+                detail=e.get_formatted_details()
+            )
+        except DBError as e:
+            # check if code is one of ["NoOnboardingError", "NoBookingError"] if yes then return code 404 otherwise 500
+            if e.code == "NoOnboardingError" or e.code == "NoBookingError":
+                # no onboarding or booking data (user not found)
+                status_code = 404
+            else:
+                status_code = 505
+            logger.error(f"Database error in {func.__name__}: {str(e)}",
+                        extra={
+                            'user_id': e.user_id,
+                            'endpoint': func.__name__
+                        })
+            raise HTTPException(
+                status_code=status_code,
+                detail=e.get_formatted_details()
+            )
+        except (UserError, AssistantError, ConversationManagerError, UtilsError) as e:
+            # Known internal errors
+            logger.error(f"Internal error in {func.__name__}: {str(e)}", 
+                        extra={
+                            'user_id': e.user_id, 
+                            'endpoint': func.__name__,
+                            'traceback': traceback.extract_stack()
+                        })
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                # detail = traceback.extract_stack()
+                detail=e.get_formatted_details()
+            )
+        except openai.BadRequestError as e:
+            # OpenAI request error
+            user_id = kwargs.get('user_id', 'no-user')
+            logger.error(f"OpenAI request error in {func.__name__}: {str(e)}", 
+                        extra={
+                            'user_id': user_id,
+                            'endpoint': func.__name__
+                        })
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail={
+                    "type": "OpenAIError",
+                    "message": str(e),
+                    "user_id": user_id,
+                    "at": datetime.now(timezone.utc).isoformat()
+                }
+            )
+        except Exception as e:
+            # Unknown errors
+            user_id = kwargs.get('user_id', 'no-user')
+            if len(args) and hasattr(args[0], 'user_id'):
+                user_id = args[0].user_id
+                
+            logger.error(f"Unexpected error in {func.__name__}: {str(e)}", 
+                        extra={
+                            'user_id': user_id,
+                            'endpoint': func.__name__
+                        })
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail={
+                    "type": "FastAPIError",
+                    "message": str(e),
+                    "user_id": user_id,
+                    "at": datetime.now(timezone.utc).isoformat()
+                }
+            )
+            # raise FastAPIError(
+            #     user_id=user_id,
+            #     message=f"Unexpected error in {func.__name__}",
+            #     e=str(e)
+            # )
+    return wrapper
+
+# Apply decorator to all endpoints
 @app.post("/set_intro_done")
-def set_intro_done(user_id: str, api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def set_intro_done(
+    user_id: str,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     user = get_user(user_id)
+        
     user.set_intro_done()
     logger.info("Intro done", extra={"user_id": user_id, "endpoint": "/set_intro_done"})
     return {"response": "ok"}
 
+
 @app.post("/set_goal")
-def set_goal(user_id: str, goal: str, api_key: str = Security(get_api_key)):
-    user = get_user(user_id)
+@catch_endpoint_error
+async def set_goal(
+    user_id: str,
+    goal: str,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
+    user = get_user(user_id) 
+
     user.set_goal(goal)
     logger.info(f"Goal set: {goal}", extra={"user_id": user_id, "endpoint": "/set_goal"})
     return {"response": "ok"}
 
-@app.post("/do_micro")
-def do_micro(request: ChangeDateItem, day: int, api_key: str = Security(get_api_key)):
-    print_log("INFO", "do_micro endpoint")
-    logger.info("do_micro endpoint called", extra={"endpoint": "/do_micro"})
-    
-    # get user
-    user = get_user(request.user_id)
-
-    try:
+@app.post("/do_micro") 
+@catch_endpoint_error
+async def do_micro(
+    request: ChangeDateItem,
+    day: int,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
+        user = get_user(request.user_id)
         response = user.do_micro(request.date, day)
-    except openai.BadRequestError:
-        # Check if there is an active run for the thread id
-        recent_run = user.get_recent_run()
-        print_log("INFO",f"Recent run: {recent_run}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-        logger.info(f"Recent run: {recent_run}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-        # If there is an active run, cancel it and resubmit the previous message
-        if recent_run:
-            user.cancel_run(recent_run)
-            response = user.send_message(user.get_recent_message())
-    
-    print_log("INFO",f"Assistant: {response['content']}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-    logger.info(f"Assistant: {response['content']}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-    return {"response": response}
-
-
+        logger.info(f"Micro action completed", extra={"user_id": request.user_id, "endpoint": "/do_micro"})
+        return {"response": response}
+        
 # endpoint to change user assistant using user.change_to_latest_assistant()
 @app.post("/change_assistant")
-def change_assistant(request: AssistantItem, api_key: str = Security(get_api_key)):
-    user_id = request.user_id
-    assistant_id = request.assistant_id
-    print_log("INFO", "Changing assistant", extra={"user_id": user_id, "endpoint": "/change_assistant"})
-    logger.info("Changing assistant", extra={"user_id": user_id, "endpoint": "/change_assistant"})
-    user = get_user(user_id)
-    user.change_assistant(assistant_id)
-    logger.info(f"Assistant changed to {assistant_id}", extra={"user_id": user_id, "endpoint": "/change_assistant"})
-    return {"assistant_id": assistant_id}
-    
+@catch_endpoint_error 
+async def change_assistant(
+    request: AssistantItem,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
+    user = get_user(request.user_id)
+
+    user.change_assistant(request.assistant_id)
+    logger.info(f"Assistant changed to {request.assistant_id}", 
+                extra={"user_id": request.user_id, "endpoint": "/change_assistant"})
+    return {"assistant_id": request.assistant_id}
+
 
 @app.post("/clear_cache")
-def clear_cache(api_key: str = Security(get_api_key)):
-    print_log("INFO", "Clearing entire cache", extra={"endpoint": "/clear_cache"})
-    logger.info("Clearing entire cache", extra={"endpoint": "/clear_cache"})
-    try:
-        pop_cache(user_id='all')
-        print_log("INFO", "Cache cleared successfully", extra={"endpoint": "/clear_cache"})
-        logger.info("Cache cleared successfully", extra={"endpoint": "/clear_cache"})
-        return {"response": "Cache cleared successfully"}
-    except Exception as e:
-        print_log("ERROR", f"Error clearing cache: {str(e)}", extra={"endpoint": "/clear_cache"}, exc_info=True)
-        logger.error(f"Error clearing cache: {str(e)}", extra={"endpoint": "/clear_cache"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+@catch_endpoint_error
+async def clear_cache(
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
+    pop_cache(user_id='all')
+    logger.info("Cache cleared successfully", extra={"endpoint": "/clear_cache"})
+    return {"response": "Cache cleared successfully"}
 
 @app.post("/migrate_user")
-def migrate_user(request: CreateUserItem, api_key: str = Security(get_api_key)):
-    user_id = request.user_id
-    print_log("INFO", "Migrating user", extra={"user_id": request.user_id, "endpoint": "/migrate_user"})
-    logger.info("Migrating user", extra={"user_id": request.user_id, "endpoint": "/migrate_user"})
-    def download_file_from_s3(filename, bucket):
-        user_id = filename.split('.')[0]
-        function_name = download_file_from_s3.__name__
-        logger.info(f"Downloading file {filename} from [staging] S3 bucket {bucket}", extra={'user_id': user_id, 'endpoint': function_name})
-        file_path = os.path.join('users', 'data', filename)
-        try:
-            if (AWS_ACCESS_KEY and AWS_SECRET_KEY):
-                session = boto3.session.Session(aws_access_key_id=AWS_ACCESS_KEY, aws_secret_access_key=AWS_SECRET_KEY, region_name=REGION)
-            else:
-                session = boto3.session.Session()
-            s3_client = session.client('s3')
-            with open(file_path, 'wb') as f:
-                ## Upload to Staging Folder
-                s3_client.download_fileobj(bucket, f"staging/users/{filename}", f)
-            logger.info(f"File {filename} downloaded successfully from S3", extra={'user_id': user_id, 'endpoint': function_name})
-            return True
-        except Exception as e:
-            logger.error(f"Error downloading file {filename} from S3: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-            if (os.path.exists(file_path)):
-                os.remove(file_path)
-            return False
-    try:
-        client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
-        user_file = os.path.join('users', 'data', f'{user_id}.pkl')
-        download = download_file_from_s3(f'{user_id}.pkl', 'core-ai-assets')
-        logger.info(f"Download success: {download}", extra={'user_id': user_id, 'endpoint': 'migrate_user'})
-        if (download):
-            with open(user_file, 'rb') as f:
-                old_user_object = pickle.load(f)
-                # recreate user using data from above
-                user = User(user_id, old_user_object.user_info, client, GENERAL_ASSISTANT)
-                user.conversations.current_thread = old_user_object.conversations.current_thread
-                user.conversations.intro_done = True
-                user.done_first_reflection = old_user_object.done_first_reflection
-                user.client = client
-                user.conversations.client = client
-
-                api_response = {"user": user.user_info, "user_messages": user.get_messages(), "general_assistant": user.conversations.assistants['general'].id, "intro_assistant": user.conversations.assistants['intro'].id}
-        
-                if user.goal:
-                    api_response["goal"] = user.goal
-                else:
-                    api_response["goal"] = "No goal is not set yet"
-
-                api_response["current_day"] = user.growth_plan.current()['day']
-                api_response['micro_actions'] = user.micro_actions
-                api_response['recommended_actions'] = user.recommended_micro_actions
-                api_response['challenges'] = user.challenges
-                api_response['other_focusses'] = user.other_focusses
-                api_response['scores'] = f"Personal Growth: {user.personal_growth_score} || Career: {user.career_growth_score} || Health/Wellness: {user.health_and_wellness_score} || Relationships: {user.relationship_score} || Mental Health: {user.mental_well_being_score}"
-                api_response['recent_wins'] = user.recent_wins
-
-                add_to_cache(user)
-                pop_cache(user.user_id)
-                return api_response
-                # user.save_user()
-                # pop_cache(user.user_id)
-                # user.client = client
-                # user.conversations.client = client
-            os.remove(user_file)
-            logger.info(f"User {user_id} loaded successfully from S3", extra={'user_id': user_id, 'endpoint': 'migrate_user'})
-
-
-
-    except Exception as e:
-        logger.error(f"Error migrating user {user_id}: {e}", extra={'user_id': user_id, 'endpoint': 'migrate_user'})
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )   
+@catch_endpoint_error
+async def migrate_user(
+    request: CreateUserItem,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
+    client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
+    if not client:
+        raise OpenAIRequestError(
+            user_id=request.user_id,
+            message="Failed to initialize OpenAI client"
+        )
+
+    user_file = os.path.join('users', 'data', f'{request.user_id}.pkl')
+    
+    download_file_from_s3(f'{request.user_id}.pkl', 'core-ai-assets')
+
+    with open(user_file, 'rb') as f:
+        old_user_object = pickle.load(f)
+        user = User(request.user_id, old_user_object.user_info, client, GENERAL_ASSISTANT)
+        user.conversations.current_thread = old_user_object.conversations.current_thread
+        user.conversations.intro_done = True
+        user.done_first_reflection = old_user_object.done_first_reflection
+        user.client = client
+        user.conversations.client = client
+
+        api_response = {
+            "user": user.user_info,
+            "user_messages": user.get_messages(),
+            "general_assistant": user.conversations.assistants['general'].id,
+            "intro_assistant": user.conversations.assistants['intro'].id,
+            "goal": user.goal if user.goal else "No goal is not set yet",
+            "current_day": user.growth_plan.current()['day'],
+            "micro_actions": user.micro_actions,
+            "recommended_actions": user.recommended_micro_actions,
+            "challenges": user.challenges,
+            "other_focusses": user.other_focusses,
+            "scores": f"Personal Growth: {user.personal_growth_score} || Career: {user.career_growth_score} || Health/Wellness: {user.health_and_wellness_score} || Relationships: {user.relationship_score} || Mental Health: {user.mental_well_being_score}",
+            "recent_wins": user.recent_wins
+        }
 
+        add_to_cache(user)
+        pop_cache(user.user_id)
+
+        os.remove(user_file)
+        logger.info(f"User {user.user_id} loaded successfully from S3", extra={'user_id': user.user_id, 'endpoint': 'migrate_user'})
+        return api_response
+              
 @app.get("/get_user")
-def get_user_by_id(user_id: str, api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def get_user_by_id(
+    user_id: str,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     print_log("INFO", "Getting user", extra={"user_id": user_id, "endpoint": "/get_user"})
     logger.info("Getting user", extra={"user_id": user_id, "endpoint": "/get_user"})
-    try:
-        user = get_user(user_id)
-        print_log("INFO", "Successfully retrieved user", extra={"user_id": user_id, "endpoint": "/get_user"})
-        logger.info("Successfully retrieved user", extra={"user_id": user_id, "endpoint": "/get_user"})
-        api_response = {"user": user.user_info, "user_messages": user.get_messages(), "general_assistant": user.conversations.assistants['general'].id, "intro_assistant": user.conversations.assistants['intro'].id}
-        
-        if user.goal:
-            api_response["goal"] = user.goal
-        else:
-            api_response["goal"] = "No goal is not set yet"
-
-        api_response["current_day"] = user.growth_plan.current()['day']
-        api_response['micro_actions'] = user.micro_actions
-        api_response['recommended_actions'] = user.recommended_micro_actions
-        api_response['challenges'] = user.challenges
-        api_response['other_focusses'] = user.other_focusses
-        api_response['reminders'] = user.reminders
-        api_response['scores'] = f"Personal Growth: {user.personal_growth_score} || Career: {user.career_growth_score} || Health/Wellness: {user.health_and_wellness_score} || Relationships: {user.relationship_score} || Mental Health: {user.mental_well_being_score}"
-        api_response['recent_wins'] = user.recent_wins
-
-        return api_response
-    except LookupError:
-        print_log("ERROR", "User not found", extra={"user_id": user_id, "endpoint": "/get_user"})
-        logger.error("User not found", extra={"user_id": user_id, "endpoint": "/get_user"})
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"User with ID {user_id} not found"
-        )
-    except Exception as e:
-        print_log("ERROR",f"Error getting user: {str(e)}", extra={"user_id": user_id, "endpoint": "/get_user"}, exc_info=True)
-        logger.error(f"Error getting user: {str(e)}", extra={"user_id": user_id, "endpoint": "/get_user"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+    user = get_user(user_id)
+    print_log("INFO", "Successfully retrieved user", extra={"user_id": user_id, "endpoint": "/get_user"})
+    logger.info("Successfully retrieved user", extra={"user_id": user_id, "endpoint": "/get_user"})
+    api_response = {"user": user.user_info, "user_messages": user.get_messages(), "general_assistant": user.conversations.assistants['general'].id, "intro_assistant": user.conversations.assistants['intro'].id}
+    
+    if user.goal:
+        api_response["goal"] = user.goal
+    else:
+        api_response["goal"] = "No goal is not set yet"
 
+    api_response["current_day"] = user.growth_plan.current()['day']
+    api_response['micro_actions'] = user.micro_actions
+    api_response['recommended_actions'] = user.recommended_micro_actions
+    api_response['challenges'] = user.challenges
+    api_response['other_focusses'] = user.other_focusses
+    api_response['reminders'] = user.reminders
+    api_response['scores'] = f"Personal Growth: {user.personal_growth_score} || Career: {user.career_growth_score} || Health/Wellness: {user.health_and_wellness_score} || Relationships: {user.relationship_score} || Mental Health: {user.mental_well_being_score}"
+    api_response['recent_wins'] = user.recent_wins
+    api_response['last_gg_session'] = user.last_gg_session
 
+    return api_response
 
 @app.post("/update_user_persona")
+@catch_endpoint_error
 async def update_user_persona(
     request: PersonaItem,
-    api_key: str = Security(get_api_key)
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
 ):
     """Update user's legendary persona in the database"""
     user_id = request.user_id
@@ -486,78 +541,71 @@ async def update_user_persona(
     user.update_user_info(f"User's new Legendary Persona is: {persona}")
     logger.info(f"Updated persona to {persona}", extra={"user_id": user_id, "endpoint": "/update_user_persona"})
 
-    try:
-        # Connect to database
-        db_params = {
-            'dbname': 'ourcoach',
-            'user': 'ourcoach',
-            'password': 'hvcTL3kN3pOG5KteT17T',
-            'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
-            'port': '5432'
-        }
-        conn = psycopg2.connect(**db_params)
-        cur = conn.cursor()
-
-        # Get current onboarding data
-        cur.execute("SELECT onboarding FROM users WHERE id = %s", (user_id,))
-        result = cur.fetchone()
-        if not result:
-            raise HTTPException(status_code=404, detail="User not found")
-        
-        # Update legendPersona in onboarding JSON
-        onboarding = json.loads(result[0])
-        onboarding['legendPersona'] = persona
-        
-        # Update database
-        cur.execute(
-            "UPDATE users SET onboarding = %s WHERE id = %s",
-            (json.dumps(onboarding), user_id)
+    # Connect to database
+    db_params = {
+        'dbname': 'ourcoach',
+        'user': 'ourcoach',
+        'password': 'hvcTL3kN3pOG5KteT17T',
+        'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
+        'port': '5432'
+    }
+    conn = psycopg2.connect(**db_params)
+    cur = conn.cursor()
+
+    # Get current onboarding data
+    cur.execute("SELECT onboarding FROM users WHERE id = %s", (user_id,))
+    result = cur.fetchone()
+    if not result:
+        raise DBError(
+            user_id=user_id,
+            code="NoOnboardingError",
+            message="User not found in database"
         )
-        conn.commit()
 
-        return {"status": "success", "message": f"Updated persona to {persona}"}
-
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+    # Update legendPersona in onboarding JSON
+    onboarding = json.loads(result[0])
+    onboarding['legendPersona'] = persona
     
-    finally:
-        if 'cur' in locals():
-            cur.close()
-        if 'conn' in locals():
-            conn.close()
+    # Update database
+    cur.execute(
+        "UPDATE users SET onboarding = %s WHERE id = %s",
+        (json.dumps(onboarding), user_id)
+    )
+    conn.commit()
+    if 'cur' in locals():
+        cur.close()
+    if 'conn' in locals():
+        conn.close()
+
+    return {"status": "success", "message": f"Updated persona to {persona}"}
 
 @app.post("/add_ai_message")
-def add_ai_message(request: ChatItem, api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def add_ai_message(
+    request: ChatItem,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     user_id = request.user_id
     message = request.message
     logger.info("Adding AI response", extra={"user_id": user_id, "endpoint": "/add_ai_message"})
     print_log("INFO", "Adding AI response", extra={"user_id": user_id, "endpoint": "/add_ai_message"})
-    try:
-        user = get_user(user_id)
-        user.add_ai_message(message)
+ 
+    user = get_user(user_id)
+    user.add_ai_message(message)
 
-        add_to_cache(user)
-        update = pop_cache(user.user_id)
-
-        print_log("INFO", "AI response added", extra={"user_id": user_id, "endpoint": "/add_ai_message"})
-        return {"response": "ok"}
-    except LookupError:
-        print_log("ERROR", "User not found", extra={"user_id": user_id, "endpoint": "/add_ai_message"})
-        logger.error("User not found", extra={"user_id": user_id, "endpoint": "/add_ai_message"})
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"User with ID {user_id} not found"
-        )
-    except Exception as e:
-        print_log("ERROR",f"Error adding AI response: {str(e)}", extra={"user_id": user_id, "endpoint": "/add_ai_message"}, exc_info=True)
-        logger.error(f"Error adding AI response: {str(e)}", extra={"user_id": user_id, "endpoint": "/add_ai_message"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )  
+    add_to_cache(user)
+    pop_cache(user.user_id)
+
+    print_log("INFO", "AI response added", extra={"user_id": user_id, "endpoint": "/add_ai_message"})
+    return {"response": "ok"}
+ 
 
 @app.post("/schedule_gg_reminder")
-def schedule_gg_reminder(request: ChangeDateItem, api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def schedule_gg_reminder(
+    request: ChangeDateItem,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     # session_id = request.gg_session_id
     user_id = request.user_id
     logger.info(f"Scheduling GG session reminder for {request.date}", extra={"user_id": user_id, "endpoint": "/schedule_gg_reminder"})
@@ -573,53 +621,59 @@ def schedule_gg_reminder(request: ChangeDateItem, api_key: str = Security(get_ap
     return {"response": response}
 
 @app.post("/process_gg_session")
-def process_gg_session(request: GGItem, api_key: str = Security(get_api_key)):
-    session_id = request.gg_session_id
-    user_id = request.user_id
-    logger.info(f"Processing GG session: {session_id}", extra={"user_id": user_id, "endpoint": "/process_gg_session"})  
-    print_log("INFO", f"Processing GG session: {session_id}", extra={"user_id": user_id, "endpoint": "/process_gg_session"})
-
-    # get user
-    user = get_user(user_id)
-
-    # get the session_data
-    session_data = get_growth_guide_session(user_id, session_id)
+@catch_endpoint_error
+async def process_gg_session(
+    request: GGItem,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
+    logger.info("Processing growth guide session", extra={"user_id": request.user_id, "endpoint": "/process_gg_session"})
     
-    # update user
-    response = user.process_growth_guide_session(session_data, session_id)
-    logger.info(f"GG session processed: {session_id}, response: {response}", extra={"user_id": user_id, "endpoint": "/process_gg_session"})
+    user = get_user(request.user_id)
+    session_data = get_growth_guide_session(request.user_id, request.gg_session_id)
+    response = user.process_growth_guide_session(session_data, request.gg_session_id)
+    add_to_cache(user)
+    pop_cache(user.user_id)
     return {"response": response}
 
+
 @app.get("/user_daily_messages")
-def get_daily_message(user_id: str,  api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def get_daily_message(
+    user_id: str,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     logger.info("Getting daily messages", extra={"user_id": user_id, "endpoint": "/user_daily_messages"})
     user = get_user(user_id)
     daily_messages = user.get_daily_messages()
     return {"response": daily_messages}
 
 @app.post("/batch_refresh_users")
-def refresh_multiple_users(user_ids: List[str], api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def refresh_multiple_users(
+    user_ids: List[str],
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     logger.info("Refreshing multiple users", extra={"endpoint": "/batch_refresh_users"})
     client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
     failed_users = []
 
     for i,user_id in enumerate(user_ids):
-        try:
-            old_user = get_user(user_id)
-            user = old_user.refresh(client)
-            add_to_cache(user)
-            update = pop_cache(user.user_id)
-            logger.info(f"Successfully refreshed user {i+1}/{len(user_ids)}", extra={"user_id": user_id, "endpoint": "/batch_refresh_users"})
-        except Exception as e:
-            logger.error(f"Failed to refresh user: {str(e)}", extra={"user_id": user_id, "endpoint": "/batch_refresh_users"})
-            failed_users.append(user_id)
+        old_user = get_user(user_id)
+        user = old_user.refresh(client)
+        add_to_cache(user)
+        pop_cache(user.user_id)
+        logger.info(f"Successfully refreshed user {i+1}/{len(user_ids)}", extra={"user_id": user_id, "endpoint": "/batch_refresh_users"})
 
     if failed_users:
         return {"status": "partial", "failed_users": failed_users}
     return {"status": "success", "failed_users": []}
 
 @app.post("/refresh_user")
-def refresh_user(request: CreateUserItem, api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def refresh_user(
+    request: CreateUserItem,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     print_log("INFO","Refreshing user", extra={"user_id": request.user_id, "endpoint": "/refresh_user"})
     logger.info("Refreshing user", extra={"user_id": request.user_id, "endpoint": "/refresh_user"})
 
@@ -633,267 +687,131 @@ def refresh_user(request: CreateUserItem, api_key: str = Security(get_api_key)):
     return {"response": "ok"}
 
 @app.post("/create_user")
-def create_user(request: CreateUserItem, api_key: str = Security(get_api_key)):
-
-    # # delete and recreate user log file
-    # user_id = request.user_id
-    # user_log_file = os.path.join('logs', 'users', f'{user_id}.log')
-    # if os.path.exists(user_log_file):
-    #     os.remove(user_log_file)
-    # # create new user log file
-    # open(user_log_file, 'w').close()
-
-    print_log("INFO","Creating new user", extra={"user_id": request.user_id, "endpoint": "/create_user"})
+@catch_endpoint_error
+async def create_user(
+    request: CreateUserItem,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     logger.info("Creating new user", extra={"user_id": request.user_id, "endpoint": "/create_user"})
-    try:
-        client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
-
-        # check if user exists by looking for pickle file in users/data
-        # if os.path.exists(f'users/data/{request.user_id}.pkl'):
-        #     print_log("INFO",f"User already exists: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/create_user"})
-        #     logger.info(f"User already exists: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/create_user"})
-        #     return {"message": f"[OK] User already exists: {request.user_id}"}
-        
-        user_info, _ = get_user_info(request.user_id)
-        if not user_info:
-            print_log("ERROR",f"Could not fetch user information from DB {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/create_user"})
-            logger.error(f"Could not fetch user information from DB {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/create_user"})
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Could not fetch user information from DB"
-            )
 
-        user = User(request.user_id, user_info, client, GENERAL_ASSISTANT)
+    client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
+    if not client:
+        raise OpenAIRequestError("client_init", "Failed to initialize OpenAI client")
 
-        # create memento folder for user
-        folder_path = os.path.join("mementos", "to_upload", request.user_id)
+    if os.path.exists(f'users/data/{request.user_id}.pkl'):
+        return {"message": f"[OK] User already exists: {request.user_id}"}
+    
+    user_info, _ = get_user_info(request.user_id)
+    user = User(request.user_id, user_info, client, GENERAL_ASSISTANT)
+    folder_path = os.path.join("mementos", "to_upload", request.user_id)
+    os.makedirs(folder_path, exist_ok=True)
 
-        # create folder if not exists
-        os.makedirs(folder_path, exist_ok=True)
-        print_log("INFO",f"Created temp memento folder for user", extra={"user_id": request.user_id, "endpoint": "/create_user"})
-        logger.info(f"Created temp memento folder for user", extra={"user_id": request.user_id, "endpoint": "/create_user"})
+    add_to_cache(user)
+    pop_cache(request.user_id)
 
-
-        # upload user pickle file to s3 bucket 
-        try:
-            add_to_cache(user)
-            pop_cache(request.user_id)
-            upload = True
-        except:
-            upload = False
-
-        if upload == True:
-            print_log("INFO",f"Successfully created user", extra={"user_id": request.user_id, "endpoint": "/create_user"})
-            logger.info(f"Successfully created user", extra={"user_id": request.user_id, "endpoint": "/create_user"})
-            return {"message": {"info": f"[OK] User created: {user}", "messages": user.get_messages()}} 
-        else:
-            print_log("ERROR",f"Failed to upload user pickle to S3", extra={"user_id": request.user_id, "endpoint": "/create_user"})
-            logger.error(f"Failed to upload user pickle to S3", extra={"user_id": request.user_id, "endpoint": "/create_user"})
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="Failed to upload user pickle to S3"
-            )        
-
-    except Exception as e:
-        print_log("ERROR",f"Failed to create user: {str(e)}", extra={"user_id": request.user_id, "endpoint": "/create_user"}, exc_info=True)
-        logger.error(f"Failed to create user: {str(e)}", extra={"user_id": request.user_id, "endpoint": "/create_user"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+    logger.info(f"Successfully created user", extra={"user_id": request.user_id, "endpoint": "/create_user"})
+    return {"message": {"info": f"[OK] User created: {user}", "messages": user.get_messages()}} 
 
 @app.post("/chat")
-def chat(request: ChatItem, api_key: str = Security(get_api_key)):
-    print_log("INFO","Processing chat request", extra={"user_id": request.user_id, "endpoint": "/chat"})
+@catch_endpoint_error
+async def chat(
+    request: ChatItem,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     logger.info("Processing chat request", extra={"user_id": request.user_id, "endpoint": "/chat"})
-    
-    try:
-        # get user
-        user = get_user(request.user_id)
-
-        try:
-            response = user.send_message(request.message)
-        except openai.BadRequestError as e:
-            print(e)
-            # Check if there is an active run for the thread id
-            recent_run = user.get_recent_run()
-            print_log("INFO",f"Recent run: {recent_run}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-            logger.info(f"Recent run: {recent_run}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-            # If there is an active run, cancel it and resubmit the previous message
-            if recent_run:
-                user.cancel_run(recent_run)
-                response = user.send_message(user.get_recent_message())
-        finally:
-            print_log("INFO",f"Assistant: {response['content']}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-            logger.info(f"Assistant: {response['content']}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-
-            return {"response": response}
-    except LookupError:
-        print_log("ERROR",f"User not found for chat: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-        logger.error(f"User not found for chat: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"User with ID {request.user_id} not found"
-        )
-    except ReferenceError:
-        logger.warning(f"User pickle creation still ongoing for user: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-        print_log("WARNING",f"User pickle creation still ongoing for user: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/chat"})
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="User pickle creation still ongoing"
-        )
-    except Exception as e:
-        print_log("ERROR",f"Chat error for user {request.user_id}: {str(e)}", extra={"user_id": request.user_id, "endpoint": "/chat"}, exc_info=True)
-        logger.error(f"Chat error for user {request.user_id}: {str(e)}", extra={"user_id": request.user_id, "endpoint": "/chat"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+    user = get_user(request.user_id)
 
+    response = user.send_message(request.message)
+    logger.info(f"Assistant response generated", extra={"user_id": request.user_id, "endpoint": "/chat"})
+    return {"response": response}
+    
 @app.get("/reminders")
-def get_reminders(user_id: str, date:str, api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def get_reminders(
+    user_id: str,
+    date:str,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     print_log("INFO","Getting reminders", extra={"user_id": user_id, "endpoint": "/reminders"})
     logger.info("Getting reminders", extra={"user_id": user_id, "endpoint": "/reminders"})
-    try:
-        user = get_user(user_id)
-        reminders = user.get_reminders(date)
-        if len(reminders) == 0:
-            print_log("INFO",f"No reminders for {date}", extra={"user_id": user_id, "endpoint": "/reminders"})
-            logger.info(f"No reminders for {date}", extra={"user_id": user_id, "endpoint": "/reminders"})
-            reminders = None
-            
-        print_log("INFO",f"Successfully retrieved reminders: {reminders}", extra={"user_id": user_id, "endpoint": "/reminders"})
-        logger.info(f"Successfully retrieved reminders: {reminders} for {date}", extra={"user_id": user_id, "endpoint": "/reminders"})
-        return {"reminders": reminders}
-    except LookupError:
-        print_log("ERROR","User not found", extra={"user_id": user_id, "endpoint": "/reminders"})
-        logger.error("User not found", extra={"user_id": user_id, "endpoint": "/reminders"})
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"User with ID {user_id} not found"
-        )
-    except Exception as e:
-        print_log("ERROR",f"Error getting reminders: {str(e)}", extra={"user_id": user_id, "endpoint": "/reminders"}, exc_info=True)
-        logger.error(f"Error getting reminders: {str(e)}", extra={"user_id": user_id, "endpoint": "/reminders"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+
+    user = get_user(user_id)
+    reminders = user.get_reminders(date)
+    if len(reminders) == 0:
+        print_log("INFO",f"No reminders for {date}", extra={"user_id": user_id, "endpoint": "/reminders"})
+        logger.info(f"No reminders for {date}", extra={"user_id": user_id, "endpoint": "/reminders"})
+        reminders = None
+        
+    print_log("INFO",f"Successfully retrieved reminders: {reminders}", extra={"user_id": user_id, "endpoint": "/reminders"})
+    logger.info(f"Successfully retrieved reminders: {reminders} for {date}", extra={"user_id": user_id, "endpoint": "/reminders"})
+    return {"reminders": reminders}
 
 @app.post("/change_date")
-def change_date(request: ChangeDateItem, api_key: str = Security(get_api_key)):
-    print_log("INFO",f"Processing date change request, new date: {request.date}", 
-               extra={"user_id": request.user_id, "endpoint": "/change_date"})
-    logger.info(f"Processing date change request, new date: {request.date}", 
-               extra={"user_id": request.user_id, "endpoint": "/change_date"})
+@catch_endpoint_error
+async def change_date(
+    request: ChangeDateItem,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
+    logger.info(f"Processing date change request", extra={"user_id": request.user_id, "endpoint": "/change_date"})
+    
+    user = get_user(request.user_id)
+
+    # Validate date format
     try:
-        user_id = request.user_id
+        datetime.strptime(request.date, "%d-%m-%Y %a %H:%M:%S")
+    except ValueError:
+        # HF format is YYYY-MM-DD 
+        try:
+            request.date = datetime.strptime(request.date, "%Y-%m-%d")
+            # convert to '%d-%m-%Y %a 10:00:00'
+            request.date = request.date.strftime("%d-%m-%Y %a 10:00:00")
+        except ValueError as e:
+            raise FastAPIError(
+                message="Invalid date format",
+                e=str(e)
+            )
 
-        user = get_user(user_id)
-        logger.info(f"User: {user}", extra={"user_id": user_id, "endpoint": "/change_date"})
+    # Upload mementos to DB
+    upload_mementos_to_db(request.user_id)
 
-        # infer follow_up dates
-        user.infer_memento_follow_ups()
+    # Change date and get response
+    response = user.change_date(request.date)
+    response['user_id'] = request.user_id
+
+    # Update cache
+    add_to_cache(user)
+    pop_cache(user.user_id)
+
+    return response
 
-        # Push users mementos to DB
-        try:
-            upload = upload_mementos_to_db(user_id)
-            if upload:
-                print_log("INFO",f"Uploaded mementos to DB for user: {user_id}", extra={"user_id": user_id, "endpoint": "/change_date"})
-                logger.info(f"Uploaded mementos to DB for user: {user_id}", extra={"user_id": user_id, "endpoint": "/change_date"})
-            else:
-                print_log("ERROR",f"Failed to upload mementos to DB for user: {user_id}", extra={"user_id": user_id, "endpoint": "/change_date"})
-                logger.error(f"Failed to upload mementos to DB for user: {user_id}", extra={"user_id": user_id, "endpoint": "/change_date"})
-                raise HTTPException(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail=f"Failed to upload mementos to DB for user: {user_id}"
-                )
-        except ConnectionError as e:
-            print_log("ERROR",f"Failed to connect to DB for user: {user_id}", extra={"user_id": user_id, "endpoint": "/change_date"})
-            logger.error(f"Failed to connect to DB for user: {user_id}", extra={"user_id": user_id, "endpoint": "/change_date"})
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail=f"Failed to connect to DB for user: {user_id}"
-            )
-        
-        response = user.change_date(request.date)
-        response['user_id'] = user_id
-        
-        print_log("INFO",f"Date changed successfully for user: {user_id}", extra={"user_id": user_id, "endpoint": "/change_date"})
-        logger.info(f"Date changed successfully for user: {user_id}", extra={"user_id": user_id, "endpoint": "/change_date"})
-        print_log("DEBUG",f"Change date response: {response}", extra={"user_id": user_id, "endpoint": "/change_date"})
-        logger.debug(f"Change date response: {response}", extra={"user_id": user_id, "endpoint": "/change_date"})
-        
-        # Update user
-        add_to_cache(user)
-        update = pop_cache(user.user_id)
-        if not update:
-            print_log("ERROR",f"Failed to update user pickle in S3: {user_id}", extra={"user_id": user_id, "endpoint": "/change_date"})
-            logger.error(f"Failed to update user pickle in S3: {user_id}", extra={"user_id": user_id, "endpoint": "/change_date"})
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail=f"Failed to update user pickle in S3 {user_id}"
-            )
-            
-        return response
-        # return {"response": response}          
-        
-    except ValueError as e:
-        print_log("ERROR",f"Invalid date format for user {request.user_id}: {str(e)}", extra={"user_id": request.user_id, "endpoint": "/change_date"})
-        logger.error(f"Invalid date format for user {request.user_id}: {str(e)}", extra={"user_id": request.user_id, "endpoint": "/change_date"})
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=str(e)
-        )
-    except LookupError:
-        print_log("ERROR",f"User not found for date change: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/change_date"})
-        logger.error(f"User not found for date change: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/change_date"})
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"User with ID {request.user_id} not found"
-        )
-    except Exception as e:
-        print_log("ERROR",f"Error changing date for user {request.user_id}: {str(e)}", extra={"user_id": request.user_id, "endpoint": "/change_date"}, exc_info=True)
-        logger.error(f"Error changing date for user {request.user_id}: {str(e)}", extra={"user_id": request.user_id, "endpoint": "/change_date"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
-    
 @app.post("/reset_user_messages")
-def reset_user_messages(request: CreateUserItem, api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def reset_user_messages(
+    request: CreateUserItem,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     print_log("INFO","Resetting messages", extra={"user_id": request.user_id, "endpoint": "/reset_user"})
     logger.info("Resetting messages", extra={"user_id": request.user_id, "endpoint": "/reset_user"})
-    try:
-        user = get_user(request.user_id)
-        user.reset_conversations()
-        print_log("INFO",f"Successfully reset messages for user: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/reset_user"})
-        logger.info(f"Successfully reset messages for user: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/reset_user"})
-        
-        add_to_cache(user)
-        update = pop_cache(user.user_id)
-
-        print_log("INFO",f"Successfully updated user pickle: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/reset_user"})
-        logger.info(f"Successfully updated user pickle: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/reset_user"})
-
-        return {"response": "ok"}
-    except LookupError:
-        print_log("ERROR",f"User not found for reset: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/reset_user"})
-        logger.error(f"User not found for reset: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/reset_user"})
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"User with ID {request.user_id} not found"
-        )
-    except Exception as e:
-        print_log("ERROR",f"Error resetting user {request.user_id}: {str(e)}", extra={"user_id": request.user_id, "endpoint": "/reset_user"}, exc_info=True)
-        logger.error(f"Error resetting user {request.user_id}: {str(e)}", extra={"user_id": request.user_id, "endpoint": "/reset_user"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+
+    user = get_user(request.user_id)
+    user.reset_conversations()
+    print_log("INFO",f"Successfully reset messages for user: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/reset_user"})
+    logger.info(f"Successfully reset messages for user: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/reset_user"})
+    
+    add_to_cache(user)
+    update = pop_cache(user.user_id)
+
+    print_log("INFO",f"Successfully updated user pickle: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/reset_user"})
+    logger.info(f"Successfully updated user pickle: {request.user_id}", extra={"user_id": request.user_id, "endpoint": "/reset_user"})
+
+    return {"response": "ok"}
+
 
 @app.get("/get_logs")
-def get_logs(user_id: str = Query(default="", description="User ID to fetch logs for")):
+@catch_endpoint_error
+async def get_logs(
+    user_id: str = Query(default="", description="User ID to fetch logs for")
+):
     if (user_id):
         log_file_path = os.path.join('logs', 'users', f'{user_id}.log')
         if not os.path.exists(log_file_path):
@@ -918,201 +836,164 @@ def get_logs(user_id: str = Query(default="", description="User ID to fetch logs
     )
 
 @app.get("/is_user_responsive")
-def is_user_responsive(user_id: str, api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def is_user_responsive(
+    user_id: str,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     logger.info("Checking if user is responsive", extra={"user_id": user_id, "endpoint": "/is_user_responsive"})
-    try:
-        user = get_user(user_id)
-        messages = user.get_messages()
-        if len(messages) >= 3 and messages[-1]['role'] == 'assistant' and messages[-2]['role'] == 'assistant':
-            return {"response": False}
-        else:
-            return {"response": True}
-    except LookupError:
-        logger.error(f"User not found: {user_id}", extra={"user_id": user_id, "endpoint": "/is_user_responsive"})
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"User with ID {user_id} not found"
-        )
-    except Exception as e:
-        logger.error(f"Error checking user responsiveness: {str(e)}", extra={"user_id": user_id, "endpoint": "/is_user_responsive"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+
+    user = get_user(user_id)
+    messages = user.get_messages()
+    if len(messages) >= 3 and messages[-1]['role'] == 'assistant' and messages[-2]['role'] == 'assistant':
+        return {"response": False}
+    else:
+        return {"response": True}
+    
 
 @app.get("/get_user_summary")
-def get_summary_by_id(user_id: str, api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def get_summary_by_id(
+    user_id: str,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     print_log("INFO", "Getting user's summary", extra={"user_id": user_id, "endpoint": "/get_user_summary"})
     logger.info("Getting user's summary", extra={"user_id": user_id, "endpoint": "/get_user_summary"})
-    try:
-        user_summary = get_user_summary(user_id)
-        print_log("INFO", "Successfully generated summary", extra={"user_id": user_id, "endpoint": "/get_user_summary"})
-        logger.info("Successfully generated summary", extra={"user_id": user_id, "endpoint": "/get_user_summary"})
-        return user_summary
-    except LookupError:
-        print_log("ERROR", "User not found", extra={"user_id": user_id, "endpoint": "/get_user_summary"})
-        logger.error("User not found", extra={"user_id": user_id, "endpoint": "/get_user_summary"})
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"User with ID {user_id} not found"
-        )
-    except Exception as e:
-        print_log("ERROR",f"Error getting user: {str(e)}", extra={"user_id": user_id, "endpoint": "/get_user_summary"}, exc_info=True)
-        logger.error(f"Error getting user: {str(e)}", extra={"user_id": user_id, "endpoint": "/get_user_summary"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+    user_summary = get_user_summary(user_id)
+    print_log("INFO", "Successfully generated summary", extra={"user_id": user_id, "endpoint": "/get_user_summary"})
+    logger.info("Successfully generated summary", extra={"user_id": user_id, "endpoint": "/get_user_summary"})
+    return user_summary
+    
     
 @app.get("/get_life_status")
-def get_life_status_by_id(user_id: str, api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def get_life_status_by_id(
+    user_id: str,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     print_log("INFO", "Getting user's life status", extra={"user_id": user_id, "endpoint": "/get_life_status"})
     logger.info("Getting user's life status", extra={"user_id": user_id, "endpoint": "/get_life_status"})
-    try:
-        life_status = get_user_life_status(user_id)
-        print_log("INFO", "Successfully generated life status", extra={"user_id": user_id, "endpoint": "/get_life_status"})
-        logger.info("Successfully generated life status", extra={"user_id": user_id, "endpoint": "/get_life_status"})
-        return life_status
-    except LookupError:
-        print_log("ERROR", "User not found", extra={"user_id": user_id, "endpoint": "/get_life_status"})
-        logger.error("User not found", extra={"user_id": user_id, "endpoint": "/get_life_status"})
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"User with ID {user_id} not found"
-        )
-    except Exception as e:
-        print_log("ERROR",f"Error getting user: {str(e)}", extra={"user_id": user_id, "endpoint": "/get_life_status"}, exc_info=True)
-        logger.error(f"Error getting user: {str(e)}", extra={"user_id": user_id, "endpoint": "/get_life_status"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+
+    life_status = get_user_life_status(user_id)
+    print_log("INFO", "Successfully generated life status", extra={"user_id": user_id, "endpoint": "/get_life_status"})
+    logger.info("Successfully generated life status", extra={"user_id": user_id, "endpoint": "/get_life_status"})
+    return life_status
     
 @app.post("/add_booking_point")
-def add_booking_point_by_user(user_id: str, api_key: str = Security(get_api_key)):
-    try:    
-        user = get_user(user_id)
-        user.add_point_for_booking()
-        return {"response": "ok"}
-    except Exception as e:
-        print_log("ERROR",f"Error: {str(e)}", extra={"user_id": user_id, "endpoint": "/add_booking_point"}, exc_info=True)
-        logger.error(f"Error: {str(e)}", extra={"user_id": user_id, "endpoint": "/add_booking_point"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+@catch_endpoint_error
+async def add_booking_point_by_user(
+    user_id: str,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
+    user = get_user(user_id)
+    user.add_point_for_booking()
+    return {"response": "ok"}
+   
 
 @app.post("/add_session_completion_point")
-def add_session_completion_point_by_user(user_id: str, api_key: str = Security(get_api_key)):
-    try:
-        user = get_user(user_id)
-        user.add_point_for_completing_session()
-        return {"response": "ok"}
-    except Exception as e:
-        print_log("ERROR",f"Error: {str(e)}", extra={"user_id": user_id, "endpoint": "/add_session_completion_point"}, exc_info=True)
-        logger.error(f"Error: {str(e)}", extra={"user_id": user_id, "endpoint": "/add_session_completion_point"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+@catch_endpoint_error
+async def add_session_completion_point_by_user(
+    user_id: str,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
+    user = get_user(user_id)
+    user.add_point_for_completing_session()
+    return {"response": "ok"}
+    
 
 @app.post("/create_pre_gg_report")
-def create_pre_gg_by_booking(request: BookingItem, api_key: str = Security(get_api_key)):
-    try:
-        create_pre_gg_report(request.booking_id)
-        return {"response": "ok"}
-    except Exception as e:
-        print_log("ERROR",f"Error: {str(e)}", extra={"booking_id": request.booking_id, "endpoint": "/create_pre_gg_report"}, exc_info=True)
-        logger.error(f"Error: {str(e)}", extra={"booking_id": request.booking_id, "endpoint": "/create_pre_gg_report"}, exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+@catch_endpoint_error
+async def create_pre_gg_by_booking(
+    request: BookingItem,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
+    create_pre_gg_report(request.booking_id)
+    return {"response": "ok"}
+    
 
 @app.get("/get_user_persona")
-def get_user_persona(user_id: str, api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def get_user_persona(
+    user_id: str,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     """Get user's legendary persona from the database"""
     logger.info("Getting user's persona", extra={"user_id": user_id, "endpoint": "/get_user_persona"})
 
-    try:
-        # Connect to database
-        db_params = {
-            'dbname': 'ourcoach',
-            'user': 'ourcoach',
-            'password': 'hvcTL3kN3pOG5KteT17T',
-            'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
-            'port': '5432'
-        }
-        conn = psycopg2.connect(**db_params)
-        cur = conn.cursor()
-
-        # Get onboarding data
-        cur.execute("SELECT onboarding FROM users WHERE id = %s", (user_id,))
-        result = cur.fetchone()
-        if not result:
-            raise HTTPException(status_code=404, detail="User not found")
-        
-        # Extract persona from onboarding JSON
-        onboarding = json.loads(result[0])
-        persona = onboarding.get('legendPersona', '')
+    # Connect to database
+    db_params = {
+        'dbname': 'ourcoach',
+        'user': 'ourcoach',
+        'password': 'hvcTL3kN3pOG5KteT17T',
+        'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
+        'port': '5432'
+    }
+    conn = psycopg2.connect(**db_params)
+    cur = conn.cursor()
+
+    # Get onboarding data
+    cur.execute("SELECT onboarding FROM users WHERE id = %s", (user_id,))
+    result = cur.fetchone()
+    if not result:
+        raise DBError(
+            user_id=user_id,
+            code="NoOnboardingError",
+            message="User not found in database"
+        )
+    # Extract persona from onboarding JSON
+    onboarding = json.loads(result[0])
+    persona = onboarding.get('legendPersona', '')
+    
+    if 'cur' in locals():
+        cur.close()
+    if 'conn' in locals():
+        conn.close()
         
-        return {"persona": persona}
+    return {"persona": persona}
 
-    except Exception as e:
-        logger.error(f"Error getting user persona: {str(e)}", extra={"user_id": user_id, "endpoint": "/get_user_persona"})
-        raise HTTPException(status_code=500, detail=str(e))
-    
-    finally:
-        if 'cur' in locals():
-            cur.close()
-        if 'conn' in locals():
-            conn.close()
+        
 
 @app.get("/get_recent_booking")
-def get_recent_booking(user_id: str, api_key: str = Security(get_api_key)):
+@catch_endpoint_error
+async def get_recent_booking(
+    user_id: str,
+    api_key: str = Depends(get_api_key)  # Change Security to Depends
+):
     """Get the most recent booking ID for a user"""
     logger.info("Getting recent booking", extra={"user_id": user_id, "endpoint": "/get_recent_booking"})
 
-    try:
-        # Connect to database
-        db_params = {
-            'dbname': 'ourcoach',
-            'user': 'ourcoach',
-            'password': 'hvcTL3kN3pOG5KteT17T',
-            'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
-            'port': '5432'
-        }
-        conn = psycopg2.connect(**db_params)
-        cur = conn.cursor()
-
-        # Get most recent booking where status == 2
-        cur.execute("""
-            SELECT booking_id 
-            FROM public.user_notes 
-            WHERE user_id = %s 
-            ORDER BY created_at DESC 
-            LIMIT 1
-        """, (user_id,))
-        result = cur.fetchone()
-        
-        if not result:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="No bookings found for user"
-            )
-        
-        booking_id = result[0]
-        logger.info(f"Found recent booking: {booking_id}", extra={"user_id": user_id, "endpoint": "/get_recent_booking"})
-        return {"booking_id": booking_id}
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error getting recent booking: {str(e)}", extra={"user_id": user_id, "endpoint": "/get_recent_booking"})
-        raise HTTPException(status_code=500, detail=str(e))
+    # Connect to database
+    db_params = {
+        'dbname': 'ourcoach',
+        'user': 'ourcoach',
+        'password': 'hvcTL3kN3pOG5KteT17T',
+        'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
+        'port': '5432'
+    }
+    conn = psycopg2.connect(**db_params)
+    cur = conn.cursor()
+
+    # Get most recent booking where status == 2
+    cur.execute("""
+        SELECT booking_id 
+        FROM public.user_notes 
+        WHERE user_id = %s 
+        ORDER BY created_at DESC 
+        LIMIT 1
+    """, (user_id,))
+    result = cur.fetchone()
+    
+    if not result:
+        raise DBError(
+            user_id=user_id,
+            code="NoBookingError",
+            message="No bookings found for user"
+        )
     
-    finally:
-        if 'cur' in locals():
-            cur.close()
-        if 'conn' in locals():
-            conn.close()
+    booking_id = result[0]
+    logger.info(f"Found recent booking: {booking_id}", extra={"user_id": user_id, "endpoint": "/get_recent_booking"})
+    if 'cur' in locals():
+        cur.close()
+    if 'conn' in locals():
+        conn.close() 
+    return {"booking_id": booking_id}

app/user.py

@@ -1,6 +1,7 @@
 import json
 import io
 import os
+import openai
 import pandas as pd
 from datetime import datetime, timezone
 import json
@@ -11,7 +12,8 @@ import random
 import logging
 import psycopg2
 from psycopg2 import sql
-import random
+from app.conversation_manager import ConversationManager
+from app.exceptions import BaseOurcoachException, OpenAIRequestError, UserError
 
 from app.flows import FINAL_SUMMARY_STATE, FINAL_SUMMARY_STATE, MICRO_ACTION_STATE, MOTIVATION_INSPIRATION_STATE, OPEN_DISCUSSION_STATE, POST_GG_STATE, PROGRESS_REFLECTION_STATE, PROGRESS_SUMMARY_STATE, EDUCATION_STATE, FOLLUP_ACTION_STATE, FUNFACT_STATE
 from pydantic import BaseModel
@@ -45,261 +47,21 @@ logger = logging.getLogger(__name__)
 def get_current_datetime():
     return datetime.now(timezone.utc)
 
-class ConversationManager:
-    def __init__(self, client, user, asst_id, intro_done=False):
-        self.user = user
-        self.intro_done = intro_done
-        self.assistants = {'general': Assistant('asst_vnucWWELJlCWadfAARwyKkCW', self), 'intro': Assistant('asst_baczEK65KKvPWIUONSzdYH8j', self)}
-
-        self.client = client
-        self.state = {'date': pd.Timestamp.now(tz='UTC').strftime("%d-%m-%Y %a %H:%M:%S")}
-
-        self.current_thread = self.create_thread()
-        self.daily_thread = None
-
-        logger.info("Initializing conversation state", extra={"user_id": self.user.user_id, "endpoint": "conversation_init"})
-    
-    def __getstate__(self):
-        state = self.__dict__.copy()
-        # Remove unpicklable or unnecessary attributes
-        if 'client' in state:
-            del state['client']
-        return state
-
-    def __setstate__(self, state):
-        self.__dict__.update(state)
-        # Re-initialize attributes that were not pickled
-        self.client = None
-
-    def create_thread(self):
-        user_interaction_guidelines =self.user.user_interaction_guidelines
-        thread = self.client.beta.threads.create()
-        self.system_message = self.add_message_to_thread(thread.id, "assistant", 
-                                f"""
-                                You are coaching:
-                                \n\n{user_interaction_guidelines}\n\n\
-                                Be mindful of this information at all times in order to
-                                be as personalised as possible when conversing. Ensure to
-                                follow the conversation guidelines and flow templates. Use the
-                                current state of the conversation to adhere to the flow. Do not let the user know about any transitions.\n\n
-                                ** Today is {self.state['date']}.\n\n **
-                                ** You are now in the INTRODUCTION STATE. **
-                                """)
-        return thread
-
-    def _get_current_thread_history(self, remove_system_message=True, _msg=None, thread=None):
-        if thread is None:
-            thread = self.current_thread
-        if not remove_system_message:
-            return [{"role": msg.role, "content": msg.content[0].text.value} for msg in self.client.beta.threads.messages.list(thread.id, order="asc")]
-        if _msg:
-            return [{"role": msg.role, "content": msg.content[0].text.value} for msg in self.client.beta.threads.messages.list(thread.id, order="asc", after=_msg.id)][1:]
-        return [{"role": msg.role, "content": msg.content[0].text.value} for msg in self.client.beta.threads.messages.list(thread.id, order="asc")][1:] # remove the system message
-
-    def add_message_to_thread(self, thread_id, role, content):
-        message = self.client.beta.threads.messages.create(
-            thread_id=thread_id,
-            role=role,
-            content=content
-        )
-        return message
-    
-    def _run_current_thread(self, text, thread=None, hidden=False):
-        if thread is None:
-            thread = self.current_thread
-        logger.warning(f"{self}", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-        logger.info(f"User Message: {text}", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-
-        # need to select assistant
-        if self.intro_done:
-            logger.info(f"Running general assistant", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-            run, just_finished_intro, message = self.assistants['general'].process(thread, text)
-        else:
-            logger.info(f"Running intro assistant", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-            run, just_finished_intro, message = self.assistants['intro'].process(thread, text) 
-        
-        
-        if run == 'cancelled':
-            self.intro_done = True
-            logger.info(f"Run was cancelled", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-            return None, {"message": "cancelled"}
-        elif run == 'change_goal':
-            self.intro_done = False
-            logger.info(f"Changing goal, reset to intro assistant", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-            return None, {"message": "change_goal"}
-        else:
-            status = run.status
-            logger.info(f"Run {run.id} {status} just finished intro: {just_finished_intro}", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-
-        if hidden:
-            self.client.beta.threads.messages.delete(message_id=message.id, thread_id=thread.id)
-            logger.info(f"Deleted hidden message: {message}", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-        
-        if just_finished_intro:
-            self.intro_done = True
-            logger.info(f"Intro done", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-            return self._get_current_thread_history(remove_system_message=False)[-1], {"message": "intro_done"}
-        
-        # NOTE: this is a hack, should get the response straight from the run  
-        return self._get_current_thread_history(remove_system_message=False)[-1], {"message": "coach_response"} 
-    
-    def _send_and_replace_message(self, text, replacement_msg=None):
-        logger.info(f"Sending hidden message: {text}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
-        response, _ = self._run_current_thread(text, hidden=True)
-
-        # check if there is a replacement message
-        if replacement_msg:
-            logger.info(f"Adding replacement message: {replacement_msg}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
-            # get the last message
-            last_msg = list(self.client.beta.threads.messages.list(self.current_thread.id, order="asc"))[-1]
-            logger.info(f"Last message: {last_msg}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
-            response = last_msg.content[0].text.value
-
-            # delete the last message
-            self.client.beta.threads.messages.delete(message_id=last_msg.id, thread_id=self.current_thread.id)
-            self.add_message_to_thread(self.current_thread.id, "user", replacement_msg)
-            self.add_message_to_thread(self.current_thread.id, "assistant", response)
-
-        logger.info(f"Hidden message response: {response}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
-        # NOTE: this is a hack, should get the response straight from the run
-        return {'content': response, 'role': 'assistant'}
-    
-    def _add_ai_message(self, text):
-        return self.add_message_to_thread(self.current_thread.id, "assistant", text)
-
-    def get_daily_thread(self):
-        if self.daily_thread is None:
-            messages = self._get_current_thread_history(remove_system_message=False)
-
-            self.daily_thread = self.client.beta.threads.create(
-            messages=messages[:30]
-            )
-
-            # Add remaining messages one by one if there are more than 30
-            for msg in messages[30:]:
-                self.add_message_to_thread(
-                    self.daily_thread.id,
-                    msg['role'],
-                    msg['content']
-                )
-            self.last_daily_message = list(self.client.beta.threads.messages.list(self.daily_thread.id, order="asc"))[-1]
-        else:
-            messages = self._get_current_thread_history(remove_system_message=False, _msg=self.last_daily_message)
-            self.client.beta.threads.delete(self.daily_thread.id)
-            self.daily_thread = self.client.beta.threads.create(messages=messages)
-            self.last_daily_message = list(self.client.beta.threads.messages.list(self.daily_thread.id, order="asc"))[-1]
-        logger.info(f"Daily Thread: {self._get_current_thread_history(thread=self.daily_thread)}", extra={"user_id": self.user.user_id, "endpoint": "send_morning_message"})
-        logger.info(f"Last Daily Message: {self.last_daily_message}", extra={"user_id": self.user.user_id, "endpoint": "send_morning_message"})
-        return self._get_current_thread_history(thread=self.daily_thread)
-        # [{"role":, "content":}, ....]
-
-    def _send_morning_message(self, text, add_to_main=False):
-        # create a new thread
-        # OPENAI LIMITATION: Can only attach a maximum of 32 messages when creating a new thread
-        messages = self._get_current_thread_history(remove_system_message=False)
-        if len(messages) >= 29:
-            messages = [{"content": """ Remember who you are coaching.
-                        Be mindful of this information at all times in order to
-                        be as personalised as possible when conversing. Ensure to
-                        follow the conversation guidelines and flow provided.""", "role":"assistant"}] + messages[-29:]
-        logger.info(f"Current Thread Messages: {messages}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
-        
-        temp_thread = self.client.beta.threads.create(messages=messages)
-        logger.info(f"Created Temp Thread: {temp_thread}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
-        
-        if add_to_main:
-            logger.info(f"Adding message to main thread: {text}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
-            self.add_message_to_thread(self.current_thread.id, "assistant", text)
-
-        self.add_message_to_thread(temp_thread.id, "user", text)
-
-        self._run_current_thread(text, thread=temp_thread)
-        response = self._get_current_thread_history(thread=temp_thread)[-1]
-        logger.info(f"Hidden Response: {response}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
-
-        # delete temp thread
-        self.client.beta.threads.delete(temp_thread.id)
-        logger.info(f"Deleted Temp Thread: {temp_thread}", extra={"user_id": self.user.user_id, "endpoint": "send_hidden_message"})
-
-        return response
-    
-    def delete_hidden_messages(self, old_thread=None):
-        if old_thread is None:
-            old_thread = self.current_thread
-
-        # create a new thread
-        messages = [msg for msg in self._get_current_thread_history(remove_system_message=False) if not msg['content'].startswith("[hidden]")]
-        if len(messages) >= 29:
-            messages = messages[-29:]
-        logger.info(f"Current Thread Messages: {messages}", extra={"user_id": self.user.user_id, "endpoint": "delete_hidden_messages"})
-
-        new_thread = self.client.beta.threads.create(messages=messages)
-
-        # delete old thread
-        self.client.beta.threads.delete(old_thread.id)
-
-        # set current thread
-        self.current_thread = new_thread
-
-
-    def do_first_reflection(self):
-        question_format = random.choice(['[Option 1] Likert-Scale Objective Question','[Option 2] Multiple-Choice Question','[Option 3] Yes-No Question'])
-
-        tt = f"** Today's reflection topic is the user's most important area. **"
-        prompt = PROGRESS_REFLECTION_STATE + f"** Start the PROGRESS_REFLECTION_STATE flow **" + tt
-        logger.info(f"First reflection started", extra={"user_id": self.user.user_id, "endpoint": "do_first_reflection"})
-        response, _ = self._run_current_thread(prompt)
-        
-        return response
-    
-    def cancel_run(self, run):
-        cancel = self.assistants['general'].cancel_run(run, self.current_thread)
-        if cancel:
-            logger.info(f"Run cancelled", extra={"user_id": self.user.user_id, "endpoint": "cancel_run"})
-        return True
-
-    def clone(self, client):
-        """Creates a new ConversationManager with copied thread messages."""
-        # Create new instance with same init parameters
-        new_cm = ConversationManager(
-            client,
-            self.user,
-            self.assistants['general'].id,
-            intro_done=True
-        )
-
-        # Get all messages from current thread
-        messages = self._get_current_thread_history(remove_system_message=False)
-        
-        # Delete the automatically created thread from constructor
-        new_cm.client.beta.threads.delete(new_cm.current_thread.id)
-        
-        # Create new thread with first 30 messages
-        new_cm.current_thread = new_cm.client.beta.threads.create(
-            messages=messages[:30]
-        )
-
-        # Add remaining messages one by one if there are more than 30
-        for msg in messages[30:]:
-            new_cm.add_message_to_thread(
-                new_cm.current_thread.id,
-                msg['role'],
-                msg['content']
-            )
-
-        # Copy other relevant state
-        new_cm.state = self.state
-
-        return new_cm
-    
-    def __str__(self):
-        return f"ConversationManager(intro_done={self.intro_done}, assistants={self.assistants}, current_thread={self.current_thread})"
-    
-    def __repr__(self):
-        return (f"ConversationManager("
-                f"intro_done={self.intro_done}, current_thread={self.current_thread})")
-
 class User:
+    def catch_error(func):
+        def wrapper(self, *args, **kwargs):
+            try:
+                return func(self, *args, **kwargs)
+            except (BaseOurcoachException, openai.BadRequestError) as e:
+                raise e
+            except openai.BadRequestError as e:
+                raise OpenAIRequestError(user_id=self.user_id, message="OpenAI Request Error", e=str(e))
+            except Exception as e:
+                # Handle other exceptions
+                logger.error(f"An unexpected error occurred in User: {e}")
+                raise UserError(user_id=self.user_id, message="Unexpected error in User", e=str(e))
+        return wrapper
+
     def __init__(self, user_id, user_info, client, asst_id):
         self.user_id = user_id
         self.client = client
@@ -354,81 +116,79 @@ class User:
         self.user_interaction_guidelines = self.generate_user_interaction_guidelines(user_info, client)
         self.conversations = ConversationManager(client, self, asst_id)
 
+    @catch_error
     def extend_growth_plan(self):
         # Change current growth plan to 14d growth plan
         logger.info(f"Changing plan to 14d...", extra={"user_id": self.user_id, "endpoint": "extend_growth_plan"})
-        try:
-            new_growth_plan = {"growthPlan": [
-                    {
-                    "day": 1,
-                    "coachingTheme": "MICRO_ACTION_STATE"
-                    },
-                    {
-                    "day": 2,
-                    "coachingTheme": "FOLLUP_ACTION_STATE"
-                    },
-                    {
-                    "day": 3,
-                    "coachingTheme": "OPEN_DISCUSSION_STATE"
-                    },
-                    {
-                    "day": 4,
-                    "coachingTheme": "MICRO_ACTION_STATE"
-                    },
-                    {
-                    "day": 5,
-                    "coachingTheme": "FOLLUP_ACTION_STATE"
-                    },
-                    {
-                    "day": 6,
-                    "coachingTheme": "FUNFACT_STATE"
-                    },
-                    {
-                    "day": 7,
-                    "coachingTheme": "PROGRESS_REFLECTION_STATE"
-                    },
-                    {
-                    "day": 8,
-                    "coachingTheme": "MICRO_ACTION_STATE"
-                    },
-                    {
-                    "day": 9,
-                    "coachingTheme": "FOLLUP_ACTION_STATE"
-                    },
-                    {
-                    "day": 10,
-                    "coachingTheme": "OPEN_DISCUSSION_STATE"
-                    },
-                    {
-                    "day": 11,
-                    "coachingTheme": "MICRO_ACTION_STATE"
-                    },
-                    {
-                    "day": 12,
-                    "coachingTheme": "FOLLUP_ACTION_STATE"
-                    },
-                    {
-                    "day": 13,
-                    "coachingTheme": "FUNFACT_STATE"
-                    },
-                    {
-                    "day": 14,
-                    "coachingTheme": "FINAL_SUMMARY_STATE"
-                    }
-                ]
-            }
-            self.growth_plan = CircularQueue(array=new_growth_plan['growthPlan'], user_id=self.user_id)        
-            logger.info(f"User Growth Plan: {self.growth_plan} (Day: {self.growth_plan.current()['day']}/{len(self.growth_plan.array)})", extra={"user_id": self.user_id, "endpoint": "user_init"})
-            logger.info(f"Success.", extra={"user_id": self.user_id, "endpoint": "extend_growth_plan"})
-        except Exception as e:
-            logger.error(f"Error occured when changing plan: {e}", extra={"user_id": self.user_id, "endpoint": "extend_growth_plan"})
-            raise
-
-
+        new_growth_plan = {"growthPlan": [
+                {
+                "day": 1,
+                "coachingTheme": "MICRO_ACTION_STATE"
+                },
+                {
+                "day": 2,
+                "coachingTheme": "FOLLUP_ACTION_STATE"
+                },
+                {
+                "day": 3,
+                "coachingTheme": "OPEN_DISCUSSION_STATE"
+                },
+                {
+                "day": 4,
+                "coachingTheme": "MICRO_ACTION_STATE"
+                },
+                {
+                "day": 5,
+                "coachingTheme": "FOLLUP_ACTION_STATE"
+                },
+                {
+                "day": 6,
+                "coachingTheme": "FUNFACT_STATE"
+                },
+                {
+                "day": 7,
+                "coachingTheme": "PROGRESS_REFLECTION_STATE"
+                },
+                {
+                "day": 8,
+                "coachingTheme": "MICRO_ACTION_STATE"
+                },
+                {
+                "day": 9,
+                "coachingTheme": "FOLLUP_ACTION_STATE"
+                },
+                {
+                "day": 10,
+                "coachingTheme": "OPEN_DISCUSSION_STATE"
+                },
+                {
+                "day": 11,
+                "coachingTheme": "MICRO_ACTION_STATE"
+                },
+                {
+                "day": 12,
+                "coachingTheme": "FOLLUP_ACTION_STATE"
+                },
+                {
+                "day": 13,
+                "coachingTheme": "FUNFACT_STATE"
+                },
+                {
+                "day": 14,
+                "coachingTheme": "FINAL_SUMMARY_STATE"
+                }
+            ]
+        }
+        self.growth_plan = CircularQueue(array=new_growth_plan['growthPlan'], user_id=self.user_id)        
+        logger.info(f"User Growth Plan: {self.growth_plan} (Day: {self.growth_plan.current()['day']}/{len(self.growth_plan.array)})", extra={"user_id": self.user_id, "endpoint": "user_init"})
+        logger.info(f"Success.", extra={"user_id": self.user_id, "endpoint": "extend_growth_plan"})
+        return True
+    
+    @catch_error
     def add_recent_wins(self, wins, context = None):
         prompt = f"""
         ## Role
-        You are an expert in writing achievement message and progress notification. Your task is to use the user's achievement and context to formulate a short achievement message/progress notification. The output must be a one sentence short message (less than 15 words) in this JSON output schema:
+        You are an expert in writing achievement message and progress notification. Your task is to use the user's achievement and context to formulate a short and creative achievement message/progress notification. The output must be a one sentence short message (less than 15 words) in this JSON output schema:
 
         ```json
         {{
@@ -445,7 +205,7 @@ class User:
         Output:
         ```
         {{
-        achievement_message: You have completed a 10k run!
+        achievement_message: You crushed it! Completing that 10k run is a huge milestone—way to go!
         }}
         ```
 
@@ -489,6 +249,7 @@ class User:
             self.recent_wins.pop()
             self.recent_wins.insert(0,achievement_message)
 
+    @catch_error
     def add_life_score_point(self, variable, points_added, notes):
         if variable == 'Personal Growth':
             self.personal_growth_score += points_added
@@ -505,7 +266,8 @@ class User:
         elif variable == 'Relationship':
             self.relationship_score += points_added
             logger.info(f"Added {points_added} points to Relationship for {notes}", extra={"user_id": self.user_id, "endpoint": "add_life_score_point"})
-        
+    
+    @catch_error
     def get_current_goal(self, full=False):
         # look for most recent goal with status = ONGOING
         for goal in self.goal[::-1]:
@@ -520,6 +282,7 @@ class User:
                 return self.goal[-1].content
             return None
 
+    @catch_error
     def update_goal(self, goal, status, content=None):
         if goal is None:
             # complete the current goal
@@ -538,6 +301,7 @@ class User:
                 return True
         return False
 
+    @catch_error
     def set_goal(self, goal, goal_area, add=True, completed=False):
         current_goal = self.get_current_goal()
         
@@ -563,6 +327,7 @@ class User:
             else:
                 self.update_goal(current_goal, "ONGOING", content=goal)
 
+    @catch_error
     def update_recommended_micro_action_status(self, micro_action, status):
         for ma in self.recommended_micro_actions:
             if ma.content == micro_action:
@@ -571,10 +336,12 @@ class User:
                 return True
         return False
     
+    @catch_error
     def add_ai_message(self, text):
         self.conversations._add_ai_message(text)
         return text
 
+    @catch_error
     def reset_conversations(self):
         self.conversations = ConversationManager(self.client, self, self.asst_id)
         self.growth_plan.reset()
@@ -592,7 +359,15 @@ class User:
         self.reminders = None
         self.recent_wins = []
 
+    @catch_error
+    def get_last_user_message(self):
+        # find the last message from 'role': 'user' in the conversation history
+        messages = self.conversations._get_current_thread_history(remove_system_message=False)
+        for msg in messages[::-1]:
+            if msg['role'] == 'user':
+                return msg['content']
 
+    @catch_error
     def generate_user_interaction_guidelines(self, user_info, client):
         logger.info(f"Generating user interaction guidelines for user: {self.user_id}", extra={"user_id": self.user_id, "endpoint": "generate_user_interaction_guidelines"})
         # prompt = f"A 'profile' is a document containing rich insights on users for the purpose of \
@@ -628,24 +403,31 @@ class User:
         
         return user_guideline
     
+    @catch_error
     def get_recent_run(self):
         return self.conversations.assistants['general'].recent_run
     
-    def cancel_run(self, run):
-        self.conversations.cancel_run(run)
+    @catch_error
+    def cancel_run(self, run, thread=None):
+        logger.info(f"(user) Cancelling run: {run}", extra={"user_id": self.user_id, "endpoint": "cancel_run"})
+        self.conversations.cancel_run(run, thread)
 
+    @catch_error
     def update_conversation_state(self, stage, last_interaction):
         self.conversation_state['stage'] = stage
         self.conversation_state['last_interaction'] = last_interaction
 
+    @catch_error
     def _get_current_thread(self):
         return self.conversations.current_thread
 
+    @catch_error
     def send_message(self, text):
-        response, info = self.conversations._run_current_thread(text)
-        logger.info(f"Info: {info}", extra={"user_id": self.user_id, "endpoint": "user_send_message"})
+        response, run = self.conversations._run_current_thread(text)
+        message = run.metadata.get("message", "No message")
+        logger.info(f"Message: {message}", extra={"user_id": self.user_id, "endpoint": "user_send_message"})
 
-        if info.get("message") == "cancelled":
+        if message == "start_now":
             # must do current plan now
             action = self.growth_plan.current()
             logger.info(f"Current Action: {action}", extra={"user_id": self.user_id, "endpoint": "user_send_message"})
@@ -658,7 +440,7 @@ class User:
             # Move to the next action
             self.growth_plan.next()
 
-        elif info.get("message") == "change_goal":
+        elif message == "change_goal":
             # send the change goal prompt
             logger.info("Sending change goal message...", extra={"user_id": self.user_id, "endpoint": "user_send_message"})
             prompt = f"""
@@ -695,6 +477,7 @@ class User:
         logger.info(f"Response: {response}", extra={"user_id": self.user_id, "endpoint": "user_send_message"})
         return response
 
+    @catch_error
     def get_reminders(self, date=None):
         if self.reminders is None:
             return []
@@ -710,6 +493,7 @@ class User:
             return [reminder for reminder in self.reminders if reminder['timestamp'].date() == date]
         return self.reminders
     
+    @catch_error
     def find_same_reminder(self, reminder_text):
         logger.info(f"Finding similar reminders: {self.reminders} to: {reminder_text}", extra={"user_id": self.user_id, "endpoint": "find_same_reminder"})
         response = self.client.beta.chat.completions.parse(
@@ -726,6 +510,7 @@ class User:
         logger.info(f"Similar reminder idx: reminders[{index}]", extra={"user_id": self.user_id, "endpoint": "find_same_reminder"})
         return index
         
+    @catch_error
     def set_reminder(self, reminder):
         db_params = {
             'dbname': 'ourcoach',
@@ -782,6 +567,7 @@ class User:
             
         logger.info(f"Reminders: {self.reminders}", extra={"user_id": self.user_id, "endpoint": "set_reminder"})
 
+    @catch_error
     def get_messages(self, exclude_system_msg=True, show_hidden=False):
         if not exclude_system_msg:
             return self.conversations._get_current_thread_history(False)
@@ -790,9 +576,11 @@ class User:
                 return list(filter(lambda x: not (x['content'].startswith("** It is a new day:") or x['content'].startswith("Pay attention to the current state you are in") or x['content'].startswith("Date changed to")), self.conversations._get_current_thread_history(exclude_system_msg)))
             return list(filter(lambda x: not (x['content'].startswith("** It is a new day:") or x['content'].startswith("Pay attention to the current state you are in") or x['content'].startswith("Date changed to") or x['content'].startswith("[hidden]")), self.conversations._get_current_thread_history(exclude_system_msg)))
     
+    @catch_error
     def set_intro_done(self):
         self.conversations.intro_done = True
 
+    @catch_error
     def do_theme(self, theme, date, day):
         logger.info(f"Doing theme: {theme}", extra={"user_id": self.user_id, "endpoint": "do_theme"})
         
@@ -907,6 +695,7 @@ class User:
 
         return response, prompt
 
+    @catch_error
     def change_date(self, date):
         logger.info(f"Changing date from {self.conversations.state['date']} to {date}", 
                    extra={"user_id": self.user_id, "endpoint": "user_change_date"})
@@ -960,6 +749,7 @@ class User:
         logger.info(f"Date Updated: {self.conversations.state['date']}", extra={"user_id": self.user_id, "endpoint": "user_change_date"})
         return {'response': response, 'theme_prompt': '[hidden]'+prompt}
     
+    @catch_error
     def update_user_info(self, new_info):
         logger.info(f"Updating user info: [{self.user_info}] with: [{new_info}]", extra={"user_id": self.user_id, "endpoint": "update_user_info"})
         # make an api call to gpt4o to compare the current user_info and the new info and create a new consolidated user_info
@@ -988,6 +778,7 @@ class User:
         logger.info(f"Updated user info: {self.user_info}", extra={"user_id": self.user_id, "endpoint": "update_user_info"})
         return True
 
+    @catch_error
     def _summarize_zoom(self, zoom_ai_summary):        
         logger.info(f"Summarizing zoom ai summary", extra={"user_id": self.user_id, "endpoint": "summarize_zoom"})
         # make an api call to gpt4o to summarize the zoom_ai_summary and produce a text with a focus on the most amount of user insight and info extracted
@@ -1005,6 +796,7 @@ class User:
         logger.info(f"Summary: {response.choices[0].message.content}", extra={"user_id": self.user_id, "endpoint": "summarize_zoom"})
         return {'overview': response.choices[0].message.content}
 
+    @catch_error
     def _update_user_data(self, data_type, text_input, extra_text=""):
         data_mapping = {
             'micro_actions': {
@@ -1041,32 +833,29 @@ class User:
             f"Text:\n{text_input}"
         )
 
-        try:
-            current_time = datetime.now(timezone.utc).strftime("%d-%m-%Y %a %H:%M:%S")
-            
-            response = self.client.beta.chat.completions.parse(
-                model="gpt-4o",
-                messages=[{"role": "user", "content": prompt}],
-                response_format=UserDataResponse,
-                temperature=0.2
-            )
-
-            data = getattr(response.choices[0].message.parsed, 'data')
-            
-            # Update the common fields for each item
-            for item in data:
-                item.role = "assistant"
-                item.user_id = self.user_id
-                item.status = mapping['status']
-                item.created_at = current_time
-                item.updated_at = current_time
-
-            logger.info(f"Updated {data_type}: {data}", extra={"user_id": self.user_id, "endpoint": mapping['endpoint']})
-            getattr(self, mapping['attribute']).extend(data)
-            
-        except Exception as e:
-            logger.error(f"Failed to update {data_type}: {e}", extra={"user_id": self.user_id})
+        current_time = datetime.now(timezone.utc).strftime("%d-%m-%Y %a %H:%M:%S")
+        
+        response = self.client.beta.chat.completions.parse(
+            model="gpt-4o",
+            messages=[{"role": "user", "content": prompt}],
+            response_format=UserDataResponse,
+            temperature=0.2
+        )
 
+        data = getattr(response.choices[0].message.parsed, 'data')
+        
+        # Update the common fields for each item
+        for item in data:
+            item.role = "assistant"
+            item.user_id = self.user_id
+            item.status = mapping['status']
+            item.created_at = current_time
+            item.updated_at = current_time
+
+        logger.info(f"Updated {data_type}: {data}", extra={"user_id": self.user_id, "endpoint": mapping['endpoint']})
+        getattr(self, mapping['attribute']).extend(data)
+
+    @catch_error
     def update_user_data(self, gg_report):
         self._update_user_data('micro_actions', gg_report[0]['answer'])
 
@@ -1077,6 +866,7 @@ class User:
         
         self._update_goal(gg_report[4]['answer'])
 
+    @catch_error
     def _update_goal(self, goal_text):
         prompt = f"""
         The user has a current goal: {self.get_current_goal()}
@@ -1190,6 +980,7 @@ class User:
         else:
             logger.info(f"User goal remains unchanged.", extra={"user_id": self.user_id, "endpoint": "_update_goal"})
 
+    @catch_error
     def update_micro_action_status(self, completed_micro_action):
         if completed_micro_action:
             self.micro_actions[-1].status = "COMPLETE"
@@ -1201,25 +992,30 @@ class User:
                 self.add_life_score_point(variable = self.get_current_goal(full=True).area, points_added = 10, notes = f"Completing the {num_of_micro_actions_completed}-th micro-action")
                 self.add_recent_wins(wins = "You have completed a micro action!", context= self.micro_actions[-1]['content'])
 
+    @catch_error
     def trigger_deep_reflection_point(self, area_of_deep_reflection):
         if len(area_of_deep_reflection)>0:
             for area in area_of_deep_reflection:
                 self.add_life_score_point(variable = area, points_added = 5, notes = f"Doing a deep reflection about {area}")
                 self.add_recent_wins(wins = f"You have done a deep reflection about your {area}!", context = 'Deep reflection')
 
+    @catch_error
     def add_point_for_booking(self):
         self.add_life_score_point(variable = self.get_current_goal(full=True).area, points_added = 5, notes = "Booking a GG session")
         self.add_recent_wins(wins = "You have booked a Growth Guide session!", context = "Growth Guide is a life coach")
     
+    @catch_error
     def add_point_for_completing_session(self):
         self.add_life_score_point(variable = self.get_current_goal(full=True).area, points_added = 20, notes = "Completing a GG session")
         self.add_recent_wins(wins = "You have completed a Growth Guide session!", context = "Growth Guide is a life coach")
-        
+    
+    @catch_error
     def build_ourcoach_report(self, overview, action_plan, gg_session_notes):
         logger.info(f"Building ourcoach report", extra={"user_id": self.user_id, "endpoint": "build_ourcoach_report"})
         ourcoach_report = {'overview': overview['overview'], 'action_plan': action_plan, 'others': gg_session_notes}
         return ourcoach_report
 
+    @catch_error
     def process_growth_guide_session(self, session_data, booking_id):
         logger.info(f"Processing growth guide session data: {session_data}", extra={"user_id": self.user_id, "endpoint": "process_growth_guide_session"})
         self.last_gg_session = booking_id
@@ -1252,6 +1048,7 @@ class User:
         logger.info(f"Response: {response}", extra={"user_id": self.user_id, "endpoint": "process_growth_guide_session"})
         return response
     
+    @catch_error
     def ask_to_schedule_growth_guide_reminder(self, date):
         prompt = f""" ** The user has scheduled a Growth Guide session for {date} (current date: {self.conversations.state['date']}) **\n\nFirstly, greet the user warmly and excitedly and let them know that they have succesfully booked their Growth Guide session. 
         Then, ask the user if they would like a reminder for the Growth Guide session. If they would like a reminder, create a new reminder 1 hour before their scheduled session."""
@@ -1261,189 +1058,27 @@ class User:
         logger.info(f"Response: {response}", extra={"user_id": self.user_id, "endpoint": "process_growth_guide_session"})
         return response
 
-    def __hash__(self) -> int:
-        return hash(self.user_id)
-    
-    def _prepare_growth_guide_report(self, zoom_transcript):
-        system_prompt = """You are an AI assistant tasked with transforming a raw Zoom transcript of a coaching session into a well-structured report. 
-        The report should be organized into the following sections:
-1) Session Details
-2) Session Objectives
-3) Summary of Discussion
-4) Key Takeaways
-5) Action Items
-6) Next Steps
-7) Additional Notes (if any)
-Ensure that each section is clearly labeled and the information is concise and well-organized. 
-Use bullet points or numbered lists where appropriate to enhance readability."""
-        prompt = f"Using the above format, convert the provided raw Zoom transcript into a structured report. Ensure clarity, coherence, and completeness in each section.\n\
-            Raw Zoom Transcript:\n\n{zoom_transcript}.\n\nKeep the report personalised to the 'user': {self.user_info}."
-
-        response = self.client.chat.completions.create(
-            model="gpt-4o-mini",
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": prompt}
-            ],
-            temperature=0.2
-        )
-        return response.choices[0].message.content
-    
-    # def summarize_chat_history(self):
-    #     prompt = f"""
-    #     # ROLE #
-    #     You are a world-class life coach dedicated to helping users improve their mental well-being, physical health, relationships, career, financial stability, and personal growth.
-    #     You have done some dialogues with your client and you need to take some coaching notes to understand the key characteristic of your client and the topics that can be followed up in the next
-    #     conversation.
-    #     # TASK #
-    #     Based on the chat history that is available, you must create a coaching notes that includes these parts:
-    #     1. Updates from last session (based on this latest summary). This is the latest coaching note from previous session that might be helpful for you as an additional context for the new coaching note:
-    #         {request.latest_summary}
-    #     2. Celebrations/what has the client tried?
-    #     3. Today's focus
-    #     4. Recurring themes
-    #     5. New awareness created
-    #     6. What did I learn about the client
-    #     7. Notes to self
-    #     8. Client committed to
-    #     9. Events/problems to be followed up in the next session
-    #     ##USER PROFILE##
-    #     This is the profile of the user that you’re coaching:
-    #     a) User Name: {request.firstName}
-    #     b) Pronouns: {request.pronouns}
-    #     c) Birthday: {request.birthDate}
-    #     d) Ideal life, according to the user: {request.describeIdealLife}
-    #     e) What matters most to user (area of focus), according to the user: {request.mattersMost}
-    #     f) Goals in areas of focus: {request.goals}
-    #     g) User's source of inspiration: {request.inspiration}
-    #     h) Email address: {request.email}
-    #     i) Whatsapp number: {request.phoneNo}
-    #     k) User's MBTI: {request.mbti}
-    #     l) User's Love Language: {request.loveLanguage}
-    #     m) Whether or not the user have tried coaching before: {request.triedCoaching}
-    #     n) What does the user do for a living: 
-    #         {doLiving}
-    #     o) The user's current situation: {request.mySituation}
-    #     p) Who is the most important person for the user: 
-    #         {whoImportant}
-    #     q) Legendary persona: {request.legendPersona}
-    #     """
-            
-    #     response = self.client.chat.completions.create(
-    #         model="gpt-4o",
-    #         messages=[{"role": "user", "content": prompt}],
-    #         response_format = {
-    #             "type": "json_schema",
-    #             "json_schema": {
-    #             "name": "goal_determination",
-    #             "strict": True,
-    #             "schema": {
-    #                 "type": "object",
-    #                 "properties": {
-    #                 "same_or_not": {
-    #                     "type": "boolean",
-    #                     "description": "Indicates whether the new goal is the same as the current goal."
-    #                 },
-    #                 "goal": {
-    #                     "type": "string",
-    #                     "description": "The final goal determined based on input."
-    #                 },
-    #                 "area": {
-    #                     "type": "string",
-    #                     "description": "The area of the goal.",
-    #                     "enum": [
-    #                     "Personal Growth",
-    #                     "Career Growth",
-    #                     "Relationship",
-    #                     "Mental Well-Being",
-    #                     "Health and Wellness"
-    #                     ]
-    #                 }
-    #                 },
-    #                 "required": [
-    #                 "same_or_not",
-    #                 "goal",
-    #                 "area"
-    #                 ],
-    #                 "additionalProperties": False
-    #             }
-    #             }
-    #         },
-    #         temperature=0.2
-    #     )
-
-    #     final_goal = json.loads(response.choices[0].message.content)['goal']
-    #     final_goal_area = json.loads(response.choices[0].message.content)['area']
-    #     # if json.loads(response.choices[0].message.content)['same_or_not']:
-    #     #     final_goal_status = self.get_current_goal()['status']
-    #     # else:
-    #     #     final_goal_status = 'PENDING'
-        
-    #     if json.loads(response.choices[0].message.content)['same_or_not'] == False:
-    #         self.set_goal(final_goal, final_goal_area)
-    #         logger.info(f"User goal updated to: {final_goal}", extra={"user_id": self.user_id, "endpoint": "_update_goal"})
-    #     else:
-    #         logger.info(f"User goal remains unchanged.", extra={"user_id": self.user_id, "endpoint": "_update_goal"})
-
-    def _infer_follow_ups(self, created, context):
-        prompt = f"Infer the datetime of the next follow-up for the user based on the created date:{created} and the context:{context}"
-
-        system_prompt = """
-        You are an event reminder that excels at estimating when to follow up events with the users. Your task is to infer the next follow-up date and time for a user based on the created date (%d-%m-%Y %a %H:%M:%S) and the provided context. 
-        Only output a single string representing the follow-up datetime in the format '%d-%m-%Y %a %H:%M:%S'. Ensure that the inferred follow-up date occurs after the current date.
-        # Output Format
-        
-        - Output a single string representing the follow-up date.
-        - Format the string as: '%d-%m-%Y %a %H:%M:%S' (e.g., '20-11-2024 Wed 14:30:45').
-        
-        # Notes
-        
-        - The follow-up date must be after the current date.
-        - Use the context to infer the time. If a time cannot be inferred, then set it as 10:30:00.
-        - Only provide the date string, with no additional text.
-        # Example
-        User: Infer the date of the follow-up for the user based on the created date: '01-01-2024 Mon 10:10:12' and the context: I will have an exam the day after tomorrow
-        Assistant: '03-01-2024 Wed 10:30:00'
-        User: Infer the date of the follow-up for the user based on the created date: '02-01-2024 Tue 14:00:00' and the context: I will have a lunch tomorrow with friends
-        Assistant: '03-01-2024 Wed 12:00:00'
-        User: Infer the date of the follow-up for the user based on the created date: '17-11-2024 Sun 11:03:43' and the context: Next Wednesday, i will have a dinner with someone
-        Assistant: '20-11-2024 Wed 19:30:00'      
-        User: Infer the date of the follow-up for the user based on the created date: '20-11-2024 Wed 10:33:15' and the context: I have a weekend trip planned
-        Assistant: '22-11-2024 Fri 23:30:00'  
-        User: Infer the date of the follow-up for the user based on the created date: '20-11-2024 Wed 10:33:15' and the context: I have a lunch this Sunday
-        Assistant: '24-11-2024 Sun 12:00:00'   
-        """
-        response = self.client.chat.completions.create(
-            model="gpt-4o",
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": prompt}
-            ],
-            top_p=0.1
-        )
-        return response.choices[0].message.content
-
+    @catch_error
     def infer_memento_follow_ups(self):
-        try:
-            mementos_path = os.path.join("mementos", "to_upload", f"{self.user_id}", "*.json")
-            # mementos_path = f"mementos/to_upload/{self.user_id}/*.json"
-            
-            for file_path in glob.glob(mementos_path):
-                with open(file_path, 'r+') as file:
-                    data = json.load(file)
-                    infered_follow_up = self._infer_follow_ups(data['created'], data['context'])
-                    logger.info(f"[Infered Follow Up]: {infered_follow_up}", extra={"user_id": self.user_id, "endpoint": "infer_memento_follow_ups"})
-                    data['follow_up_on'] = infered_follow_up
-                    file.seek(0)
-                    json.dump(data, file, indent=4)
-                    file.truncate()
-            return True
-        except Exception as e:
-            return False
+        mementos_path = os.path.join("mementos", "to_upload", f"{self.user_id}", "*.json")
+        # mementos_path = f"mementos/to_upload/{self.user_id}/*.json"
+        
+        for file_path in glob.glob(mementos_path):
+            with open(file_path, 'r+') as file:
+                data = json.load(file)
+                infered_follow_up = self._infer_follow_ups(data['created'], data['context'])
+                logger.info(f"[Infered Follow Up]: {infered_follow_up}", extra={"user_id": self.user_id, "endpoint": "infer_memento_follow_ups"})
+                data['follow_up_on'] = infered_follow_up
+                file.seek(0)
+                json.dump(data, file, indent=4)
+                file.truncate()
+        return True
     
+    @catch_error
     def get_daily_messages(self):
         return self.conversations.get_daily_thread()
 
+    @catch_error
     def change_assistant(self, asst_id):
         self.asst_id = asst_id
         self.conversations.assistants['general'] = Assistant(self.asst_id, self.conversations)
@@ -1495,18 +1130,15 @@ Use bullet points or numbered lists where appropriate to enhance readability."""
 
     def save_user(self):
         # Construct the file path dynamically for cross-platform compatibility
-        try:
-            file_path = os.path.join("users", "to_upload", f"{self.user_id}.pkl")
-            
-            # Ensure the directory exists
-            os.makedirs(os.path.dirname(file_path), exist_ok=True)
-            
-            # Save the user object as a pickle file
-            with open(file_path, 'wb') as file:
-                pickle.dump(self, file)
-            return file_path
-        except Exception as e:
-            return False
+        file_path = os.path.join("users", "to_upload", f"{self.user_id}.pkl")
+        
+        # Ensure the directory exists
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        
+        # Save the user object as a pickle file
+        with open(file_path, 'wb') as file:
+            pickle.dump(self, file)
+        return file_path
         
     @staticmethod
     def load_user(user_id, client):

app/utils.py

@@ -6,6 +6,7 @@ from dotenv import load_dotenv
 from fastapi import FastAPI, HTTPException, Security, Query, status
 from fastapi.security import APIKeyHeader
 from openai import OpenAI
+import openai
 import pandas as pd
 from pydantic import BaseModel
 import os
@@ -28,6 +29,8 @@ import PyPDF2
 import secrets
 import string
 
+from app.exceptions import BaseOurcoachException, DBError, OpenAIRequestError, UtilsError
+
 load_dotenv()
 
 # Environment Variables for API Keys
@@ -45,21 +48,32 @@ logger = logging.getLogger(__name__)
 # Replace the simple TTLCache with our custom implementation
 user_cache = CustomTTLCache(ttl=120, cleanup_interval=30) # 2 minutes TTL
 
+def catch_error(func):
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except BaseOurcoachException as e:
+            raise e
+        except openai.BadRequestError as e:
+            raise OpenAIRequestError(user_id='no-user', message="Bad Request to OpenAI", code="OpenAIError")
+        except Exception as e:
+            # Handle other exceptions
+            logger.error(f"An unexpected error occurred in Utils: {e}")
+            raise UtilsError(user_id='no-user', message="Unexpected error in Utils", e=str(e))
+    return wrapper
+
+@catch_error
 def force_file_move(source, destination):
     function_name = force_file_move.__name__
     logger.info(f"Attempting to move file from {source} to {destination}", extra={'endpoint': function_name})
-    try:
-        # Ensure the destination directory exists
-        os.makedirs(os.path.dirname(destination), exist_ok=True)
-        
-        # Move the file, replacing if it already exists
-        os.replace(source, destination)
-        logger.info(f"File moved successfully: {source} -> {destination}", extra={'endpoint': function_name})
-    except FileNotFoundError:
-        logger.error(f"Source file not found: {source}", extra={'endpoint': function_name})
-    except Exception as e:
-        logger.error(f"An error occurred while moving file: {e}", extra={'endpoint': function_name})
+    # Ensure the destination directory exists
+    os.makedirs(os.path.dirname(destination), exist_ok=True)
+    
+    # Move the file, replacing if it already exists
+    os.replace(source, destination)
+    logger.info(f"File moved successfully: {source} -> {destination}", extra={'endpoint': function_name})
 
+@catch_error
 def get_user(user_id):
     function_name = get_user.__name__
     logger.info(f"Fetching user {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
@@ -69,6 +83,8 @@ def get_user(user_id):
         return user_cache[user_id]
     else:
         client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
+        if not client:
+            raise OpenAIRequestError(user_id=user_id, message="Error creating OpenAI client", code="OpenAIError")
         user_file = os.path.join('users', 'data', f'{user_id}.pkl')
         # if os.path.exists(user_file):
         #     with open(user_file, 'rb') as f:
@@ -96,9 +112,10 @@ def get_user(user_id):
             user_info = get_user_info(user_id)
             if (user_info):
                 # user has done onboarding but pickle file not created
-                raise ReferenceError(f"User {user_id} pickle still being created")
-            raise LookupError(f"User [{user_id}] has not onboarded yet")
+                raise DBError(user_id=user_id, message="User has done onboarding but pickle file not created", code="NoPickleError")
+            raise DBError(user_id=user_id, message="User has not onboarded yet", code="NoOnboardingError")
 
+@catch_error
 def generate_html(json_data, coach_name='Growth Guide', booking_id = None):
     function_name = generate_html.__name__
     data = json_data["pre_growth_guide_session_report"]
@@ -276,37 +293,32 @@ def generate_html(json_data, coach_name='Growth Guide', booking_id = None):
     password = "Ourcoach2024!"
 
     ## SAVING HTML FILE
-    try:
-        # Open the file in write mode
-        with open(file_path, 'w', encoding='utf-8') as html_file:
-            html_file.write(html_content)
-        logger.info(f"File '{booking_id}.html' has been created successfully.", extra={'booking_id': booking_id, 'endpoint': function_name})
-
-        # Saving as PDF File
-        pdfkit.from_file(file_path, path_to_upload, options={'encoding': 'UTF-8'})
-        logger.info(f"File '{booking_id}.pdf' has been created successfully.", extra={'booking_id': booking_id, 'endpoint': function_name})
-
-        ## ENCRYPTING PDF
-        logger.info(f"Encrypting '{booking_id}.pdf'...", extra={'booking_id': booking_id, 'endpoint': function_name})
-        with open(path_to_upload, 'rb') as file:
-            pdf_reader = PyPDF2.PdfReader(file)
-            pdf_writer = PyPDF2.PdfWriter()
-
-            # Add all pages to the writer
-            for page_num in range(len(pdf_reader.pages)):
-                pdf_writer.add_page(pdf_reader.pages[page_num])
-
-            # Encrypt the PDF with the given password
-            pdf_writer.encrypt(password)
-
-            with open(path_to_upload, 'wb') as encrypted_file:
-                pdf_writer.write(encrypted_file)
-        
-        logger.info(f"Succesfully encrypted '{booking_id}.pdf'", extra={'booking_id': booking_id, 'endpoint': function_name})
-        
-    except Exception as e:
-        logger.error(f"An error occurred: {e}", extra={'booking_id': booking_id, 'endpoint': function_name})
-        raise
+    # Open the file in write mode
+    with open(file_path, 'w', encoding='utf-8') as html_file:
+        html_file.write(html_content)
+    logger.info(f"File '{booking_id}.html' has been created successfully.", extra={'booking_id': booking_id, 'endpoint': function_name})
+
+    # Saving as PDF File
+    pdfkit.from_file(file_path, path_to_upload, options={'encoding': 'UTF-8'})
+    logger.info(f"File '{booking_id}.pdf' has been created successfully.", extra={'booking_id': booking_id, 'endpoint': function_name})
+
+    ## ENCRYPTING PDF
+    logger.info(f"Encrypting '{booking_id}.pdf'...", extra={'booking_id': booking_id, 'endpoint': function_name})
+    with open(path_to_upload, 'rb') as file:
+        pdf_reader = PyPDF2.PdfReader(file)
+        pdf_writer = PyPDF2.PdfWriter()
+
+        # Add all pages to the writer
+        for page_num in range(len(pdf_reader.pages)):
+            pdf_writer.add_page(pdf_reader.pages[page_num])
+
+        # Encrypt the PDF with the given password
+        pdf_writer.encrypt(password)
+
+        with open(path_to_upload, 'wb') as encrypted_file:
+            pdf_writer.write(encrypted_file)
+    
+    logger.info(f"Succesfully encrypted '{booking_id}.pdf'", extra={'booking_id': booking_id, 'endpoint': function_name})
     
     filename = booking_id
     
@@ -331,21 +343,17 @@ def generate_html(json_data, coach_name='Growth Guide', booking_id = None):
 
         # force_file_move(os.path.join('users', 'to_upload', filename), os.path.join('users', 'data', filename))
     except (FileNotFoundError, NoCredentialsError, PartialCredentialsError) as e:
-        logger.error(f"S3 upload failed for {filename}: {e}", extra={'booking_id': booking_id, 'endpoint': function_name})
-        raise
+        raise DBError(user_id="no-user", message="Error uploading file to S3", code="S3Error")
 
+@catch_error
 def get_user_summary(user_id):
     function_name = get_user_summary.__name__
     logger.info(f"Generating user summary for user {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
 
     # Step 1: Call get_user to get user's info
-    try:
-        user = get_user(user_id)
-        user_info = user.user_info
-        user_messages = user.get_messages()
-    except LookupError as e:
-        logger.error(f"Error fetching user data: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-        raise e
+    user = get_user(user_id)
+    user_info = user.user_info
+    user_messages = user.get_messages()
 
     # Step 2: Construct the Prompt
     chat_history = "\n".join(
@@ -596,282 +604,270 @@ def get_user_summary(user_id):
 
     # Step 3: Call the OpenAI API using the specified function
     client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
-    try:
-        response = client.chat.completions.create(
-            model="gpt-4o-mini",
-            messages=[
-                {
-                    "role": "system",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": system_prompt
-                        }
-                    ]
-                },
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": user_context
-                        }
-                    ]
-                }
-            ],
-            response_format={
-            "type": "json_schema",
-            "json_schema": {
-                "name": "growth_guide_session",
-                "strict": True,
-                "schema": {
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {
+                "role": "system",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": system_prompt
+                    }
+                ]
+            },
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": user_context
+                    }
+                ]
+            }
+        ],
+        response_format={
+        "type": "json_schema",
+        "json_schema": {
+            "name": "growth_guide_session",
+            "strict": True,
+            "schema": {
+            "type": "object",
+            "properties": {
+                "pre_growth_guide_session_report": {
                 "type": "object",
+                "description": "A comprehensive summary of the user's profile and life context for the Growth Guide.",
                 "properties": {
-                    "pre_growth_guide_session_report": {
+                    "user_overview": {
                     "type": "object",
-                    "description": "A comprehensive summary of the user's profile and life context for the Growth Guide.",
                     "properties": {
-                        "user_overview": {
-                        "type": "object",
-                        "properties": {
-                            "name": {
-                            "type": "string",
-                            "description": "The user's full name."
-                            },
-                            "age_group": {
-                            "type": "string",
-                            "description": "The user's age range (e.g., '30-39')."
-                            },
-                            "primary_goals": {
-                            "type": "string",
-                            "description": "The main goals the user is focusing on."
-                            },
-                            "preferred_coaching_style": {
-                            "type": "string",
-                            "description": "The coaching style the user prefers."
-                            }
-                        },
-                        "required": ["name", "age_group", "primary_goals", "preferred_coaching_style"],
-                        "additionalProperties": False
+                        "name": {
+                        "type": "string",
+                        "description": "The user's full name."
                         },
-                        "personality_insights": {
-                        "type": "object",
-                        "properties": {
-                            "mbti": {
-                            "type": "string",
-                            "description": "The user's Myers-Briggs Type Indicator personality type."
-                            },
-                            "top_love_languages": {
-                            "type": "array",
-                            "items": {
-                                "type": "string"
-                            },
-                            "description": "A list of the user's top two love languages."
-                            },
-                            "belief_in_astrology": {
-                            "type": "string",
-                            "description": "Whether the user believes in horoscope/astrology."
-                            }
+                        "age_group": {
+                        "type": "string",
+                        "description": "The user's age range (e.g., '30-39')."
                         },
-                        "required": ["mbti", "top_love_languages", "belief_in_astrology"],
-                        "additionalProperties": False
+                        "primary_goals": {
+                        "type": "string",
+                        "description": "The main goals the user is focusing on."
                         },
-                        "progress_snapshot": {
-                        "type": "object",
-                        "properties": {
-                            "mental_well_being": {
-                            "type": "string",
-                            "description": "Summary of the user's mental well-being."
-                            },
-                            "physical_health_and_wellness": {
-                            "type": "string",
-                            "description": "Summary of the user's physical health and wellness."
-                            },
-                            "relationships": {
-                            "type": "string",
-                            "description": "Summary of the user's relationships."
-                            },
-                            "career_growth": {
-                            "type": "string",
-                            "description": "Summary of the user's career growth."
-                            },
-                            "personal_growth": {
-                            "type": "string",
-                            "description": "Summary of the user's personal growth."
-                            }
-                        },
-                        "required": [
-                            "mental_well_being",
-                            "physical_health_and_wellness",
-                            "relationships",
-                            "career_growth",
-                            "personal_growth"
-                        ],
-                        "additionalProperties": False
+                        "preferred_coaching_style": {
+                        "type": "string",
+                        "description": "The coaching style the user prefers."
                         }
                     },
-                    "required": ["user_overview", "personality_insights", "progress_snapshot"],
+                    "required": ["name", "age_group", "primary_goals", "preferred_coaching_style"],
                     "additionalProperties": False
                     },
-                    "users_growth_guide_preparation_brief": {
+                    "personality_insights": {
+                    "type": "object",
+                    "properties": {
+                        "mbti": {
+                        "type": "string",
+                        "description": "The user's Myers-Briggs Type Indicator personality type."
+                        },
+                        "top_love_languages": {
                         "type": "array",
-                        "description": "A brief guiding the user on what to discuss with the Growth Guide, providing actionable advice and highlighting key areas to focus on.",
                         "items": {
-                        "type": "object",
-                        "properties": {
-                            "key": {
-                            "type": "string",
-                            "description": "The section heading."
-                            },
-                            "value": {
-                            "type": "string",
-                            "description": "Content for the section."
-                            }
+                            "type": "string"
                         },
-                        "required": [
-                            "key",
-                            "value"
-                        ],
-                        "additionalProperties": False
+                        "description": "A list of the user's top two love languages."
+                        },
+                        "belief_in_astrology": {
+                        "type": "string",
+                        "description": "Whether the user believes in horoscope/astrology."
                         }
                     },
-                    "30_minute_coaching_session_script": {
+                    "required": ["mbti", "top_love_languages", "belief_in_astrology"],
+                    "additionalProperties": False
+                    },
+                    "progress_snapshot": {
                     "type": "object",
-                    "description": "A detailed, partitioned script to help the coach prepare for the session, following the specified session order and focusing on the user's top three most important areas.",
                     "properties": {
-                        "session_overview": {
+                        "mental_well_being": {
+                        "type": "string",
+                        "description": "Summary of the user's mental well-being."
+                        },
+                        "physical_health_and_wellness": {
+                        "type": "string",
+                        "description": "Summary of the user's physical health and wellness."
+                        },
+                        "relationships": {
+                        "type": "string",
+                        "description": "Summary of the user's relationships."
+                        },
+                        "career_growth": {
+                        "type": "string",
+                        "description": "Summary of the user's career growth."
+                        },
+                        "personal_growth": {
+                        "type": "string",
+                        "description": "Summary of the user's personal growth."
+                        }
+                    },
+                    "required": [
+                        "mental_well_being",
+                        "physical_health_and_wellness",
+                        "relationships",
+                        "career_growth",
+                        "personal_growth"
+                    ],
+                    "additionalProperties": False
+                    }
+                },
+                "required": ["user_overview", "personality_insights", "progress_snapshot"],
+                "additionalProperties": False
+                },
+                "users_growth_guide_preparation_brief": {
+                    "type": "array",
+                    "description": "A brief guiding the user on what to discuss with the Growth Guide, providing actionable advice and highlighting key areas to focus on.",
+                    "items": {
+                    "type": "object",
+                    "properties": {
+                        "key": {
+                        "type": "string",
+                        "description": "The section heading."
+                        },
+                        "value": {
+                        "type": "string",
+                        "description": "Content for the section."
+                        }
+                    },
+                    "required": [
+                        "key",
+                        "value"
+                    ],
+                    "additionalProperties": False
+                    }
+                },
+                "30_minute_coaching_session_script": {
+                "type": "object",
+                "description": "A detailed, partitioned script to help the coach prepare for the session, following the specified session order and focusing on the user's top three most important areas.",
+                "properties": {
+                    "session_overview": {
+                    "type": "array",
+                    "items": {
+                            "type": "string"
+                        },
+                    "description": "Breakdown of the session segments with time frames."
+                    },
+                    "detailed_segments": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                        "segment_title": {
+                            "type": "string",
+                            "description": "Title of the session segment."
+                        },
+                        "coach_dialogue": {
                         "type": "array",
                         "items": {
                                 "type": "string"
                             },
-                        "description": "Breakdown of the session segments with time frames."
+                            "description": "Suggested coach dialogue during the session"
                         },
-                        "detailed_segments": {
+                        "guidance": {
                         "type": "array",
                         "items": {
-                            "type": "object",
-                            "properties": {
-                            "segment_title": {
-                                "type": "string",
-                                "description": "Title of the session segment."
-                            },
-                            "coach_dialogue": {
-                            "type": "array",
-                            "items": {
-                                    "type": "string"
-                                },
-                                "description": "Suggested coach dialogue during the session"
-                            },
-                            "guidance": {
-                            "type": "array",
-                            "items": {
-                                    "type": "string"
-                                },
-                                "description": "Suggestions for the coach on how to navigate responses."
-                            }
+                                "type": "string"
                             },
-                            "required": ["segment_title", "coach_dialogue", "guidance"],
-                            "additionalProperties": False
-                        },
-                        "description": "Detailed information for each session segment."
+                            "description": "Suggestions for the coach on how to navigate responses."
                         }
+                        },
+                        "required": ["segment_title", "coach_dialogue", "guidance"],
+                        "additionalProperties": False
                     },
-                    "required": [
-                        "session_overview",
-                        "detailed_segments"
-                    ],
-                    "additionalProperties": False
+                    "description": "Detailed information for each session segment."
                     }
                 },
                 "required": [
-                    "pre_growth_guide_session_report",
-                    "users_growth_guide_preparation_brief",
-                    "30_minute_coaching_session_script"
+                    "session_overview",
+                    "detailed_segments"
                 ],
                 "additionalProperties": False
                 }
+            },
+            "required": [
+                "pre_growth_guide_session_report",
+                "users_growth_guide_preparation_brief",
+                "30_minute_coaching_session_script"
+            ],
+            "additionalProperties": False
             }
-            }
-            ,
-            temperature=0.5,
-            max_tokens=3000,
-            top_p=1,
-            frequency_penalty=0,
-            presence_penalty=0
-        )
-
-        # Get response and convert into dictionary
-        reports = json.loads(response.choices[0].message.content)
-        # html_output = generate_html(reports, coach_name)
-        # reports['html_report'] = html_output
+        }
+        }
+        ,
+        temperature=0.5,
+        max_tokens=3000,
+        top_p=1,
+        frequency_penalty=0,
+        presence_penalty=0
+    )
 
-    except Exception as e:
-        logger.error(f"OpenAI API call failed: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-        raise e
+    # Get response and convert into dictionary
+    reports = json.loads(response.choices[0].message.content)
+    # html_output = generate_html(reports, coach_name)
+    # reports['html_report'] = html_output
 
     # Step 4: Return the JSON reports
     logger.info(f"User summary generated successfully for user {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
     return reports
 
+@catch_error
 def create_pre_gg_report(booking_id):
     function_name = create_pre_gg_report.__name__
 
     # Get user_id from booking_id
+    logger.info(f"Retrieving booking details for {booking_id}", extra={'booking_id': booking_id, 'endpoint': function_name})
+    db_params = {
+        'dbname': 'ourcoach',
+        'user': 'ourcoach',
+        'password': 'hvcTL3kN3pOG5KteT17T',
+        'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
+        'port': '5432'
+    }
     try:
-        logger.info(f"Retrieving booking details for {booking_id}", extra={'booking_id': booking_id, 'endpoint': function_name})
-        db_params = {
-            'dbname': 'ourcoach',
-            'user': 'ourcoach',
-            'password': 'hvcTL3kN3pOG5KteT17T',
-            'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
-            'port': '5432'
-        }
-        try:
-            with psycopg2.connect(**db_params) as conn:
-                with conn.cursor() as cursor:
-                    query = sql.SQL("""
-                    select user_id
-                    from {table}
-                    where id = %s
-                    """
-                    ).format(table=sql.Identifier('public', 'booking'))
-                    cursor.execute(query, (booking_id,))
-                    row = cursor.fetchone()
-                    if (row):
-                        colnames = [desc[0] for desc in cursor.description]
-                        booking_data = dict(zip(colnames, row))
-                        ### MODIFY THE FORMAT OF USER DATA
-                        user_id = booking_data['user_id']
-                        logger.info(f"User info retrieved successfully for {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
-                    else:
-                        logger.warning(f"No user info found for {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
-        except psycopg2.Error as e:
-            logger.error(f"Database error while retrieving user info for {user_id}: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-            raise
-        
-        # Run get_user_summary
-        user_report = get_user_summary(user_id)
+        with psycopg2.connect(**db_params) as conn:
+            with conn.cursor() as cursor:
+                query = sql.SQL("""
+                select user_id
+                from {table}
+                where id = %s
+                """
+                ).format(table=sql.Identifier('public', 'booking'))
+                cursor.execute(query, (booking_id,))
+                row = cursor.fetchone()
+                if (row):
+                    colnames = [desc[0] for desc in cursor.description]
+                    booking_data = dict(zip(colnames, row))
+                    ### MODIFY THE FORMAT OF USER DATA
+                    user_id = booking_data['user_id']
+                    logger.info(f"User info retrieved successfully for {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
+                else:
+                    logger.warning(f"No user info found for {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
+    except psycopg2.Error as e:
+        logger.error(f"Database error while retrieving user info for {user_id}: {e}", extra={'user_id': user_id, 'endpoint': function_name})
+        raise DBError(user_id=user_id, message="Error retrieving user info", code="SQLError", e=str(e))
+    
+    # Run get_user_summary
+    user_report = get_user_summary(user_id)
 
-        # Run generate_html
-        generate_html(user_report, booking_id=booking_id)
-        
-        return True
-    except Exception as e:
-        logger.error(f"An error occured: {e}", extra={'booking_id': booking_id, 'endpoint': function_name})
-        raise
+    # Run generate_html
+    generate_html(user_report, booking_id=booking_id)
+    
+    return True
 
+@catch_error  
 def get_user_life_status(user_id):
     function_name = get_user_life_status.__name__
     logger.info(f"Generating user life status for user {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
 
-    # Step 1: Call get_user to get user's info
-    try:
-        user = get_user(user_id)
-        user_info = user.user_info
-        user_messages = user.get_messages()
-    except LookupError as e:
-        logger.error(f"Error fetching user data: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-        raise e
+    user = get_user(user_id)
+    user_info = user.user_info
+    user_messages = user.get_messages()
 
     # Step 2: Construct the Prompt
     chat_history = "\n".join(
@@ -918,63 +914,58 @@ def get_user_life_status(user_id):
 
     # Step 3: Call the OpenAI API using the specified function
     client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
-    try:
-        response = client.chat.completions.create(
-            model="gpt-4o-mini",
-            messages=[
-                {
-                    "role": "system",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": system_prompt
-                        }
-                    ]
-                },
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": user_context
-                        }
-                    ]
-                }
-            ],
-            response_format={
-                "type": "json_schema",
-                "json_schema": {
-                    "name": "life_status_report",
-                    "strict": True,
-                    "schema": {
-                        "type": "object",
-                        "properties": {
-                            "mantra_of_the_week": {
-                                "type": "string",
-                                "description": "A very short encouragement quote that encapsulates the user's journey to achieve their goals."
-                            }
-                        },
-                        "required": [
-                            "mantra_of_the_week"
-                        ],
-                        "additionalProperties": False
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {
+                "role": "system",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": system_prompt
+                    }
+                ]
+            },
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": user_context
                     }
+                ]
+            }
+        ],
+        response_format={
+            "type": "json_schema",
+            "json_schema": {
+                "name": "life_status_report",
+                "strict": True,
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "mantra_of_the_week": {
+                            "type": "string",
+                            "description": "A very short encouragement quote that encapsulates the user's journey to achieve their goals."
+                        }
+                    },
+                    "required": [
+                        "mantra_of_the_week"
+                    ],
+                    "additionalProperties": False
                 }
             }
-            ,
-            temperature=0.5,
-            max_tokens=3000,
-            top_p=1,
-            frequency_penalty=0,
-            presence_penalty=0
-        )
-
-        # Get response and convert into dictionary
-        mantra = json.loads(response.choices[0].message.content)["mantra_of_the_week"]
+        }
+        ,
+        temperature=0.5,
+        max_tokens=3000,
+        top_p=1,
+        frequency_penalty=0,
+        presence_penalty=0
+    )
 
-    except Exception as e:
-        logger.error(f"OpenAI API call failed: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-        raise e
+    # Get response and convert into dictionary
+    mantra = json.loads(response.choices[0].message.content)["mantra_of_the_week"]
 
     # Get current life score
     life_score = {
@@ -1002,14 +993,15 @@ def get_user_life_status(user_id):
     logger.info(f"User life status generated successfully for user {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
     return reports
 
-def get_api_key(api_key_header: str = Security(api_key_header)) -> str:
-    if api_key_header == os.getenv("FASTAPI_KEY"):
-        return api_key_header
-    raise HTTPException(
-        status_code=403,
-        detail="Could not validate credentials"
-    )
+async def get_api_key(api_key_header: str = Security(api_key_header)) -> str:
+    if api_key_header not in api_keys:  # Check against list of valid keys
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Invalid API key"
+        )
+    return api_key_header
 
+@catch_error
 def get_user_info(user_id):
     function_name = get_user_info.__name__
     logger.info(f"Retrieving user info for {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
@@ -1064,11 +1056,13 @@ def get_user_info(user_id):
                     return user_data_formatted, user_data_clean.get('mattersMost', ['', '', '', '', ''])
                 else:
                     logger.warning(f"No user info found for {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
-                    return None
+                    raise DBError(user_id=user_id, message="Error retrieving user info", code="NoOnboardingError", e=str(e))
+
     except psycopg2.Error as e:
         logger.error(f"Database error while retrieving user info for {user_id}: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-        return None
+        raise DBError(user_id=user_id, message="Error retrieving user info", code="SQLError", e=str(e))
 
+@catch_error
 def get_growth_guide_summary(user_id, session_id):
     function_name = get_growth_guide_summary.__name__
     logger.info(f"Retrieving growth guide summary for user {user_id} and session {session_id}", extra={'user_id': user_id, 'endpoint': function_name})
@@ -1095,8 +1089,10 @@ def get_growth_guide_summary(user_id, session_id):
                     return None
     except psycopg2.Error as e:
         logger.error(f"Database error while retrieving growth guide summary for user {user_id} and session {session_id}: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-        return None
+        raise DBError(user_id=user_id, message="Error retrieving user info", code="SQLError", e=str(e))
+
     
+@catch_error
 def get_all_bookings():
     function_name = get_all_bookings.__name__
     logger.info(f"Retrieving all bookings", extra={'endpoint': function_name})
@@ -1117,9 +1113,13 @@ def get_all_bookings():
                 logger.info(f"Retrieved {len(bookings)} bookings", extra={'endpoint': function_name})
                 return bookings
     except psycopg2.Error as e:
+        bookings = []
         logger.error(f"Database error while retrieving bookings: {e}", extra={'endpoint': function_name})
-        return []
+        raise DBError(user_id='no-user', message="Error retrieving user info", code="SQLError", e=str(e))
+    finally:
+        return bookings
 
+@catch_error
 def update_growth_guide_summary(user_id, session_id, ourcoach_summary):
     function_name = update_growth_guide_summary.__name__
     logger.info(f"Updating growth guide summary for user {user_id} and session {session_id}", extra={'user_id': user_id, 'endpoint': function_name})
@@ -1145,8 +1145,9 @@ def update_growth_guide_summary(user_id, session_id, ourcoach_summary):
                 logger.info(f"Growth guide summary updated successfully for user {user_id} and session {session_id}", extra={'user_id': user_id, 'endpoint': function_name})
     except psycopg2.Error as e:
         logger.error(f"Database error while updating growth guide summary: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-        raise e
+        raise DBError(user_id=user_id, message="Error updating growth guide summary", code="SQLError", e=str(e))
 
+@catch_error
 def add_growth_guide_session(user_id, session_id, coach_id, session_started_at, zoom_ai_summary, gg_report, ourcoach_summary):
     function_name = add_growth_guide_session.__name__
     logger.info(f"Adding growth guide session for user {user_id} and session {session_id}", extra={'user_id': user_id, 'endpoint': function_name})
@@ -1182,8 +1183,9 @@ def add_growth_guide_session(user_id, session_id, coach_id, session_started_at,
                 logger.info(f"Growth guide session added successfully for user {user_id} and session {session_id}", extra={'user_id': user_id, 'endpoint': function_name})
     except psycopg2.Error as e:
         logger.error(f"Database error while adding growth guide session: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-        raise e
+        raise DBError(user_id=user_id, message="Error adding growth guide session", code="SQLError", e=str(e))
 
+@catch_error
 def get_growth_guide_session(user_id, session_id):
     # returns the zoom_ai_summary and the gg_report columns from the POST_GG table
     function_name = get_growth_guide_session.__name__
@@ -1211,9 +1213,10 @@ def get_growth_guide_session(user_id, session_id):
                     return None
     except psycopg2.Error as e:
         logger.error(f"Database error while retrieving growth guide session for user {user_id} and session {session_id}: {e}", extra={'user_id': user_id, 'endpoint': function_name})
-        return None
+        raise DBError(user_id=user_id, message="Error retrieving user info", code="SQLError", e=str(e))
     
 
+@catch_error
 def download_file_from_s3(filename, bucket):
     user_id = filename.split('.')[0]
     function_name = download_file_from_s3.__name__
@@ -1234,8 +1237,9 @@ def download_file_from_s3(filename, bucket):
         logger.error(f"Error downloading file {filename} from S3: {e}", extra={'user_id': user_id, 'endpoint': function_name})
         if (os.path.exists(file_path)):
             os.remove(file_path)
-        return False
+        raise DBError(user_id=user_id, message="Error downloading file from S3", code="S3Error", e=str(e))
 
+@catch_error
 def add_to_cache(user):
     user_id = user.user_id
     function_name = add_to_cache.__name__
@@ -1244,6 +1248,7 @@ def add_to_cache(user):
     logger.info(f"User {user_id} added to the cache", extra={'user_id': user_id, 'endpoint': function_name})
     return True
 
+@catch_error
 def pop_cache(user_id):
     if user_id == 'all':
         user_cache.reset_cache()
@@ -1256,13 +1261,13 @@ def pop_cache(user_id):
             # upload file
             logger.info(f"Attempting upload file {user_id}.json to S3", extra={'user_id': user_id, 'endpoint': 'pop_cache'})
             upload_file_to_s3(f"{user_id}.pkl")
-    try:
-        user_cache.pop(user_id, None)
-        logger.info(f"User {user_id} has been removed from the cache", extra={'user_id': user_id, 'endpoint': 'pop_cache'})
-        return True
-    except:
-        return False
 
+    user_cache.pop(user_id, None)
+    logger.info(f"User {user_id} has been removed from the cache", extra={'user_id': user_id, 'endpoint': 'pop_cache'})
+    return True
+    
+
+@catch_error
 def update_user(user):
     user_id = user.user_id
     function_name = update_user.__name__
@@ -1276,6 +1281,7 @@ def update_user(user):
 
     return True
 
+@catch_error
 def upload_mementos_to_db(user_id):
     function_name = upload_mementos_to_db.__name__
     logger.info(f"Uploading mementos to DB for user {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
@@ -1345,11 +1351,9 @@ def upload_mementos_to_db(user_id):
         return True
     except psycopg2.Error as e:
         logger.error(f"Database error while uploading mementos: {str(e)}", extra={'user_id': user_id, 'endpoint': function_name})
-        raise ConnectionError(f"Database error: {str(e)}")
-    except Exception as e:
-        logger.error(f"Unexpected error uploading mementos: {str(e)}", extra={'user_id': user_id, 'endpoint': function_name})
-        return False
+        raise DBError(user_id=user_id, message="Error uploading mementos", code="SQLError", e=str(e))
 
+@catch_error
 def get_users_mementos(user_id, date):
     function_name = get_users_mementos.__name__
     db_params = {
@@ -1383,8 +1387,11 @@ def get_users_mementos(user_id, date):
                     logger.info(f"No mementos found for user {user_id} on date {date}", extra={'endpoint': function_name, 'user_id': user_id})
                     return []
     except psycopg2.Error as e:
+        mementos = []
         logger.error(f"Database error while retrieving mementos: {e}", extra={'endpoint': function_name, 'user_id': user_id})
-        return []
+        raise DBError(user_id=user_id, message="Error retrieving mementos", code="SQLError", e=str(e))
+    finally:
+        return mementos
 
 def generate_uuid():
     return str(uuid.uuid4())