Added Alerts and other HF feedback

app/assistants.py

@@ -13,7 +13,7 @@ import psycopg2
 from psycopg2 import sql
 import pytz
 
-from app.exceptions import AssistantError, BaseOurcoachException, OpenAIRequestError
+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.flows import FOLLOW_UP_STATE, GENERAL_COACHING_STATE, MICRO_ACTION_STATE, REFLECTION_STATE
 
@@ -311,8 +311,6 @@ class Assistant:
                 return func(self, *args, **kwargs)
             except (BaseOurcoachException) as e:
                 raise e
-            except openai.BadRequestError as e:
-                raise OpenAIRequestError(user_id=self.cm.user.user_id, message="Error getting response from OpenAI", e=str(e), run_id=self.recent_run.id)
             except Exception as e:
                 # Handle other exceptions
                 logger.error(f"An unexpected error occurred in Assistant: {e}")
@@ -324,7 +322,6 @@ class Assistant:
         self.cm = cm
         self.recent_run = None
 
-    @catch_error
     def cancel_run(self, run, thread):
         logger.info(f"(asst) Attempting to cancel run: {run} for thread: {thread}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
         if isinstance(run, str):
@@ -338,7 +335,9 @@ class Assistant:
                 logger.warning(f"Thread {thread} already deleted: {run}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_cancel_run"})
                 return True
         if isinstance(run, PseudoRun):
-            return True
+            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':
@@ -366,16 +365,17 @@ class Assistant:
 
     @catch_error 
     def process(self, thread, text):
-        # template_search = self.cm.add_message_to_thread(thread.id, "assistant", f"Pay attention to the current state you are in and the flow template to respond to the users query:") 
-        message = self.cm.add_message_to_thread(thread.id, "user", text)
-
-        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
@@ -393,12 +393,14 @@ class Assistant:
                     reccursion += 1
                     if reccursion > 10:
                         logger.warning(f"Run has exceeded maximum recussrion depth({10}) for function_call: {run}", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_process"})
-                        self.cancel_run(run, thread)
                         raise OpenAIRequestError(user_id=self.cm.id, message="Tool Call Reccursion Depth Reached")
-                    if run.status == 'cancelled':
+                    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)
-                        break
+                        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
@@ -406,344 +408,347 @@ class Assistant:
                     elif run.status == 'failed':
                         raise OpenAIRequestError(user_id=self.cm.id, message="Run failed")
                 return run, just_finished_intro, message 
-        except openai.BadRequestError as e:
-            raise OpenAIRequestError(user_id=self.cm.user, message="Error getting response from OpenAI", e=str(e))
+        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
     
-    @catch_error
     def call_tool(self, run, thread):
-        tool_outputs = []
-        logger.info(f"Required actions: {list(map(lambda x: f'{x.function.name}({x.function.arguments})', run.required_action.submit_tool_outputs.tool_calls))}", 
-                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":
+        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"})
+
                     tool_outputs.append({
                     "tool_call_id": tool.id,
-                    "output": f"help the user set a new goal"
+                    "output": f"{self.cm.state['date']}"
                     })
-                    # 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
+                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)
 
-                                            """ + flow_instructions
+                    # Ensure the directory exists
+                    os.makedirs(user_mementos_folder, exist_ok=True)
 
-                    elif transitions['to'] == "FOLLOW UP STATE":
-                        flow_instructions = FOLLOW_UP_STATE
+                    # 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)
                     
-                    elif transitions['to'] == "GENERAL COACHING STATE":
-                        flow_instructions = GENERAL_COACHING_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"})
 
                     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 **"
+                    "output": f"** retrieve any files related to: {queries} **"
                     })
-            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"})
-
-                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 == '':
+                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 = 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": "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"})
+                        on = args['on']
+                        if on == '':
+                            on = pd.to_datetime(self.cm.state['date']).date()
+                        else:
+                            on = pd.to_datetime(args['on']).date()
 
-                user_goal = json.loads(tool.function.arguments)['goal']
-                user_goal_area = json.loads(tool.function.arguments)['area']
 
-                self.cm.user.set_goal(user_goal, user_goal_area)
+                    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)
 
-                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"})
+                    # 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} **"
 
-                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)
-                run = PseudoRun(status="cancelled", metadata={"message": "start_now"})
-                return run, just_finish_intro
-            elif tool.function.name == "change_goal":
-                logger.info(f"Changing user goal...", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_change_goal"})
-                
-                # 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)
-                run = PseudoRun(status="cancelled", metadata={"message": "change_goal"})
-                return run, just_finish_intro 
-            elif tool.function.name == "complete_goal":
-                logger.info(f"Completing user goal...", extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_complete_goal"})
-                goal = self.cm.user.update_goal(None, 'COMPLETED')
-                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({
+                    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"** {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}"
-                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' unless the user specifically wants to know the name/who their growth guide is) **\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"})
+                    "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_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"})
+
+                    user_goal = json.loads(tool.function.arguments)['goal']
+                    user_goal_area = json.loads(tool.function.arguments)['area']
+
+                    self.cm.user.set_goal(user_goal, user_goal_area)
+
+                    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"})
+
+                    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"})
                     
-                    booked_sessions = get_booked_gg_sessions(self.cm.user.user_id)
+                    # switch back to the intro assistant, so we set just_finish_intro to False again
+                    just_finish_intro = False
+                    
+                    # 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}"
+                    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"})
 
-                    # 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}", 
+                        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"})
-                            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) **\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."
-                })
+                            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."
+                    })
 
-        # Submit all tool outputs at once after collecting them in a list
-        if tool_outputs:
-            try:
+            # Submit all tool outputs at once after collecting them in a list
+            if tool_outputs:         
                 run = self.cm.client.beta.threads.runs.submit_tool_outputs_and_poll(
                     thread_id=thread.id,
                     run_id=run.id,
@@ -752,17 +757,22 @@ class Assistant:
                 logger.info("Tool outputs submitted successfully", 
                         extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_submit_tools"})
                 return run, just_finish_intro
-            except Exception as e:
-                raise OpenAIRequestError(user_id=self.cm.user.id, message="Error submitting tool outputs", e=str(e), run_id=run.id)                
-        else:
-            logger.warning("No tool outputs to submit", 
-                        extra={"user_id": self.cm.user.user_id, "endpoint": "assistant_submit_tools"})
-            run = PseudoRun(status="completed", metadata={"message": "No tool outputs to submit"})
-            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, metadata=None):
-        self.id = "pseudo_run"
+    def __init__(self, status, id='pseudo_run', metadata=None):
+        self.id = id
         self.status = status
         self.metadata = metadata or {}
 

app/conversation_manager.py

@@ -128,7 +128,11 @@ class ConversationManager:
             elif message == 'change_goal':
                 self.intro_done = False
                 logger.info(f"Changing goal, reset to intro assistant", extra={"user_id": self.user.user_id, "endpoint": "run_current_thread"})
-
+            # Actually dont need this
+            elif message == '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)

app/flows.py

@@ -472,7 +472,7 @@ 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 Growth Guide Session(s) (most recent first):
+User's Past Growth Guide Session(s) (most recent first):
 {{}}
 
 ## ** GUIDELINE ** :

app/main.py

@@ -295,6 +295,11 @@ class ChangeDateItem(BaseModel):
     user_id: str
     date: str
 
+class UpsellGGItem(BaseModel):
+    user_id: str
+    day: int
+    date: str
+
 class BookingItem(BaseModel):
     booking_id: str
 
@@ -320,15 +325,15 @@ def catch_endpoint_error(func):
                             '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__})
+            # 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__})
 
             raise HTTPException(
                 status_code=status.HTTP_502_BAD_GATEWAY,
@@ -812,6 +817,17 @@ async def 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: UpsellGGItem,
+    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.day, request.date)
+    return {"response": response}
+
 @app.post("/chat")
 @catch_endpoint_error
 async def chat(

app/user.py

@@ -19,7 +19,7 @@ from app.flows import FINAL_SUMMARY_STATE, FINAL_SUMMARY_STATE, MICRO_ACTION_STA
 from pydantic import BaseModel
 from datetime import datetime
 
-from app.utils import generate_uuid, get_booked_gg_sessions, get_growth_guide_summary, update_growth_guide_summary
+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
@@ -612,6 +612,98 @@ class User:
     def set_intro_done(self):
         self.conversations.intro_done = True
 
+    @catch_error
+    def get_alerts(self, day, date):
+        # make timezone ISO
+        responses = []
+        # day = self.cumulative_plan_day
+        if day == 2 or day == 5:
+            # upsell the GG
+            growth_guide = get_growth_guide(self.user_id)
+        
+            upsell_prompt = "introduce WHO their grwoth guide is and how a GG can help them" if day == 2 else "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}.
+
+            Respond with a enthusiatic hello! Then, based on the current day ({day}), succintly:
+            {upsell_prompt}
+            Frame your response like a you are telling the user a fun fact, but dont explicitly mention "fun fact".
+            """   
+
+            # 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"""** User's Subscription Information **
+                Users current subscription:
+                {subscription}
+
+                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"""** User's Subscription Information **
+                Users current subscription:
+                {subscription}
+
+                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 []
+                
+        response, run = self.conversations._run_current_thread(prompt, hidden=True)
+        message = run.metadata.get("message", "No message")
+        logger.info(f"Message: {message}", extra={"user_id": self.user_id, "endpoint": "upsell_gg"})
+       
+        response['timestamp'] = timestamp
+        return [response]
+
     @catch_error
     def do_theme(self, theme, date, day, last_msg_is_answered = True):
         logger.info(f"Doing theme: {theme}", extra={"user_id": self.user_id, "endpoint": "do_theme"})
@@ -656,10 +748,29 @@ class User:
         elif theme == "PROGRESS_SUMMARY_STATE":
             formatted_message = PROGRESS_SUMMARY_STATE.format(self.get_current_goal(), day, len(self.growth_plan.array))
         elif theme == "FINAL_SUMMARY_STATE":
-            gg_summary = "<User has not had a Growth Guide session yet>"
-            if self.last_gg_session:
-                gg_summary = get_growth_guide_summary(self.user_id, self.last_gg_session)
-            formatted_message = FINAL_SUMMARY_STATE.format(self.get_current_goal(), day, len(self.growth_plan.array), gg_summary)
+            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(), day, len(self.growth_plan.array), growth_guide, past_gg_summary)
         elif theme == "EDUCATION_STATE":
             formatted_message = EDUCATION_STATE.format(self.get_current_goal(), day, len(self.growth_plan.array))
         elif theme == "FOLLUP_ACTION_STATE":