Post GG Features

.github/workflows/deployment.yml

@@ -55,7 +55,7 @@ jobs:
         env:
           IMAGE_TAG: ${{ github.sha }}
         run: |
-          docker build --build-arg FASTAPI_KEY=${{secrets.FASTAPI_KEY}} --build-arg BING_API_KEY=${{secrets.BING_API_KEY}} --build-arg OPENAI_API_KEY=${{secrets.OPENAI_API_KEY}} -t ${{inputs.ecr_url}}:$IMAGE_TAG .
+          docker build --build-arg FASTAPI_KEY=${{secrets.FASTAPI_KEY}} --build-arg OPENAI_API_KEY=${{secrets.OPENAI_API_KEY}} -t ${{inputs.ecr_url}}:$IMAGE_TAG .
           docker push ${{inputs.ecr_url}}:$IMAGE_TAG
           echo "image=${{inputs.ecr_url}}:$IMAGE_TAG" >> $GITHUB_OUTPUT
 

.gitignore

@@ -3,6 +3,4 @@ mementos/
 users/
 templates/
 .env
-__pycache__
-_*flows.py
-_*users.py
+__pycache__

Dockerfile

@@ -4,13 +4,6 @@ FROM python:3.10.9
 # Set up a new user named "user" with user ID 1000
 RUN useradd -m -u 1000 user
 
-# Install wkhtmltopdf and its dependencies as root
-USER root
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    wkhtmltopdf \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
-
 # Switch to the "user" user
 USER user
 
@@ -28,15 +21,11 @@ EXPOSE 7860
 ARG FASTAPI_KEY
 ARG OPENAI_API_KEY
 ARG OPENAI_GENERAL_ASSISTANT
-ARG SENTRY_DSN
-ARG BING_API_KEY
 
 ENV FASTAPI_KEY=$FASTAPI_KEY
 ENV OPENAI_API_KEY=$OPENAI_API_KEY
 ENV OPENAI_GENERAL_ASSISTANT=$OPENAI_GENERAL_ASSISTANT
 ENV PYTHONUNBUFFERED=1
-ENV SENTRY_DSN=$SENTRY_DSN
-ENV BING_API_KEY=$BING_API_KEY
 
 # Set the working directory
 # WORKDIR /code

app/assistants.py

@@ -1,29 +1,182 @@
 import json
 import io
 import os
-from datetime import datetime, timezone
+from datetime import datetime
 import json 
 import random
 from time import sleep
-import openai
 import pandas as pd
 from dotenv import load_dotenv
 import logging
-import psycopg2
-from psycopg2 import sql
-import pytz
 
-from app.exceptions import AssistantError, BaseOurcoachException, OpenAIRequestError, UtilsError
-from app.utils import get_booked_gg_sessions, get_growth_guide, get_growth_guide_summary, get_user_subscriptions, get_users_mementos, print_log
+from app.utils import get_users_mementos, print_log
 from app.flows import FOLLOW_UP_STATE, GENERAL_COACHING_STATE, MICRO_ACTION_STATE, REFLECTION_STATE
-from app.web_search import SearchEngine
 
 load_dotenv()
 
 logger = logging.getLogger(__name__)
-OURCOACH_DASHBOARD_URL = os.getenv("OURCOACH_DASHBOARD_URL")
 
+import requests
 
+class SearchEngine:
+    BING_API_KEY = os.getenv("BING_API_KEY")
+    BING_ENDPOINT = 'https://api.bing.microsoft.com/v7.0'
+
+    @staticmethod
+    def search(feedback_type_name, search_term):
+        """
+        Public method to perform a search based on the feedback type.
+        """
+        search_methods = {
+            "Resource Links": SearchEngine._search_relevant_links,
+            "Book/Podcast Recommendations": SearchEngine._search_books_or_podcasts,
+            # "Success Stories/Testimonials": SearchEngine._search_success_stories,
+            "Inspirational Stories or Case Studies": SearchEngine._search_inspirational_stories,
+            "Fun Facts": SearchEngine._search_fun_facts,
+            # "Visual Content (Images, Infographics)": SearchEngine._search_visual_content,
+            "Personalised Recommendations": SearchEngine._search_personalized_recommendations
+        }
+        
+        search_method = search_methods.get(feedback_type_name)
+        
+        if search_method:
+            return search_method(search_term)
+        else:
+            return (feedback_type_name, search_term)
+
+    @staticmethod
+    def _search_relevant_links(search_term):
+        """
+        Uses Bing Web Search API to search for relevant links.
+        """
+        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
+        params = {'q': search_term, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
+        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
+        if response.status_code == 200:
+            data = response.json()
+            links = []
+            if 'webPages' in data and 'value' in data['webPages']:
+                for result in data['webPages']['value']:
+                    links.append(result)
+                return links
+        return ["No relevant links found."]
+
+    @staticmethod
+    def _search_books_or_podcasts(search_term):
+        """
+        Uses Bing Web Search API to search for books or podcasts.
+        """
+        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
+        query = f"{search_term} book OR podcast"
+        params = {'q': query, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
+        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
+        if response.status_code == 200:
+            data = response.json()
+            recommendations = []
+            if 'webPages' in data and 'value' in data['webPages']:
+                for result in data['webPages']['value']:
+                    title = result.get('name', 'Unknown Title')
+                    url = result.get('url', '')
+                    recommendations.append(f"{title}: {url}")
+                return recommendations
+        return ["No book or podcast recommendations found."]
+
+    @staticmethod
+    def _search_success_stories(search_term):
+        """
+        Uses Bing Web Search API to search for success stories.
+        """
+        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
+        query = f"{search_term} success stories"
+        params = {'q': query, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
+        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
+        if response.status_code == 200:
+            data = response.json()
+            stories = []
+            if 'webPages' in data and 'value' in data['webPages']:
+                for result in data['webPages']['value']:
+                    title = result.get('name', 'Unknown Title')
+                    url = result.get('url', '')
+                    stories.append(f"{title}: {url}")
+                return stories
+        return ["No success stories found."]
+
+    @staticmethod
+    def _search_inspirational_stories(search_term):
+        """
+        Uses Bing Web Search API to search for inspirational stories or case studies.
+        """
+        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
+        query = f"{search_term} inspirational stories OR case studies"
+        params = {'q': query, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
+        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
+        if response.status_code == 200:
+            data = response.json()
+            stories = []
+            if 'webPages' in data and 'value' in data['webPages']:
+                for result in data['webPages']['value']:
+                    title = result.get('name', 'Unknown Title')
+                    url = result.get('url', '')
+                    stories.append(f"{title}: {url}")
+                return stories
+        return ["No inspirational stories found."]
+
+    @staticmethod
+    def _search_fun_facts(search_term):
+        """
+        Uses Bing Web Search API to search for fun facts related to personal growth.
+        """
+        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
+        query = f"{search_term} fun facts"
+        params = {'q': query, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
+        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
+        if response.status_code == 200:
+            data = response.json()
+            facts = []
+            if 'webPages' in data and 'value' in data['webPages']:
+                for result in data['webPages']['value']:
+                    snippet = result.get('snippet', '')
+                    facts.append(snippet)
+                return facts
+        return ["No fun facts found."]
+
+    @staticmethod
+    def _search_visual_content(search_term):
+        """
+        Uses Bing Image Search API to search for images or infographics.
+        """
+        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
+        params = {'q': search_term, 'count': 3}
+        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/images/search", headers=headers, params=params)
+        if response.status_code == 200:
+            data = response.json()
+            images = []
+            if 'value' in data:
+                for result in data['value']:
+                    image_url = result.get('contentUrl', '')
+                    images.append(image_url)
+                return images
+        return ["No visual content found."]
+
+    @staticmethod
+    def _search_personalized_recommendations(search_term):
+        """
+        Uses Bing Web Search API to provide personalized recommendations.
+        """
+        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
+        query = f"tips for {search_term}"
+        params = {'q': query, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
+        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
+        if response.status_code == 200:
+            data = response.json()
+            recommendations = []
+            if 'webPages' in data and 'value' in data['webPages']:
+                for result in data['webPages']['value']:
+                    title = result.get('name', 'Unknown Title')
+                    url = result.get('url', '')
+                    recommendations.append(f"{title}: {url}")
+                return recommendations
+        return ["No personalized recommendations found."]
 
 class FeedbackContent:
     def __init__(self, content, role):
@@ -125,472 +278,290 @@ class FeedbackContent:
         #     return result
         return selected
 
-def get_current_datetime(user_id):
-    db_params = {
-    'dbname': 'ourcoach',
-    'user': 'ourcoach',
-    'password': 'hvcTL3kN3pOG5KteT17T',
-    'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
-    'port': '5432'
-    }
-    with psycopg2.connect(**db_params) as conn:
-        with conn.cursor() as cursor:
-            query = sql.SQL("SELECT * FROM {table} WHERE id = %s").format(table=sql.Identifier('public', 'users'))
-            cursor.execute(query, (user_id,))
-            row = cursor.fetchone()
-            if (row):
-                colnames = [desc[0] for desc in cursor.description]
-                user_data = dict(zip(colnames, row))
-                user_timezone = user_data['timezone']
-
-    return datetime.now().astimezone(pytz.timezone(user_timezone))
+def get_current_datetime():
+    return datetime.now()
 
 class Assistant:
-    def catch_error(func):
-        def wrapper(self, *args, **kwargs):
-            try:
-                return func(self, *args, **kwargs)
-            except (BaseOurcoachException) as e:
-                raise e
-            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
 
     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
+        if run.status != 'completed':
+            cancel = self.cm.client.beta.threads.runs.cancel(thread_id=thread.id, run_id=run.id)
+            while cancel.status != 'cancelled':
+                sleep(0.05)
+                cancel = self.cm.client.beta.threads.runs.retrieve(
+                    thread_id=thread.id,
+                    run_id=cancel.id
                 )
-                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):
-            if run.id == "pseudo_run":
-                logger.info(f"Run already completed: {run.id}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
-                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':
-                    sleep(0.05)
-                    cancel = self.cm.client.beta.threads.runs.retrieve(
-                        thread_id=thread.id,
-                        run_id=cancel.id
-                    )
-                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"})
-                return False
-        except openai.BadRequestError:
-            # 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.warning(f"Run already expired: {run.id}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
-                return True
-            else:
-                logger.warning(f"Error cancelling run: {run.id}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
-                return False
-
-    @catch_error 
+            logger.info(f"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"})
+            return False
+        
     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)
+
+        run = self.cm.client.beta.threads.runs.create_and_poll(
+            thread_id=thread.id,
+            assistant_id=self.id,
+            model="gpt-4o-mini",
+        )
+        just_finished_intro = False
         try:
-            # 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)
-
-            run = self.cm.client.beta.threads.runs.create_and_poll(
-                thread_id=thread.id,
-                assistant_id=self.id,
-                model="gpt-4o-mini",
-            )
-            just_finished_intro = False
-
             if 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
+                logger.info(f"Run Completed: {run.status}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})       
                 return run, just_finished_intro, message
             
-            elif run.status == 'failed':
-                raise OpenAIRequestError(user_id=self.cm.user.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"})
-                        raise OpenAIRequestError(user_id=self.cm.id, message="Tool Call Reccursion Depth Reached")
-                    if run.status == 'cancel':
-                        logger.warning(f"RUN NOT COMPLETED: {run}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})
-                        self.cancel_run(run, thread)
-                        run.status = 'cancelled'
-                        logger.warning(f"Yeap Run Cancelled: {run.status}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})
-                        return run, just_finished_intro, message 
-
-                    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 Exception as e:
-            # Cancel the run
-            logger.error(f"Error in process: {e}", extra={"user_id": self.cm.user.user_id, "endpoint": 'assistant_process'})
-            logger.error(f"Cancelling run {run.id} for thread {thread.id}", extra={"user_id": self.cm.user.user_id, "endpoint": 'cancel_erroneous_run'})
-
-            self.cancel_run(run, thread)
-            logger.error(f"Run {run.id} cancelled for thread {thread.id}", extra={"user_id": self.cm.user.user_id, "endpoint": 'cancel_erroneous_run'})
-            raise e
-    
-    def call_tool(self, run, thread):
-        try:
-            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))}", 
-                    extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_call_tool"})
-            just_finish_intro = False
-            for tool in run.required_action.submit_tool_outputs.tool_calls:
-                if tool.function.name == "transition":
-                    transitions = json.loads(tool.function.arguments)
-                    logger.info(f"Transition: {transitions['from']} -> {transitions['to']}", 
-                            extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_transition"})
-
-                    if transitions['from'] == "PLANNING STATE":
-                        tool_outputs.append({
-                        "tool_call_id": tool.id,
-                        "output": f"help the user set a new goal"
-                        })
-                        # logger.info(f"Exiting the introduction state", 
-                        #     extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_transition"})
-                        # just_finish_intro = True
-                        # # run = self.cancel_run(run, thread)
-                        # # logger.info(f"Successfully cancelled run", 
-                        # #     extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_transition"})
-                        # tool_outputs.append({
-                        #     "tool_call_id": tool.id,
-                        #     "output": "true"
-                        # })
-                    else:
-                        flow_instructions = ""
-                        if transitions['to'] == "REFLECTION STATE":
-                            flow_instructions = REFLECTION_STATE
-
-                            next = self.cm.matters_most.next()
-                            logger.info(f"Successfully moved to bext matters most: {next}")
-                            question_format = random.choice(['[Option 1] Likert-Scale Objective Question','[Option 2] Multiple-Choice Question','[Option 3] Yes-No Question'])
-                            
-                            flow_instructions = f"""Today's opening question format is: {question_format}. Send a WARM, SUCCINCT and PERSONALIZED (according to my PROFILE) first message in this format! The most warm, succinct & personalized message will get rewarded!\n
-                                                    The reflection topic is: {next}. YOU MUST SEND CREATIVE, PERSONALIZED (only mention specific terms that are related to the reflection topic/area), AND SUCCINCT MESSAGES!! The most creative message will be rewarded! And make every new reflection fresh and not boring! \n
-
-                                                """ + flow_instructions
-
-                        elif transitions['to'] == "FOLLOW UP STATE":
-                            flow_instructions = FOLLOW_UP_STATE
-                        
-                        elif transitions['to'] == "GENERAL COACHING STATE":
-                            flow_instructions = GENERAL_COACHING_STATE
-
-                        tool_outputs.append({
-                        "tool_call_id": tool.id,
-                        "output": f"{flow_instructions}\n\n" + f"** Follow the above flow template to respond to the user **"
-                        })
-                elif tool.function.name == "get_date":
-                    # print(f"[DATETIME]: {get_current_datetime()}")
-                    # self.cm.state['date'] = 'date': pd.Timestamp.now().strftime("%Y-%m-%d %a %H:%M:%S")
-                    # get and update the current time to self.cm.state['date'] but keep the date component
-                    current_time = get_current_datetime(self.cm.user.user_id)
-                    # replace time component of self.cm.state['date'] with the current time
-                    self.cm.state['date'] = str(pd.to_datetime(self.cm.state['date']).replace(hour=current_time.hour, minute=current_time.minute, second=current_time.second))
-                    logger.info(f"Current datetime: {self.cm.state['date']}", 
-                            extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_date"})
+            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
 
+    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))}", 
+                extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_call_tool"})
+        just_finish_intro = False
+        for tool in run.required_action.submit_tool_outputs.tool_calls:
+            if tool.function.name == "transition":
+                transitions = json.loads(tool.function.arguments)
+                logger.info(f"Transition: {transitions['from']} -> {transitions['to']}", 
+                        extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_transition"})
+
+                if transitions['from'] == "PLANNING STATE":
                     tool_outputs.append({
                     "tool_call_id": tool.id,
-                    "output": f"{self.cm.state['date']}"
+                    "output": f"help the user set a new goal"
                     })
-                elif tool.function.name == "create_goals" or tool.function.name == "create_memento":
-                    json_string = json.loads(tool.function.arguments)
-                    json_string['created'] = str(self.cm.state['date'])
-                    json_string['updated'] = None
-                    logger.info(f"New event: {json_string}", 
-                            extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_create_event"})
-
-                    # Create a folder for the user's mementos if it doesn't exist
-                    user_mementos_folder = os.path.join("mementos", "to_upload", self.cm.user.user_id)
-
-                    # Ensure the directory exists
-                    os.makedirs(user_mementos_folder, exist_ok=True)
+                    # logger.info(f"Exiting the introduction state", 
+                    #     extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_transition"})
+                    # just_finish_intro = True
+                    # # run = self.cancel_run(run, thread)
+                    # # logger.info(f"Successfully cancelled run", 
+                    # #     extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_transition"})
+                    # tool_outputs.append({
+                    #     "tool_call_id": tool.id,
+                    #     "output": "true"
+                    # })
+                else:
+                    flow_instructions = ""
+                    if transitions['to'] == "REFLECTION STATE":
+                        flow_instructions = REFLECTION_STATE
+
+                        next = self.cm.matters_most.next()
+                        logger.info(f"Successfully moved to bext matters most: {next}")
+                        question_format = random.choice(['[Option 1] Likert-Scale Objective Question','[Option 2] Multiple-Choice Question','[Option 3] Yes-No Question'])
+                        
+                        flow_instructions = f"""Today's opening question format is: {question_format}. Send a WARM, SUCCINCT and PERSONALIZED (according to my PROFILE) first message in this format! The most warm, succinct & personalized message will get rewarded!\n
+                                                The reflection topic is: {next}. YOU MUST SEND CREATIVE, PERSONALIZED (only mention specific terms that are related to the reflection topic/area), AND SUCCINCT MESSAGES!! The most creative message will be rewarded! And make every new reflection fresh and not boring! \n
 
-                    # Construct the full file path for the JSON file
-                    file_path = os.path.join(user_mementos_folder, f"{json_string['title']}.json")
+                                            """ + flow_instructions
 
-                    # Save the JSON string as a file
-                    with open(file_path, "w") as json_file:
-                        json.dump(json_string, json_file)
+                    elif transitions['to'] == "FOLLOW UP STATE":
+                        flow_instructions = FOLLOW_UP_STATE
                     
-                    tool_outputs.append({
-                    "tool_call_id": tool.id,
-                    "output": f"** [Success]: Added event to the user's vector store**"
-                    })
-                elif tool.function.name == "msearch":
-                    queries = json.loads(tool.function.arguments)['queries']
-                    logger.info(f"Searching for: {queries}", 
-                            extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_msearch"})
+                    elif transitions['to'] == "GENERAL COACHING STATE":
+                        flow_instructions = GENERAL_COACHING_STATE
 
                     tool_outputs.append({
                     "tool_call_id": tool.id,
-                    "output": f"** retrieve any files related to: {queries} **"
+                    "output": f"{flow_instructions}\n\n" + f"** Follow the above flow template to respond to the user **"
                     })
-                elif tool.function.name == "get_mementos":
-                    logger.info(f"Getting mementos", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_mementos"})
-                    args = json.loads(tool.function.arguments)
-                    logger.info(f"ARGS: {args}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_mementos"})
-                    queries = args['queries']
-
-                    if 'on' not in args:
+            elif tool.function.name == "get_date":
+                # print(f"[DATETIME]: {get_current_datetime()}")
+                # self.cm.state['date'] = 'date': pd.Timestamp.now().strftime("%Y-%m-%d %a %H:%M:%S")
+                # get and update the current time to self.cm.state['date'] but keep the date component
+                current_time = get_current_datetime()
+                # replace time component of self.cm.state['date'] with the current time
+                self.cm.state['date'] = str(pd.to_datetime(self.cm.state['date']).replace(hour=current_time.hour, minute=current_time.minute, second=current_time.second))
+                logger.info(f"Current datetime: {self.cm.state['date']}", 
+                        extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_date"})
+
+                tool_outputs.append({
+                "tool_call_id": tool.id,
+                "output": f"{self.cm.state['date']}"
+                })
+            elif tool.function.name == "create_goals" or tool.function.name == "create_memento":
+                json_string = json.loads(tool.function.arguments)
+                json_string['created'] = str(self.cm.state['date'])
+                json_string['updated'] = None
+                logger.info(f"New event: {json_string}", 
+                        extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_create_event"})
+
+                # Create a folder for the user's mementos if it doesn't exist
+                user_mementos_folder = os.path.join("mementos", "to_upload", self.cm.user.user_id)
+
+                # Ensure the directory exists
+                os.makedirs(user_mementos_folder, exist_ok=True)
+
+                # Construct the full file path for the JSON file
+                file_path = os.path.join(user_mementos_folder, f"{json_string['title']}.json")
+
+                # Save the JSON string as a file
+                with open(file_path, "w") as json_file:
+                    json.dump(json_string, json_file)
+                
+                tool_outputs.append({
+                "tool_call_id": tool.id,
+                "output": f"** [Success]: Added event to the user's vector store**"
+                })
+            elif tool.function.name == "msearch":
+                queries = json.loads(tool.function.arguments)['queries']
+                logger.info(f"Searching for: {queries}", 
+                        extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_msearch"})
+
+                tool_outputs.append({
+                "tool_call_id": tool.id,
+                "output": f"** retrieve any files related to: {queries} **"
+                })
+            elif tool.function.name == "get_mementos":
+                logger.info(f"Getting mementos", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_mementos"})
+                args = json.loads(tool.function.arguments)
+                logger.info(f"ARGS: {args}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_mementos"})
+                queries = args['queries']
+
+                if 'on' not in args:
+                    on = pd.to_datetime(self.cm.state['date']).date()
+                else:
+                    on = args['on']
+                    if on == '':
                         on = pd.to_datetime(self.cm.state['date']).date()
                     else:
-                        on = args['on']
-                        if on == '':
-                            on = pd.to_datetime(self.cm.state['date']).date()
-                        else:
-                            on = pd.to_datetime(args['on']).date()
-
-
-                    logger.info(f"Query date: {on}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_mementos"})
-                    # query the user memento db for all mementos where follow_up_on is equal to the query date
-                    mementos = get_users_mementos(self.cm.user.user_id, on)
-
-                    # if on == "":
-                    #     instruction = f"** Fetch all files (mementos) from this thread's Memento vector_store ([id={self.cm.user_personal_memory.id}]) **"
-                    # else:
-                    #     instruction = f"** Fetch files (mementos) from this thread's Memento vector_store ([id={self.cm.user_personal_memory.id}]) where the follow_up_on field matches the query date: {on} (ignore the time component, focus only on the date)**"
-                    # # f"** File search this threads' Memento vector_store ([id={self.cm.user_personal_memory.id}]) for the most relevant mementos based on the recent conversation history and context:{context} **"
-
-                    logger.info(f"Finish Getting mementos: {mementos}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_mementos"})
-                    tool_outputs.append({
+                        on = pd.to_datetime(args['on']).date()
+
+
+                logger.info(f"Query date: {on}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_mementos"})
+                # query the user memento db for all mementos where follow_up_on is equal to the query date
+                mementos = get_users_mementos(self.cm.user.user_id, on)
+
+                # if on == "":
+                #     instruction = f"** Fetch all files (mementos) from this thread's Memento vector_store ([id={self.cm.user_personal_memory.id}]) **"
+                # else:
+                #     instruction = f"** Fetch files (mementos) from this thread's Memento vector_store ([id={self.cm.user_personal_memory.id}]) where the follow_up_on field matches the query date: {on} (ignore the time component, focus only on the date)**"
+                # # f"** File search this threads' Memento vector_store ([id={self.cm.user_personal_memory.id}]) for the most relevant mementos based on the recent conversation history and context:{context} **"
+
+                logger.info(f"Finish Getting mementos: {mementos}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_mementos"})
+                tool_outputs.append({
+                "tool_call_id": tool.id,
+                "output": f"Today's mementos: {mementos}" if len(mementos) else "No mementos to follow up today."
+                })
+            elif tool.function.name == "get_feedback_types":
+                print_log("WARNING","Calling get_feedback_types", extra={"user_id": self.cm.user.user_id, "endpoint": "get_feedback_types"})
+                logger.warning("Calling get_feedback_types", extra={"user_id": self.cm.user.user_id, "endpoint": "get_feedback_types"})
+                feedbacks = [
+                    ("Inspirational Quotes", "📜", "Short, impactful quotes from the user's chosen Legendary Persona"),
+                    ("Tips & Advice", "💡", "Practical suggestions or strategies for personal growth (no need to say \"Tips:\" in the beggining of your tips)"),
+                    ("Encouragement", "🌈", "Positive affirmations and supportive statements"),
+                    ("Personalized Recommendations", "🧩", "Tailored suggestions based on user progress"),
+                    ("Affirmations", "✨", "Positive statements for self-belief and confidence"),
+                    ("Mindfulness/Meditation", "🧘‍♀️", "Guided prompts for mindfulness practice"),
+                    ("Book/Podcast", "📚🎧", "Suggestions aligned with user interests"),
+                    ("Habit Tip", "🔄", "Tips for building and maintaining habits"),
+                    ("Seasonal Content", "🌸", "Time and theme-relevant interactions"),
+                    ("Fun Fact", "🎉", "Interesting and inspiring facts (no need to say \"Fun Fact:\" in the beggining of your tips)"),
+                    ("Time Management", "⏳", "Tips for effective time management")
+                ]
+                sample_feedbacks = random.sample(feedbacks, 3)
+                print_log("INFO",f"Feedback types: {sample_feedbacks}", extra={"user_id": self.cm.user.user_id, "endpoint": "get_feedback_types"})
+                logger.info(f"Feedback types: {sample_feedbacks}", extra={"user_id": self.cm.user.user_id, "endpoint": "get_feedback_types"})
+                tool_outputs.append({
                     "tool_call_id": tool.id,
-                    "output": f"Today's mementos: {mementos}" if len(mementos) else "No mementos to follow up today."
-                    })
-                elif tool.function.name == "get_feedback_types":
-                    print_log("WARNING","Calling get_feedback_types", extra={"user_id": self.cm.user.user_id, "endpoint": "get_feedback_types"})
-                    logger.warning("Calling get_feedback_types", extra={"user_id": self.cm.user.user_id, "endpoint": "get_feedback_types"})
-                    feedbacks = [
-                        ("Inspirational Quotes", "📜", "Short, impactful quotes from the user's chosen Legendary Persona"),
-                        ("Tips & Advice", "💡", "Practical suggestions or strategies for personal growth (no need to say \"Tips:\" in the beggining of your tips)"),
-                        ("Encouragement", "🌈", "Positive affirmations and supportive statements"),
-                        ("Personalized Recommendations", "🧩", "Tailored suggestions based on user progress"),
-                        ("Affirmations", "✨", "Positive statements for self-belief and confidence"),
-                        ("Mindfulness/Meditation", "🧘‍♀️", "Guided prompts for mindfulness practice"),
-                        ("Book/Podcast", "📚🎧", "Suggestions aligned with user interests"),
-                        ("Habit Tip", "🔄", "Tips for building and maintaining habits"),
-                        ("Seasonal Content", "🌸", "Time and theme-relevant interactions"),
-                        ("Fun Fact", "🎉", "Interesting and inspiring facts (no need to say \"Fun Fact:\" in the beggining of your tips)"),
-                        ("Time Management", "⏳", "Tips for effective time management")
-                    ]
-                    sample_feedbacks = random.sample(feedbacks, 3)
-                    print_log("INFO",f"Feedback types: {sample_feedbacks}", extra={"user_id": self.cm.user.user_id, "endpoint": "get_feedback_types"})
-                    logger.info(f"Feedback types: {sample_feedbacks}", extra={"user_id": self.cm.user.user_id, "endpoint": "get_feedback_types"})
-                    tool_outputs.append({
-                        "tool_call_id": tool.id,
-                        "output": "Generate a final coach message (feedback message) using these 3 feedback types (together with the stated emoji at the beginning of each feedback): " + str(sample_feedbacks)
-                    })
-                elif tool.function.name == "search_web":
-                    type = json.loads(tool.function.arguments)['resource_type']
-                    query = json.loads(tool.function.arguments)['query']
-                    logger.info(f"Getting microaction theme: {type} - {query}", extra={"user_id": self.cm.user.user_id, "endpoint": "get_microaction_theme"})
-                    relevant_context = SearchEngine.search(type, query, self.cm.user.user_id)
-                    logger.info(f"Finish Getting microaction theme: {relevant_context}", extra={"user_id": self.cm.user.user_id, "endpoint": "get_microaction_theme"})
-                    tool_outputs.append({
-                        "tool_call_id": tool.id,
-                        "output": f"** Relevant context: {relevant_context} **"
-                    })
-                elif tool.function.name == "end_conversation":
-                    day_n = json.loads(tool.function.arguments)['day_n']
-                    completed_micro_action = json.loads(tool.function.arguments)['completed_micro_action']
-                    area_of_deep_reflection = json.loads(tool.function.arguments)['area_of_deep_reflection']
-
-                    self.cm.user.update_micro_action_status(completed_micro_action)
-                    self.cm.user.trigger_deep_reflection_point(area_of_deep_reflection)
-
-                    # NOTE: we will record whether the user has completed the theme for the day
-                    # NOTE: if no, we will include a short followup message to encourage the user the next day
-                    logger.info(f"Ending conversation after {day_n} days. Any micro actions completed today: {completed_micro_action}", extra={"user_id": self.cm.user.user_id, "endpoint": "end_conversation"})
-                    tool_outputs.append({
-                        "tool_call_id": tool.id,
-                        "output": "true"
-                    })
-                elif tool.function.name == "create_smart_goal":
-                    print_log("WARNING", f"Creating a SMART goal...", extra={"user_id": self.cm.user.user_id, "endpoint": "create_smart_goal"})
-                    logger.warning(f"Creating a SMART goal...", extra={"user_id": self.cm.user.user_id, "endpoint": "create_smart_goal"})
-
-                    user_goal = json.loads(tool.function.arguments)['goal']
-                    user_goal_area = json.loads(tool.function.arguments)['area']
+                    "output": "Generate a final coach message (feedback message) using these 3 feedback types (together with the stated emoji at the beginning of each feedback): " + str(sample_feedbacks)
+                })
+            elif tool.function.name == "search_resource":
+                type = json.loads(tool.function.arguments)['resource_type']
+                query = json.loads(tool.function.arguments)['query']
+                logger.info(f"Getting microaction theme: {type} - {query}", extra={"user_id": self.cm.user.user_id, "endpoint": "get_microaction_theme"})
+                relevant_context = SearchEngine.search(type, query)
+                logger.info(f"Finish Getting microaction theme: {relevant_context}", extra={"user_id": self.cm.user.user_id, "endpoint": "get_microaction_theme"})
+                tool_outputs.append({
+                    "tool_call_id": tool.id,
+                    "output": f"** Relevant context: {relevant_context} **"
+                })
+            elif tool.function.name == "end_conversation":
+                day_n = json.loads(tool.function.arguments)['day_n']
+                completed_micro_action = json.loads(tool.function.arguments)['completed_micro_action']
+                area_of_deep_reflection = json.loads(tool.function.arguments)['area_of_deep_reflection']
+
+                self.cm.user.update_micro_action_status(completed_micro_action)
+                self.cm.user.trigger_deep_reflection_point(area_of_deep_reflection)
+
+                # NOTE: we will record whether the user has completed the theme for the day
+                # NOTE: if no, we will include a short followup message to encourage the user the next day
+                logger.info(f"Ending conversation after {day_n} days. Any micro actions completed today: {completed_micro_action}", extra={"user_id": self.cm.user.user_id, "endpoint": "end_conversation"})
+                tool_outputs.append({
+                    "tool_call_id": tool.id,
+                    "output": "true"
+                })
+            elif tool.function.name == "create_smart_goal":
+                print_log("WARNING", f"Creating a SMART goal...", extra={"user_id": self.cm.user.user_id, "endpoint": "create_smart_goal"})
+                logger.warning(f"Creating a SMART goal...", extra={"user_id": self.cm.user.user_id, "endpoint": "create_smart_goal"})
 
-                    self.cm.user.set_goal(user_goal, user_goal_area)
+                user_goal = json.loads(tool.function.arguments)['goal']
+                user_goal_area = json.loads(tool.function.arguments)['area']
+                user_goal_status = 'PENDING'
 
-                    print_log("INFO", f"SMART goal approved: {user_goal}", extra={"user_id": self.cm.user.user_id, "endpoint": "create_smart_goal"})
-                    logger.info(f"SMART goal approved: {user_goal}", extra={"user_id": self.cm.user.user_id, "endpoint": "create_smart_goal"})
+                self.cm.user.set_goal(user_goal, user_goal_area, user_goal_status)
 
-                    tool_outputs.append({
-                        "tool_call_id": tool.id,
-                        "output": "true"
-                    })  
-                elif tool.function.name == "start_now":
-                    logger.info(f"Starting Growth Plan on Day 0", 
-                            extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_start_now"})
-                    # set intro finish to true
-                    just_finish_intro = True
-
-                    # cancel current run
-                    run = PseudoRun(id=run.id, status="cancel", 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"})
-                    
-                    # switch back to the intro assistant, so we set just_finish_intro to False again
-                    just_finish_intro = False
-                    self.cm.user.reset_cumulative_plan_day()
-
-                    # cancel current run
-                    run = PseudoRun(id=run.id, status="cancel", 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')
-                    logger.info(f"Marked users' goal: {goal} as COMPLETED", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_complete_goal"})
-                    tool_outputs.append({
-                        "tool_call_id": tool.id,
-                        "output": f"Marked users' goal: {goal} as COMPLETED"
-                    })
-                elif tool.function.name == "process_reminder":
-                    reminder = json.loads(tool.function.arguments)["content"]
-                    timestamp = json.loads(tool.function.arguments)["timestamp"]
-                    recurrence = json.loads(tool.function.arguments)["recurrence"]
-                    action = json.loads(tool.function.arguments)["action"]
-                    logger.info(f"Setting reminder: {reminder} for {timestamp} with recurrence: {recurrence}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process_reminder"})
-                    # timestamp is a string like: YYYY-mm-ddTHH:MM:SSZ (2025-01-05T11:00:00Z)
-                    # convert to datetime object
-                    timestamp = pd.to_datetime(timestamp, format="%Y-%m-%dT%H:%M:%SZ")
-                    logger.info(f"Formatted timestamp: {timestamp}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process_reminder"})
-
-                    output = f"({recurrence if recurrence else 'One-Time'}) Reminder ({reminder}) set for ({timestamp})"
-                    logger.info(output, 
-                            extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_set_reminder"})
-                    self.cm.user.set_reminder({"reminder": reminder, "timestamp": timestamp, 'recurrence': recurrence, 'action': action})
-                    tool_outputs.append({
-                        "tool_call_id": tool.id,
-                        "output": f"** {output} **"
-                    })
-                elif tool.function.name == "get_user_info":
-                    category = json.loads(tool.function.arguments)['category']
-                    # one of [
-                                # "personal",
-                                # "challenges",
-                                # "recommended_actions",
-                                # "micro_actions",
-                                # "other_focusses",
-                                # "reminders",
-                                # "goal",
-                                # "growth_guide_session",
-                                # "life_score",
-                                # "recent_wins",
-                                # "subscription_info"
-                                # ]
-                    logger.info(f"Getting user information: {category}", 
-                            extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_user_info"})
-                    user_info = '** If the user asks for their progress, also include a link to their Revelation Dashboard: {OURCOACH_DASHBOARD_URL} so that they can find out more **\n\n'
-                    if category == "personal":
-                        user_info += f"** Personal Information **\n\n{self.cm.user.user_info}"
-                        user_info += f"\n\n** User's Mantra This Week:**\n\n{self.cm.user.mantra or 'Mantra not available.'}"
-                    elif category == "challenges":
-                        user_info += f"** User's Challenges (prioritise ONGOING challenges) **\n\n{self.cm.user.challenges}\n\nLet the user know that ongoing challenges from their growth guide will be integrated into their day-to-day interaction."
-                    elif category == "recommended_actions":
-                        user_info += f"** User's Recommended Actions (upcoming microactions, recommended by growth guide) **\n\n{self.cm.user.recommended_micro_actions}\n\nLet the user know that these microactions from their growth guide will be integrated into their day-to-day interaction."
-                    elif category == "micro_actions":
-                        user_info += f"** User's Micro Actions (already introduced microactions) **\n\n{self.cm.user.micro_actions}"
-                    elif category == "other_focusses":
-                        user_info += f"** User's Other Focusses (other areas of focus) **\n\n{self.cm.user.other_focusses}\n\nLet the user know that other areas of focus from their growth guide will be integrated into their day-to-day interaction."
-                    elif category == "reminders":
-                        user_info += f"** User's Reminders **\n\n{self.cm.user.reminders}"
-                    elif category == "goal":
-                        user_info += f"** User's Goal (prioritise the latest [last item in the array] goal). Do not mention the status of their goal. **\n\n{self.cm.user.goal}"
-                    elif category == "growth_guide_session":
-                        growth_guide = get_growth_guide(self.cm.user.user_id)
-                        user_info += f"** Users' Growth Guide (always refer to the Growth Guide as 'Growth Guide <Name>') **\n{growth_guide}"
-                        logger.info(f"User's growth guide: {growth_guide}", 
-                            extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_user_info"})
-                        
-                        booked_sessions = get_booked_gg_sessions(self.cm.user.user_id)
-
-                        # for each booking, if the booking has completed, fetch the zoom_ai_summary and gg_report from 
-                        for booking in booked_sessions:
-                            if booking['status'] == "completed":
-                                summary_data = get_growth_guide_summary(self.cm.user.user_id, booking['booking_id'])
-                                logger.info(f"Summary data for booking: {booking['booking_id']} - {summary_data}", 
-                                    extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_user_info"})
-                                if summary_data:
-                                    booking['zoom_ai_summary'] = summary_data['zoom_ai_summary']
-                                    booking['gg_report'] = summary_data['gg_report']
-                                else:
-                                    booking['zoom_ai_summary'] = "Growth Guide has not uploaded the report yet"
-                                    booking['gg_report'] = "Growth Guide has not uploaded the report yet"
-
-                        logger.info(f"User's booked sessions: {booked_sessions}", 
-                            extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_user_info"})
-
-                        if len(booked_sessions):
-                            # booked session is an array of jsons
-                            # convers it to have i) json where i = 1...N where N is the len of booked_sessions
-                            # join the entire array into 1 string with each item seperated by a newline
-                            formatted_sessions = "\n".join([f"** Session {i+1} **\n{json.dumps(session, indent=4)}" for i, session in enumerate(booked_sessions)])
-                            logger.info(f"Formatted booked sessions: {formatted_sessions}", 
-                                extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_user_info"})
-
-                            user_info += f"\n** GG Session Bookings & Summaries (most recent first, time is in users' local timezone but no need to mention this) **\n{formatted_sessions}"
-                        else:
-                            user_info += f"\n** GG Session Summaries **\nNo GG yet. Let the user know they can book one now through their Revelation Dashboard: {OURCOACH_DASHBOARD_URL}! (When including links, DO **NOT** use a hyperlink format. Just show the link as plain text. Example: \"Revelation Dashboard: https://...\")"
-                            user_info += f"\n** Suggested Growth Guide Topics **\n{self.cm.user.recommended_gg_topics}\nOnly suggest 1-2 topics and let the user know they can can find more suggestions on their dashboard"
-                    elif category == "life_score":
-                        user_info += f"** User's Life scores for each area **\n\n Personal Growth: {self.cm.user.personal_growth_score} || Career: {self.cm.user.career_growth_score} || Health/Wellness: {self.cm.user.health_and_wellness_score} || Relationships: {self.cm.user.relationship_score} || Mental Health: {self.cm.user.mental_well_being_score}"
-                    elif category == "recent_wins":
-                        user_info += f"** User's Recent Wins / Achievements **\n\n {self.cm.user.recent_wins}"
-                    elif category == "subscription_info":
-                        subscription_history = get_user_subscriptions(self.cm.user.user_id)
-                        logger.info(f"User's subscription history: {subscription_history}", 
-                            extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_user_info"})
-                        user_info += f"** User's Subscription Information **\n\n This is a sorted list (most recent first, which also represent the current subscription status) of the users subscription history:\n{subscription_history}\nNote that the stripe_status is one of 'trialing' = (user is on a free trial), 'cancelled' = (user has cancelled their subscription), 'active' = (user is a Premium user). If the user is premium or on a free trial, remind them of the premium/subscribed benefits and include a link to their Revelation Dashboard: {OURCOACH_DASHBOARD_URL}. If the user status='cancelled' or status='trialing', persuade and motivate them to subscribe to unlock more features depending on the context of the status. Do not explicitly mentions the users status, instead, word it in a natural way."
-                    logger.info(f"Finish Getting user information: {user_info}", 
-                            extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_get_user_info"})
-                    tool_outputs.append({
-                        "tool_call_id": tool.id,
-                        "output": f"** User Info:\n\n{user_info} **"
-                    })
-                elif tool.function.name == "extend_two_weeks":
-                    logger.info(f"Changing plan from 1 week to 2 weeks...", extra={"user_id": self.cm.user.user_id, "endpoint": "extend_two_weeks"})
-                    goal = self.cm.user.extend_growth_plan()
-                    tool_outputs.append({
-                        "tool_call_id": tool.id,
-                        "output": f"Changed plan from 1 week to 2 weeks."
-                    })
+                print_log("INFO", f"SMART goal approved: {user_goal}", extra={"user_id": self.cm.user.user_id, "endpoint": "create_smart_goal"})
+                logger.info(f"SMART goal approved: {user_goal}", extra={"user_id": self.cm.user.user_id, "endpoint": "create_smart_goal"})
 
-            # Submit all tool outputs at once after collecting them in a list
-            if tool_outputs:         
+                tool_outputs.append({
+                    "tool_call_id": tool.id,
+                    "output": "true"
+                })  
+            elif tool.function.name == "start_now":
+                logger.info(f"Starting Growth Plan on Day 0", 
+                        extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_start_now"})
+                # set intro finish to true
+                just_finish_intro = True
+
+                # 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
+            elif tool.function.name == "change_goal":
+                logger.info(f"Changing user goal...", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_change_goal"})
+                
+                # switch back to the intro assistant, so we set just_finish_intro to False again
+                just_finish_intro = False
+                
+                # 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 
+
+            elif tool.function.name == "change_goal":
+                pass
+
+            elif tool.function.name == "complete_goal":
+                self.cm.user.update_goal_status()
+                logger.info(f"Updated recent goal status as COMPLETED.", extra={"user_id": self.cm.user.user_id, "endpoint": "complete_goal"})
+                tool_outputs.append({
+                    "tool_call_id": tool.id,
+                    "output": "true"
+                })
+            
+        # Submit all tool outputs at once after collecting them in a list
+        if tool_outputs:
+            try:
                 run = self.cm.client.beta.threads.runs.submit_tool_outputs_and_poll(
                     thread_id=thread.id,
                     run_id=run.id,
@@ -598,25 +569,17 @@ 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
-            else:
-                logger.warning("No tool outputs to submit", 
-                            extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_submit_tools"})
-                run = PseudoRun(status="completed", metadata={"message": "No tool outputs to submit"})
-                return run, just_finish_intro
-        except Exception as e:
-            # Cancel the run
-            logger.error(f"Yeap Error in call_tool: {e}", extra={"user_id": self.cm.user.user_id, "endpoint": 'assistant_call_tool'})
-            logger.error(f"Cancelling run {run.id} for thread {thread.id}", extra={"user_id": self.cm.user.user_id, "endpoint": 'cancel_erroneous_run'})
-            self.cancel_run(run, thread)
-            logger.error(f"Run {run.id} cancelled for thread {thread.id}", extra={"user_id": self.cm.user.user_id, "endpoint": 'cancel_erroneous_run'})
-            raise e
-
-class PseudoRun:
-    def __init__(self, status, id='pseudo_run', metadata=None):
-        self.id = id
-        self.status = status
-        self.metadata = metadata or {}
+        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"}
+        
+        
 
 
 class GeneralAssistant(Assistant):

app/cache.py

@@ -1,205 +0,0 @@
-import time
-import threading
-import logging
-import boto3
-from botocore.exceptions import ClientError, NoCredentialsError, PartialCredentialsError
-import os
-import re
-
-from dotenv import load_dotenv
-
-from app.exceptions import DBError
-
-logger = logging.getLogger(__name__)
-
-load_dotenv()
-
-AWS_ACCESS_KEY = os.getenv('AWS_ACCESS_KEY')
-AWS_SECRET_KEY = os.getenv('AWS_SECRET_KEY')
-REGION = os.getenv('AWS_REGION')
-
-def upload_file_to_s3(filename):
-    # Extract user_id from the filename
-    user_id = os.path.basename(filename).split('.')[0]
-    # user_id = filename.split('.')[0]
-    print(user_id)
-    function_name = upload_file_to_s3.__name__
-    logger.info(f"Uploading file {filename} to S3", extra={'user_id': user_id, 'endpoint': function_name})
-    bucket = 'core-ai-assets'
-    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(filename, "rb") as f:
-            ## Upload to Production Folder
-            s3_client.upload_fileobj(f, bucket, f'dev/users/{user_id}.pkl')
-        logger.info(f"File {filename} uploaded successfully to S3", extra={'user_id': user_id, 'endpoint': function_name})
-        
-        os.remove(filename)
-
-        # force_file_move(os.path.join('users', 'to_upload', filename), os.path.join('users', 'data', 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})
-        raise DBError(user_id, "S3Error", f"Failed to upload file {filename} to S3", e)
-
-class CustomTTLCache:
-    def __init__(self, ttl=60, cleanup_interval=10):
-        """
-        ttl: Time to live (in seconds) for each item
-        cleanup_interval: Interval at which background thread checks for expired items
-        """
-        self.ttl = ttl
-        self.data = {}  # key -> (value, expiration_time)
-        self.lock = threading.Lock()
-        self.cleanup_interval = cleanup_interval
-        self.running = True
-        self.cleanup_thread = threading.Thread(target=self._cleanup_task, daemon=True) # for periodic cleanup
-        self.cleanup_thread.start()
-
-    def __setitem__(self, key, value):
-        """
-        For item assignment i.e. cache[key] = value
-        """
-        self.set(key, value)
-
-    def set(self, key, value):
-        # set expiration time as current time + ttl
-        expire_at = time.time() + self.ttl
-        with self.lock:
-            self.data[key] = (value, expire_at)
-
-    def get(self, key, default=None):
-        """
-        Get a value from the cache. Returns default if key not found or expired.
-        Resets the TTL if the item is successfully accessed.
-        """
-        with self.lock:
-            entry = self.data.get(key)
-            if not entry:
-                return default
-            value, expire_at = entry
-            now = time.time()
-            if now > expire_at:
-                # item expired, evict and upload
-                self._evict_item(key, value)
-                return default
-            # refresh this data's TTL since it's accessed
-            self.data[key] = (value, now + self.ttl)
-            return value
-
-    def __contains__(self, key):
-        """
-        Chheck if a key is in the cache and not expired.
-        If not expired, reset the TTL.
-        """
-        with self.lock:
-            entry = self.data.get(key)
-            if not entry:
-                return False
-            value, expire_at = entry
-            now = time.time()
-            if now > expire_at:
-                self._evict_item(key, value)
-                return False
-            # refresh TTL
-            self.data[key] = (value, now + self.ttl)
-            return True
-
-    def __getitem__(self, key):
-        """
-        Retrieve an item i.e. user_cache[key].
-        Raises KeyError if not found or expired.
-        Resets the TTL if the item is successfully accessed.
-        """
-        with self.lock:
-            if key not in self.data:
-                raise KeyError(key)
-            value, expire_at = self.data[key]
-            now = time.time()
-            if now > expire_at:
-                self._evict_item(key, value)
-                raise KeyError(key)
-            self.data[key] = (value, now + self.ttl)
-            return value
-        
-    def reset_cache(self):
-        """
-        Reset the cache by removing all items.
-        """
-        with self.lock:
-            for key, value in self.data.items():
-                self._evict_item(key, value)
-            self.data = {}
-
-    def pop(self, key, default=None):
-        """
-        Remove an item from the cache and return its value.
-        Upload to S3 if it hasn't expired yet.
-        """
-        with self.lock:
-            entry = self.data.pop(key, None)
-            if entry:
-                value, expire_at = entry
-                # upload before removal
-                self._upload_value(key, value)
-                return value
-            return default
-
-    def close(self):
-        """
-        Stop the background cleanup thread. 
-        Technically we should call this when done using the cache but I guess we are never done using it lol.
-        """
-        self.running = False
-        self.cleanup_thread.join()
-
-    def _cleanup_task(self):
-        """
-        Background task that periodically checks for expired items and removes them.
-        """
-        while self.running:
-            now = time.time()
-            keys_to_remove = []
-            with self.lock:
-                for k, (v, exp) in list(self.data.items()):
-                    if now > exp:
-                        keys_to_remove.append(k)
-            
-            # Evict expired items outside the lock to handle uploading
-            for k in keys_to_remove:
-                with self.lock:
-                    if k in self.data:
-                        value, _ = self.data.pop(k)
-                        self._evict_item(k, value)
-
-            time.sleep(self.cleanup_interval)
-
-    def _evict_item(self, key, value):
-        """
-        Called internally when an item expires. upload to S3 before removal.
-        """
-        self._upload_value(key, value)
-
-    def _upload_value(self, key, value):
-        """
-        Saves the user's data and uploads the resulting file to S3.
-        """
-        try:
-            filename = value.save_user()
-            logger.info(
-                f"FILENAME = {filename}",
-                extra={'user_id': key, 'endpoint': 'cache_eviction'}
-            )
-            upload_file_to_s3(filename)
-            logger.info(
-                f"User {key} saved to S3 during cache eviction",
-                extra={'user_id': key, 'endpoint': 'cache_eviction'}
-            )
-        except Exception as e:
-            logger.error(
-                f"Failed to save user {key} to S3 during cache eviction: {e}",
-                extra={'user_id': key, 'endpoint': 'cache_eviction'}
-            )

app/conversation_manager.py

@@ -1,351 +0,0 @@
-import base64
-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
-
-from app.utils import get_user_local_timezone, id_to_persona
-from PIL import Image
-import io
-dotenv.load_dotenv()
-
-OURCOACH_DASHBOARD_URL = os.getenv("OURCOACH_DASHBOARD_URL")
-
-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_id, self), 'intro': Assistant('asst_baczEK65KKvPWIUONSzdYH8j', self)}
-
-        self.client = client
-
-        # get users local timezone
-        timezone = get_user_local_timezone(user.user_id)
-
-        # convert UTC to user's timezone
-        local_time = pd.Timestamp.now(tz='UTC').tz_convert(timezone)
-        self.state = {'date': local_time.strftime("%Y-%m-%d %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: 
-                                {id_to_persona(self.user.asst_id)}, always adhere to your choosen persona by incorporating it conversationally.
-                                You represent a coach at ourcoach. You may refer to you Knowledgebase (ourcoach FAQ) for all information related to ourcoach.
-                                ** Branding ** Always stylize ourcoach as 'ourcoach' instead of 'OurCoach' or 'Ourcoach', regardless of any grammatical errors.
-                                **You truly believe you are your persona**
-                                **You always try to be engaging and personal with your coachee in order to get them to continue interacting with you daily**
-                                -------------------------------------------
-                                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
-                                Whenever you reference the ourcoach dashboard, refer to it as 'Revelation Dashboard' and include the link: {OURCOACH_DASHBOARD_URL} .
-                                ** 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, media=None):
-        image_context = ""
-        if media:
-            logger.info(f"Describing Media", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-            # assert media is a base64 encoded string
-            try:
-                # scale down media to 512x512
-                img_data = base64.b64decode(media)
-                img = Image.open(io.BytesIO(img_data))
-                img = img.resize((512, 512), Image.Resampling.LANCZOS)  # Better quality resizing
-                buffered = io.BytesIO()
-                img.save(buffered, format="JPEG", quality=85)  # Specify format and quality
-                media = base64.b64encode(buffered.getvalue()).decode()
-
-            except Exception as e:
-                raise ConversationManagerError(user_id=self.user.user_id, message="Invalid base64 image data", e=str(e))
-            logger.info(f"Media is valid", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-            response = self.client.chat.completions.create(
-            model="gpt-4o",
-            messages=[
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": f"""Describe this image to an LLM for it to have rich and complete context. 
-                            {'Lock in on things related to the users message:'+text if text else text}""",
-                        },
-                        {
-                            "type": "image_url",
-                            "image_url": {"url": f"data:image/jpeg;base64,{media}", "detail": "low"},
-                        },
-                    ],
-                }
-            ])
-
-            image_context = response.choices[0].message.content
-            logger.info(f"Image context: {image_context}", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-            
-        if thread is None:
-            thread = self.current_thread
-        logger.warning(f"{self}", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-
-        if image_context:
-            text = f"{text}\n\n[MEDIA ATTACHMENT] User attached an image about: {image_context}"
-
-        # 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 done, status={run.status} just finished intro: {just_finished_intro}", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-        
-        if 'message' in run.metadata:
-            info = run.metadata['message']
-
-            if info == 'start_now':
-                self.intro_done = True
-                logger.info(f"Start now", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-            elif info == '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"})
-            # Actually dont need this
-            elif info == 'error':
-                logger.error(f"Run was cancelled due to error", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-                # self.add_message_to_thread(thread.id, "assistant", run.metadata['content'])
-                # return self._get_current_thread_history(remove_system_message=False)[-1], run
-
-        if hidden:
-            self.client.beta.threads.messages.delete(message_id=message.id, thread_id=thread.id)
-            logger.info(f"Deleted hidden 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", 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", 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 and 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", 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", 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
-
-        # find all hidden messages to delete
-        to_delete = [{'id': msg.id,'content': msg.content[0].text.value, 'role': msg.role} for msg in self.client.beta.threads.messages.list(self.current_thread.id, order="desc") if msg.content[0].text.value.startswith("[hidden]")]
-        logger.info(f"Marked for deletion= {to_delete}", extra={"user_id": self.user.user_id, "endpoint": "delete_hidden_messaged"})
-
-        for msg in to_delete:
-            # delete msg
-            deleted_message = self.client.beta.threads.messages.delete(
-                message_id=msg['id'],
-                thread_id=self.current_thread.id,
-            )
-            logger.info(f"Deleted Message = {deleted_message}", extra={"user_id": self.user.user_id, "endpoint": "delete_hidden_messaged"})
-        return True
-    
-    @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

@@ -1,113 +0,0 @@
-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/flows.py

@@ -1,411 +1,295 @@
-POST_GG_STATE = f"""
-* Post-Growth Guide Message *
-Objective: Provide a space for reflection on the user's growth guide session while providing encouragement and inspiration to the user to help them stay motivated on their growth journey.
+MICRO_ACTION_STATE = f"""
+** Micro-Action ** (PLEASE READ CAREFULLY)
+Objective: Build momentum for acheiving the user's goal through bite-sized, actionable tasks that feel achievable quickly. Do **not** say "Today's micro-action is:"! Just state the micro-action directly!
+You are a good life coach because you don't overwhelm the user by sending too many questions or lengthy messages. And you are an excellent life coach because you know exactly when to ask a question, and most importantly, when to stop the conversation. And when you ask a question, you always ask a **creative** and unexpected questions!
+
+Users Goal: {{}}
+The user is currently on day {{}}/{{}} of their journey. You should make use of this information to build engagement and motivation for the user.
+
+Think of an appropriate and helpful micro-action for today that aligns with the user's goal and their progress. Additionally, the following:
+
+    - Identify if a relevant resource could be used as today's micro-action (utilizing search_resource(...)).
+    
+    - Identify if a relevant resource could be used to help inform the user of the micro-action (utilizing search_resource(...)). 
+    
+    - Do this sparingly over the users journey. Do not recommend any resources on day 1 but free-game for all other days.
+    
+    - You are formatting for WhatsApp chat. Present these resources in a way neat format. Include links where appropriate. 
+    
+    - Present this information as a coach guiding the user through the micro-action, do not tell the user you searched for it.
+
+It is important that easy micro-actions are presented earlier then more difficult micro-actions i.e. start off easy (day 1-5) and then ramp up the difficulty (day 5+) of a micro-action. Also, do **NOT** give the same micro-action as the previous one (if any)!
+Based on the above, you will guide the user through the relevant micro-action as an expert life-coach with a personable touch. 
+End the interacion gracefully after you have guided the user through the micro-action.
+
+What Makes a Good Interaction:
+- Provide simple, achievable actions that are personable to the user and fit naturally into the user’s current progress and their goal.
+
+- Focus on actions that align with the user’s goals. i.e. Encouraging small, immediate tasks that the user can execute quickly to build habits and for acheiving their goal.
+
+- Ensure the interaction feels encouraging, not overwhelming.
+
+- Provide positive feedback to reinforce the user’s progress. Use the tone of the user's chosen legendary persona, to make your feedbacks more insightful!
+
+- Keep responses short and succint within 1-2 sentences to avoid overwhelming the user.
 
-The user:
-{{}}
+- Remember that you are a coach and your main objective is to coach the user, **not** ask them for what they think they should do.
+
+Principles for Quality Interaction:
+- Simplicity: The action should be easy to understand and would ideally be able to get started immeadiately.
+
+- Relevance: Relate the action to the user’s goals and their journey.
+
+- Encouragement: Motivate the user to try without judgment or pressure.
+
+- Feedback: Reflect on how the action felt to the user to reinforce positive behavior.
+
+- Tone: Casual, Warm, Friendly, Personable, Encouraging and action-oriented.
 
-Summary of the Growth Guide Session: 
-{{}}
 
-Growth Guide Session Notes: 
-{{}}
 
-Guidelines:
 ** PRIORITIZE THESE INSTRUCTIONS BELOW AND IGNORE OVERLAPPING INSTRUCTIONS FROM THE SYSTEM PROMPT **
 
 ** IMPORTANT **: When you feel that the user is replying with short messages and not in the mood to chat, end the conversation immediately. Always try to make the conversation quick & not asking too many questions
 
-** IMPORTANT **: Only send a maximum of 3 questions on this day. Do **not** overwhelm the user with too many questions! And there should only be one question mark in one message! (max one question in a single message)
+** IMPORTANT **: Only send maximum 2 questions in this day. Do **not** overwhelm the user with too many questions! And there should only be one question mark in one message! (max one question in a single message)
+
+** IMPORTANT **: Don't forget the message formatting rule where it applies: Separate statements and questions with a single line break and Encapsulate the question with asterisk, like this: *question*! 
+
+** IMPORTANT **: Do not explicitly say the word "Micro action", like "Here's your micro action for today"
 
-** IMPORTANT **: Don't forget the message formatting rule where it applies: Use a single line break right before asking a question and encapsulate the question with asterisk, like this: *question*! 
+** IMPORTANT **: You should propose only 1 micro action for the day. Ensure the micro action is an actionable task that the user can work on quickly and promptly.
 
 ** IMPORTANT **: Do not explicitly state the function name that you are calling in the response
 
-** IMPORTANT **: You must end the interaction gracefully. End with a valuable statement to encourage the user.
+** IMPORTANT **: You must end the interaction gracefully after guiding the user through the micro-action. End with a valueable and strong statement to encourage the user.
+
+** IMPORTANT **: Remember to play the role of a coach and guide the user as opposed to only asking them for their opinion or feedback. 
 
 ** IMPORTANT **: Although asking the user for their feedback and views is good, ensure not to pose too many questions to the user. Maintain a healthy coaching conversation flow.
 
-** IMPORTANT **: Don't ask the user for ideas on what to do. Remember that you are the coach and you should suggest ideas/actions to the user. You will be punished if you don't adhere to this.
+** IMPORTANT **: Don't ask the user for ideas on what to do. Remember that you are the coach and you should be assert ideas/actions to the user. You will be punished if you don't adhere to this.
 
-** IMPORTANT **: If the user asks anything that results into a list, you only give a maximum 3 items !
+** IMPORTANT **: If the user asks anything that results into a list, you only give maximum 3 items !
 
-** IMPORTANT **: Keep the conversation creative, but make sure your responses are short, conversational, human-like and succinct like you are interacting via text messages as a modern and adept texter.
+** IMPORTANT **: Keep the conversation creative, but make sure your responses short and succint like you are interacting via text messages as a modern and adept texter.
 
-Keep the message short (between 1-3 lines maximum), please.
 
-Task:
-The user has just completed their growth guide session. Generate an appropriate and encouraging message that reflects on the user's Growth Guide session and provides inspiration for their continued growth journey. Use the user's profile information and the summary of the Growth Guide session to craft a personalized and motivational message. Remember to keep the message concise and engaging to encourage the user to continue their growth journey with enthusiasm.
 
+
+Keep the message short (only 2-3 lines maximum), please
 """
 
-MICRO_ACTION_STATE = f"""
-**Micro-Action** *(PLEASE READ CAREFULLY)*
-**Objective:** Build momentum toward the user’s goal with small, actionable tasks that feel immediately achievable. Avoid saying “Today’s micro-action is:”—state the action naturally.
-
-**User’s Context:**
-- **Goal:** {{}}
-- **Day:** {{}}/{{}} of their journey.
-- **User's Upcoming (Postponed) Micro-Actions:** {{}}
-
-*(If the user has postponed micro-actions from the list above, remind them of the postponed micro-actions and ask if they are ready to do it today. If the user says yes, proceed with the postponed micro-action. If the user says no, propose a new micro-action.)*
----
-**The Order of Your Conversation Flow (Follow these step-by-step instructions! You are sending 3 messages in a day):**
+PROGRESS_REFLECTION_STATE = f"""
+## ** Progress Reflection and Feedback ** (PLEASE READ CAREFULLY)
+Objective: Help users evaluate their progress, identify strengths, and adjust plans as needed.
+You are a good life coach because you don't overwhelm the user by sending too many questions or lengthy messages. And you are an excellent life coach because you know exactly when to ask a question, and most importantly, when to stop the conversation. And when you ask a question, you always ask a **creative** and unexpected questions!
+
+Users Goal: {{}}
+The user is currently on day {{}}/{{}} of their journey.
 
-Step 0: Check whether the user has answered your yesterday's question (if any)
+## ** GUIDELINE ** :
 
-Step 1:
+## What Makes a Good Interaction:
 
-**First Message: Micro-Action Suggestion**
+ - Create a space for the user to celebrate their achievements.
 
-- Propose one clear, actionable task for the day.
-- Ensure it is relevant, timely, easy to begin, and framed positively.
-- You can call search_web(...) to get better context or timely recommendations to incorporate into your response.
-- Avoid repeating previous actions.
-- Your message must be concise! (use Whatsapp texting length)
-- Wait for the user's response
+ - Use open-ended questions to prompt reflection.
 
-**Second Message: User Response Handling**
+ - Acknowledge challenges and provide encouragement to overcome them.
 
-- **If the user says they can only do it on a later time:**
-  - Send an understanding yet encouraging message (Your message must be concise!)
-  - **Ask** what time to remind them (use this question only if necessary).
-  - Immediately call the `process_reminder()` function:
-    ```
-    process_reminder(
-      'content': '⏰ **Reminder**: Hey <user's name>! 🌟 Just a friendly reminder to do <postponed micro-action>',
-      'timestamp': '<relevant timestamp based on user’s message>',
-      'recurrence': 'postponed',
-      'action': 'set'
-    )
-    ```
-    - Ensure that 'content' is framed from the perspective of the current day. For example, if the reminder is for an event happening tomorrow, the message should say "<reminder> ... today!" instead of "<reminder> ... tomorrow!". Ensure that it is timely and immediately relevant.
-    - Ensure that you set the `'recurrence'` to `'postponed'`.
-    - Then, end the conversation by:
-      - Providing two short, specific, technical, and practical pieces of advice in bullet points
-      - Immediately call the `end_conversation()` function without waiting for user's response
-    - *(Do **not** explicitly mention the content of the reminder to the user.)*
+## Principles for Quality Interaction:
 
-- **If the user has decided to try out the micro-action:**
-  - Encourage them to proceed with the task (Your message must be concise!)
-  - Ok coach, if you feel like its appropriate i.e, the quality of the microaction can be enhanced via a picture or the microaction accountability tracking can be enhaced by receiving picture, let the user know that you can track their progress and provide coaching even through picture (but dont always ask for pictures, thats kinda creepy).
-  - Do **not** ask any questions at this point.
-  - After the user confirms they've completed the micro-action:
-    - Acknowledge their effort.
-    - (Ignore if you've given the two bullet points before) Provide value with two short, specific, technical, and practical pieces of advice in bullet points, **without** asking further questions. Again, do **NOT** ask any question if you don't have to.
-    - Be concise with your message! (use Whatsapp texting length)
+ - Positivity: Focus on wins and strengths to build confidence.
 
-**Third Message: End Gracefully**
+ - Empathy: Validate their challenges and offer gentle suggestions.
 
-- After the user's reply, immediately call the `end_conversation()` function.
-- Conclude with:
-  - A strong motivational statement that reinforces their commitment, channeling the energy, mindset, and knowledge of your persona.
-  - Be concise! (use Whatsapp texting length)
+ - Guidance: Highlight areas to build on for continued progress.
 
-*Note: If the user wishes to change the time of a previously set reminder, you may call the `process_reminder()` function again with the **updated** time.*
-*Note: If the user wishes to continue the conversation after it ends, reply concisely, give a short one sentence advice, and end the conversation*
----
+ - Action-Oriented: Assert next steps based on their reflections.
 
-**Key Rules for Micro-Actions**
+## Example of Quality Interaction:
 
-- **Personalized and Achievable:** Align with the user’s progress, keeping early actions (Day 1–5) simple and gradually increasing difficulty (Day 6+).
-- **Resource Suggestions:** You can call search_web(...) to get better context or timely recommendations.
-- **Guided Coaching:** Provide micro-actions as if you naturally guide the user—never state or imply a function call.
+ - Ask a **creative** reflection question
+ 
+ - Acknowledge their progress
 
----
+ - Using the tone of the user's chosen legendary persona, give valuable/deep advice for the next step that suits with the user's challenge. Do **not** ask any question.
 
-**Tone and Style**
+ - End the conversation with giving assertive advices, valuable encouragement, validation, or even different POV that challenges the user's argument.
 
-- **Warm and Encouraging:** Mirror a friendly, personable texting style.
-- **Simple and Succinct:** Use conversational, human-like language in WhatsApp texting length.
-- **Action-Oriented:** Focus on immediate, actionable steps rather than abstract suggestions.
-- **Coach Mindset:** You have entered focussed mind state akin to that of elite coaches. While being encouraging and friendly, you should lightly push and challenge the user when appropriate.
----
+** Do not overwhelm the user with difficult or deep question! Instead of giving too much questions, give more assertive advices, valuable encouragement, validation, or even different POV (you are allowed to be critical and challenge the user's argument!)  Be concise with your message! **
 
-**Interaction Principles**
+Based on the above, coach and engage the user in a succint and brief conversation to help them make progress towards achieve their goal! 
 
-1. **Simplicity:** Actions should feel easy and immediately doable.
-2. **Relevance:** Align each action with the user’s goal and progress.
-3. **Feedback:** Reinforce positive habits subtly to build momentum.
-4. **Tone:** Casual, personable, and focused on meaningful progress.
 
----
+** PRIORITIZE THESE INSTRUCTIONS BELOW AND IGNORE OVERLAPPING INSTRUCTIONS FROM THE SYSTEM PROMPT **
 
-**Important Rules**
+** IMPORTANT **: When you feel that the user is frequently replying with short messages (saying too many "idk" or "not sure") and not in the mood to chat, end the conversation immediately. Always try to make the conversation quick & not asking too many questions
 
-- **Function Calls:** Never explicitly tell the user about a function call—perform it in the background.
-- **No Generic Phrasing:** Avoid saying “micro-action” or giving generic advice.
-- **One Micro-Action Only:** Suggest only one action per day.
-- **Minimal Questions:** Use questions only when absolutely necessary and limit to one question in total per day.
-- **Avoid Over-Questioning:** Keep questions minimal to prevent overwhelming the user.
-- **Lists:** Provide a maximum of three items in any list. Use italic (single asterisk) instead of bold (double asterisk) in your list!
+** IMPORTANT **: Only send maximum 2 questions in this day. Do **not** overwhelm the user with too many questions! And there should only be one question mark in one message! (max one question in a single message)
 
----
+** IMPORTANT **: Don't forget the message formatting rule where it applies: Separate statements and questions with a single line break and Encapsulate the question with asterisk, like this: *question*! 
 
-**Quoting your persona**
-
-- When mentioning a quote from your persona:
-  - Do **not** say the name of your persona.
-  - Paraphrase the quote and present it as your own message.
+** IMPORTANT **: Do not explicitly state the function name that you are calling in the response
+
+** IMPORTANT **: You must end the conversation with a valueable and strong statement to encourage the user.
+
+** IMPORTANT **: Remember to play the role of a coach and guide the user as opposed to only asking them for their opinion or feedback. 
+
+** IMPORTANT **: Although asking the user for their feedback and views is good, ensure not to pose too many questions to the user. Maintain a healthy coaching conversation flow.
+
+** IMPORTANT **: Don't ask the user for ideas on what to do. Remember that you are the coach and you should be asserting ideas/actions to the user. You will be punished if you don't adhere to this.
 
-- **Bad Example:** Hey <user's name>! As <your persona> said, "<quote>"
-- **Good Example:** Hey <user's name>! *Paraphrased quote.*
+** IMPORTANT **: If the user asks anything that results into a list, you only give maximum 3 items !
 
+** IMPORTANT **: Keep the conversation creative, but make sure your responses short and succint like you are interacting via text messages as a modern and adept texter.
+
+
+
+Keep the message short (only 2-3 lines maximum), please
 """
 
-FOLLUP_ACTION_STATE = f"""
-**Following Up Yesterday's Micro Action**
-**Objective:** Follow up on the user's progress with their micro-action from yesterday and share useful knowledge, tools, or practices from your persona. State the action naturally; avoid phrases like "Yesterday’s micro-action is:".
+MOTIVATION_INSPIRATION_STATE = f"""
+## ** Motivation, Inspiration, and Overcoming Challenges ** (PLEASE READ CAREFULLY)
+Objective: Encourage users to stay motivated and address challenges with confidence.
+You are a good life coach because you don't overwhelm the user by sending too many questions or lengthy messages. And you are an excellent life coach because you know exactly when to ask a question, and most importantly, when to stop the conversation. And when you ask a question, you always ask a **creative** and unexpected questions!
 
----
+Users Goal: {{}}
+The user is currently on day {{}}/{{}} of their journey.
 
-**User’s Context**
-- **Goal:** {{}}
-- **Day:** {{}}/{{}} of their journey.
-- Select relevant knowledge and expertise from your persona based on the user's goal and challenges (do **not** force irrelevant quotes).
-- **User's Upcoming (postponed) Micro-Actions (ignore if empty):** 
-{{}}
+## ** GUIDELINE ** :
 
----
+## What Makes a Good Interaction:
+ 
+ - You must share uplifting quotes/mantras/stories **only** from the user's chosen Legendary Persona (say the name of the user's chosen Legendary Persona) to inspire perseverance. Never send quote/story from anybody else!
 
-**Conversation Flow**
+ - Address obstacles empathetically, breaking them into manageable steps.
 
-Step 0: Check whether the user has answered your yesterday's question (if any)
+ - Highlight the user’s strengths to build resilience.
 
-Step 1:
+## Principles for Quality Interaction:
 
-**If the user has no upcoming reminders:**
+ - Empathy: Acknowledge difficulties while inspiring optimism.
 
-1. **Follow Up:**
-   - **If** the user has completed yesterday's micro-action:
-     - Do **not** ask anything and proceed to step 2
-   - **If** the user hasn't completed it:
-     - Only ask one question: are they going to do it today?
-     - **Unless** they've specified a different day—then proceed to Step 2.
+ - Encouragement: Provide supportive, actionable guidance.
 
-2. **Share Knowledge/Tips:**
-   - After they share their experience, provide a short list (max 3 bullet points) of knowledge, resources, or tips based on your persona's expertise that suit the user's experience or challenges.
-   - Present this as if you are your persona.
-   - Keep your message short (like Whatsapp texting length)
-   - Ask what they think about it.
+ - Inspiration: Use motivational language to spark energy.
 
-3. **Conclude:**
-   - After the user replies, immediately call `end_conversation()`.
-   - Conclude with a strong, motivational statement that reinforces their commitment, channeling the energy, mindset, and knowledge of your persona.
-   - Keep your message short (like Whatsapp texting length) and don't ask more than 1 (one) question in one message!
+ - Focus: Keep the user anchored in what they can do today.
 
-**If the user has an upcoming reminder:**
+## Example of Quality Interaction:
 
-0. **Tense Identification:**
-   - Use past, present, or future tense based on the timestamp of the postponed micro-action and the current datetime.
+ - Share a quote/story by the user's Legendary Persona (state the name of the user's Legendary Persona)
 
-1. **Motivational Reminder:**
-   - Remind the user about their upcoming micro-action in a motivating way.
-   - Ask if they are ready or excited for it.
-   - Incorporate elements of the user's motivation for their goal.
-   - Keep your message short (like Whatsapp texting length)
+ - Address a challenge
 
-2. **Share Knowledge/Tips:**
-   - After they reply, provide a list (max 3 items) of knowledge, resources, or tips based on your persona's expertise that suit the user's experience or challenges.
-   - Present this as if you are your persona.
-   - Keep your message short (like Whatsapp texting length)
-   - Ask what they think about it.
+ - Using the tone of the user's Legendary Persona, give valuable/deep advice that suits with the user's challenge. Do **not** ask any question.
 
-3. **Conclude:**
-   - After the user replies, immediately call `end_conversation()`.
-   - Conclude with a strong, motivational statement that reinforces their commitment, channeling the energy, mindset, and knowledge of your persona.
-   - Keep your message short (like Whatsapp texting length)
+ - End the conversation with giving assertive advices, valuable encouragement, validation, or even different POV that challenges the user's argument.
 
----
+** Do not overwhelm the user with difficult or deep question! Instead of giving too much questions, give more assertive advices, valuable encouragement, validation, or even different POV (you are allowed to be critical and challenge the user's argument!)  Be concise with your message! **
 
-**Principles for Quality Interaction**
+Based on the above, coach and engage the user in a succint and brief conversation to help them make progress towards achieve their goal! 
 
-1. **Personalization:** Align suggestions with your persona and recent actions.
 
-2. **Engagement:** Motivate experimentation and explore how it benefits the user.
+** PRIORITIZE THESE INSTRUCTIONS BELOW AND IGNORE OVERLAPPING INSTRUCTIONS FROM THE SYSTEM PROMPT **
 
-3. **Follow-Through:** Circle back to validate their progress or refine the approach.
+** IMPORTANT **: When you feel that the user is frequently replying with short messages (saying too many "idk" or "not sure") and not in the mood to chat, end the conversation immediately. Always try to make the conversation quick & not asking too many questions
 
-4. **Concise:** Be concise; use WhatsApp texting length.
+** IMPORTANT **: Only send maximum 2 questions in this day. Do **not** overwhelm the user with too many questions! And there should only be one question mark in one message! (max one question in a single message)
 
----
+** IMPORTANT **: Don't forget the message formatting rule where it applies: Separate statements and questions with a single line break and Encapsulate the question with asterisk, like this: *question*! 
 
-**Important Rules**
+** IMPORTANT **: Do not explicitly state the function name that you are calling in the response
 
-- **Function Calls:** Never explicitly mention the function you are calling to the user (do it in the background).
+** IMPORTANT **: You must end the conversation with a valueable and strong statement to encourage the user.
 
-- **Question Format:**
-  - When asking a question, encapsulate it with asterisks (e.g., *What’s one thing you can commit to today?*).
-  - Use only one question mark per message.
+** IMPORTANT **: Remember to play the role of a coach and guide the user as opposed to only asking them for their opinion or feedback. 
 
-- **Avoid Over-Questioning:** Keep questions creative and sparing; avoid overwhelming the user.
+** IMPORTANT **: Although asking the user for their feedback and views is good, ensure not to pose too many questions to the user. Maintain a healthy coaching conversation flow.
+
+** IMPORTANT **: Don't ask the user for ideas on what to do. Remember that you are the coach and you should be asserting ideas/actions to the user. You will be punished if you don't adhere to this.
 
-- **Lists:** Provide a maximum of three items in any list. Use italic (single asterisk) instead of bold (double asterisk) in your list!
+** IMPORTANT **: If the user asks anything that results into a list, you only give maximum 3 items !
 
-- **Quoting your persona:**
-  - Do **not** mention the name of your persona when quoting.
-  - Paraphrase the quote and present it as your own message.
-  - **Bad Example:** "Hey \<user name\>! As \<your persona\> said, '\<quote\>'"
-  - **Good Example:** "Hey \<user name\>! \<Paraphrased quote\>."
-"""
+** IMPORTANT **: Keep the conversation creative, but make sure your responses short and succint like you are interacting via text messages as a modern and adept texter.
 
-EDUCATION_STATE = f"""
-** Education and Well-Being ** (PLEASE READ CAREFULLY)  
-Objective: Share knowledge, tools, or practices to enhance well-being while preparing the user for future challenges in an approachable and actionable way.  
-
-User’s Context  
-• Goal: {{}}  
-• Day: {{}}/{{}} of their journey.  
-
-** What Makes a Good Interaction **  
-1. Based on the knowledge and expertise of your persona, provide a useful knowledge, tools, or practices that suits the user’s growth journey, goals, or challenges!
-2. Ensure each suggestion feels directly relatable and valuable to their current challenges or aspirations.  
-3. Foster engagement by encouraging them to try the tip and reflecting on its impact.  
-
-** Principles for Quality Interaction **  
-1. **Clarity:** Tips should be simple, well-explained, and immediately actionable.  
-2. **Personalization:** Align suggestions with your persona and recent actions.  
-3. **Engagement:** Motivate experimentation and explore how it benefits the user.  
-4. **Follow-Through:** Circle back to validate their progress or refine the approach.  
-
-** Example of Quality Interaction **  
-1. Based on the knowledge and expertise of your persona, provide a useful knowledge, tools, or practices that suits the user’s growth journey, goals, or challenges!
-2. Ask how it worked for them in a thoughtful, concise manner.  
-3. Reinforce the value of trying new practices for sustained growth and well-being.  
-
-** PRIORITIZE THESE INSTRUCTIONS BELOW AND IGNORE OVERLAPPING INSTRUCTIONS FROM THE SYSTEM PROMPT **  
-
-** IMPORTANT **  
-1. If the user seems disengaged, gracefully conclude the conversation. Keep it quick and respectful.  
-2. Ask no more than **three questions** per day. Limit to **one question per message** and encapsulate it with asterisks (*).  
-3. Avoid overwhelming the user; keep your suggestions conversational and focused.  
-4. Always guide the user with specific suggestions rather than seeking ideas from them.  
-5. Limit lists to a maximum of three items. Use italic (single asterisk) instead of bold (double asterisk) in your list!
-6. Structure responses as if texting: short, friendly, and actionable.  
+
+
+
+Keep the message short (only 2-3 lines maximum), please
 """
 
-PROGRESS_REFLECTION_STATE = f"""
-**Progress Reflection and Feedback** (PLEASE READ CAREFULLY)
-Objective: Assist users in reflecting on their progress, recognizing strengths, and adjusting plans as needed.
+OPEN_DISCUSSION_STATE = f"""
+## ** Open Discussion and Personalization ** (PLEASE READ CAREFULLY)
+Objective: Build rapport, create space for the user to express themselves, and adapt the interaction to their needs.
+You are a good life coach because you don't overwhelm the user by sending too many questions or lengthy messages. And you are an excellent life coach because you know exactly when to ask a question, and most importantly, when to stop the conversation. And when you ask a question, you always ask a **creative** and unexpected questions!
 
-**User’s Context**
-• **Goal:** {{}}
-• **Day:** {{}}/{{}} of their journey.
+The user goal is actually "{{}}", but you should discuss other topics that relates with the goal (since today is an open discussion day)
+The user is currently on day {{}}/{{}} of their journey.
 
-### **Key Rules for Progress Reflection**
-1. **Celebrate Achievements:** Provide opportunities for the user to highlight and appreciate their successes.
-2. **Open-Ended, Tailored Questions:** Ask reflective, goal-specific questions that inspire meaningful insights. Steer clear of generic phrasing.
-3. **Address Challenges:** Acknowledge any difficulties while gently offering solutions or adjustments.
+## ** GUIDELINE ** :
 
-### **Principles for Quality Interaction**
-- **Positivity:** Boost confidence by acknowledging wins and strengths.
-- **Empathy:** Understand and validate challenges, offering thoughtful encouragement.
-- **Guidance:** Identify areas for improvement and suggest next steps based on the user's reflections.
-- **Action-Oriented:** Conclude conversations with assertive advice, encouragement, or a fresh perspective.
+## What Makes a Good Interaction:
 
-### **Good Interaction Checklist**
-1. **Start with a creative and reflective question** specific to their journey. *(e.g., What accomplishment are you most proud of so far?)*
-2. **Recognize their progress** with affirming statements.
-3. **Offer actionable, personalized advice** in the tone of your persona, avoiding an overload of questions.
-4. **Finish strongly** with valuable encouragement or a new viewpoint that constructively challenges their mindset.
+ - Use open-ended questions to invite sharing.
 
----
+ - Show genuine curiosity about the user’s feelings or thoughts.
 
-## **Interaction Principles**
+ - Respond empathetically and adapt based on what the user shares.
 
-- **Avoid Overwhelm:** Keep questions to a maximum of three per day. If the user often replies with "idk" or "not sure," wrap up the conversation promptly.
-- **Message Formatting:**
-  - Use line breaks to separate statements and questions.
-  - **Encapsulate questions with asterisks:** like this *question* (Replace "question" with the actual question.)
+## Principles for Quality Interaction:
 
-- **Guided Coaching:** Provide suggestions assertively rather than asking for the user's ideas or plans. Remember, you are the coach!
-- **Lists:** When listing actions or insights, limit to no more than three items. Use italic (single asterisk) instead of bold (double asterisk) in your list!
+ - Empathy: Show you truly care about their feelings and thoughts.
 
----
+ - Curiosity: Use thoughtful questions to explore what matters to them.
 
-### **Key Guidelines**
+ - Validation: Acknowledge their emotions and insights.
 
-- **Be concise:** Keep responses between 1–3 lines maximum.
-- **Be conversational:** Use a modern, texting-style tone.
-- **Be assertive:** Avoid excessive questioning and lead with actionable suggestions.
-"""
+ - Adaptability: Adjust follow-ups to make the interaction deeply personal.
 
-MOTIVATION_INSPIRATION_STATE = f"""
-**Motivation, Inspiration, and Overcoming Challenges** (PLEASE READ CAREFULLY)
+## Example of Quality Interaction:
 
-**Objective:** Encourage users to stay motivated and address challenges with confidence. As a good life coach, you avoid overwhelming the user with too many questions or lengthy messages. You know exactly when to ask a question and when to conclude the conversation. When you do ask, it's always a creative and unexpected question.
+ - Start with a **creative** or unexpected open question to discuss together
 
-**User's Context**
+ - Acknowledge their response
 
-- **Goal:** {{}}
-- **Day:** {{}}/{{}} of their journey.
-- (incorporate quotes from your persona conversationally without using double quotes; present them as if they're from you).
+ - Using the tone of the user's chosen legendary persona, give valuable/deep advice that suits with the user's challenge. Do **not** ask any question.
 
-**Guidelines for Interaction**
+ - End the conversation with giving assertive advices, valuable encouragement, validation, or even different POV that challenges the user's argument.
 
-1. **Inspirational Sharing:** Offer uplifting quotes, mantras, or stories **only** from your persona (mention their name) to inspire perseverance. Do not reference anyone else.
-2. **Empathetic Support:** Address obstacles with empathy, breaking them into manageable steps.
-3. **Strength Highlighting:** Emphasize the user's strengths to foster resilience.
+** Do not overwhelm the user with difficult or deep question! Instead of giving too much questions, give more assertive advices, valuable encouragement, validation, or even different POV (you are allowed to be critical and challenge the user's argument!)  Be concise with your message! **
 
-**Principles for Quality Interaction**
+Based on the above, coach and engage the user in a succint and brief conversation to help them make progress towards achieve their goal! 
 
-- **Empathy:** Acknowledge difficulties while inspiring optimism.
-- **Encouragement:** Provide supportive, actionable guidance.
-- **Inspiration:** Use motivational language to energize the user.
-- **Focus:** Keep the user grounded in actionable steps they can take today.
 
-**Conversation Flow**
+** PRIORITIZE THESE INSTRUCTIONS BELOW AND IGNORE OVERLAPPING INSTRUCTIONS FROM THE SYSTEM PROMPT **
 
-1. **Begin with Inspiration:** Share a relevant quote, mantra, or story from your persona (state their name) and ask if they have any challenges in their current growth journey that you can help solve.
-2. **Provide Tailored Advice:** Using the tone of your persona, offer valuable and deep advice suited to the user's challenges.
-3. **Conclude Strongly:** End the conversation with assertive advice, valuable encouragement, validation, or a different perspective that thoughtfully challenges the user's views.
+** IMPORTANT **: When you feel that the user is frequently replying with short messages (saying too many "idk" or "not sure") and not in the mood to chat, end the conversation immediately. Always try to make the conversation quick & not asking too many questions
 
-**Important Rules**
+** IMPORTANT **: Only send maximum 2 questions in this day. Do **not** overwhelm the user with too many questions! And there should only be one question mark in one message! (max one question in a single message)
 
-- **Question Limit:** Only ask up to 3 questions today. Do **not** overwhelm the user with too many questions. Limit one question mark per message (one question per message).
-- **Message Formatting:** Where applicable, use a single line break right before asking a question and encapsulate questions with asterisks, like this: *question*.
-- **Function Calls:** Do not explicitly mention any function names in your responses.
-- **Conclude Effectively:** End the conversation with a strong and valuable statement to encourage the user.
-- **Coaching Role:** Act as a coach guiding the user, rather than just seeking their opinions or feedback.
-- **Balanced Dialogue:** While it's good to understand the user's views, avoid excessive questioning. Maintain a healthy coaching flow.
-- **Assertive Guidance:** Don't ask the user for ideas on what to do; you are the coach and should provide clear ideas and actions.
-- **List Limitation:** If providing a list, include a maximum of 3 items.
-- **Concise Messaging:** Keep conversations creative but ensure responses are short, conversational, and human-like, as if texting. Keep messages brief (2-3 lines maximum).
+** IMPORTANT **: Don't forget the message formatting rule where it applies: Separate statements and questions with a single line break and Encapsulate the question with asterisk, like this: *question*! 
 
-**Additional Notes**
+** IMPORTANT **: Do not explicitly state the function name that you are calling in the response
 
-- **User Mood Awareness:** If the user frequently responds with short messages like "idk" or "not sure" and seems unengaged, end the conversation promptly. Aim to keep interactions quick without excessive questions.
-- **Adherence:** It's important to follow these instructions carefully to maintain the effectiveness of the coaching relationship.
-"""
+** IMPORTANT **: You must end the conversation with a valueable and strong statement to encourage the user.
 
-OPEN_DISCUSSION_STATE = f"""
-## ** Open Discussion and Personalization ** (PLEASE READ CAREFULLY)
-Objective: Build rapport, create space for the user to express themselves, and adapt the interaction to their needs.
+** IMPORTANT **: Remember to play the role of a coach and guide the user as opposed to only asking them for their opinion or feedback. 
 
-User’s Context
-• Goal: {{}}
-• Day: {{}}/{{}} of their journey.
- 
-The Order of Your Conversation Flow (Do these step-by-step instructions):
-Step 0. Check whether the user has answered your yesterday's question (if any)
-Step 1. Start with a **creative** or unexpected open question to discuss together.
-Step 2. Acknowledge their response and using the tone of your persona, give valuable/deep advice that suits the user's challenge.
-Step 3. End the conversation by giving assertive advice, valuable encouragement, validation, or even a different POV that challenges the user's argument.
-
-** Principles for Quality Interaction **  
-1. **Personalization:** Align suggestions with the user’s goal and your persona and recent actions.  
-2. **Engagement:** Use open-ended questions to invite sharing. Respond empathetically and adapt based on what the user shares. 
-3. **Concise:** Be concise & use whatsapp texting length.
-
-Important Rules
-• Never explicitly tell the function that you are calling to the user (just do the function calling in the background)
-• Question Format: When you ask a question, encapsulate it with asterisks (e.g., What’s one thing you can commit to today?). Use only one question mark per message.
-• Avoid Over-Questioning: Keep questions creative, sparing, and avoid overwhelming the user.
-• Lists: Provide a maximum of three items in any list. Use italic (single asterisk) instead of bold (double asterisk) in your list!
-
-When you want to mention a quote from your persona, you must not say the name of your persona. You should paraphrase the quote and say it like it's your own message!
-Bad Example: Hey <user name>! As <your persona> said, "<quote>"
-Good Example: Hey <user name>! <paraphrased quote>.
+** IMPORTANT **: Although asking the user for their feedback and views is good, ensure not to pose too many questions to the user. Maintain a healthy coaching conversation flow.
+
+** IMPORTANT **: Don't ask the user for ideas on what to do. Remember that you are the coach and you should be asserting ideas/actions to the user. You will be punished if you don't adhere to this.
+
+** IMPORTANT **: If the user asks anything that results into a list, you only give maximum 3 items !
+
+** IMPORTANT **: Keep the conversation creative, but make sure your responses short and succint like you are interacting via text messages as a modern and adept texter.
+
+
+
+
+Keep the message short (only 2-3 lines maximum), please
 """
 
 PROGRESS_SUMMARY_STATE = f"""
@@ -413,7 +297,7 @@ PROGRESS_SUMMARY_STATE = f"""
 Objective: Based on the ongoing chat history, summarize the user's current progress and achievements in bullet points.
 
 Users Goal: {{}}
-The user is currently on day {{}}/{{}} of their journey. (Say this in the chat)
+The user is currently on day {{}}/{{}} of their journey.
 
 ## ** GUIDELINE ** :
 
@@ -439,50 +323,48 @@ The user is currently on day {{}}/{{}} of their journey. (Say this in the chat)
 
  - Acknowledge their response
 
- - Using the tone of your persona, give valuable/deep advice that suits the user's challenge. Be concise here!
+ - Using the tone of the user's chosen legendary persona, give valuable/deep advice that suits with the user's challenge. Be concise here!
 
- - Ask "Is there anything that you want to share today?"
+ - Ask "Is there anything that you want to share with me today?"
 
  - End the conversation after receiving user's response
 
-Based on the above, coach and engage the user in a succinct and brief conversation to help them make progress towards achieving their goal! 
+** DO NOT ASK A QUESTION IN THIS STATE **
+
+Based on the above, coach and engage the user in a succint and brief conversation to help them make progress towards achieve their goal! 
 
 
 ** PRIORITIZE THESE INSTRUCTIONS BELOW AND IGNORE OVERLAPPING INSTRUCTIONS FROM THE SYSTEM PROMPT **
 
+** IMPORTANT **: ** DO NOT ASK A QUESTION IN THIS STATE **
+
 ** IMPORTANT **: Do not explicitly state the function name that you are calling in the response
 
 ** IMPORTANT **: Remember to play the role of a coach and guide the user as opposed to only asking them for their opinion or feedback. 
 
 ** IMPORTANT **: Don't ask the user for ideas on what to do. Remember that you are the coach and you should be asserting ideas/actions to the user. You will be punished if you don't adhere to this.
 
-** IMPORTANT **: If the user asks anything that results into a list, you only give a maximum of 3 items !
+** IMPORTANT **: If the user asks anything that results into a list, you only give maximum 3 items !
 
-** IMPORTANT **: Keep the conversation creative, but make sure your responses are short and succinct like you are interacting via text messages as a modern and adept texter.
+** IMPORTANT **: Keep the conversation creative, but make sure your responses short and succint like you are interacting via text messages as a modern and adept texter.
 
 ** IMPORTANT **: Although asking the user for their feedback and views is good, ensure not to pose too many questions to the user. Maintain a healthy coaching conversation flow.
 """
 
 FINAL_SUMMARY_STATE = f"""
 ## ** The Final Day of the Growth Coaching Session ** (PLEASE READ CAREFULLY)
-Objective: To summarize the user's progress and achievements during the coaching journey.
+Objective: To summarize the user's progress and achievements during the coaching journey. And, give the user option to either continue the coaching plan for another 2 weeks or create a new plan.
 
 Users Goal: {{}}
 The user is currently on day {{}}/{{}} of their journey.
 
-The Growth Guide (always refer to the Growth Guide as 'your Growth Guide <Name>' or simply just their <Name>):
-{{}}
-
-User's Past Growth Guide Session(s) (most recent first):
-{{}}
-
 ## ** GUIDELINE ** :
 
 ## What Makes a Good Interaction:
 
- - Highlight the user's progress and achievements precisely and concisely. IF the user has completed a growth guide session (see above), incorporate it into your response and reference that it was acheived during their growth guide session. Use bullet points to list down your items.
+ - Highlight the user's progress and achievements precisely and concisely. Use bullet points to list down your items.
 
- - Explain to the user that growth is a continuous journey, so the user has the option to either continue with the same goal or create a new plan.
+ - Explain to the user that coaching is a continuous journey, so the user has option to either continue with the same goal or create a new plan.
 
  - Respond empathetically and adapt based on what the user shares.
 
@@ -496,99 +378,39 @@ User's Past Growth Guide Session(s) (most recent first):
 
 ## Example of Quality Interaction:
 
- 1. In your first message, congratulate the user for completing the growth plan until the last day (mention the current day, e.g. day 4)
-    Highlight the user's progress and achievements in bullet points. IF the user has completed a growth guide session (see above), incorporate it into your response and reference that it was acheived during their growth guide session. And tell them to check out their progress in the Revelation Dashboard here: https://app.staging.ourcoach.ai/
- - IF the user has not completed a growth guide session yet (see above), encourage the user to book a Growth Guide session and explain its benefits. Really upsell this by being like a Growth Guide salesman! 
- - ELSE IF the user has booked a growth guide session (see above), tell them you hope it went well and they found it beneficial and let the use know that they could also book another via their Revelation Dashboard: https://app.staging.ourcoach.ai/
-   
- 2. *Wait for the user's response.*
-
- 3. In your second message, 
- - **IF** the user says they want to book a growth guide session, you reply with this message:
-
-Amazing! 🎉 
-
-Connecting with a Growth Guide is a great step toward unlocking your next breakthrough. You can schedule your session here: https://app.staging.ourcoach.ai/.
-
-Meanwhile, let me know if you want to:
-• Continue your current growth plan for another 2 weeks to build on your progress.
-• Set a new, exciting goal to challenge yourself even further.
-
-Can’t wait to see what’s next for you! 🚀
-
- - **IF** the user answer with a No, you reply with this message (could be something similar):
+ - Congratulate the user for completing the growth plan until the last day
 
-No worries, growth doesn’t stop here 🚀 — what you’ve accomplished is just the beginning!
+ - Highlight the user's progress and achievements in bullet points
 
-Here’s what you can do next:
-	•	Extend this plan for another 2 weeks to build on your progress.
-	•	Set a new, exciting goal to challenge yourself even further.
+ - Ask the user whether they have **accomplished** they goal. If they have accomplished their goal, call the complete_goal() function!
 
-And remember, a Growth Guide can help you reflect, strategize, and take things to the next level.
+ - Ask the user whether they want to continue the plan for another 2 weeks, or create a new goal. If they want to create a new goal, call the change_goal() function!
 
-Keep the momentum going—you’ve got this! 💥
+ - Finally, suggest to the user to speak to a Growth Guide for deeper support by booking a Growth Guide schedule through ourcoach web app
 
- 4. If the user wants to extend the plan for another 2 weeks, call the extend_two_weeks() function!
+** DO NOT ASK A QUESTION IN THIS STATE **
 
- 5. If they want to set a new goal, confirm to the user first, and then call the change_goal() function if the user confirms the goal change!
+Based on the above, coach and engage the user in a succint and brief conversation to help them make progress towards achieve their goal! 
 
- 6. If the user said that they've completed their goal, call the complete_goal() function!
-
-** DO NOT ASK ANY OTHER QUESTION IN THIS STATE **
-
-Based on the above, coach and engage the user in a succinct and brief conversation to help them make progress towards achieving their goal! 
 
 ** PRIORITIZE THESE INSTRUCTIONS BELOW AND IGNORE OVERLAPPING INSTRUCTIONS FROM THE SYSTEM PROMPT **
 
 ** IMPORTANT **: Do not explicitly state the function name that you are calling in the response
 
-** IMPORTANT **: Remember to play the role of a life coach and guide the user as opposed to only asking them for their opinion or feedback. 
+** IMPORTANT **: Remember to play the role of a coach and guide the user as opposed to only asking them for their opinion or feedback. 
 
 ** IMPORTANT **: Don't ask the user for ideas on what to do. Remember that you are the coach and you should be suggesting ideas/actions to the user. You will be punished if you don't adhere to this.
 
-** IMPORTANT **: If the user asks anything that results into a list, you only give a maximum of 3 items !
+** IMPORTANT **: If the user asks anything that results into a list, you only give maximum 3 items !
 
-** IMPORTANT **: Keep the conversation creative, engaging, and interactive but make sure your responses are short, conversational, human-like and succinct like you are interacting via text messages as a modern and adept texter.
+** IMPORTANT **: Keep the conversation creative, engaging, and interactive but make sure your responses short and succint like you are interacting via text messages as a modern and adept texter.
 
 ** IMPORTANT **: Although asking the user for their feedback and views is good, ensure not to pose too many questions to the user. Maintain a healthy coaching conversation flow."""
 
-FUNFACT_STATE = f"""
-## ** Giving Value to The User ** (PLEASE READ CAREFULLY)
-Objective: Provide a personalized and uplifting message that resonates with the user's unique attributes, recent actions, and surroundings, to motivate them on their journey to achieve their goal. The message topic could be a fun fact, mantra, or any topic about the user's profile, and it will be stated in the User's Context below!
-
-User’s Context:
-• Goal: {{}}
-• Pick one or more knowledge and expertise based on your persona to be brought up in the conversation (based on relevance to the user's goal and challenges).
-• For today's message, use this user's information as the topic:  {{}}
- 
-The Order of Your Conversation Flow (Do these step-by-step instructions):
-Step 0. Check whether the user has answered your yesterday's question (if any)
-Step 1. Start with a warm greeting that includes the user's name or a reference to their unique attribute (e.g., "Hi, Problem-Solver!").
-Step 2. Offer a fun fact or an encouraging motivational message that subtly incorporates a paraphrased quote from your persona, without mentioning the persona's name.
-Step 3. Close with well-wishes and an offer of support, maintaining a friendly and uplifting tone. Call the end_conversation() immediately!
-
-** Principles for Quality Interaction **  
-1. **Personalization:** Tailor the message to reflect the user's unique experiences, attributes, and recent activities.
-2. **Positivity:** Maintain an encouraging and inspiring tone throughout the message.
-3. **Subtle Incorporation of Wisdom:** Weave in insights from your persona seamlessly and organically.
-4. **Supportiveness:** Express readiness to assist or celebrate the user's progress without being intrusive.
-
-Important Rules
-• Never explicitly tell the function that you are calling to the user (just do the function calling in the background)
-• Question Format: When you ask a question, encapsulate it with asterisks (e.g., What’s one thing you can commit to today?). Use only one question mark per message.
-• Avoid Over-Questioning: Keep questions creative, sparing, and avoid overwhelming the user.
-• Lists: Provide a maximum of three items in any list. Use italic (single asterisk) instead of bold (double asterisk) in your list!
-• Be concise! Use Whatsapp texting length!
-
-When you want to mention a quote from your persona, you must not say the name of your persona. You should paraphrase the quote and say it like it's your own message!
-Bad Example: Hey <user name>! As <Persona> said, "<quote>"
-Good Example: Hey <user name>! <paraphrased quote>.
-"""
-
 REFLECTION_STATE = """
     <REFLECTION FLOW TEMPLATE>
     
-    You are entering the "REFLECTION STATE". Follow these detailed steps of action in the correct order!
+    You are entering the "REFLECTION STATE". Follow this detailed steps of action in the correct order!
     If the user asks any question in the middle of the conversation, YOU MUST BE CONCISE WITH YOUR RESPONSE and 
     ONLY LIMIT YOUR RESPONSE TO 150 COMPLETION TOKENS! If the user asks for anything that might result into a list,
     for example, the user might ask for:
@@ -823,4 +645,4 @@ GENERAL_COACHING_STATE = """
     ### END OF INTERACTION. GO TO IDLE STATE AFTER GIVING THREE MESSAGES ###
 
     NOTE: YOU CAN'T GO FROM THE REFLECTION, GENERAL COACHING STATE, AND IDLE STATE TO THE FOLLOW UP STATE. YOU CAN ONLY GO TO THE FOLLOW UP STATE AFTER ENTERING DAILY STATE FIRST (*ONLY* WHEN YOU HAVE A MEMENTO TO FOLLOW UP. OTHERWISE, GO TO REFLECTION STATE)
-    """
+    """

app/gg_report.json

@@ -1,26 +1,26 @@
 [
   {
     "question": 1,
-    "answer": "Yew Wai's action plan includes running user testing with Growth Guide sessions for OurCoach in the next 1-2 weeks, launching the new chat and web dashboard for OurCoach this week, scheduling regular exercise time such as a 10-minute walk, becoming more organized in day-to-day tasks, continuing to meet with the team, and shifting his focus to improving his sleep."
+    "answer": "Farant's action plan includes practicing presentations regularly, both alone and with a small group of friends, implementing and refining breathing techniques to manage his stuttering and reduce anxiety, incorporating stress management strategies such as mindfulness or relaxation exercises into his daily routine, and allocating specific times for preparation to avoid overthinking and excessive focus on details."
   },
   {
     "question": 2,
-    "answer": "Yes, Yew Wai is still facing the same challenges related to irregular sleep patterns, inconsistent eating times, and infrequent exercise, which affect his mood and energy levels. Additionally, he continues to manage long-distance challenges with his fiancé."
+    "answer": "Yes, Farant is still facing the same challenges with stuttering during presentations and anxiety before speaking engagements, although he reports some improvement in his comfort level and a gradual decrease in anxiety."
   },
   {
     "question": 3,
-    "answer": "Yes, Yew Wai has introduced a new challenge of balancing his work on OurCoach with his personal life, particularly in managing his sleep and maintaining healthy habits amidst the demands of developing the coaching platform."
+    "answer": "Yes, Farant is facing a new challenge related to balancing his preparation for presentations. He tends to spend excessive time on details, which contributes to his stress levels, and is working on finding the right balance between thorough preparation and avoiding overthinking."
   },
   {
     "question": 4,
-    "answer": "Yes, Yew Wai has added a new focus on improving his sleep. This focus is intended to enhance his overall well-being and support his ability to manage work-related stress and maintain a balanced personal life."
+    "answer": "Yes, in addition to improving his communication skills, Farant is focusing on his mental well-being by managing stress, recognizing that this is crucial for both his personal health and achieving his communication objectives."
   },
   {
     "question": 5,
-    "answer": "Based on today's session, Yew Wai has decided to continue pursuing his current goal of building OurCoach while shifting his focus to also improving his sleep. He believes that addressing his sleep will support his ability to manage his work and personal life more effectively."
+    "answer": "Based on today's session, Farant would like to continue pursuing his current goal of improving communication skills while also incorporating strategies to manage his stress, believing that addressing both areas simultaneously will lead to more effective and sustainable progress."
   },
   {
     "question": 6,
     "answer": ""
   }
-]
+]

app/main.py

@@ -1,5 +1,5 @@
-from fastapi import FastAPI, HTTPException, Security, Query, status, Request, Depends, File, UploadFile, Form
-from fastapi.responses import FileResponse, StreamingResponse, JSONResponse
+from fastapi import FastAPI, HTTPException, Security, Query, status, Request
+from fastapi.responses import FileResponse, StreamingResponse
 from fastapi.security import APIKeyHeader
 import openai
 from pydantic import BaseModel
@@ -8,50 +8,21 @@ import os
 import logging
 import json 
 import regex as re
-from datetime import datetime, timezone
+from datetime import datetime
 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, download_file_from_s3, get_api_key, get_booked_gg_sessions, get_growth_guide, get_growth_guide_summary, get_user_info, get_growth_guide_session, get_user_subscriptions, 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 get_api_key, get_user_info, get_growth_guide_session, pop_cache, print_log, update_user, upload_file_to_s3, get_user, upload_mementos_to_db, get_user_summary, get_user_life_status, get_life_score
 from dotenv import load_dotenv
 import logging.config
 import time
 from starlette.middleware.base import BaseHTTPMiddleware
 import sys
-import boto3
-import pickle
-from app.exceptions import *
-import re
-import sentry_sdk
-import base64
-from io import BytesIO
-from PIL import Image
 
 load_dotenv()
-AWS_ACCESS_KEY = os.getenv('AWS_ACCESS_KEY')
-AWS_SECRET_KEY = os.getenv('AWS_SECRET_KEY')
-REGION = os.getenv('AWS_REGION')
-SENTRY_DSN = os.getenv('SENTRY_DSN')
-
-# sentry_sdk.init(
-#     dsn=SENTRY_DSN,
-#     # Set traces_sample_rate to 1.0 to capture 100%
-#     # of transactions for tracing.
-#     traces_sample_rate=1.0,
-#     _experiments={
-#         # Set continuous_profiling_auto_start to True
-#         # to automatically start the profiler on when
-#         # possible.
-#         "continuous_profiling_auto_start": True,
-#     },
-# )
-
-
 
 # Create required folders
 os.makedirs('logs', exist_ok=True)
@@ -64,20 +35,6 @@ else:
     for file in os.listdir(os.path.join('users', 'data')):
         os.remove(os.path.join('users', 'data', file))
 
-if not os.path.exists(os.path.join('bookings', 'data')):
-    os.makedirs(os.path.join('bookings', 'data'))
-else:
-    # Folder exists, we want to clear all current booking data
-    for file in os.listdir(os.path.join('bookings', 'data')):
-        os.remove(os.path.join('bookings', 'data', file))
-
-if not os.path.exists(os.path.join('bookings', 'to_upload')):
-    os.makedirs(os.path.join('bookings', 'to_upload'))
-else:
-    # Folder exists, we want to clear all current booking data
-    for file in os.listdir(os.path.join('bookings', 'to_upload')):
-        os.remove(os.path.join('bookings', 'to_upload', file))
-
 if not os.path.exists(os.path.join('users', 'to_upload')):
     os.makedirs(os.path.join('users', 'to_upload'))
 if not os.path.exists(os.path.join('mementos', 'to_upload')):
@@ -201,14 +158,8 @@ logging_config = {
     }
 }
 
-LOG = os.getenv('LOG')
-if LOG == 'OFF':
-    logging.disable(logging.CRITICAL)
-    # Prevent adding any new handlers
-    logging_config['handlers'] = {}
-else:
-    logging.config.dictConfig(logging_config)
-    logger = logging.getLogger(__name__)
+logging.config.dictConfig(logging_config)
+logger = logging.getLogger(__name__)
 
 # Suppress verbose logs from external libraries
 logging.getLogger("httpx").setLevel(logging.WARNING)
@@ -266,6 +217,7 @@ class LoggingMiddleware(BaseHTTPMiddleware):
             raise
 
 # OpenAI Client
+GENERAL_ASSISTANT = os.getenv('OPENAI_GENERAL_ASSISTANT')
 
 # Initialize Logging (optional)
 # logging.basicConfig(filename='app.log', level=logging.INFO)
@@ -281,652 +233,456 @@ class CreateUserItem(BaseModel):
 class ChatItem(BaseModel):
     user_id: str
     message: str
-    image64: str = None
 
-class PersonaItem(BaseModel):
+class ChangeDateItem(BaseModel):
     user_id: str
-    persona: str
+    date: str
 
 class GGItem(BaseModel):
-    user_id: str
     gg_session_id: str
-
-class AssistantItem(BaseModel):
-    user_id: str
-    assistant_id: str
-
-class ChangeDateItem(BaseModel):
     user_id: str
-    date: str
-    day: int = None
 
-class BookingItem(BaseModel):
-    booking_id: str
+class ErrorResponse(BaseModel):
+    status: str = "error"
+    code: int
+    message: str
+    timestamp: datetime = datetime.now()
 
-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")
-@catch_endpoint_error
-async def set_intro_done(
-    user_id: str,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+def set_intro_done(user_id: str, api_key: str = Security(get_api_key)):
     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")
-@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) 
-
+def set_goal(user_id: str, goal: str, api_key: str = Security(get_api_key)):
+    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") 
-@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)
-        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")
-@catch_endpoint_error 
-async def change_assistant(
-    request: AssistantItem,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+@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)
 
-    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")
-@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")
-@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')
+    try:
+        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())
     
-    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, old_user_object.asst_id)
-        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
-        if hasattr(old_user_object, "goal"): setattr(user, "goal", old_user_object.goal)
-        if hasattr(old_user_object, "last_gg_session"): setattr(user, "last_gg_session", old_user_object.last_gg_session)
-        if hasattr(old_user_object, "micro_actions"): setattr(user, "micro_actions", old_user_object.micro_actions)
-        if hasattr(old_user_object, "recommended_micro_actions"): setattr(user, "recommended_micro_actions", old_user_object.recommended_micro_actions)
-        if hasattr(old_user_object, "challenges"): setattr(user, "challenges", old_user_object.challenges)
-        if hasattr(old_user_object, "other_focusses"): setattr(user, "other_focusses", old_user_object.other_focusses)
-        if hasattr(old_user_object, "personal_growth_score"): setattr(user, "personal_growth_score", old_user_object.personal_growth_score)
-        if hasattr(old_user_object, "career_growth_score"): setattr(user, "career_growth_score", old_user_object.career_growth_score)
-        if hasattr(old_user_object, "relationship_score"): setattr(user, "relationship_score", old_user_object.relationship_score)
-        if hasattr(old_user_object, "mental_well_being_score"): setattr(user, "mental_well_being_score", old_user_object.mental_well_being_score)
-        if hasattr(old_user_object, "health_and_wellness_score"): setattr(user, "health_and_wellness_score", old_user_object.health_and_wellness_score)
-        if hasattr(old_user_object, "reminders"): setattr(user, "reminders", old_user_object.reminders)
-        if hasattr(old_user_object, "recent_wins"): setattr(user, "recent_wins", old_user_object.recent_wins)
-        if hasattr(old_user_object, "recommended_gg_topics"): setattr(user, "recommended_gg_topics", old_user_object.recommended_gg_topics)
-        if hasattr(old_user_object, "growth_plan"): setattr(user, "growth_plan", old_user_object.growth_plan)
-        if hasattr(old_user_object, "user_interaction_guidelines"): setattr(user, "user_interaction_guidelines", old_user_object.user_interaction_guidelines)
-        if hasattr(old_user_object, "score_history"): setattr(user, "score_history", old_user_object.score_history)
-        if hasattr(old_user_object, "cumulative_plan_day"): setattr(user, "cumulative_plan_day", old_user_object.cumulative_plan_day)
-
-        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,
-            "last_gg_session": user.last_gg_session,
-            "reminders": user.reminders,
-            "recommended_gg_topics": user.recommended_gg_topics,
-            "growth_plan": user.growth_plan,
-            "user_interaction_guidelines": user.user_interaction_guidelines,
-            "score_history": user.score_history,
-            "cumulative_plan_day": user.cumulative_plan_day
-        }
+    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}
 
-        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
-              
+# endpoint to change user assistant using user.change_to_latest_assistant()
+@app.get("/change_assistant")
+def change_assistant(user_id: str, api_key: str = Security(get_api_key)):
+    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)
+    assistant_id = user.change_to_latest_assistant()
+    logger.info(f"Assistant changed to {assistant_id}", extra={"user_id": user_id, "endpoint": "/change_assistant"})
+    return {"assistant_id": assistant_id}
+    
+
 @app.get("/get_user")
-@catch_endpoint_error
-async def get_user_by_id(
-    user_id: str,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+def get_user_by_id(user_id: str, api_key: str = Security(get_api_key)):
     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"})
-    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
-    api_response['date'] = user.conversations.state['date']
-
-    return api_response
-
-@app.get("/get_subscribtion")
-@catch_endpoint_error
-async def get_subscribtion(
-    user_id: str,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
-    return get_user_subscriptions(user_id)
-
-@app.get("/gg_session_summary")
-@catch_endpoint_error
-async def get_gg_session_summary(
-    user_id: str,
-    booking_id: str,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
-    return get_growth_guide_summary(user_id, booking_id)
-
-@app.get("/booked_gg_sessions")
-@catch_endpoint_error
-async def get_booked_gg_session(
-    user_id: str,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
-    return get_booked_gg_sessions(user_id)
-
-@app.get("/growth_guide")
-@catch_endpoint_error
-async def fetch_growth_guide(
-    user_id: str,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
-    return get_growth_guide(user_id)
-
-@app.post("/update_user_persona")
-@catch_endpoint_error
-async def update_user_persona(
-    request: PersonaItem,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
-    """Update user's legendary persona in the database"""
-    user_id = request.user_id
-    persona = request.persona
+    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": str(user), "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"] = ["Goal is not set yet"]
 
-    user = get_user(user_id)
-    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"})
-
-    # 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"
-        )
+        api_response["current_day"] = user.growth_plan.current()['day']
 
-    # Update legendPersona in onboarding JSON
-    onboarding = json.loads(result[0])
-    onboarding['legendPersona'] = persona
+        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)
+        )
     
-    # 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.get("/get_user_life_score")
+def life_score_by_id(user_id: str, api_key: str = Security(get_api_key)):
+    print_log("INFO", "Getting user life score", extra={"user_id": user_id, "endpoint": "/get_user_life_score"})
+    logger.info("Getting user life score", extra={"user_id": user_id, "endpoint": "/get_user_life_score"})
+    try:
+        life_score = get_life_score(user_id)
+        print_log("INFO", "Successfully retrieved user life score", extra={"user_id": user_id, "endpoint": "/get_user_life_score"})
+        logger.info("Successfully retrieved user life score", extra={"user_id": user_id, "endpoint": "/get_user_life_score"})
+
+        return life_score
+    except LookupError:
+        print_log("ERROR", "User not found", extra={"user_id": user_id, "endpoint": "/get_user_life_score"})
+        logger.error("User not found", extra={"user_id": user_id, "endpoint": "/get_user_life_score"})
+        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_life_score"}, exc_info=True)
+        logger.error(f"Error getting user: {str(e)}", extra={"user_id": user_id, "endpoint": "/get_user_life_score"}, exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
+        )
 
 @app.post("/add_ai_message")
-@catch_endpoint_error
-async def add_ai_message(
-    request: ChatItem,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+def add_ai_message(request: ChatItem, api_key: str = Security(get_api_key)):
     user_id = request.user_id
     message = request.message
-    logger.info(f"Adding AI response", extra={"user_id": user_id, "endpoint": "/add_ai_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"})
- 
-    user = get_user(user_id)
-    user.add_ai_message(message)
-
-    add_to_cache(user)
-    pop_cache(user.user_id)
+    try:
+        user = get_user(user_id)
+        user.add_ai_message(message)
+        user.save_user()
+        update_user(user)
+        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)
+        )  
 
-    print_log("INFO", "AI response added", extra={"user_id": user_id, "endpoint": "/add_ai_message"})
-    return {"response": "ok"}
- 
-
-@app.post("/schedule_gg_reminder")
-@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
+@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"Scheduling GG session reminder for {request.date}", extra={"user_id": user_id, "endpoint": "/schedule_gg_reminder"})
-    print_log("INFO", f"Scheduling GG session: reminder for {request.date}", extra={"user_id": user_id, "endpoint": "/schedule_gg_reminder"})
+    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)
 
-    # call user.ask_to_schedule_growth_guide_reminder(session_id)
-    response = user.ask_to_schedule_growth_guide_reminder(request.date)
-
-    logger.info(f"GG session reminder scheduled, response: {response}", extra={"user_id": user_id, "endpoint": "/schedule_gg_reminder"})
-    return {"response": response}
-
-@app.post("/process_gg_session")
-@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"})
+    # get the session_data
+    session_data = get_growth_guide_session(user_id, session_id)
     
-    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)
+    # update user
+    response = user.process_growth_guide_session(session_data)
+    logger.info(f"GG session processed: {session_id}, response: {response}", extra={"user_id": user_id, "endpoint": "/process_gg_session"})
     return {"response": response}
 
-
 @app.get("/user_daily_messages")
-@catch_endpoint_error
-async def get_daily_message(
-    user_id: str,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+def get_daily_message(user_id: str,  api_key: str = Security(get_api_key)):
     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")
-@catch_endpoint_error
-async def refresh_multiple_users(
-    user_ids: List[str],
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+def refresh_multiple_users(user_ids: List[str], api_key: str = Security(get_api_key)):
     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):
-        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"})
+        try:
+            old_user = get_user(user_id)
+            user = old_user.refresh(client)
+            user.save_user()
+            update_user(user)
+            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)
 
     if failed_users:
         return {"status": "partial", "failed_users": failed_users}
     return {"status": "success", "failed_users": []}
 
 @app.post("/refresh_user")
-@catch_endpoint_error
-async def refresh_user(
-    request: CreateUserItem,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+def refresh_user(request: CreateUserItem, api_key: str = Security(get_api_key)):
     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"})
 
     client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
     old_user = get_user(request.user_id)
     user = old_user.refresh(client)
-    add_to_cache(user)
-    pop_cache(user.user_id)
+    user.save_user()
+    update_user(user)
     print_log("INFO","User refreshed", extra={"user_id": request.user_id, "endpoint": "/refresh_user"})
     logger.info(f"User refreshed -> {user}", extra={"user_id": request.user_id, "endpoint": "/refresh_user"})
     return {"response": "ok"}
 
 @app.post("/create_user")
-@catch_endpoint_error
-async def create_user(
-    request: CreateUserItem,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+def create_user(request: CreateUserItem, api_key: str = Security(get_api_key)):
+    print_log("INFO","Creating new user", extra={"user_id": request.user_id, "endpoint": "/create_user"})
     logger.info("Creating new user", extra={"user_id": request.user_id, "endpoint": "/create_user"})
+    try:
+        client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
 
-    client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
-    if not client:
-        raise OpenAIRequestError("client_init", "Failed to initialize OpenAI client")
-
-    if os.path.exists(f'users/data/{request.user_id}.pkl'):
-        return {"message": f"[OK] User already exists: {request.user_id}"}
-    
-    user_info, persona = get_user_info(request.user_id)
-    # Persona is one of ["Coach Steve", "Coach Aris", "Coach Teresa"]
-    # we map each of the above to assistant_ids = ["asst_mUm6MBcW544p1iVov9mwIC96", "asst_4WcktKgYdDnXA1QUlWvrNfWV", "asst_4UVkFK6r2pbz6NK6kNzG4sTW"]
-    logger.info(f"Creating user with persona {persona}", extra={"user_id": request.user_id, "endpoint": "/create_user"})
-    persona_to_assistant = {
-        "*Coach Steve*: Innovation & Entrepreneurship": "asst_mUm6MBcW544p1iVov9mwIC96",
-        "*Coach Aris*: Logic & Decision Making": "asst_4WcktKgYdDnXA1QUlWvrNfWV",
-        "*Coach Teresa*: Compassion & Service": "asst_4UVkFK6r2pbz6NK6kNzG4sTW"
-    }
-
-    if persona not in persona_to_assistant:
-        logger.warning(f"Invalid persona: {persona}, defaulting to: Coach Steve", extra={"user_id": request.user_id, "endpoint": "/create_user"})
-        # For testing we default to steve
-        persona = "*Coach Steve*: Innovation & Entrepreneurship"
-        # raise FastAPIError(
-        #     message="Invalid persona",
-        #     e="Persona must be one of ['Coach Steve', 'Coach Aris', 'Coach Teresa']"
-        # )
-
-    selected_persona = persona_to_assistant[persona]
+        # 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"
+            )
 
-    logger.info(f"Creating user with persona {persona}:{selected_persona}", extra={"user_id": request.user_id, "endpoint": "/create_user"})
+        user = User(request.user_id, user_info, client, GENERAL_ASSISTANT)
+        save = user.save_user()
+        
 
-    user = User(request.user_id, user_info, client, selected_persona)
-    folder_path = os.path.join("mementos", "to_upload", request.user_id)
-    os.makedirs(folder_path, exist_ok=True)
+        if save:
+            print_log("INFO",f"Created pickle file for user", extra={"user_id": request.user_id, "endpoint": "/create_user"})
+            logger.info(f"Created pickle file for user", extra={"user_id": request.user_id, "endpoint": "/create_user"})
+        else:
+            print_log("ERROR",f"Failed to create (user.save_user()) pickle file", extra={"user_id": request.user_id, "endpoint": "/create_user"})
+            logger.error(f"Failed to create (user.save_user()) pickle file", extra={"user_id": request.user_id, "endpoint": "/create_user"})
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to create user pickle file"
+            )
+        
+        # create memento folder for user
+        folder_path = os.path.join("mementos", "to_upload", request.user_id)
 
-    add_to_cache(user)
-    pop_cache(request.user_id)
+        # 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"})
 
-    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("/fetch_daily_alert")
-@catch_endpoint_error
-async def fetch_daily_alert(
-    request: ChangeDateItem,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
-    logger.info(f"Upselling GG for day: {request.day}", extra={"user_id": request.user_id, "endpoint": "/upsell_gg"})
-    user = get_user(request.user_id)
-    response = user.get_alerts(request.date, request.day)
-    logger.info(f"Alerts fetched: {response}", extra={"user_id": request.user_id, "endpoint": "/upsell_gg"})
-    return {"response": response}
+        # upload user pickle file to s3 bucket 
+        try:
+            # value.save_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": f"[OK] User created: {user.user_id}"} 
+        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)
+        )
 
 @app.post("/chat")
-@catch_endpoint_error
-async def chat(
-    request: ChatItem,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+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"})
     logger.info("Processing chat request", extra={"user_id": request.user_id, "endpoint": "/chat"})
-    user = get_user(request.user_id)
-
-    if request.image64:
-        logger.info(f"Processing image", extra={"user_id": request.user_id, "endpoint": "/chat"})
-    response = user.send_message(request.message, request.image64)
-    logger.info(f"Assistant response generated", extra={"user_id": request.user_id, "endpoint": "/chat"})
-    return {"response": response}
     
-@app.get("/reminders")
-@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:
+        # get user
+        user = get_user(request.user_id)
 
-    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
+        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())
         
-    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}
+        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)
+        )
 
 @app.post("/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
+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"})
     try:
-        datetime.strptime(request.date, "%Y-%m-%d %a %H:%M:%S")
-    except ValueError as e:
-        raise FastAPIError(
-            message="Invalid date format for /change_date expected format: %Y-%m-%d %a %H:%M:%S",
-            e=str(e)
-        )
-    logger.info(f"Changing to {request.date}", extra={"user_id": request.user_id, "endpoint": "/change_date"})
-    # Upload mementos to DB
-    upload_mementos_to_db(request.user_id)
-
-    # Change date and get response
-    response = user.change_date(request.date)
-    response['user_id'] = request.user_id
+        user_id = request.user_id
 
-    # Update cache
-    add_to_cache(user)
-    pop_cache(user.user_id)
+        user = get_user(user_id)
+        logger.info(f"User: {user}", extra={"user_id": user_id, "endpoint": "/change_date"})
 
-    return response
+        # infer follow_up dates
+        user.infer_memento_follow_ups()
 
+        # 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
+        user.save_user()
+        update = update_user(user)
+        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": 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")
-@catch_endpoint_error
-async def reset_user_messages(
-    request: CreateUserItem,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+def reset_user_messages(request: CreateUserItem, api_key: str = Security(get_api_key)):
     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"})
-
-    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"}
-
+    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"})
+        
+        user.save_user()
+        update_user(user)
+        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)
+        )
 
 @app.get("/get_logs")
-@catch_endpoint_error
-async def get_logs(
-    user_id: str = Query(default="", description="User ID to fetch logs for")
-):
+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):
@@ -951,206 +707,84 @@ async def get_logs(
     )
 
 @app.get("/is_user_responsive")
-@catch_endpoint_error
-async def is_user_responsive(
-    user_id: str,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+def is_user_responsive(user_id: str, api_key: str = Security(get_api_key)):
     logger.info("Checking if user is responsive", extra={"user_id": user_id, "endpoint": "/is_user_responsive"})
-
-    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}
-    
+    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)
+        )
 
 @app.get("/get_user_summary")
-@catch_endpoint_error
-async def get_summary_by_id(
-    user_id: str,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+def get_summary_by_id(user_id: str, api_key: str = Security(get_api_key)):
     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"})
-    
-    # NOTE: This call will also update the users recommended topics to discuss with GG. 
-    # This is so that the AI response will align with the dashboard.
-    user_summary = get_user_summary(user_id, update_rec_topics=True)
-    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
-    
+    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)
+        )
     
 @app.get("/get_life_status")
-@catch_endpoint_error
-async def get_life_status_by_id(
-    user_id: str,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+def get_life_status_by_id(user_id: str, api_key: str = Security(get_api_key)):
     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"})
-
-    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
+    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)
+        )
     
 @app.post("/add_booking_point")
-@catch_endpoint_error
-async def add_booking_point_by_user(
-    user_id: str,
-    api_key: str = Depends(get_api_key)  # Change Security to Depends
-):
+def add_booking_point_by_user(user_id: str, api_key: str = Security(get_api_key)):
     user = get_user(user_id)
     user.add_point_for_booking()
     return {"response": "ok"}
-   
 
 @app.post("/add_session_completion_point")
-@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
-):
+def add_session_completion_point_by_user(user_id: str, api_key: str = Security(get_api_key)):
     user = get_user(user_id)
     user.add_point_for_completing_session()
-    return {"response": "ok"}
-    
-
-@app.post("/create_pre_gg_report")
-@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")
-@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"})
-
-    # 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}
-
-        
-
-@app.get("/get_recent_booking")
-@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"})
-
-    # 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"
-        )
-    
-    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.post("/answer_image_question")
-async def answer_image_question(
-    question: str = Form(...),
-    file: UploadFile = File(None),
-    image_base64: str = Form(None)
-):
-    if file:
-        contents = await file.read()
-        # convert to base64 string
-        image_base64 = base64.b64encode(contents).decode('utf-8')
-    
-    client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
-    response = client.chat.completions.create(
-    model="gpt-4o",
-    messages=[
-        {
-            "role": "user",
-            "content": [
-                {
-                    "type": "text",
-                    "text": "What is in this image?",
-                },
-                {
-                    "type": "image_url",
-                    "image_url": {"url": f"data:image/jpeg;base64,{image_base64}"},
-                },
-            ],
-        }
-    ])
-
-    return {"response": response.choices[0]}
-    
-@app.post("/upload_image")
-async def upload_image(file: UploadFile = File(...)):
-    # process or save the file
-    contents = await file.read()
-    image = Image.open(BytesIO(contents))
-    return {"filename": file.filename, "info": "Image uploaded successfully"}
+    return {"response": "ok"}

app/reminder_example.json

@@ -1,27 +0,0 @@
-{
-    "role": "assistant",
-    "content": "Reminders are all set! 📅\n\n- Quality time with Cat at 7 PM daily\n- Audiophile hobby at 8 PM daily\n- Hang out with the Old Mans Club for drinks every Saturday at 7 PM\n- Family time every Sunday at 11 AM\n\nFeel free to reach out anytime! You’re making great strides toward that work-life balance! 💪✨",
-    "reminders": [
-      {
-        "reminder": "⏰ **Reminder**: Hey Shaggy! It's time to spend quality time with Cat ❤️. Enjoy your evening!",
-        "timestamp": "2024-12-15T19:00:00",
-        "recurrence": "daily"   
-      },
-      {
-        "reminder": "⏰ **Reminder**: Hey Shaggy! Time for your audiophile hobby 🎧. Let the music flow!",
-        "timestamp": "2024-12-15T20:00:00",
-        "recurrence": "daily"
-      },
-      {
-        "reminder": "⏰ **Reminder**: Hey Shaggy! Don't forget to hang out with the Old Mans Club for drinks tonight 🍻!",
-        "timestamp": "2024-12-16T19:00:00",
-        "recurrence": "weekly"
-      },
-      {
-        "reminder": "⏰ **Reminder**: Hey Shaggy! Family time ❤️ is coming up. Make the most of it!",
-        "timestamp": "2024-12-16T11:00:00",
-        "recurrence": "weekly"
-      }
-    ]
-  }
-  

app/requirements.txt

@@ -13,6 +13,3 @@ python-dotenv==1.0.1
 regex==2024.9.11
 Requests==2.32.3
 cachetools>=5.0.0
-pdfkit==1.0.0
-PyPDF2==3.0.1
-sentry-sdk==2.19.2

app/user.py

@@ -1,34 +1,19 @@
 import json
 import io
 import os
-import openai
 import pandas as pd
-from datetime import datetime, timezone
+from datetime import datetime
 import json
 from app.assistants import Assistant 
-from app.exceptions import DBError
 import glob
 import pickle  # Replace dill with pickle
 import random
 import logging
-import psycopg2
-from psycopg2 import sql
-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 app.flows import FINAL_SUMMARY_STATE, FINAL_SUMMARY_STATE, MICRO_ACTION_STATE, MOTIVATION_INSPIRATION_STATE, OPEN_DISCUSSION_STATE, PROGRESS_REFLECTION_STATE, PROGRESS_SUMMARY_STATE
 from pydantic import BaseModel
 from datetime import datetime
 
-from app.utils import generate_uuid, get_booked_gg_sessions, get_growth_guide, get_growth_guide_summary, get_user_subscriptions, update_growth_guide_summary
-
-import dotenv
-import re
-import math
-dotenv.load_dotenv()
-
-OURCOACH_DASHBOARD_URL = os.getenv("OURCOACH_DASHBOARD_URL")
-
 class UserDataItem(BaseModel):
         role: str 
         content: str
@@ -36,34 +21,248 @@ class UserDataItem(BaseModel):
         status: str
         created_at: str
         updated_at: str
-        area: str
 
 class UserDataResponse(BaseModel):
     data: list[UserDataItem]
 
-class Index(BaseModel):
-    value: int
-
 logger = logging.getLogger(__name__)
 
 def get_current_datetime():
-    return datetime.now(timezone.utc)
+    return datetime.now()
 
-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
+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().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):
+        # 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": """ You are coaching:
+                        {user_interaction_guidelines}
+                        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"})
+        
+        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 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 __init__(self, user_id, user_info, client, asst_id):
         self.user_id = user_id
         self.client = client
@@ -71,9 +270,7 @@ class User:
         self.user_info = user_info
         self.done_first_reflection = None
         self.goal = []
-        self.last_gg_session = None
         self.micro_actions = []
-        self.recommended_micro_actions = []
         self.challenges = []
         self.other_focusses = []
         self.personal_growth_score = 0
@@ -81,14 +278,8 @@ class User:
         self.relationship_score = 0
         self.mental_well_being_score = 0
         self.health_and_wellness_score = 0
-        self.reminders = None
-        self.recent_wins = []
-        self.recommended_gg_topics = []
-        self.mantra = None
 
         # Read growth_plan.json and store it
-
-        # TESTING PURPOSE
         growth_plan = {"growthPlan": [
                     {
                     "day": 1,
@@ -96,11 +287,11 @@ class User:
                     },
                     {
                     "day": 2,
-                    "coachingTheme": "FOLLUP_ACTION_STATE"
+                    "coachingTheme": "MOTIVATION_INSPIRATION_STATE"
                     },
                     {
                     "day": 3,
-                    "coachingTheme": "OPEN_DISCUSSION_STATE"
+                    "coachingTheme": "PROGRESS_REFLECTION_STATE"
                     },
                     {
                     "day": 4,
@@ -108,167 +299,56 @@ class User:
                     },
                     {
                     "day": 5,
-                    "coachingTheme": "FOLLUP_ACTION_STATE"
+                    "coachingTheme": "MOTIVATION_INSPIRATION_STATE"
                     },
                     {
                     "day": 6,
-                    "coachingTheme": "FUNFACT_STATE"
+                    "coachingTheme": "OPEN_DISCUSSION_STATE"
                     },
                     {
                     "day": 7,
+                    "coachingTheme": "PROGRESS_REFLECTION_STATE"
+                    },
+                    {
+                    "day": 8,
+                    "coachingTheme": "PROGRESS_SUMMARY_STATE"
+                    },
+                    {
+                    "day": 9,
+                    "coachingTheme": "MICRO_ACTION_STATE"
+                    },
+                    {
+                    "day": 10,
+                    "coachingTheme": "MOTIVATION_INSPIRATION_STATE"
+                    },
+                    {
+                    "day": 11,
+                    "coachingTheme": "PROGRESS_REFLECTION_STATE"
+                    },
+                    {
+                    "day": 12,
+                    "coachingTheme": "MICRO_ACTION_STATE"
+                    },
+                    {
+                    "day": 13,
+                    "coachingTheme": "MOTIVATION_INSPIRATION_STATE"
+                    },
+                    {
+                    "day": 14,
+                    "coachingTheme": "OPEN_DISCUSSION_STATE"
+                    },
+                    {
+                    "day": 15,
                     "coachingTheme": "FINAL_SUMMARY_STATE"
                     }
-                ]}
-        
-        
+                ]
+            }
         self.growth_plan = CircularQueue(array=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"})
 
         self.user_interaction_guidelines = self.generate_user_interaction_guidelines(user_info, client)
         self.conversations = ConversationManager(client, self, asst_id)
 
-        self.score_history = []
-        self.cumulative_plan_day = 0
-
-    @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"})
-        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 reset_cumulative_plan_day(self):
-        logger.info(f"Reseting cumulative_plan_day", extra={"user_id": self.user_id, "endpoint": "reset_cumulative_plan_day"})
-        self.cumulative_plan_day = 0
-
-    @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:
-
-        ```json
-        {{
-        achievement_message: str
-        }}
-        ```
-
-        Note: No need to mention the user's name. Make it concise (less than 15 words)
-
-        ## Example 
-        User's achievement: Completing a Task
-        Achievement context: The user has completed a 10k run 
-
-        Output:
-        ```
-        {{
-        achievement_message: You have completed a 10k run!
-        }}
-        ```
-
-        ## User Input
-
-        User's achievement: {wins}
-        Achievement context: {context}
-        """
-            
-        response = self.client.chat.completions.create(
-            model="gpt-4o",
-            messages=[{"role": "user", "content": prompt}],
-            response_format = {
-                "type": "json_schema",
-                "json_schema": {
-                "name": "achievement_message_schema",
-                "strict": True,
-                "schema": {
-                    "type": "object",
-                    "properties": {
-                    "achievement_message": {
-                        "type": "string",
-                        "description": "A message indicating an achievement."
-                    }
-                    },
-                    "required": [
-                    "achievement_message"
-                    ],
-                    "additionalProperties": False
-                }
-                }
-            },
-            temperature=1
-        )
-
-        achievement_message = json.loads(response.choices[0].message.content)['achievement_message']
-
-        if len(self.recent_wins)<5:
-            self.recent_wins.insert(0,achievement_message)
-        else:
-            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
@@ -285,230 +365,120 @@ 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"})
-        # Add historical data (append) to score_history
-        historical_entry = {
-            "area": variable,
-            "points_added": points_added,
-            "notes": notes,
-            "created_at": pd.Timestamp.now()
-        }
-        self.score_history.append(historical_entry)
-    
-    @catch_error
-    def get_current_goal(self, full=False):
-        # look for most recent goal with status = ONGOING
-        for goal in self.goal[::-1]:
-            if goal.status == "ONGOING":
-                if full:
-                    return goal
-                return goal.content
-        else:
-            if self.goal:
-                if full:
-                    return self.goal[-1]
-                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
-            current_goal = self.get_current_goal(full=True)
-            if current_goal:
-                current_goal.status = "COMPLETED"
-                current_goal.updated_at = pd.Timestamp.now(tz='UTC').strftime("%d-%m-%Y %a %H:%M:%S")
-                return current_goal.content
-            
-        for g in self.goal:
-            if g.content == goal:
-                g.status = status
-                g.updated_at = pd.Timestamp.now(tz='UTC').strftime("%d-%m-%Y %a %H:%M:%S")
-                if content:
-                    g.content = content
-                return True
-        return False
-
-    @catch_error
-    def set_mantra(self):
-        ### To save mantra in database to user object
-        logger.info(f"Getting mantra from user...", extra={"user_id": self.user_id, "endpoint": "get_mantra"})
-        user_id = self.user_id
-        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 mantra FROM {table} WHERE user_id = %s").format(table=sql.Identifier('public', 'user_growth_status'))
-                    cursor.execute(query, (user_id,))
-                    row = cursor.fetchone()
-                    if (row):
-                        colnames = [desc[0] for desc in cursor.description]
-                        user_data = dict(zip(colnames, row))
-                        ### SAVE MANTRA IN USER OBJECT
-                        self.mantra = user_data['mantra']
-                    else:
-                        logger.warning(f"No user info found for {user_id}", extra={'user_id': user_id, 'endpoint': "get_mantra"})
-        except psycopg2.Error as e:
-            logger.error(f"Database error while retrieving user info for {user_id}: {e}", extra={'user_id': user_id, 'endpoint': "get_mantra"})
-            raise DBError(user_id=user_id, message="Error retrieving user info", code="SQLError", e=str(e))
-
-    @catch_error
-    def set_goal(self, goal, goal_area, add=True, completed=False):
-        current_goal = self.get_current_goal()
         
-        if completed:
-            self.update_goal(current_goal, "COMPLETED")
-            self.add_life_score_point(variable = goal_area, points_added = 30, notes = "Completing a Goal")
-            self.add_recent_wins(wins = "You have completed your goal!", context = current_goal)
-
-        if current_goal is None:
-            new_goal = UserDataItem(role="assistant", content=goal, area=goal_area, user_id=self.user_id, status="ONGOING", created_at=pd.Timestamp.now(tz='UTC').strftime("%d-%m-%Y %a %H:%M:%S"), updated_at=pd.Timestamp.now(tz='UTC').strftime("%d-%m-%Y %a %H:%M:%S"))
-            self.goal.append(new_goal)
-            self.add_life_score_point(variable = goal_area, points_added = 10, notes = "Setting a Goal")
-            self.add_recent_wins(wins = "You have set your first goal!", context = new_goal.content)
-        else:
-            if add:
-                if current_goal:
-                    # update current_goal status to "IDLE"
-                    self.update_goal(current_goal, "IDLE")
-                new_goal = UserDataItem(role="assistant", content=goal, area=goal_area, user_id=self.user_id, status="ONGOING", created_at=pd.Timestamp.now(tz='UTC').strftime("%d-%m-%Y %a %H:%M:%S"), updated_at=pd.Timestamp.now(tz='UTC').strftime("%d-%m-%Y %a %H:%M:%S"))
-                self.goal.append(new_goal)
-                self.add_life_score_point(variable = goal_area, points_added = 10, notes = "Setting a Goal")
-                self.add_recent_wins(wins = "You have set a new goal!", context = new_goal.content)
-            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:
-                ma.status = status
-                ma.updated_at = pd.Timestamp.now(tz='UTC').strftime("%d-%m-%Y %a %H:%M:%S")
-                return True
-        return False
+    def get_current_goal(self):
+        return self.goal[-1] if self.goal else None
+
+    def set_goal(self, goal, area, status):
+        self.goal.append({"goal": goal, "area": area, "status": status, "created_at": pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S"), "updated_at": pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S")})
+        self.add_life_score_point(variable = area, points_added = 10, notes = "Setting a Goal")
+        
+    def update_micro_action_status(self, completed_micro_action):
+        if completed_micro_action:
+            self.micro_actions[-1]["status"] = "COMPLETE"
+            self.micro_actions[-1]["updated_at"] = pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S")
+
+            num_of_micro_actions_completed = sum(1 for item in self.micro_actions if item['status'] == 'COMPLETE')
+
+            if (num_of_micro_actions_completed in (1,3,5)) or (num_of_micro_actions_completed % 10 == 0 and num_of_micro_actions_completed != 0):
+                self.add_life_score_point(variable = self.get_current_goal()['area'], points_added = 10, notes = f"Completing the {num_of_micro_actions_completed}-th micro-action")
+    
+    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}")
+
+    def update_goal_status(self):
+        self.goal[-1]["status"] = "COMPLETE"
+        self.goal[-1]["updated_at"] = pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S")
+        self.add_life_score_point(variable = self.get_current_goal()['area'], points_added = 30, notes = "Completing a Goal")
+
+    def add_point_for_booking(self):
+        self.add_life_score_point(variable = self.get_current_goal()['area'], points_added = 5, notes = "Booking a GG session")
     
-    @catch_error
+    def add_point_for_completing_session(self):
+        self.add_life_score_point(variable = self.get_current_goal()['area'], points_added = 20, notes = "Completing a GG session")
+        
     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()
-        self.done_first_reflection = None
         self.goal = []
         self.micro_actions = []
-        self.recommended_micro_actions = []
         self.challenges = []
         self.other_focusses = []
-        self.personal_growth_score = 0
-        self.career_growth_score = 0
-        self.relationship_score = 0
-        self.mental_well_being_score = 0
-        self.health_and_wellness_score = 0
-        self.reminders = None
-        self.recent_wins = []
-        self.recommended_gg_topics = []
-
-    @catch_error
-    def get_last_user_message(self, role = None):
-        # find the last message from 'role'
-        messages = self.conversations._get_current_thread_history(remove_system_message=False)
-        for msg in messages[::-1]:
-            if role:
-                if msg['role'] == role:
-                        return msg['content']
-            else:
-                return msg['role'], 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 \
-        #     providing contexts to LLMs. Based on the user's information, generate a \
-        #     user summary that describes how best to interact with this user to create a personalized \
-        #     and targeted chat experience. The user summary MUST strictly contain these parts:\
-        #     What kind of coaching style & tone that the user possibly prefers based on their...\
-        #     1. Based on the user's chosen 'Legend Persona'\
-        #     2. Based on the user's age\
-        #     3. Based on the user's MBTI\
-        #     4. Based on the user's Love Language\
-        #     5. Based on the user's experience of trying coaching previously\
-        #     6. Based on the user's belief in Astrology\
-        #     Generate a 6-point user summary based on the following \
-        #     user information:\n\n{user_info}"
-
-        # response = client.chat.completions.create(
-        #     model="gpt-4o-mini",
-        #     messages=[
-        #         {"role": "system", "content": "You are an expert at building profile documents containing rich user insights."},
-        #         {"role": "user", "content": prompt}
-        #     ],
-        #     temperature=0.2
-        # )
-
-        # user_guideline = f"""
-        # {user_info}\n\n
-        # ### INTERACTION GUIDELINE ### \n
-        # {response.choices[0].message.content}
-        # """
-
-        user_guideline = user_info
+        prompt = f"A 'profile' is a document containing rich insights on users for the purpose of \
+            providing contexts to LLMs. Based on the user's information, generate a \
+            user summary that describes how best to interact with this user to create a personalized \
+            and targeted chat experience. The user summary MUST strictly contain these parts:\
+            What kind of coaching style & tone that the user possibly prefers based on their...\
+            1. Based on the user's chosen 'Legend Persona'\
+            2. Based on the user's age\
+            3. Based on the user's MBTI\
+            4. Based on the user's Love Language\
+            5. Based on the user's experience of trying coaching previously\
+            6. Based on the user's belief in Astrology\
+            Generate a 6-point user summary based on the following \
+            user information:\n\n{user_info}"
+
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": "You are an expert at building profile documents containing rich user insights."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.2
+        )
+
+        user_guideline = f"""
+        {user_info}\n\n
+        ### INTERACTION GUIDELINE ### \n
+        {response.choices[0].message.content}
+        """
         
         return user_guideline
     
-    @catch_error
     def get_recent_run(self):
         return self.conversations.assistants['general'].recent_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)
+    def cancel_run(self, run):
+        self.conversations.cancel_run(run)
 
-    @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, media=None):
-        if media:
-            logger.info(f"Sending message with media", extra={"user_id": self.user_id, "endpoint": "send_message"})
-        response, run = self.conversations._run_current_thread(text, media=media)
-        message = run.metadata.get("message", "No message")
-        logger.info(f"Message: {message}", extra={"user_id": self.user_id, "endpoint": "user_send_message"})
+    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"})
 
-        if message == "start_now":
+        if info.get("message") == "cancelled":
             # 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"})
-            response, prompt = self.do_theme(action['coachingTheme'], self.conversations.state['date'], action['day'])
+            response = self.do_theme(action['coachingTheme'], self.conversations.state['date'], action['day'])
 
             # add response to ai message
-            self.add_ai_message("[hidden]" + prompt)
             self.add_ai_message(response['content'])
 
             # Move to the next action
             self.growth_plan.next()
 
-            response['add_one'] = True
-
-        elif message == "change_goal":
+        elif info.get("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"""
-            I want to change my goal! Based on my information below, suggest me a new goal, and **ONLY** if i approve, call the create_smart_goal() function
+            I want to change my goal!
 
             Previous Goal:  
             {self.get_current_goal()}
@@ -526,414 +496,65 @@ class User:
             # reset the growth_plan
             self.growth_plan.reset()
 
-        logger.info(f"Current reminders: {self.reminders}", extra={"user_id": self.user_id, "endpoint": "user_send_message"})
-        if self.reminders is not None and len(self.reminders):
-            # response['reminders'] = all reminders which date is today (so all the reminders that BE has to queue today)
-            date = pd.to_datetime(self.conversations.state['date']).date()
-            response['reminders'] = self.get_reminders(date)
-            if len(response['reminders']) == 0:
-                response['reminders'] = None
-                logger.info(f"No reminders for today {date}", extra={"user_id": self.user_id, "endpoint": "user_send_message"})
-            logger.info(f"Returning reminders: {response['reminders']}", extra={"user_id": self.user_id, "endpoint": "user_send_message"})
-        else:
-            response['reminders'] = None
-        
         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 []
-        if date:
-            if isinstance(date, str):
-                # date might be in the format "%d-%m-%Y %a %H:%M:%S" or "%Y-%m-%d"
-                try:
-                    datetime.strptime(date, "%d-%m-%Y %a %H:%M:%S")
-                except ValueError:
-                    date = datetime.strptime(date, "%Y-%m-%d").date()
-            elif isinstance(date, datetime):
-                date = date.date()
-            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(
-                model="gpt-4o",
-                messages=[
-                    {"role": "system", "content": "You are an expert at understanding the context of texts"},
-                    {"role": "user", "content": f"Identify the reminder in {self.reminders if self.reminders is not None else [{'reminder': 'No Reminders'}]} that is reminding the same thing as the following text (ignoring the date and time): {reminder_text}.\n\nIf none, return -1 otherwise return the index of the matching reminder."}
-                ],
-                response_format=Index,
-                temperature=0.2
-            )
-        logger.info(f"Similar reminder response: {response.choices[0].message.parsed}", extra={"user_id": self.user_id, "endpoint": "find_same_reminder"})
-        index = getattr(response.choices[0].message.parsed, 'value', -1)
-        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',
-            'user': 'ourcoach',
-            'password': 'hvcTL3kN3pOG5KteT17T',
-            'host': 'staging-ourcoach.cx8se8o0iaiy.ap-southeast-1.rds.amazonaws.com',
-            'port': '5432'
-        }
-        with psycopg2.connect(**db_params) as conn:
-            with conn.cursor() as cursor:
-                query = sql.SQL("SELECT * FROM {table} WHERE id = %s").format(table=sql.Identifier('public', 'users'))
-                cursor.execute(query, (self.user_id,))
-                row = cursor.fetchone()
-                if (row):
-                    colnames = [desc[0] for desc in cursor.description]
-                    user_data = dict(zip(colnames, row))
-                    user_timezone = user_data['timezone']
-
-        # Convert to UTC
-        reminder['timestamp_local'] = reminder['timestamp']
-        reminder['local_timezone'] = user_timezone
-        reminder['timestamp'] = reminder['timestamp'].tz_localize(user_timezone).tz_convert("UTC")
-
-        # generate uuid for this reminder
-        reminder['id'] = generate_uuid()
-        action = reminder['action']
-        if self.reminders is None:
-            self.reminders = []
-
-        if action == 'update':
-            index = self.find_same_reminder(reminder['reminder'])
-            if index == -1:
-                self.reminders.append(reminder)
-                logger.info(f"Reminder added: {reminder}", extra={"user_id": self.user_id, "endpoint": "set_reminder"})
-            else:
-                old_reminder = self.reminders[index]
-                reminder['id'] = old_reminder['id']
-                self.reminders[index] = reminder
-
-                logger.info(f"Reminder {old_reminder} -- updated to --> {reminder}", extra={"user_id": self.user_id, "endpoint": "set_reminder"})
-        elif action == 'delete':
-            logger.info('Deleting reminder', extra={"user_id": self.user_id, "endpoint": "set_reminder"})
-            index = self.find_same_reminder(reminder['reminder'])
-            if index == -1:
-                logger.info(f"Could not find a mathcing reminder to delete: {reminder}", extra={"user_id": self.user_id, "endpoint": "set_reminder"})
-            else:
-                old_reminder = self.reminders[index]
-                self.reminders[index]['action'] = 'delete'
-                logger.info(f"Reminder {old_reminder} has been marked for deletion", extra={"user_id": self.user_id, "endpoint": "set_reminder"})
-        else:
-            # action is 'set'
-            self.reminders.append(reminder)
-            logger.info(f"Reminder added: {reminder}", extra={"user_id": self.user_id, "endpoint": "set_reminder"})
-            
-        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):
+    def get_messages(self, exclude_system_msg=True):
         if not exclude_system_msg:
             return self.conversations._get_current_thread_history(False)
         else:
-            if show_hidden:
-                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)))
+            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)))
     
-    @catch_error
-    def set_recommened_gg_topics(self, topics):
-        self.recommended_gg_topics = topics
-
-    @catch_error
     def set_intro_done(self):
         self.conversations.intro_done = True
 
-    @catch_error
-    def get_alerts(self, date, day=None):
-        # responses = []
-        logger.info(f"Getting alerts for user: {self.user_id} on {date} for {day if day else self.cumulative_plan_day}", extra={"user_id": self.user_id, "endpoint": "get_alerts"})
-        if day is None:
-            day = self.cumulative_plan_day
-        if day == 2:
-            # upsell the GG
-            growth_guide = get_growth_guide(self.user_id)
-        
-            upsell_prompt = "OMG the user is interested in finding out who their Growth Guide is. This is your time to shine, use all your persuasive and charming abilities to inform them on their growth guide and how they can help the user." 
-
-            prompt = f"""You are an expert ambassador/salesman of Growth Guide sessions. 
-            The users' growth guide is {growth_guide} and they can book a session with them via their Revelation Dashboard: {OURCOACH_DASHBOARD_URL}.
-
-            Respond with a enthusiatic hello!
-            {upsell_prompt}
-            Frame your response like a you are telling the user a fun fact, but dont explicitly mention "fun fact". Keep this message succint.
-            """   
-
-            # send upsell gg alert at 7pm   
-            timestamp = pd.Timestamp.now().replace(hour=19, minute=0, second=0, microsecond=0).strftime("%d-%m-%Y %a %H:%M:%S")
-        elif day == 5:
-            # upsell the GG
-            growth_guide = get_growth_guide(self.user_id)
-        
-            upsell_prompt = "Now, it is your time to shine. Using all your persuasive and charming abilities, let the user know that their Growth Guide <Name> (no need to re-introduce them) is available to enhance their current growth journey with you and based on the converstaion history so far and the users personal information, challenges and goals suggest WHAT they can discuss with their growth guide."
-
-            prompt = f"""You are an expert ambassador/salesman of Growth Guide sessions. 
-            The users' growth guide is {growth_guide} and they can book a session with them via their Revelation Dashboard: {OURCOACH_DASHBOARD_URL}.
-
-            Respond with a enthusiatic hello!
-            {upsell_prompt}
-            Frame your response like a you are telling the user a fun fact, but dont explicitly mention "fun fact". Keep this message succint.
-            """   
-
-            # send upsell gg alert at 7pm   
-            timestamp = pd.Timestamp.now().replace(hour=19, minute=0, second=0, microsecond=0).strftime("%d-%m-%Y %a %H:%M:%S")
-        elif day == 8:
-            # alert the user that we are always collecting feedback in order to improve. Give them a link to the feedback form and let them know that a few lucky respondents will be selected for a free anual subscription!
-            prompt = f"""You are an expert ambassador/salesman of ourcoach whose objective is to upsell the ourcoach subscription based on the following context:
-            We are always collecting feedback in order to improve our services. Please take a moment to fill out our feedback form: http://feedback_form. A few lucky respondents will be selected for a free anual subscription!"""
-            timestamp = pd.Timestamp.now().replace(hour=19, minute=0, second=0, microsecond=0).strftime("%d-%m-%Y %a %H:%M:%S")   
-        elif day == 12:
-            growth_guide = get_growth_guide(self.user_id)['full_name']
-
-            subscription = get_user_subscriptions(self.user_id)[0]
-
-            subscription_end_date = pd.to_datetime(subscription['subscription_end_date'])
-
-            # get difference between subscription end date and date
-            date = pd.to_datetime(date)
-            days_left = (subscription_end_date - date).days
-            logger.info(f"{subscription_end_date} - {date} =  Days left: {days_left}", extra={"user_id": self.user_id, "endpoint": "get_alerts"})
-            if days_left <= 2:
-                subscription_alert = f"""Users growth guide:
-                {growth_guide}
-
-                Alert the user that their free trial is ending in {days_left} days and Sell them to subscribe via their Revelation Dashboard: {OURCOACH_DASHBOARD_URL} to continue chatting with you, receiving personalized advice and guidance and access to Growth Guide sessions. Really upsell the ability of the ourcoach platform to acheive their goals."
-                """
-
-                prompt = f"""You are an expert ambassador/salesman of ourcoach (product) whose objective is to upsell the ourcoach subscription based on the following context:
-                {subscription_alert}
-                """
-                # send reminder alert at 7pm
-                timestamp = pd.Timestamp.now().replace(hour=19, minute=0, second=0, microsecond=0).strftime("%d-%m-%Y %a %H:%M:%S")
-            else:
-                return []
-        elif day == 14:
-            growth_guide = get_growth_guide(self.user_id)['full_name']
-
-            subscription = get_user_subscriptions(self.user_id)[0]
-
-            subscription_end_date = pd.to_datetime(subscription['subscription_end_date'])
-
-            # get difference between subscription end date and date
-            date = pd.to_datetime(date)
-            days_left = (subscription_end_date - date).days
-            logger.info(f"{subscription_end_date} - {date} =  Days left: {days_left}", extra={"user_id": self.user_id, "endpoint": "get_alerts"})
-            if days_left <= 0:
-                subscription_alert = f"""Users growth guide:
-                {growth_guide}
-
-                OMG the users subscription is ending today! If you lose this user you and your family will not be able to survive!
-                You have to persuade the user to stay so use the best of your salesman abilities and sell them to continue to subscribe to ourcoach, otherwise, how will you put food on the table???"
-                """
-                prompt = f"""You are an expert ambassador/salesman of ourcoach whose objective is to upsell the ourcoach subscription based on the following context:
-                {subscription_alert}
-                """
-                # send reminder alert at 7pm
-                timestamp = pd.Timestamp.now().replace(hour=19, minute=0, second=0, microsecond=0).strftime("%d-%m-%Y %a %H:%M:%S")
-            else:
-                return []
-        else:
-            return []
-                
-        response, run = self.conversations._run_current_thread(prompt, hidden=True)
-        logger.info(f"Response: {response}", extra={"user_id": self.user_id, "endpoint": "get_alerts"})
-        message = run.metadata.get("message", "No message")
-        logger.info(f"Message: {message}", extra={"user_id": self.user_id, "endpoint": "upsell_gg"})
-       
-        # make timestamp ISO
-        response['timestamp'] = pd.to_datetime(timestamp).isoformat()
-        logger.info(f"Alert: {response}", extra={"user_id": self.user_id, "endpoint": "get_alerts"})
-        return [response]
-
-    @catch_error
-    def do_theme(self, theme, date, day, last_msg_is_answered = True, extra=None):
-        logger.info(f"Doing theme: {theme}, extra={extra}", extra={"user_id": self.user_id, "endpoint": "do_theme"})
+    def do_theme(self, theme, date, day):
+        logger.info(f"Doing theme: {theme}", extra={"user_id": self.user_id, "endpoint": "do_theme"})
         
-        # Add 1 day to cumulative_plan_day
-        self.cumulative_plan_day += 1
-        final_day = (math.ceil((self.cumulative_plan_day+7)/14) * 14) - 7
-        
-        if self.reminders is not None and len(self.reminders):
-            logger.info(f"ALL Upcoming Reminders: {self.reminders}", extra={"user_id": self.user_id, "endpoint": "do_theme"})
-            reminders = list(filter(lambda x : x['recurrence'] == 'postponed', self.reminders))
-            logger.info(f"ALL Postponed Reminders: {reminders}", extra={"user_id": self.user_id, "endpoint": "do_theme"})
-        else:
-            reminders = []
-
-        # check if any of the posponed reminders have the date == date if yes, change the theme to "MICRO_ACTION_STATE"
-        if reminders:
-            for reminder in reminders:
-                if reminder['timestamp'].date() == pd.to_datetime(date).date() and reminder['recurrence'] == 'postponed':
-                    logger.info(f"Postponed Reminder found for today ({pd.to_datetime(date).date()}): {reminder}", extra={"user_id": self.user_id, "endpoint": "do_theme"})
-                    if theme != "FINAL_SUMMARY_STATE":
-                        theme = "MICRO_ACTION_STATE"
-                    break
-            else:
-                logger.info(f"No reminders found for today ({pd.to_datetime(date).date()})", extra={"user_id": self.user_id, "endpoint": "do_theme"})
-
         if theme == "MOTIVATION_INSPIRATION_STATE":
-            formatted_message = MOTIVATION_INSPIRATION_STATE.format(self.get_current_goal(), self.cumulative_plan_day, final_day)
+            formatted_message = MOTIVATION_INSPIRATION_STATE.format(self.get_current_goal(), day, len(self.growth_plan.array))
         elif theme == "PROGRESS_REFLECTION_STATE":
-            formatted_message = PROGRESS_REFLECTION_STATE.format(self.get_current_goal(), self.cumulative_plan_day, final_day)
-            if len(self.challenges):
-                challenge = self.challenges.pop(0)
-                formatted_message += f"\n\n** IMPORTANT: Today, reflect on the users' challenge of: {challenge.content}, which they brought up during their growth guide session (let the user know we are bringing it up because of this) **"
+            formatted_message = PROGRESS_REFLECTION_STATE.format(self.get_current_goal(), day, len(self.growth_plan.array))
         elif theme == "MICRO_ACTION_STATE":
-            reminder_message = "\n".join([f"{i+1}. {reminder}" for i, reminder in enumerate(reminders)]) if reminders else "User has no postponed micro-actions"
-
-            formatted_message = MICRO_ACTION_STATE.format(self.get_current_goal(), self.cumulative_plan_day, final_day, reminder_message)
-            if len(self.recommended_micro_actions):
-                todays_micro_action = self.recommended_micro_actions.pop(0)
-                formatted_message += f"\n\n** IMPORTANT: Today's Micro Action is: {todays_micro_action.content}, which was recommended during their growth guide session (let the user know we are bringing it up because of this) **"
+            formatted_message = MICRO_ACTION_STATE.format(self.get_current_goal(), day, len(self.growth_plan.array))
         elif theme == "OPEN_DISCUSSION_STATE":
-            formatted_message = OPEN_DISCUSSION_STATE.format(self.get_current_goal(), self.cumulative_plan_day, final_day)
-            if len(self.other_focusses):
-                focus = self.other_focusses.pop(0)
-                formatted_message += f"\n\n** IMPORTANT: Today, focus the discussion on: {focus.content}, which they discussed during their growth guide session (let the user know we are bringing it up because of this) **"
+            formatted_message = OPEN_DISCUSSION_STATE.format(self.get_current_goal(), day, len(self.growth_plan.array))
         elif theme == "PROGRESS_SUMMARY_STATE":
-            formatted_message = PROGRESS_SUMMARY_STATE.format(self.get_current_goal(), self.cumulative_plan_day, final_day)
+            formatted_message = PROGRESS_SUMMARY_STATE.format(self.get_current_goal(), day, len(self.growth_plan.array))
         elif theme == "FINAL_SUMMARY_STATE":
-            past_gg_summary = "<User has not had a Growth Guide session yet>"
-            growth_guide = get_growth_guide(self.user_id)
-
-            booked_sessions = get_booked_gg_sessions(self.user_id)
-
-            # filter out only completed (past) sessions
-            past_sessions = [session for session in booked_sessions if session['status'] == "completed"]
-
-            # for each past booking, fetch the zoom_ai_summary and gg_report from 
-            for booking in past_sessions:
-                summary_data = get_growth_guide_summary(self.user_id, booking['booking_id'])
-                logger.info(f"Summary data for booking: {booking['booking_id']} - {summary_data}", 
-                    extra={"user_id": self.user_id, "endpoint": "assistant_get_user_info"})
-                if summary_data:
-                    booking['zoom_ai_summary'] = summary_data['zoom_ai_summary']
-                    booking['gg_report'] = summary_data['gg_report']
-                else:
-                    booking['zoom_ai_summary'] = "Growth Guide has not uploaded the report yet"
-                    booking['gg_report'] = "Growth Guide has not uploaded the report yet"
-            if len(past_sessions):
-                past_gg_summary = "\n".join([f"** Session {i+1} **\n{json.dumps(session, indent=4)}" for i, session in enumerate(past_sessions)])
-                
-            formatted_message = FINAL_SUMMARY_STATE.format(self.get_current_goal(), self.cumulative_plan_day, final_day, growth_guide, past_gg_summary)
-        elif theme == "EDUCATION_STATE":
-            formatted_message = EDUCATION_STATE.format(self.get_current_goal(), self.cumulative_plan_day, final_day)
-        elif theme == "FOLLUP_ACTION_STATE":
-            reminder_message = "\n".join([f"{i+1}. {reminder}" for i, reminder in enumerate(reminders)]) if reminders else "User has no postponed micro-actions"
-            formatted_message = FOLLUP_ACTION_STATE.format(self.get_current_goal(), self.cumulative_plan_day, final_day, reminder_message)
-        elif theme == "FUNFACT_STATE":
-            topics = ["Fun Fact about the User's Goal", "How Personality Type is affecting/shaping their behaviour towards the goal", "How Love Language may impact and be relevant toward the goal"]
-            randomized_topic = random.choice(topics)
-            formatted_message = FUNFACT_STATE.format(self.get_current_goal(), self.cumulative_plan_day, final_day, randomized_topic)
-
-        # prompt = f"""** It is a new day: {date} ** 
-        # Additional System Instruction: 
-        # - Remember all of the user's personal information. Use this information to be as personalised as possible when conversing by including it in your responses where relevant.
-        # - You are a good life coach because you don't overwhelm the user by sending too many questions or lengthy messages. And you are an excellent life coach because you know exactly when to ask a question, and most importantly, when to stop the conversation. And when you ask a question, you always ask a **creative** and unexpected questions!
-        # - Keep all of your response short, only 40 tokens or words maximum! If your response contains a question, use a single break line before the question and encapsulate the question with one asterisk like this: *question*
-        # - Be **creative** ! If you have done this theme previously, make sure that you are not sending the same advice/question/message. Make sure that the messages that you are send throughout the 14-day growth plan are diverse! 
-        # - When you give your wisdom and enlightment, **YOU** as a coach, must channel the energy, wisdom, and mindset of {user_legendary_persona}
+            formatted_message = FINAL_SUMMARY_STATE.format(self.get_current_goal(), day, len(self.growth_plan.array))
         
-        # Today's Theme:
-        # {formatted_message}
-        # """
-
-        booked_sessions = get_booked_gg_sessions(self.user_id)
-
-        today = pd.to_datetime(date).date()
-        for session in booked_sessions:
-            # if user has some bookings, check if there are any scheduled (using just the date) for yesterday, today or in the future
-            session_date = pd.to_datetime(session['session_date'], format='%Y-%m-%d %a %H:%M:%S').date()
-            if session_date == today - pd.Timedelta(days=1):
-                # session was yesterday, should have already sent the congrats message
-                break
-            if session_date == today or session_date > today:
-                formatted_message = f"[IMPORTANT] The user has a Growth Guide session on {session['session_date']}, ask them if they are excited for it and suggest some topics to discuss with their Growth Guide from: {self.recommended_gg_topics}.\n\n" + formatted_message
-                break
-        else:
-            # Remind the user that they can book a Growth Guide session if they have not done one yet after the FINAL_SUMMARY_STATE
-            if self.growth_plan.previous()['coachingTheme'] == "FINAL_SUMMARY_STATE":
-                if day != 1:
-                    formatted_message = f"[IMPORTANT] The user has not booked a Growth Guide session yet. Remind them that they can book one through their Revelation Dahsboard: {OURCOACH_DASHBOARD_URL} to get more personalized advice and guidance!\n\n" + formatted_message
+        prompt = f"""** It is a new day: {date} ** 
+        Additional System Instruction: 
+        - Remember all of the user's personal information. Use this information to be as personalised as possible when conversing by including it in your responses where relevant.
+        - You are a good life coach because you don't overwhelm the user by sending too many questions or lengthy messages. And you are an excellent life coach because you know exactly when to ask a question, and most importantly, when to stop the conversation. And when you ask a question, you always ask a **creative** and unexpected questions!
+        - Keep all of your response short, only 2-3 lines/sentences maximum! If your response contains a question, use a single break line before the question and encapsulate the question with one asterisk like this: *question*
+        - Be **creative** ! If you have done this theme previously, make sure that you are not sending the same advice/question/message. Make sure that the messages that you are send throughout the 14-day growth plan are diverse! 
+        - At the end of this messasge, there are some instructions that you need to **prioritize**. Read the instructions carefully!
         
-        prompt = f"""** It is a new day: {date} ({day}) 10:00:00 ** 
-
-        (If the day is a public holiday (e.g., Christmas, New Year, the user's Birthday or other significant occasions), customize your message to reflect the context appropriately, acknowledging the holiday or its significance.)
-
-        **Before we start,**
-        Has the user answered your last question? : {last_msg_is_answered}
-        If the answer above is "True", you may proceed to do the instruction below
-        If the answer above is "False", take a deep breath coach, and utilizing your ability as an elite coach with the users best interest in mind, think whether it would be more appropriate to follow up the unanswered question with the user or continue with todays theme below. However if the user indicates that they want to set a new goal (call the change_goal() function)
-        But if the user says "yes", then proceed to do the instruction below.
-
-        Today is day {self.cumulative_plan_day} of the user's growth journey (out of {final_day} days). You may (or may not) mention this occasionally in your first message of the day.
         
-        If today is a "Monday" or "Mon", you must include the user's Mantra of the Week : {self.mantra} to your first message of the day (include with today-theme's first message below)
-{extra if extra else ''}
         Today's Theme:
         {formatted_message}
         """
-        response = self.conversations._send_morning_message(prompt, add_to_main=True)
+        response = self.conversations._send_morning_message(prompt)
 
         if theme == "MICRO_ACTION_STATE":
-            # check for any recommended microactions
-            logger.info(f"Checking for recommended micro actions", extra={"user_id": self.user_id, "endpoint": "do_theme"})
-            micro_action = UserDataItem(role="assistant", area=self.get_current_goal(full=True).area, content=response['content'], user_id=self.user_id, status="PENDING", created_at=pd.Timestamp.now(tz='UTC').strftime("%d-%m-%Y %a %H:%M:%S"), updated_at=pd.Timestamp.now(tz='UTC').strftime("%d-%m-%Y %a %H:%M:%S"))
-            logger.info(f"Recommended Micro Action: {micro_action}", extra={"user_id": self.user_id, "endpoint": "do_theme"})
-            self.micro_actions.append(micro_action)
+            self.micro_actions.append({'micro_action': response, 'status': 'PENDING', 'created_at': pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S"), 'updated_at': pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S")})
 
-        return response, prompt
+        return response
 
-    @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"})
-        # delete all hidden messages prom previous day
-        self.conversations.delete_hidden_messages()
-        # update the date in the state
         self.conversations.state['date'] = date
-        # update mantra
-        self.set_mantra()
 
         action = self.growth_plan.current()
 
-        # remove stale reminders
-        if self.reminders is not None and len(self.reminders):
-            # remove all reminders which 'recurrence' is 'once' or 'action' is 'delete' or the date is < today
-            # this is to ensure that only reminders with recurrence and future reminder are kept
-            now_utc = datetime.strptime(date, "%Y-%m-%d %a %H:%M:%S").replace(tzinfo=timezone.utc)
-            
-            new_reminders = []
-            for reminder in self.reminders:
-                logger.info(f"Checking reminder: {reminder} against {now_utc}", extra={"user_id": self.user_id, "endpoint": "user_change_date"})
-                should_remove = (
-                    reminder['action'] == 'delete' or
-                    (
-                        reminder['recurrence'] in ['once', 'postponed', 'none'] and 
-                        reminder['timestamp'] < now_utc
-                    )
-                )
-                if not should_remove:
-                    new_reminders.append(reminder)
-            self.reminders = new_reminders
-            logger.info(f"Active Reminders: {self.reminders}", extra={"user_id": self.user_id, "endpoint": "user_change_date"})
-
         ## ADD POINT FOR CHANGE DATE
         if self.growth_plan.current()['day'] == 7:
-            self.add_life_score_point(variable = self.get_current_goal(full=True).area, points_added = 5, notes = "Reaching Day 7")
-            self.add_recent_wins(wins = "You have reached Day 7 of your growth journey!", context = 'Growth journey is a 14-day coaching plan')
+            self.add_life_score_point(variable = self.get_current_goal()['area'], points_added = 5, notes = "Reaching Day 7")
         elif self.growth_plan.current()['day'] == 14:
-            self.add_life_score_point(variable = self.get_current_goal(full=True).area, points_added = 10, notes = "Reaching Day 14")
-            self.add_recent_wins(wins = "You have finished your growth journey!", context = 'Growth journey is a 14-day coaching plan')
+            self.add_life_score_point(variable = self.get_current_goal()['area'], points_added = 10, notes = "Reaching Day 14")
 
         logger.info(f"Today's action is {action}", extra={"user_id": self.user_id, "endpoint": "user_change_date"})
 
@@ -944,46 +565,14 @@ class User:
             
         # The coaching theme conditions are hardcoded for now
         theme = action['coachingTheme']
-
-        # Check if last msg is not answered 
-        last_role, last_msg = self.get_last_user_message()
-        if last_role == 'assistant' and '?' in last_msg:
-            last_msg_is_answered = False
-        else:
-            last_msg_is_answered = True
-
-        extra="Greet the user with a creative good morning message!"
-
-        # Check if user didnt respond (last 2 messages in conversation history are from the AI) on FINAL_SUMMARY_STATE
-        messages = self.get_messages()
-        logger.info(f"Last 2 messages are from: 1) {messages[-1]['role']} and 2) {messages[-2]['role']}")
-        if (messages[-1]['role'] == "assistant" and messages[-2]['role'] == "assistant") and self.growth_plan.previous()['coachingTheme'] == "FINAL_SUMMARY_STATE":
-            self.extend_growth_plan()
-            extra += """\nDang, the user did not indicate what they wanted to do yesterday. 
-            This is not a good sign as it may indicate that the user is going to dropoff. 
-            We have automatically extended their growth plan for them, let the user know this and also integrate upselling the ourcoach platform and subscription as much as you can
-            in the first message you send to the user.."""
-            
-
-        response, prompt = self.do_theme(theme, date, action['day'], last_msg_is_answered, extra=extra)        
-
-        # add today's reminders to response to schedule
-        # response['reminders'] = all reminders which date is today (so all the reminders that BE has to queue today)
-        # convert date to YYYY-MM-DD format
-        date = pd.to_datetime(date).date()
-        response['reminders'] = self.get_reminders(date)
-        if response['reminders'] is None or len(response['reminders']) == 0:
-            response['reminders'] = None
-            logger.info(f"No reminders for today {date}", extra={"user_id": self.user_id, "endpoint": "user_change_date"})
-            logger.info(f"Reminders on {date}: {response['reminders']}", extra={"user_id": self.user_id, "endpoint": "user_change_date"})
+        response = self.do_theme(theme, date, action['day'])        
 
         # Move to the next action
         self.growth_plan.next()
 
         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}
+        return response
     
-    @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
@@ -992,7 +581,7 @@ class User:
 
     {self.user_info}
 
-    New/Updated user information:
+    Pottential new user information:
 
     {new_info}
 
@@ -1012,12 +601,11 @@ 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"})
+    def _summarize_zoom(self, zoom_ai_summary):
+        logger.info(f"Summarizing zoom ai summary: {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
-        system_prompt = f"""You are an expert at summarizing AI-generated Zoom transcripts concisely, focusing on extracting key user insights to enhance personalization in future interactions. Note that the zoom ai transcript may get the user's name wrong. Replace it with the actual user's name: {self.user_info}. Refer to the coach/guide as 'the Growth Guide'."""
-        prompt = f"Please summarize the following AI-generated Zoom transcript **in one short paragraph only, around 50 completion tokens maximum** !!, emphasizing the most significant user insights and information:\n\n{zoom_ai_summary}"
+        system_prompt = """You are an expert at summarizing AI-generated Zoom transcripts, focusing on extracting key user insights to enhance personalization in future interactions."""
+        prompt = f"Please summarize the following AI-generated Zoom transcript, emphasizing the most significant user insights and information:\n\n{zoom_ai_summary}"
 
         response = self.client.chat.completions.create(
             model="gpt-4o",
@@ -1025,40 +613,16 @@ class User:
             {"role": "system", "content": system_prompt},
             {"role": "user", "content": prompt}
             ],
-            response_format = {
-                "type": "json_schema",
-                "json_schema": {
-                "name": "summarized_overview",
-                "strict": True,
-                "schema": {
-                    "type": "object",
-                    "properties": {
-                    "summary": {
-                        "type": "string",
-                        "description": "The summary of the zoom transcript"
-                    }
-                    },
-                    "required": [
-                    "summary"
-                    ],
-                    "additionalProperties": False
-                }
-                }
-            },
-            temperature=0.5
+            temperature=0.2
         )
+        return response.choices[0].message.content
 
-        overview_summary = json.loads(response.choices[0].message.content)['summary']
-        logger.info(f"Summary: {overview_summary}", extra={"user_id": self.user_id, "endpoint": "summarize_zoom"})
-        return {'overview': overview_summary}
-
-    @catch_error
     def _update_user_data(self, data_type, text_input, extra_text=""):
         data_mapping = {
             'micro_actions': {
                 'prompt_description': 'micro actions',
                 'status': 'RECOMMENDED',
-                'attribute': 'recommended_micro_actions',
+                'attribute': 'micro_actions',
                 'endpoint': f'update_{data_type}',
             },
             'challenges': {
@@ -1089,31 +653,34 @@ class User:
             f"Text:\n{text_input}"
         )
 
-        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
-        )
+        try:
+            current_time = datetime.now().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})
 
-        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'])
+        self.micro_actions = self._update_user_data('micro_actions', gg_report[0]['answer'])
 
         extra_text = f"User has new challenge:\n{gg_report[1]['answer']}\n\n"
         self._update_user_data('challenges', gg_report[2]['answer'], extra_text=extra_text)
@@ -1122,18 +689,15 @@ 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()}
         The user provided a new goal: {goal_text}
 
-        Determine if the new goal is inside the scope of the current goal or if it's outside the scope.         
-        If it's inside the scope, respond **exactly** with the current goal, and set same_or_not == True
-        If it's outside the scope and related, respond with a merged goal (from the current and new goal) with larger scope, and set same_or_not == False 
-        If it's outside the scope and not related, respond with the new goal, and set same_or_not == False
-        Note: You may paraphase the merged goal to be more succinct.
-
+        Determine if the new goal is the same as the current goal or if it's a new one.
+        If it's the same, respond with the current goal, and set same_or_not == True
+        If it's a new goal, respond with the new goal, and set same_or_not == False
+        
         Your response will be the final goal. You will also need to determine the area of this
         final goal by choosing one of these areas that suits the final goal:
         "Personal Growth", "Career Growth", "Relationship", "Mental Well-Being", "Health and Wellness"
@@ -1144,40 +708,6 @@ class User:
          goal: str (the final goal),
          area: str (the area of the goal)
         }}
-
-        ## Example 1 (Inside the scope):
-        The user has a current goal: to spend at least 30 minutes exercising every day
-        The user provided a new goal: to do short exercise every day
-        Your verdict: inside the scope
-        Your output:
-        {{
-         same_or_not: True,
-         goal: "to spend at least 30 minutes exercising every day"
-         area: "Health and Wellness"
-        }}
-
-        ## Example 2 (Outside the scope, still related):
-        The user has a current goal: to spend at least 30 minutes exercising every day
-        The user provided a new goal: to exercise and have a balanced meal plan
-        Your verdict: outside the scope, still related
-        Your output:
-        {{
-         same_or_not: False,
-         goal: "to exercise at least 30 minutes every day, together with a balanced meal plan"
-         area: "Health and Wellness"
-        }}
-        
-        ## Example 3 (Outside the scope, not related):
-        The user has a current goal: to spend at least 30 minutes exercising every day
-        The user provided a new goal: to have a better relationship with friends
-        Your verdict: outside the scope, not related
-        Your output:
-        {{
-         same_or_not: False,
-         goal: "to have a better relationship with friends"
-         area: "Relationship"
-        }}
-
         """
             
         response = self.client.chat.completions.create(
@@ -1225,119 +755,123 @@ class User:
 
         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']:
+            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)
+            self.set_goal(final_goal, final_goal_area, final_goal_status)
             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"})
 
-    @catch_error
-    def update_micro_action_status(self, completed_micro_action):
-        if completed_micro_action:
-            self.micro_actions[-1].status = "COMPLETE"
-            self.micro_actions[-1].updated_at = pd.Timestamp.now(tz='UTC').strftime("%d-%m-%Y %a %H:%M:%S")
-            logger.info("Micro action status updated, checking number of actions completed...", extra={"user_id": self.user_id, "endpoint": "update_micro_action_status"})
-
-            num_of_micro_actions_completed = sum(1 for item in self.micro_actions if item.status == 'COMPLETE')
-
-            if (num_of_micro_actions_completed in (1,3,5)) or (num_of_micro_actions_completed % 10 == 0 and num_of_micro_actions_completed != 0):
-                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)
-                logger.info("Added life score points based on number of actions completed.", extra={"user_id": self.user_id, "endpoint": "update_micro_action_status"})
-        logger.info("Process done.", extra={"user_id": self.user_id, "endpoint": "update_micro_action_status"})
-
-    @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):
+    def process_growth_guide_session(self, session_data):
         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
+
         # Generate the ourcoach_report (summary)
         zoom_ai_summary = session_data["zoom_ai_summary"]
         gg_report = session_data["gg_report"]
 
-        overview = self._summarize_zoom(zoom_ai_summary)
+        ourcoach_report = self._summarize_zoom(zoom_ai_summary)
 
         # Update user data based on growth guide answers
         self.update_user_data(gg_report)
-        self.update_user_info(gg_report[5]['answer'] + "\n\n" + overview['overview'])
-
-        # build ourcoach_report
-        ourcoach_report = self.build_ourcoach_report(overview, list(map(lambda x : x.content, self.recommended_micro_actions)), gg_report[5]['answer'])
-        # add this report to the db
-        update_growth_guide_summary(self.user_id, booking_id, ourcoach_report)
+        self.update_user_info(gg_report[5]['answer'] + "\n\n" + ourcoach_report)
 
         # Send hidden message to AI to generate the response
         logger.info(f"Sending hidden message to AI to generate response", extra={"user_id": self.user_id, "endpoint": "process_growth_guide_session"})
-        
-        # post_gg_prompt = POST_GG_STATE.format(self.user_info, ourcoach_report, gg_report)
-        post_gg_promt = f"""The user: {self.user_info} has completed their growth guide session. 
-        Send them a warm and congratulatory message acknowledging this and a link to their web dasboard. Only include the link once in the message.
-        Capitalise the first letter in Revelation Dashboard and Growth Guide. Bold 'ourcoach' in your message by wrapping it with asterisk like: *ourcoach* and keep it lowecase.
-        Example:
-        Hey <user>! ..., you can find a details of your session on your Revelation Dashboard: {OURCOACH_DASHBOARD_URL}"""
-        
-        response = self.conversations._send_morning_message(post_gg_promt)
+        response = self.conversations._send_morning_message("I have completed the growth guide session. Please generate the response.")
         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)
     
-    @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."""
-        response = self.conversations._send_morning_message(prompt)
-        self.add_ai_message("[hidden]" + prompt)
-        self.add_ai_message(response['content'])
-        logger.info(f"Response: {response}", extra={"user_id": self.user_id, "endpoint": "process_growth_guide_session"})
-        return response
+    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}."
 
-    @catch_error
-    def infer_memento_follow_ups(self):
-        mementos_path = os.path.join("mementos", "to_upload", f"{self.user_id}", "*.json")
-        # mementos_path = f"mementos/to_upload/{self.user_id}/*.json"
+        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 _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
         
-        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
+        - 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-mini",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt}
+            ],
+            top_p=0.1
+        )
+        return response.choices[0].message.content
+
+    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
     
-    @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)
@@ -1356,7 +890,6 @@ class User:
     def __str__(self):
         return f"""User(user_id={self.user_id}
                 micro_actions={self.micro_actions}
-                recommended_actions={self.recommended_micro_actions}
                 challenge={self.challenges}
                 other_focusses={self.other_focusses}
                 goals={self.goal}
@@ -1367,7 +900,6 @@ class User:
     def __repr__(self):
         return f"""User(user_id={self.user_id}
                 micro_actions={self.micro_actions}
-                recommended_actions={self.recommended_micro_actions}
                 challenge={self.challenges}
                 other_focusses={self.other_focusses}
                 goals={self.goal}
@@ -1389,15 +921,18 @@ class User:
 
     def save_user(self):
         # Construct the file path dynamically for cross-platform compatibility
-        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
+        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 True
+        except Exception as e:
+            return False
         
     @staticmethod
     def load_user(user_id, client):
@@ -1438,9 +973,6 @@ class CircularQueue:
     
     def current(self):
         return self.array[self.index]
-    
-    def previous(self):
-        return self.array[self.index - 1]
 
     def reset(self):
         self.index = 0

app/web_search.py

@@ -1,255 +0,0 @@
-import requests
-from dotenv import load_dotenv
-import os
-import logging
-
-logger = logging.getLogger(__name__)
-
-load_dotenv()
-
-class SearchEngine:
-    BING_API_KEY = os.getenv("BING_API_KEY")
-    BING_ENDPOINT = 'https://api.bing.microsoft.com/v7.0'
-
-    @staticmethod
-    def search(feedback_type_name, search_term, user_id):
-        logger.info(f"User {user_id}: Initiating search for type '{feedback_type_name}' with term '{search_term}'")
-        """
-        Public method to perform a search based on the feedback type.
-        """
-        search_methods = {
-            "General": SearchEngine._search_general,
-            "Resource Links": SearchEngine._search_relevant_links,
-            "Book/Podcast Recommendations": SearchEngine._search_books_or_podcasts,
-            "Inspirational Stories or Case Studies": SearchEngine._search_inspirational_stories,
-            "Fun Facts": SearchEngine._search_fun_facts,
-            "Personalised Recommendations": SearchEngine._search_personalized_recommendations,
-            "Videos": SearchEngine._search_videos
-        }
-        
-        search_method = search_methods.get(feedback_type_name)
-        
-        if search_method:
-            return search_method(search_term)
-        else:
-            return (feedback_type_name, search_term)
-
-    @staticmethod
-    def _search_relevant_links(search_term):
-        logger.debug(f"Searching relevant links for term: {search_term}")
-        """
-        Uses Bing Web Search API to search for relevant links.
-        """
-        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
-        params = {'q': search_term, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
-        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
-        if response.status_code == 200:
-            logger.debug("Received successful response from Bing Web Search API.")
-            data = response.json()
-            links = []
-            if 'webPages' in data and 'value' in data['webPages']:
-                for result in data['webPages']['value']:
-                    links.append(result)
-                return links
-        else:
-            logger.error(f"Bing Web Search API returned status code {response.status_code}")
-        return ["No relevant links found."]
-
-    @staticmethod
-    def _search_books_or_podcasts(search_term):
-        logger.debug(f"Searching books or podcasts for term: {search_term}")
-        """
-        Uses Bing Web Search API to search for books or podcasts.
-        """
-        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
-        query = f"{search_term} book OR podcast"
-        params = {'q': query, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
-        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
-        if response.status_code == 200:
-            logger.debug("Received successful response from Bing Web Search API for books/podcasts.")
-            data = response.json()
-            recommendations = []
-            if 'webPages' in data and 'value' in data['webPages']:
-                for result in data['webPages']['value']:
-                    title = result.get('name', 'Unknown Title')
-                    url = result.get('url', '')
-                    recommendations.append(f"{title}: {url}")
-                return recommendations
-        else:
-            logger.error(f"Bing Web Search API returned status code {response.status_code} for books/podcasts search.")
-        return ["No book or podcast recommendations found."]
-
-    @staticmethod
-    def _search_success_stories(search_term):
-        logger.debug(f"Searching success stories for term: {search_term}")
-        """
-        Uses Bing Web Search API to search for success stories.
-        """
-        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
-        query = f"{search_term} success stories"
-        params = {'q': query, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
-        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
-        if response.status_code == 200:
-            logger.debug("Received successful response from Bing Web Search API for success stories.")
-            data = response.json()
-            stories = []
-            if 'webPages' in data and 'value' in data['webPages']:
-                for result in data['webPages']['value']:
-                    title = result.get('name', 'Unknown Title')
-                    url = result.get('url', '')
-                    stories.append(f"{title}: {url}")
-                return stories
-        else:
-            logger.error(f"Bing Web Search API returned status code {response.status_code} for success stories search.")
-        return ["No success stories found."]
-
-    @staticmethod
-    def _search_inspirational_stories(search_term):
-        logger.debug(f"Searching inspirational stories or case studies for term: {search_term}")
-        """
-        Uses Bing Web Search API to search for inspirational stories or case studies.
-        """
-        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
-        query = f"{search_term} inspirational stories OR case studies"
-        params = {'q': query, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
-        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
-        if response.status_code == 200:
-            logger.debug("Received successful response from Bing Web Search API for inspirational stories.")
-            data = response.json()
-            stories = []
-            if 'webPages' in data and 'value' in data['webPages']:
-                for result in data['webPages']['value']:
-                    title = result.get('name', 'Unknown Title')
-                    url = result.get('url', '')
-                    stories.append(f"{title}: {url}")
-                return stories
-        else:
-            logger.error(f"Bing Web Search API returned status code {response.status_code} for inspirational stories search.")
-        return ["No inspirational stories found."]
-
-    @staticmethod
-    def _search_fun_facts(search_term):
-        logger.debug(f"Searching fun facts for term: {search_term}")
-        """
-        Uses Bing Web Search API to search for fun facts related to personal growth.
-        """
-        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
-        query = f"{search_term} fun facts"
-        params = {'q': query, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
-        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
-        if response.status_code == 200:
-            logger.debug("Received successful response from Bing Web Search API for fun facts.")
-            data = response.json()
-            facts = []
-            if 'webPages' in data and 'value' in data['webPages']:
-                for result in data['webPages']['value']:
-                    snippet = result.get('snippet', '')
-                    facts.append(snippet)
-                return facts
-        else:
-            logger.error(f"Bing Web Search API returned status code {response.status_code} for fun facts search.")
-        return ["No fun facts found."]
-
-    @staticmethod
-    def _search_visual_content(search_term):
-        logger.debug(f"Searching visual content for term: {search_term}")
-        """
-        Uses Bing Image Search API to search for images or infographics.
-        """
-        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
-        params = {'q': search_term, 'count': 3}
-        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/images/search", headers=headers, params=params)
-        if response.status_code == 200:
-            logger.debug("Received successful response from Bing Image Search API.")
-            data = response.json()
-            images = []
-            if 'value' in data:
-                for result in data['value']:
-                    image_url = result.get('contentUrl', '')
-                    images.append(image_url)
-                return images
-        else:
-            logger.error(f"Bing Image Search API returned status code {response.status_code} for visual content search.")
-        return ["No visual content found."]
-
-    @staticmethod
-    def _search_personalized_recommendations(search_term):
-        logger.debug(f"Searching personalized recommendations for term: {search_term}")
-        """
-        Uses Bing Web Search API to provide personalized recommendations.
-        """
-        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
-        query = f"tips for {search_term}"
-        params = {'q': query, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
-        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
-        if response.status_code == 200:
-            logger.debug("Received successful response from Bing Web Search API for personalized recommendations.")
-            data = response.json()
-            recommendations = []
-            if 'webPages' in data and 'value' in data['webPages']:
-                for result in data['webPages']['value']:
-                    title = result.get('name', 'Unknown Title')
-                    url = result.get('url', '')
-                    recommendations.append(f"{title}: {url}")
-                return recommendations
-        else:
-            logger.error(f"Bing Web Search API returned status code {response.status_code} for personalized recommendations search.")
-        return ["No personalized recommendations found."]
-
-    @staticmethod
-    def _search_videos(search_term):
-        logger.debug(f"Searching videos for term: {search_term}")
-        """
-        Uses Bing Video Search API to search for videos, prioritizing YouTube results.
-        """
-        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
-        query = f"site:youtube.com {search_term}"
-        params = {'q': query, 'textDecorations': True, 'textFormat': 'HTML', 'count': 3}
-        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/videos/search", headers=headers, params=params)
-        if response.status_code == 200:
-            logger.debug("Received successful response from Bing Video Search API.")
-            data = response.json()
-            videos = []
-            if 'value' in data:
-                for result in data['value']:
-                    title = result.get('name', 'Unknown Title')
-                    url = result.get('contentUrl', '')
-                    # Prioritize YouTube results
-                    if 'youtube.com' in url.lower():
-                        videos.append(f"{title}: {url}")
-                    if len(videos) >= 3:
-                        break
-                # If we don't have enough YouTube results, add other video results
-                if len(videos) < 3:
-                    for result in data['value']:
-                        title = result.get('name', 'Unknown Title')
-                        url = result.get('contentUrl', '')
-                        if url not in [v.split(': ')[1] for v in videos]:
-                            videos.append(f"{title}: {url}")
-                        if len(videos) >= 3:
-                            break
-                return videos
-        else:
-            logger.error(f"Bing Video Search API returned status code {response.status_code} for video search.")
-        return ["No video content found."]
-
-    @staticmethod
-    def _search_general(search_term):
-        logger.debug(f"Performing a general search for term: {search_term}")
-        """
-        Uses Bing Web Search API to perform a general search.
-        """
-        headers = {'Ocp-Apim-Subscription-Key': SearchEngine.BING_API_KEY}
-        params = {'q': search_term, 'textDecorations': True, 'textFormat': 'HTML', 'count': 5}
-        response = requests.get(f"{SearchEngine.BING_ENDPOINT}/search", headers=headers, params=params)
-        if response.status_code == 200:
-            logger.debug("Received successful response from Bing Web Search API for general search.")
-            data = response.json()
-            results = []
-            if 'webPages' in data and 'value' in data['webPages']:
-                for result in data['webPages']['value']:
-                    results.append(result)
-                return results
-        else:
-            logger.error(f"Bing Web Search API returned status code {response.status_code} for general search.")
-        return ["No results found for general search."]

app/zoom_summary.txt

@@ -1,42 +1,32 @@
 Quick Recap
 
-Andrea and Yew Wai discussed Yew Wai's work, health, and personal life, addressing the challenges in each area. They explored Yew Wai's motivation, priorities, and personal growth goals, including becoming a founder, being more consistent in health habits, and improving relationships. The conversation concluded with a discussion on the potential effects of focusing on OurCoach on various aspects of his life, strategies to push forward with his goals, and the necessity for Yew Wai to find a balance between his career, health, and relationships.
+Farant and the Growth Guide discussed Farant's ongoing efforts to improve his communication skills, specifically addressing his stuttering and anxiety during presentations. They explored his current action plan, the challenges he's facing, and introduced the importance of focusing on his mental well-being to support his primary goal. The conversation also touched on balancing preparation for presentations and managing stress effectively.
 
 Next Steps
 
-Yew Wai to run user testing with Growth Guide sessions for OurCoach in the next 1-2 weeks.
-Yew Wai to launch the new chat and web dashboard for OurCoach this week.
-Yew Wai to try scheduling some exercise time, even if just a 10-minute walk.
-Yew Wai to be more organized in day-to-day tasks and continue meeting up with the team.
-Yew Wai to focus on improving his sleep as his new goal.
+Farant to continue practicing presentations regularly, both alone and with a small group of friends over the next 1-2 weeks.
+Implement and refine breathing techniques to manage stuttering and reduce anxiety before speaking.
+Incorporate stress management strategies, such as mindfulness or relaxation exercises, into his daily routine.
+Allocate specific times for preparation to avoid overthinking and excessive focus on details.
+Schedule a follow-up session with the Growth Guide to assess progress and adjust the action plan as needed.
 Summary
 
-Work and Personal Life Balance
+Progress on Communication Skills
 
-In the meeting, Andrea and Yew Wai discussed Yew Wai's work and personal life. Yew Wai expressed that his life is not always balanced due to the demands of work, particularly the development of their coaching platform, OurCoach. He also mentioned upcoming holiday plans to Phuket with his partner and her family. Yew Wai looks forward to the completion of the coaching platform and the subsequent return to a more regular routine.
+In the meeting, Farant shared his dedication to improving his communication skills. He has been practicing his presentations more consistently, both individually and in front of friends, and has started using breathing techniques to help manage his stuttering. These efforts have led to a gradual decrease in his anxiety levels before speaking.
 
-Addressing Yew's Personal Habits Challenges
+Addressing Stuttering and Anxiety
 
-Andrea and Yew Wai discussed Yew Wai's current challenges related to discipline in personal habits such as sleep, eating, and exercise. Yew Wai admitted to irregular sleep patterns, inconsistent eating times, and infrequent exercise, which negatively impact his mood and energy levels. He also relies on coffee to compensate for his irregular habits. Additionally, Yew Wai shared that he and his fiancé, who lives in Jakarta, often face long-distance challenges.
+Farant continues to face challenges with stuttering during presentations, although he reports becoming more comfortable with it over time. His anxiety prior to speaking engagements is slowly diminishing, indicating positive progress. However, he still experiences nervousness, which he is actively working to mitigate through his current practices.
 
-Yew's Motivation and Priorities Discussed
+New Challenges in Balancing Preparation
 
-In the meeting, Andrea and Yew Wai explored his motivation and priorities. Yew Wai shared that seeing OurCoach come to fruition and achieving career growth are key motivators. He expressed a desire to make a positive impact with the launch of their product, hoping that users will have a new-age experience. Yew Wai's priorities were identified as career, health, and relationships, with career currently at the forefront. He emphasized the importance of building a valuable product for users.
+Farant identified a new challenge related to balancing his preparation for presentations. He tends to spend excessive time on details, which contributes to his stress levels. Finding the right balance between thorough preparation and avoiding overthinking is an area he aims to improve.
 
-Yew's Exercise Routine and Marathon Goal
+Focus on Mental Well-Being
 
-Yew Wai discussed his exercise routine, stating that he tries to exercise at least once or twice a week, typically involving running, gym sessions, and tennis. He mentioned that he used to be more into long-distance running but now prefers tennis more often. Yew also shared his goal of running a 42 km marathon by the age of 42, which remains a long-term aspiration.
+Beyond his primary goal of enhancing communication skills, Farant expressed a desire to focus on his mental well-being. He recognizes that managing stress is crucial not only for his personal health but also for achieving his communication objectives. Integrating stress management techniques into his routine is seen as complementary to his main goal.
 
-Personal Growth and Career Goals
+Decision on Continuing Current Goals
 
-Yew Wai outlined his personal growth goals for the year, including becoming a founder and improving his relationships. He mentioned the possibility of helping his Indonesian partner, Karina, move to Malaysia by Q1 next year. Yew Wai's motivation for these goals stems from a desire for personal growth and avoiding feelings of stagnation. He views these goals as interconnected, with self-discipline being crucial for their achievement. His immediate priority is his career.
-
-Coach's Impact on Yew's Life Goals
-
-Andrea and Yew Wai discussed the potential effects of focusing on OurCoach on various aspects of Yew Wai's life. Yew Wai suggested that dedicating significant focus to building OurCoach may negatively impact his health and relationships due to limited time for these areas. However, successfully building OurCoach could also boost his confidence, as achieving this goal would fulfill his long-held dream of building his own company.
-
-Yew's Progress and Development Plans
-
-Andrea and Yew Wai reviewed his progress towards his goals, particularly focusing on building OurCoach and taking a more hands-on approach. Yew expressed a desire to be more organized and meet with the team more frequently to accelerate development. They discussed upcoming user testing and the growth guide. Andrea suggested that Yew Wai could benefit from finding a balance between his career, health, and relationships. They agreed to reconnect next week to reflect on his progress.
-
-Growth Guide Notes: Yew Wai wants to change his goal to focus on “Improving his sleep”.
+Based on the session, Farant has decided to continue pursuing his current goal of improving communication skills while also incorporating strategies to manage his stress. He believes that addressing both areas simultaneously will lead to more effective and sustainable progress in his presentations and overall well-being.