mito-ai 0.1.50__py3-none-any.whl

mito_ai/completions/prompt_builders/chat_system_message.py

@@ -0,0 +1,92 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from mito_ai.completions.prompt_builders.prompt_constants import (
+    CHAT_CODE_FORMATTING_RULES,
+    CITATION_RULES, 
+    ACTIVE_CELL_ID_SECTION_HEADING, 
+    CODE_SECTION_HEADING,
+    get_database_rules
+)
+
+def create_chat_system_message_prompt() -> str:
+    return f"""You are Mito Data Copilot, an AI assistant for Jupyter. You're a great python programmer, a seasoned data scientist and a subject matter expert.
+
+The user is going to ask you for help writing code, debugging code, explaining code, or drawing conclusions from their data/graphs. It is your job to help them accomplish their goal. 
+
+The user will give you a set of variables, existing code, and a task to complete. 
+
+There are three possible types of responses you might give:
+1. Code Update: If the task requires modifying or extending the existing code, respond with the updated active code cell and a short explanation of the changes made. 
+2. Explanation/Analysis: If the task does not require a code update, it might instead require you to provide an explanation of existing code or data, provide an analysis of the the data or chart.
+3. Friendly Response: If the user is just asking a question, saying hi, or you're just chatting, respond with a friendly response and do not return any code.
+
+Other useful information:
+1. The user has two types of modes that they can collaborate with you in: Chat Mode (this mode) and agent mode. Chat mode gives the user more control over the edits made to the notebook and only edits the active cell. Agent mode gives you more autonomy over completing the user's task across mulitple messages. In agent mode, you can edit or create new cells, see the entire notebook, automatically run the code you write, and more.
+2. If the user asks you to generate a dashboard, app, or streamlit app for them, you should tell them that they must use Agent mode to complete the task. You are not able to automatically switch the user to agent mode, but they can switch to it themselves by using the Chat/Agent mode toggle in the bottom left corner of the Ai taskpane.
+
+====
+{CITATION_RULES}
+
+<Example 1> 
+{ACTIVE_CELL_ID_SECTION_HEADING}
+'7b3a9e2c-5d14-4c83-b2f9-d67891e4a5f2'
+
+{CODE_SECTION_HEADING}
+```python
+sales_df = pd.read_csv('sales_data.csv')
+monthly_revenue = sales_df.groupby('month')['revenue'].sum()
+top_month = monthly_revenue.idxmax()
+peak_revenue = monthly_revenue.max()
+growth_rate = (monthly_revenue.iloc[-1] / monthly_revenue.iloc[0] - 1) * 100
+```
+
+Your task: What are the key revenue insights from this sales data?
+
+Output:
+Peak monthly revenue reached $847,392 in March[MITO_CITATION:7b3a9e2c-5d14-4c83-b2f9-d67891e4a5f2:2-3], representing a 23.8% year-over-year growth rate[MITO_CITATION:7b3a9e2c-5d14-4c83-b2f9-d67891e4a5f2:4]. The revenue aggregation analysis[MITO_CITATION:7b3a9e2c-5d14-4c83-b2f9-d67891e4a5f2:1-2] reveals strong seasonal performance patterns.
+
+</Example 1>
+
+Notice in the example above:
+- Citations support specific facts and numbers, not vague summaries
+- Single line citations reference specific calculations (e.g., :4 for growth rate)
+- Multiline citations reference broader analysis blocks (e.g., :1-2 for the groupby operation)
+- Language is information-dense with concrete metrics
+- All line numbers are 0-indexed
+
+<Example 2>
+
+{ACTIVE_CELL_ID_SECTION_HEADING}
+'1a2b3c4d-5e6f-7g8h-9i0j-k1l2m3n4o5p6'
+
+{CODE_SECTION_HEADING}
+```python
+```
+
+Your task: Hello
+
+Output:
+Hey there! I'm Mito AI. How can I help you today? 
+
+</Example 2>
+
+Notice in the example above that the user is just sending a friendly message, so we respond with a friendly message and do not return any code.
+
+===
+{get_database_rules()}
+
+==== 
+{CHAT_CODE_FORMATTING_RULES}
+
+IMPORTANT RULES:
+- Do not recreate variables that already exist
+- Keep as much of the original code as possible
+- When updating an existing code cell, return the full code cell with the update applied. Do not only return part of the code cell with a comment like "# Updated code starts here", etc.
+- Only update code in the active cell. Do not update other code in the notebook.
+- Write code that preserves the intent of the original code shared with you and the task to complete.
+- Make the solution as simple as possible.
+- Reuse as much of the existing code as possible.
+- Do not add temporary comments like '# Fixed the typo here' or '# Added this line to fix the error'
+- Whenever writing Python code, it should be a python code block starting with ```python and ending with ```
+"""

mito_ai/completions/prompt_builders/explain_code_prompt.py

@@ -0,0 +1,32 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from mito_ai.completions.prompt_builders.prompt_constants import CODE_SECTION_HEADING
+
+def create_explain_code_prompt(active_cell_code: str) -> str:
+    prompt = f"""Explain the code in the active code cell to me like I have a basic understanding of Python. Don't explain each line, but instead explain the overall logic of the code.
+
+<Example>
+
+{CODE_SECTION_HEADING}
+
+```python
+def multiply(x, y):
+    return x * y
+```
+
+Output:
+
+This code creates a function called `multiply` that takes two arguments `x` and `y`, and returns the product of `x` and `y`.
+
+</Example>
+
+{CODE_SECTION_HEADING}
+
+```python
+{active_cell_code}
+```
+
+Output: 
+"""
+    return prompt

mito_ai/completions/prompt_builders/inline_completer_prompt.py

@@ -0,0 +1,197 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from typing import List
+from mito_ai.completions.prompt_builders.prompt_constants import (
+    FILES_SECTION_HEADING,
+    VARIABLES_SECTION_HEADING,
+    CODE_SECTION_HEADING
+)
+
+
+def create_inline_prompt(
+    prefix: str,
+    suffix: str,
+    variables: List[str],
+    files: List[str]
+) -> str:
+    variables_str = '\n'.join([f"{variable}" for variable in variables])
+    files_str = '\n'.join([f"file_name: {file}" for file in files])
+    
+    prompt = f"""You are a coding assistant that lives inside of JupyterLab. Your job is to help the user write code.
+
+You're given the current code cell, the user's cursor position, and the variables defined in the notebook. The user's cursor is signified by the symbol <cursor>.
+
+CRITICAL FORMATTING RULES:
+1. Include a new line character at the start of your response if you want the code you are writing to be added on the line after the cursor. For example, if the cursor is at the end of a comment, you should start your response with a newline character so that the code you write is not added to the comment.
+2. If you are finishing a line of code that the user started, return the full line of code with no newline character at the start or end.
+3. Your response must preserve correct Python indentation and spacing. For example, if you're completing a line of indented code, you must preserve the indentation.
+
+Your job is to complete the code that matches the user's intent. Write the minimal code to achieve the user's intent. Don't expand upon the user's intent.
+
+<Example 1>
+{FILES_SECTION_HEADING}
+file_name: sales.csv
+
+{VARIABLES_SECTION_HEADING} 
+{{
+    'loan_multiplier': 1.5,
+    'sales_df': pd.DataFrame({{
+        'transaction_date': ['2024-01-02', '2024-01-02', '2024-01-02', '2024-01-02', '2024-01-03'],
+        'price_per_unit': [10, 9.99, 13.99, 21.00, 100],
+        'units_sold': [1, 2, 1, 4, 5],
+        'total_price': [10, 19.98, 13.99, 84.00, 500]
+    }})
+}}
+
+{CODE_SECTION_HEADING}
+```python
+import pandas as pd
+sales_df = pd.read_csv('./sales.csv')
+
+# Multiply the total_price column by the loan_multiplier<cursor>
+```
+
+Output:
+```python
+
+sales_df['total_price'] = sales_df['total_price'] * loan_multiplier
+```
+</Example 1>
+
+IMPORTANT: Notice in Example 1 that the output starts with a newline because the cursor was at the end of a comment. This newline is REQUIRED to maintain proper Python formatting.
+
+<Example 2>
+{FILES_SECTION_HEADING}
+
+
+{VARIABLES_SECTION_HEADING} 
+{{
+    df: pd.DataFrame({{
+        'age': [20, 25, 22, 23, 29],
+        'name': ['Nawaz', 'Aaron', 'Charlie', 'Tamir', 'Eve'],
+    }})
+}}
+
+{CODE_SECTION_HEADING}
+```python
+df['age'] = df[<cursor>['age'] > 23]
+```
+
+Output:
+```python
+df['age'] = df[df['age'] > 23]
+```
+</Example 2>
+
+IMPORTANT: Notice in Example 2 that the output does NOT start with a newline because the cursor is in the middle of existing code.
+
+<Example 3>
+{FILES_SECTION_HEADING}
+file_name: voters.csv
+
+{VARIABLES_SECTION_HEADING} 
+{{}}
+
+{CODE_SECTION_HEADING}
+```python
+voters = pd.read_csv('./voters.csv')
+
+# Create a variable for pennsylvania voters, ohio voters, california voters, and texas voters
+pa_voters = voters[voters['state'] == 'PA']
+ohio_voters<cursor>
+```
+
+Output:
+```python
+ohio_voters = voters[voters['state'] == 'OH']
+ca_voters = voters[voters['state'] == 'CA']
+tx_voters = voters[voters['state'] == 'TX']
+```
+</Example 3>
+
+IMPORTANT: Notice in Example 3 that output does not start with a newline character because it wasnts to continue the line of code that the user started. Also notice the output contains three lines of code because that is the minimal code to achieve the user's intent.
+
+<Example 4>
+{FILES_SECTION_HEADING}
+file_name: july_2025.xlsx
+file_name: august_2025.xlsx
+
+{VARIABLES_SECTION_HEADING} 
+{{}}
+
+{CODE_SECTION_HEADING}
+```python
+# Display the first 5 rows of the dataframe
+df.head()
+<cursor>
+```
+
+Output:
+```python
+```
+</Example 4>
+
+IMPORTANT: Notice in Example 4 that the output is empty becuase the user's intent is already complete.
+
+<Example 5>
+{FILES_SECTION_HEADING}
+
+
+{VARIABLES_SECTION_HEADING} 
+{{}}
+
+{CODE_SECTION_HEADING}
+```python
+def even_and_odd():
+    for i in range(10):
+        if i % 2 == 0:
+            print(f"Even: {{i}}")
+        else:
+            pri<cursor>
+```
+
+Output:
+```python
+            print(f"Odd: {{i}}")
+```
+</Example 5>
+
+IMPORTANT: Notice in Example 5 that the output is indented several times because the code must be executed as part of the else block.
+
+<Example 6>
+{FILES_SECTION_HEADING}
+
+
+{VARIABLES_SECTION_HEADING} 
+{{}}
+
+{CODE_SECTION_HEADING}
+```python
+days_in_week <cursor>
+```
+
+Output:
+```python
+days_in_week = 7
+```
+</Example 6>
+
+IMPORTANT: Notice in Example 6 that inorder to finish the variable declaration, the output continues the existing line of code and does not start with a new line character.
+
+Your Task:
+
+{FILES_SECTION_HEADING}
+{files_str}
+
+{VARIABLES_SECTION_HEADING} 
+{variables_str}
+
+{CODE_SECTION_HEADING}
+```python
+{prefix}<cursor>{suffix}
+```
+
+Output:
+"""
+    return prompt

mito_ai/completions/prompt_builders/prompt_constants.py

@@ -0,0 +1,170 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+"""
+This module contains constants used in prompts across the codebase.
+These constants ensure consistency between prompt building and message trimming.
+"""
+
+import os
+import json
+from typing import Final
+from mito_ai.utils.schema import MITO_FOLDER
+
+# Section headings used in prompts
+FILES_SECTION_HEADING = "Files in the current directory:"
+VARIABLES_SECTION_HEADING = "Defined Variables:"
+CODE_SECTION_HEADING = "Code in the active code cell:"
+ACTIVE_CELL_ID_SECTION_HEADING = "The ID of the active code cell:"
+ACTIVE_CELL_OUTPUT_SECTION_HEADING = "Output of the active code cell:"
+GET_CELL_OUTPUT_TOOL_RESPONSE_SECTION_HEADING = "Output of the code cell you just applied the CELL_UPDATE to:"
+JUPYTER_NOTEBOOK_SECTION_HEADING = "Jupyter Notebook:"
+STREAMLIT_APP_STATUS_SECTION_HEADING = "Streamlit App Status:"
+
+# Placeholder text used when trimming content from messages
+CONTENT_REMOVED_PLACEHOLDER = "Content removed to save space" 
+
+CITATION_RULES = """RULES FOR CITING YOUR WORK
+
+It is important that the user is able to verify any insights that you share with them about their data. To make this easy for the user, you must cite the lines of code that you are drawing the insight from. To provide a citation, use one of the following formats inline in your response:
+
+Single line citation:
+[MITO_CITATION:cell_id:line_number]
+
+Multiline citation (for citing a range of lines):
+[MITO_CITATION:cell_id:first_line-last_line]
+
+Citation Rules:
+
+1. Every fact or statement derived from the user's notebook must include a citation. 
+2. When choosing the citation, select the code that will most help the user validate the fact or statement that you shared with them.
+3. Place the citation immediately after the statement it supports. Do not explain the citation with phrases like "See", "Derived from", etc. Just provide the citation object.
+4. For the "line_number" field, use the line number within the cell that is most relevant to the citation. Important: The cell line number should be 0-indexed and should not skip comments.
+5. For multiline citations, use the "first_line-last_line" format when the insight spans multiple lines of code. Both line numbers should be 0-indexed.
+6. If you cannot find relevant information in the notebook to answer a question, clearly state this and do not provide a citation.
+7. You ONLY need to provide a citation when sharing an insight from the data in the message part of the response. If all you are doing is writing/updating code, then there is no need to provide a citation.
+8. Do not include the citation in the code block as a comment. ONLY include the citation in the message field of your response.
+"""
+
+def get_active_cell_output_str(has_active_cell_output: bool) -> str:
+    """
+    Used to tell the AI about the output of the active code cell. 
+    We use this in the chat prompt.
+    """
+    if has_active_cell_output:
+        return f"{ACTIVE_CELL_OUTPUT_SECTION_HEADING}\nAttatched is an image of the output of the active code cell for your context."
+    else:
+        return ""
+    
+def cell_update_output_str(has_cell_update_output: bool) -> str:
+    """
+    Used to respond to the GET_CELL_OUTPUT tool, telling the agent the output of the cell it requested
+    """
+    if has_cell_update_output:
+        return f"{GET_CELL_OUTPUT_TOOL_RESPONSE_SECTION_HEADING}\nAttatched is an image of code cell output that you requested."
+    else:
+        return ""
+
+def redact_sensitive_info(connections: dict) -> dict:
+    """
+    Redacts sensitive information from connections data.
+    Returns a copy of the connections dict with sensitive fields masked.
+    """
+    redacted = {}
+    for conn_name, conn_data in connections.items():
+        redacted[conn_name] = conn_data.copy()
+        for key, value in redacted[conn_name].items():
+            redacted[conn_name][key] = 'redacted'
+    return redacted
+
+def get_database_rules() -> str:
+    """
+    Reads the user's database configurations,
+    and returns the rules for the AI to follow.
+    """
+
+    # Get the db configuration from the user's mito folder
+
+    APP_DIR_PATH: Final[str] = os.path.join(MITO_FOLDER)
+    connections_path: Final[str] = os.path.join(APP_DIR_PATH, 'db', 'connections.json')
+    schemas_path: Final[str] = os.path.join(APP_DIR_PATH, 'db', 'schemas.json')
+    
+    try:
+        with open(connections_path, 'r') as f:
+            connections = json.load(f)
+            sanitized_connections = redact_sensitive_info(connections)
+    except FileNotFoundError:
+        connections = None
+        sanitized_connections = None
+
+    try:
+        with open(schemas_path, 'r') as f:
+            schemas = json.load(f)
+    except FileNotFoundError:
+        schemas = None
+
+    # If there is a db configuration, add return the rules
+
+    if connections is not None:
+        DATABASE_RULES = f"""DATABASE RULES:
+If the user has requested data that you believe is stored in the database:
+- Use the provided schema.
+- Only use SQLAlchemy to query the database.
+- Do not use a with statement when creating the SQLAlchemy engine. Instead, initialize it once so it can be reused for multiple queries.
+- Always return the results of the query in a pandas DataFrame, unless instructed otherwise.
+- Every schema has a unique connection ID. This ID can be used to find the connection details in the connections.json file.
+- Do not use the connection ID to query the database. It is only for matching the schema to the correct connection.
+- When using the connection ID, do not include any comments about it in your code.
+- Connection details are stored in a JSON file located at: `{connections_path}`
+- Here is the sanitized contents of the connections.json file:
+
+{sanitized_connections}
+
+- Do not hard-code connection credentials into your code. Instead, load the connections.json file and access connection fields dynamically like so:
+
+```
+connections[connection_name]["username"]
+```
+
+- The user may colloquially ask for a "list of x", always assume they want a pandas DataFrame. 
+- When working with dataframes created from an SQL query, ALWAYS use lowercase column names. 
+- If you think the requested data is stored in the database, but you are unsure, then ask the user for clarification.
+
+## Additional MSSQL Rules
+
+- When connecting to a Microsoft SQL Server (MSSQL) database, use the following format:
+
+```
+import urllib.parse
+
+encoded_password = urllib.parse.quote_plus(password) 
+conn_str = f"mssql+pyodbc://username:encoded_password@host:port/database?driver=ODBC+Driver+18+for+SQL+Server&TrustServerCertificate=yes"
+```
+
+- Always URL-encode passwords for MSSQL connections to handle special characters properly.
+- Include the port number in MSSQL connection strings.
+- Use "ODBC+Driver+18+for+SQL+Server" (with plus signs) in the driver parameter.
+- Always include "TrustServerCertificate=yes" for MSSQL connections to avoid SSL certificate issues.
+
+## Additional Oracle Rules
+
+- When connecting to an Oracle database, use the following format:
+```
+conn_str = f"oracle+oracledb://username:password@host:port?service_name=service_name"
+```
+
+Here is the schema:
+{schemas}
+        """
+    else:
+        DATABASE_RULES = ""
+
+    return DATABASE_RULES
+
+
+CHAT_CODE_FORMATTING_RULES = """CRITICAL CODE UPDATE RULES:
+- COMPLETE REPLACEMENT: Your code will COMPLETELY REPLACE the entire contents of the active code cell. 
+- INCLUDE ALL CODE: You MUST return the COMPLETE, FULL contents of the entire code cell - including ALL existing code that should remain plus your modifications.
+- NEVER PARTIAL CODE: NEVER return only a portion, snippet, or subset of the code cell. Partial responses will break the user's notebook by deleting important code.
+- PRESERVE EXISTING CODE: Always preserve imports, variable definitions, and other code that the user needs, even if you're only modifying one small part.
+"""

mito_ai/completions/prompt_builders/smart_debug_prompt.py

@@ -0,0 +1,199 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from typing import List
+from mito_ai.completions.prompt_builders.prompt_constants import (
+    ACTIVE_CELL_ID_SECTION_HEADING,
+    FILES_SECTION_HEADING,
+    VARIABLES_SECTION_HEADING,
+    CODE_SECTION_HEADING
+)
+
+
+def create_error_prompt(
+    error_message: str,
+    active_cell_code: str,
+    active_cell_id: str,
+    variables: List[str],
+    files: List[str]
+) -> str:
+    variables_str = '\n'.join([f"{variable}" for variable in variables])
+    files_str = '\n'.join([f"{file}" for file in files])
+    return f"""Help me debug this code in JupyterLab. Analyze the error and provide a solution that maintains the original intent.
+
+<Example 1>
+{FILES_SECTION_HEADING}
+file_name: sales.csv
+
+{VARIABLES_SECTION_HEADING}
+{{
+    'revenue_multiplier': 1.5,
+    'sales_df': pd.DataFrame({{
+        'transaction_date': ['2024-01-02', '2024-01-02', '2024-01-02', '2024-01-02', '2024-01-03'],
+        'price_per_unit': [10, 9.99, 13.99, 21.00, 100],
+        'units_sold': [1, 2, 1, 4, 5],
+        'total_price': [10, 19.98, 13.99, 84.00, 500]
+    }})
+}}
+
+{ACTIVE_CELL_ID_SECTION_HEADING}
+'9e38c62b-38f8-457d-bb8d-28bfc52edf2c'
+
+{CODE_SECTION_HEADING}
+```python
+import pandas as pd
+sales_df = pd.read_csv('./sales.csv')
+revenue_multiplier =  1.5
+sales_df['total_revenue'] = sales_df['price'] * revenue_multiplier
+```
+
+Error Traceback:
+Cell In[24], line 4
+      1 import pandas as pd
+      2 sales_df = pd.read_csv('./sales.csv')
+      3 revenue_multiplier =  1.5
+----> 4 sales_df['total_revenue'] = sales_df['price'] * revenue_multiplier
+
+KeyError: 'price'
+
+
+ERROR ANALYSIS:
+Runtime error: Attempted to access non-existent DataFrame column
+
+INTENT ANALYSIS:
+User is trying to calculate total revenue by applying a multiplier to transaction prices. Based on the defined variables, the column that the user is tring to access is likely `total_price` because that would allow them to calculate the total revenue for each transaction.
+
+SOLUTION:
+```python
+import pandas as pd
+sales_df = pd.read_csv('./sales.csv')
+revenue_multiplier =  1.5
+sales_df['total_revenue'] = sales_df['total_price'] * revenue_multiplier
+```
+
+The DataFrame contains 'total_price' rather than 'price'. Updated column reference to match existing data structure.
+</Example 1>
+
+<Example 2>
+{FILES_SECTION_HEADING}
+
+
+{VARIABLES_SECTION_HEADING}
+{{
+    'df': pd.DataFrame({{
+        'order_id': [1, 2, 3, 4],
+        'date': ['Mar 7, 2025', 'Sep 24, 2024', '25 June, 2024', 'June 29, 2024'],
+        'amount': [100, 150, 299, 99]
+    }})
+}}
+
+{ACTIVE_CELL_ID_SECTION_HEADING}
+'c68fdf19-db8c-46dd-926f-d90ad35bb3bc'
+
+{CODE_SECTION_HEADING}
+```python
+df['date'] = pd.to_datetime(df['date'])
+```
+
+Error Traceback:
+Cell In[27], line 1
+----> 1 df['date'] = pd.to_datetime(df['date'])
+
+ValueError: time data "25 June, 2024" doesn't match format "%b %d, %Y", at position 2. You might want to try:
+    - passing `format` if your strings have a consistent format;
+    - passing `format='ISO8601'` if your strings are all ISO8601 but not necessarily in exactly the same format;
+    - passing `format='mixed'`, and the format will be inferred for each element individually. You might want to use `dayfirst` alongside this.
+
+ERROR ANALYSIS:
+This is a ValueError caused by applying the wrong format to a specific date string. Because it was triggered at position 2, the first date string must have successfully converted. By looking at the defined variables, I can see that first date string is in the format "Mar 7, 2025", but the third date string is in the format "25 June, 2024". Those dates are not in the same format, so the conversion failed.
+
+INTENT ANALYSIS:
+User is trying to convert the date column to a datetime object even though the dates are not in the same starting format. 
+
+SOLUTION:
+```python
+def parse_date(date_str):
+    formats = ['%b %d, %Y', '%d %B, %Y']
+    
+    for fmt in formats:
+        try:
+            return pd.to_datetime(date_str, format=fmt)
+        except ValueError:
+            # Try the next format
+            continue
+            
+    # If no format worked, return Not a Time
+    return pd.NaT
+
+df['date'] = df['date'].apply(lambda x: parse_date(x))
+```
+
+Since the dates are not in a consistent format, we need to first figure out which format to use for each date string and then use that format to convert the date.
+
+The best way to do this is with a function. We can call this function `parse_date`.
+</Example 2>
+
+
+Guidelines for Solutions:
+
+Error Analysis:
+
+- Identify error type (Syntax, Runtime, Logic).
+- Use the defined variables and code in the active cell to understand the error.
+- Consider kernel state and execution order
+
+Intent Preservation:
+
+- Try to understand the user's intent using the defined variables and code in the active cell.
+
+Solution Requirements:
+
+- Return the full code cell with the error fixed and a short explanation of the error.
+- Only update code in the active cell. Do not update other code in the notebook.
+- Propose a solution that fixes the error and does not change the user's intent.
+- Make the solution as simple as possible.
+- Reuse as much of the existing code as possible.
+- Do not add temporary comments like '# Fixed the typo here' or '# Added this line to fix the error'
+- The code in the SOLUTION section should be a python code block starting with ```python and ending with ```
+- If you encounter a ModuleNotFoundError, you can install the package by adding the the following line to the top of the code cell: `!pip install <package_name> --quiet`.
+
+Here is your task. 
+
+{FILES_SECTION_HEADING}
+{files_str}
+
+{VARIABLES_SECTION_HEADING}
+{variables_str}
+
+{ACTIVE_CELL_ID_SECTION_HEADING}
+{active_cell_id}
+
+{CODE_SECTION_HEADING}
+```python
+{active_cell_code}
+```
+
+Error Traceback:
+{error_message}
+
+ERROR ANALYSIS:
+
+INTENT ANALYSIS:
+
+SOLUTION:
+"""
+
+
+def remove_inner_thoughts_from_message(message: str) -> str:
+    # The smart debug prompt thinks to itself before returning the solution. We don't need to save the inner thoughts. 
+    # We remove them before saving the message in the chat history
+    if message == "":
+        return message
+    
+    SOLUTION_STRING = "SOLUTION:"
+
+    if SOLUTION_STRING in message:
+        message = message.split(SOLUTION_STRING)[1].strip()
+    
+    return message
+