Upload 9 files

app.py

@@ -2,24 +2,49 @@
 # Filepath: ai-email-assistant/app.py
 # Main application entry point
 
-import os
-from dotenv import load_dotenv
+import json
 import gradio as gr
 from chat import create_chat_interface
-from profile_management import create_profile_management_interface, get_profile_summaries
+from profile_management import create_profile_management_interface
 from email_actions import create_email_actions_interface, get_template_summaries
 from groq_client import set_api_key
-from google_sheets_utils import connect_to_sheets
+from google_sheets_utils import (
+    get_or_create_spreadsheet,
+    get_profile_summaries,
+)
+import logging
+from dotenv import load_dotenv
+import os
+
+# Set up logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
 
-# Load environment variables
-load_dotenv()
+def load_config():
+    load_dotenv()
+    return {
+        'groq_api_key': os.getenv('GROQ_API_KEY')
+    }
 
 def main():
-    api_key = os.getenv('GROQ_API_KEY')
+    logger.debug("Starting the application")
+    config = load_config()
+    logger.debug(f"Loaded config: {config}")
+    
+    api_key = config.get('groq_api_key')
     if api_key:
         set_api_key(api_key)
+        logger.debug("API key set successfully")
+    else:
+        logger.warning("No API key found in .env file")
+    
+    spreadsheet = get_or_create_spreadsheet()
+    if not spreadsheet:
+        logger.error("Failed to connect to Google Sheets")
+        gr.Error("Failed to connect to Google Sheets. Please check your credentials and internet connection.")
+        return
     
-    sender_sheet, receiver_sheet, template_sheet = connect_to_sheets()
+    logger.debug("Connected to Google Sheets successfully")
     
     with gr.Blocks() as app:
         gr.Markdown("# AI Email Assistant")
@@ -29,28 +54,142 @@ def main():
         current_receiver = gr.State(None)
         current_template = gr.State(None)
         
-        with gr.Tabs():
+        with gr.Tabs() as tabs:
             with gr.Tab("Profile Management"):
-                with gr.Tabs():
-                    with gr.Tab("Sender Profiles"):
-                        sender_components = create_profile_management_interface(sender_sheet, "Sender", current_sender)
-                    with gr.Tab("Receiver Profiles"):
-                        receiver_components = create_profile_management_interface(receiver_sheet, "Receiver", current_receiver)
+                with gr.Tabs() as profile_tabs:
+                    with gr.TabItem("Sender Profiles"):
+                        sender_components = create_profile_management_interface(
+                            spreadsheet, "Sender Profiles", current_sender
+                        )
+                        sender_block = sender_components["block"]
+                        
+                    with gr.TabItem("Receiver Profiles"):
+                        receiver_components = create_profile_management_interface(
+                            spreadsheet, "Receiver Profiles", current_receiver
+                        )
+                        receiver_block = receiver_components["block"]
             
             with gr.Tab("Email Actions"):
-                email_actions_components = create_email_actions_interface(template_sheet, current_template)
+                email_actions_components = create_email_actions_interface(
+                    spreadsheet, current_template
+                )
+                email_actions_block = email_actions_components["block"]
             
             with gr.Tab("Chat"):
                 # Get summaries for context
-                sender_summaries = get_profile_summaries(sender_sheet)
-                receiver_summaries = get_profile_summaries(receiver_sheet)
-                template_summaries = get_template_summaries(template_sheet)
+                sender_summaries = get_profile_summaries(
+                    spreadsheet.worksheet("Sender Profiles"), "Sender Profile"
+                )
+                receiver_summaries = get_profile_summaries(
+                    spreadsheet.worksheet("Receiver Profiles"), "Receiver Profile"
+                )
+                template_summaries = get_template_summaries(spreadsheet)
                 
                 chat_interface = create_chat_interface(
                     sender_summaries, receiver_summaries, template_summaries,
                     current_sender, current_receiver, current_template,
                     sender_components, receiver_components, email_actions_components
                 )
+        
+        # Refresh profiles and templates when tabs are selected
+        def refresh_data(tab: gr.SelectData):
+            if tab.index == 0:  # Profile Management tab
+                return (
+                    sender_components["refresh_profiles"](),
+                    receiver_components["refresh_profiles"](),
+                    None
+                )
+            elif tab.index == 1:  # Email Actions tab
+                return (
+                    None,
+                    None,
+                    email_actions_components["refresh_templates"]()
+                )
+            return None, None, None  # Return None for all other cases
+        
+        tabs.select(
+            refresh_data,
+            inputs=None,
+            outputs=[
+                sender_components["profiles_list"], 
+                receiver_components["profiles_list"], 
+                email_actions_components["templates_list"]
+            ]
+        )
+        
+        # Refresh data on first load
+        app.load(
+            lambda: (
+                sender_components["refresh_profiles"](),
+                receiver_components["refresh_profiles"](),
+                email_actions_components["refresh_templates"]()
+            ),
+            inputs=None,
+            outputs=[
+                sender_components["profiles_list"],
+                receiver_components["profiles_list"],
+                email_actions_components["templates_list"]
+            ]
+        )
+        
+        # Update the select event handlers for profile lists and template list
+        sender_components["profiles_list"].select(
+            sender_components["load_profile"],
+            inputs=[
+                sender_components["name"],
+                sender_components["email"],
+                sender_components["position"], 
+                sender_components["company"],
+                sender_components["context"],
+                sender_components["profile_id"]
+            ],
+            outputs=[
+                sender_components["name"],
+                sender_components["email"],
+                sender_components["position"], 
+                sender_components["company"],
+                sender_components["context"],
+                sender_components["profile_id"]
+            ]
+        )
+
+        receiver_components["profiles_list"].select(
+            receiver_components["load_profile"],
+            inputs=[
+                receiver_components["name"],
+                receiver_components["email"],
+                receiver_components["position"], 
+                receiver_components["company"],
+                receiver_components["context"],
+                receiver_components["profile_id"]
+            ],
+            outputs=[
+                receiver_components["name"],
+                receiver_components["email"],
+                receiver_components["position"], 
+                receiver_components["company"],
+                receiver_components["context"],
+                receiver_components["profile_id"]
+            ]
+        )
+
+        email_actions_components["templates_list"].select(
+            email_actions_components["load_template"],
+            inputs=[
+                email_actions_components["t_name"],
+                email_actions_components["t_type"],
+                email_actions_components["t_subject"],
+                email_actions_components["t_body"],
+                email_actions_components["t_id"]
+            ],
+            outputs=[
+                email_actions_components["t_name"],
+                email_actions_components["t_type"],
+                email_actions_components["t_subject"],
+                email_actions_components["t_body"],
+                email_actions_components["t_id"]
+            ]
+        )
 
     app.launch()
 

chat.py

@@ -3,10 +3,33 @@
 # Implements the chat interface and message handling
 
 import gradio as gr
-from groq_client import get_ai_response
+import os
+import json
+import logging
+from groq import Groq
+from dotenv import load_dotenv
+
 from web_search import search_web
-from profile_management import get_profiles, create_profile, update_profile, delete_profile
-from email_actions import get_templates, create_template, update_template, delete_template
+from google_sheets_utils import (
+    get_or_create_spreadsheet,
+    get_profiles_from_sheet,
+    delete_profile_from_sheet,
+    get_profile_summaries,
+    get_template_summaries,
+    get_profile_by_id,
+    get_template_by_id,
+    save_profile,
+    update_profile_in_sheet,
+    delete_template_from_sheet,
+    save_template,
+    update_template,
+    generate_template_id,
+    generate_profile_id
+)
+from email_actions import get_templates
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 def load_system_prompt(filename):
     try:
@@ -18,13 +41,98 @@ def load_system_prompt(filename):
 def create_chat_interface(sender_summaries, receiver_summaries, template_summaries,
                           current_sender, current_receiver, current_template,
                           sender_components, receiver_components, email_actions_components):
-    main_system_prompt = load_system_prompt('system_prompt_main.txt')
-    function_call_prompt = load_system_prompt('system_prompt_function_call.txt')
+    system_prompt = load_system_prompt('system_prompt.txt')
     
     chatbot = gr.Chatbot()
     msg = gr.Textbox()
     clear = gr.Button("Clear")
 
+    # Global spreadsheet variable
+    global spreadsheet
+    spreadsheet = get_or_create_spreadsheet()
+    
+    # Initialize Groq client
+    load_dotenv()  # Load environment variables from .env file
+    groq_api_key = os.getenv('GROQ_API_KEY')
+    if not groq_api_key:
+        logger.error("GROQ_API_KEY not found in environment variables")
+        raise ValueError("GROQ_API_KEY not found in environment variables")
+    client = Groq(api_key=groq_api_key)
+    model = "llama3-groq-70b-8192-tool-use-preview"
+
+    # Define available functions (tools) for the assistant
+    def get_profile_summaries_tool(profile_type: str):
+        """Get summaries of profiles (Sender or Receiver)"""
+        return get_profile_summaries(spreadsheet.worksheet(profile_type), profile_type)
+
+    def get_template_summaries_tool():
+        """Get summaries of email templates"""
+        return get_template_summaries(spreadsheet)
+
+    def get_profile_by_id_tool(profile_type: str, profile_id: str):
+        """Get a specific profile by ID"""
+        return get_profile_by_id(spreadsheet.worksheet(profile_type), profile_id)
+
+    def get_template_by_id_tool(template_id: str):
+        """Get a specific template by ID"""
+        return get_template_by_id(spreadsheet.worksheet("Email Templates"), template_id)
+
+    def create_profile_tool(profile_type: str, name: str, email: str, position: str, company: str, context: str):
+        """Create a new profile"""
+        return save_profile(spreadsheet.worksheet(profile_type), [profile_type, generate_profile_id(), name, email, position, company, context])
+
+    def update_profile_tool(profile_type: str, profile_id: str, name: str, email: str, position: str, company: str, context: str):
+        """Update an existing profile"""
+        return update_profile_in_sheet(spreadsheet.worksheet(profile_type), profile_id, [profile_type, profile_id, name, email, position, company, context])
+
+    def delete_profile_tool(profile_type: str, profile_id: str):
+        """Delete a profile"""
+        return delete_profile_from_sheet(spreadsheet.worksheet(profile_type), profile_id)
+
+    def create_template_tool(name: str, template_type: str, subject: str, body: str):
+        """Create a new email template"""
+        return save_template(spreadsheet.worksheet("Email Templates"), generate_template_id(), name, template_type, subject, body)
+
+    def update_template_tool(template_id: str, name: str, template_type: str, subject: str, body: str):
+        """Update an existing email template"""
+        return update_template(spreadsheet.worksheet("Email Templates"), template_id, name, template_type, subject, body)
+
+    def delete_template_tool(template_id: str):
+        """Delete an email template"""
+        return delete_template_from_sheet(spreadsheet.worksheet("Email Templates"), template_id)
+
+    # Map function names to actual functions
+    available_functions = {
+        "get_profile_summaries": get_profile_summaries_tool,
+        "get_template_summaries": get_template_summaries_tool,
+        "get_profile_by_id": get_profile_by_id_tool,
+        "get_template_by_id": get_template_by_id_tool,
+        "create_profile": create_profile_tool,
+        "update_profile": update_profile_tool,
+        "delete_profile": delete_profile_tool,
+        "create_template": create_template_tool,
+        "update_template": update_template_tool,
+        "delete_template": delete_template_tool,
+        "search_web": search_web,
+    }
+
+    # Define functions (tools) for the assistant to use
+    tools = []
+    for func_name, func in available_functions.items():
+        tool = {
+            "type": "function",
+            "function": {
+                "name": func_name,
+                "description": func.__doc__ or "",
+                "parameters": {
+                    "type": "object",
+                    "properties": {},  # Parameters will be auto-inferred or can be explicitly defined
+                    "required": []
+                },
+            },
+        }
+        tools.append(tool)
+
     def get_context():
         context = "Current context:\n"
         
@@ -41,53 +149,75 @@ def create_chat_interface(sender_summaries, receiver_summaries, template_summari
         
         return context
 
-    def execute_function(function_call):
-        # Implementation of function execution based on the function call
-        # This should handle all the functions mentioned in the system prompt
-        function_name = function_call.split('(')[0].strip()
-        args = [arg.strip().strip("'\"") for arg in function_call.split('(')[1].split(')')[0].split(',')]
-        
-        if function_name == 'load_sender_profile':
-            current_sender.value = args[0]
-            return f"Loaded sender profile: {args[0]}"
-        elif function_name == 'load_receiver_profile':
-            current_receiver.value = args[0]
-            return f"Loaded receiver profile: {args[0]}"
-        elif function_name == 'load_template':
-            current_template.value = args[0]
-            return f"Loaded template: {args[0]}"
-        # Add more function implementations as needed
-        
-        return "Function not implemented"
+    # Initialize chat history
+    chat_history = []
 
-    def respond(message, chat_history):
+    def respond(user_input, history):
         context = get_context()
         
-        main_ai_response = get_ai_response(message, main_system_prompt, context + "\n".join([f"{m[0]}: {m[1]}" for m in chat_history]))
-        
-        if "Action required:" in main_ai_response:
-            action_context = main_ai_response.split("Action required:")[1].strip()
-            function_call_response = get_ai_response(action_context, function_call_prompt)
-            
-            if function_call_response.startswith('[SEARCH:'):
-                search_query = function_call_response[8:-1].strip()
-                result = "\n".join(search_web(search_query))
-            elif function_call_response.startswith('[FUNCTION:'):
-                function_call = function_call_response[10:-1].strip()
-                result = execute_function(function_call)
-            else:
-                result = "Invalid backend response"
-            
-            final_response = get_ai_response(
-                f"Previous context: {action_context}\n\nAction result: {result}\n\nPlease continue the conversation with the user based on this result.",
-                main_system_prompt,
-                "\n".join([f"{m[0]}: {m[1]}" for m in chat_history])
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "system", "content": context}
+        ]
+        # Append conversation history
+        for human_msg, ai_msg in history:
+            messages.append({"role": "user", "content": human_msg})
+            messages.append({"role": "assistant", "content": ai_msg})
+        # Append latest user input
+        messages.append({"role": "user", "content": user_input})
+
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            tools=tools,
+            tool_choice="auto",
+            max_tokens=512  # Adjust as needed
+        )
+
+        response_message = response.choices[0].message
+
+        # Check if the assistant made any tool calls
+        if hasattr(response_message, 'tool_calls') and response_message.tool_calls:
+            # Process each tool call
+            for tool_call in response_message.tool_calls:
+                function_name = tool_call.function.name
+                function_args = json.loads(tool_call.function.arguments)
+                function_to_call = available_functions.get(function_name)
+
+                if function_to_call:
+                    # Call the function with arguments
+                    function_response = function_to_call(**function_args)
+
+                    # Add the function response to the messages
+                    messages.append({
+                        "role": "tool",
+                        "content": json.dumps(function_response),
+                        "tool_call_id": tool_call.id,
+                    })
+                else:
+                    # If function not found, add an error message
+                    messages.append({
+                        "role": "tool",
+                        "content": json.dumps({"error": f"Function {function_name} not found."}),
+                        "tool_call_id": tool_call.id,
+                    })
+
+            # Send the updated messages back to the model for final response
+            response = client.chat.completions.create(
+                model=model,
+                messages=messages,
+                tools=tools,
+                tool_choice="auto",
+                max_tokens=512
             )
-        else:
-            final_response = main_ai_response
+            response_message = response.choices[0].message
+
+        assistant_response = response_message.content
+
+        # Update chat history
+        history.append((user_input, assistant_response))
 
-        chat_history.append((message, final_response))
-        return "", chat_history
+        return "", history
 
     msg.submit(respond, [msg, chatbot], [msg, chatbot])
     clear.click(lambda: None, None, chatbot, queue=False)

email_actions.py

@@ -1,98 +1,187 @@
 # email_actions.py
 # Filepath: ai-email-assistant/email_actions.py
-# Manages email-related actions (drafting, templating)
+# Handles email template management and actions
 
+import logging
 import gradio as gr
-from google_sheets_utils import get_templates, save_template, delete_template_from_sheet
+from google_sheets_utils import get_templates_from_sheet, save_template, delete_template_from_sheet, generate_template_id, update_template_in_sheet
 
-def get_template_summaries(sheet):
-    templates = get_templates(sheet)
-    return [template[2] for template in templates]  # Assuming the name is in the third column
+logger = logging.getLogger(__name__)
 
-def create_email_actions_interface(template_sheet, current_template):
-    with gr.Group():
+def get_templates(spreadsheet):
+    try:
+        return get_templates_from_sheet(spreadsheet.worksheet("Email Templates"))
+    except Exception as e:
+        logger.error(f"Error fetching templates: {str(e)}")
+        return []
+
+def get_template_summaries(spreadsheet):
+    templates = get_templates_from_sheet(spreadsheet.worksheet("Email Templates"))
+    return [f"{template['Name']} ({template['Type']})" for template in templates]
+
+def create_email_actions_interface(spreadsheet, current_template):
+    worksheet = spreadsheet.worksheet("Email Templates")
+    
+    with gr.Blocks() as email_actions_block:
         gr.Markdown("## Email Actions")
         
-        name = gr.Textbox(label="Template Name")
-        subject = gr.Textbox(label="Subject")
-        content = gr.Textbox(label="Content", lines=10)
-        sender_profile = gr.Dropdown(label="Sender Profile")
-        receiver_profile = gr.Dropdown(label="Receiver Profile")
+        t_name = gr.Textbox(label="Template Name", elem_id="t_name")
+        t_type = gr.Dropdown(
+            ["Cold Email", "Follow-up", "Thank You", "Other"], 
+            label="Template Type", 
+            allow_custom_value=True,
+            elem_id="t_type"
+        )
+        t_subject = gr.Textbox(label="Subject", elem_id="t_subject")
+        t_body = gr.Textbox(label="Body", lines=5, elem_id="t_body")
+        t_id = gr.Textbox(label="Template ID", interactive=False, elem_id="t_id")
         
-        save_draft_btn = gr.Button("Save as Draft")
-        save_template_btn = gr.Button("Save as Template")
+        headers = ["Type", "ID", "Name", "Subject", "Body"]
         
         templates_list = gr.Dataframe(
-            headers=["Type", "ID", "Name", "Subject", "Content", "Sender Profile", "Receiver Profile"],
-            label="Existing Templates",
-            value=get_templates(template_sheet),
-            interactive=False
+            headers=headers,
+            label="Email Templates List",
+            interactive=False,
+            elem_id="t_templates_list"
         )
-
-        load_template_btn = gr.Button("Load Selected Template")
-        delete_template_btn = gr.Button("Delete Selected Template")
-
-        def save_template_action():
-            template_data = {
-                "name": name.value,
-                "subject": subject.value,
-                "content": content.value,
-                "sender_profile": sender_profile.value,
-                "receiver_profile": receiver_profile.value
-            }
-            save_template(template_sheet, template_data)
-            return get_templates(template_sheet)
-
-        def load_template(evt: gr.SelectData):
-            if evt.value:
-                selected_template = templates_list.value[evt.index[0]]
-                current_template.value = selected_template[2]  # Set the current template to the selected name
+        
+        save_btn = gr.Button("Save New Template", elem_id="t_save_btn")
+        update_btn = gr.Button("Update Existing Template", elem_id="t_update_btn")
+        delete_btn = gr.Button("Delete Template", elem_id="t_delete_btn")
+        clear_btn = gr.Button("Clear Fields", elem_id="t_clear_btn")
+        
+        def refresh_templates():
+            templates = get_templates(spreadsheet)
+            return [[template.get(h, "") for h in headers] for template in templates]
+        
+        def load_template(evt: gr.SelectData, current_name, current_type, current_subject, current_body, current_id):
+            templates = get_templates(spreadsheet)
+            selected_row = evt.index[0]
+            selected_template = templates[selected_row]
+            
+            logger.debug(f"Selected Email Template: {selected_template}")
+            
+            # Check if ANY field is non-empty
+            fields = [current_name, current_type, current_subject, current_body, current_id]
+            non_empty_fields = any(field and field.strip() != "" for field in fields)
+            
+            logger.debug(f"Any email template field non-empty: {non_empty_fields}")
+            
+            if non_empty_fields:
+                logger.warning("Email template fields not empty, showing warning")
+                gr.Warning("Please clear all fields before loading a new email template.")
+                return [gr.update() for _ in range(5)]  # Don't update any fields
+            
+            logger.info("Loading selected email template")
+            try:
                 return (
-                    selected_template[2],  # Name
-                    selected_template[3],  # Subject
-                    selected_template[4],  # Content
-                    selected_template[5],  # Sender Profile
-                    selected_template[6],  # Receiver Profile
+                    selected_template["Name"],
+                    selected_template["Type"],
+                    selected_template["Subject"],
+                    selected_template["Body"],
+                    selected_template["ID"]
                 )
-            return [gr.update() for _ in range(5)]
-
-        def delete_template(evt: gr.SelectData):
-            if evt.value:
-                template_id = templates_list.value[evt.index[0]][1]
-                delete_template_from_sheet(template_sheet, template_id)
-                return get_templates(template_sheet)
-            return templates_list.value
-
-        save_template_btn.click(save_template_action, outputs=[templates_list])
-        load_template_btn.click(load_template, outputs=[name, subject, content, sender_profile, receiver_profile])
-        delete_template_btn.click(delete_template, outputs=[templates_list])
-
-        refresh_btn = gr.Button("Refresh Templates")
-        refresh_btn.click(lambda: get_templates(template_sheet), outputs=[templates_list])
+            except KeyError as e:
+                logger.error(f"Error loading template: missing key {e}")
+                gr.Error(f"Error loading template: missing information")
+                return [gr.update() for _ in range(5)]
 
-    return name, subject, content, sender_profile, receiver_profile, save_draft_btn, save_template_btn, templates_list, load_template_btn, delete_template_btn, refresh_btn
-
-# Implement create_template, update_template, delete_template functions
-def create_template(sheet, name, subject, content, sender_profile, receiver_profile):
-    template_data = {
-        "name": name,
-        "subject": subject,
-        "content": content,
-        "sender_profile": sender_profile,
-        "receiver_profile": receiver_profile
-    }
-    return save_template(sheet, template_data)
-
-def update_template(sheet, template_id, name, subject, content, sender_profile, receiver_profile):
-    template_data = {
-        "id": template_id,
-        "name": name,
-        "subject": subject,
-        "content": content,
-        "sender_profile": sender_profile,
-        "receiver_profile": receiver_profile
-    }
-    return save_template(sheet, template_data)
+        def save_template_action(name, template_type, subject, body):
+            # Check for empty fields
+            if not name or not template_type or not subject or not body:
+                message = gr.HTML("<p style='color:red;'>All fields are required. Please fill in all details before saving.</p>")
+                return gr.update(), message, refresh_templates()
+            
+            new_id = generate_template_id()
+            template_data = [
+                "Email Templates",  # Type
+                new_id,             # ID
+                name,
+                template_type,
+                subject,
+                body
+            ]
+            result = save_template(worksheet, template_data)
+            if result:
+                message = gr.HTML("<p style='color:green;'>Template added successfully.</p>")
+            else:
+                message = gr.HTML("<p style='color:red;'>Failed to add template.</p>")
+            return gr.update(), message, refresh_templates()
+        
+        def update_template_action(template_id, name, template_type, subject, body):
+            # Check for empty fields
+            if not template_id:
+                message = gr.HTML("<p style='color:red;'>No template selected. Please select a template to update.</p>")
+                return gr.update(), message, refresh_templates()
+            if not name or not template_type or not subject or not body:
+                message = gr.HTML("<p style='color:red;'>All fields are required. Please fill in all details before updating.</p>")
+                return gr.update(), message, refresh_templates()
+            
+            updated_data = [
+                "Email Templates",  # Type
+                template_id,
+                name,
+                template_type,
+                subject,
+                body
+            ]
+            result = update_template_in_sheet(worksheet, template_id, updated_data)
+            if result:
+                message = gr.HTML("<p style='color:green;'>Template updated successfully.</p>")
+            else:
+                message = gr.HTML("<p style='color:red;'>Failed to update template.</p>")
+            return gr.update(), message, refresh_templates()
+        
+        def delete_template_action(template_id):
+            if not template_id:
+                message = gr.HTML("<p style='color:red;'>No template selected. Please select a template to delete.</p>")
+                return message, refresh_templates()
+            
+            result = delete_template_from_sheet(worksheet, template_id)
+            if result:
+                message = gr.HTML("<p style='color:green;'>Template deleted successfully.</p>")
+            else:
+                message = gr.HTML("<p style='color:red;'>Failed to delete template.</p>")
+            return message, refresh_templates()
+        
+        def clear_fields():
+            return [""] * 5  # Clear all 5 fields
 
-def delete_template(sheet, template_id):
-    return delete_template_from_sheet(sheet, template_id)
+        save_btn.click(
+            save_template_action,
+            inputs=[t_name, t_type, t_subject, t_body],
+            outputs=[templates_list]
+        )
+        update_btn.click(
+            update_template_action,
+            inputs=[t_id, t_name, t_type, t_subject, t_body],
+            outputs=[templates_list]
+        )
+        delete_btn.click(
+            delete_template_action,
+            inputs=[t_id],
+            outputs=[templates_list]
+        )
+        clear_btn.click(clear_fields, outputs=[t_name, t_type, t_subject, t_body, t_id])
+        templates_list.select(
+            load_template,
+            inputs=[t_name, t_type, t_subject, t_body, t_id],
+            outputs=[t_name, t_type, t_subject, t_body, t_id]
+        )
+        
+        # Refresh templates on component creation
+        templates_list.value = refresh_templates()
+        
+    # Return a dictionary containing the block and required components/functions
+    return {
+        "block": email_actions_block,
+        "templates_list": templates_list,
+        "t_name": t_name,
+        "t_type": t_type,
+        "t_subject": t_subject,
+        "t_body": t_body,
+        "t_id": t_id,
+        "refresh_templates": refresh_templates,
+        "load_template": load_template,
+        # Add other components or functions you need to access
+    }

google_sheets_utils.py

@@ -2,147 +2,269 @@
 # Filepath: ai-email-assistant/google_sheets_utils.py
 # Manages interactions with Google Sheets for profile and template storage
 
-import os
-import json
-from dotenv import load_dotenv
 import gspread
-from google.oauth2.service_account import Credentials
+import json
+import os
 import logging
+from google.oauth2.service_account import Credentials
+import uuid
+import time
+from google.auth.exceptions import TransportError
+from dotenv import load_dotenv
 
-# Set up logging
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Load environment variables
-load_dotenv()
-
-# Setup Google Sheets connection
-SCOPES = ['https://www.googleapis.com/auth/spreadsheets',
-          'https://www.googleapis.com/auth/drive']
-
-creds_json = os.environ.get('GOOGLE_SHEETS_CREDENTIALS_FILE')
-if not creds_json:
-    raise ValueError("GOOGLE_SHEETS_CREDENTIALS_FILE environment variable is not set")
-
-creds_dict = json.loads(creds_json)
-creds = Credentials.from_service_account_info(creds_dict, scopes=SCOPES)
-client = gspread.authorize(creds)
-
-# Open the Google Sheet (create it if it doesn't exist)
-try:
-    spreadsheet = client.open("AI Email Assistant")
-    logger.info("Successfully opened the spreadsheet.")
-except gspread.exceptions.SpreadsheetNotFound:
-    logger.info("Spreadsheet 'AI Email Assistant' not found. Creating a new one.")
-    spreadsheet = client.create("AI Email Assistant")
-    logger.info("New spreadsheet 'AI Email Assistant' created.")
-
-def initialize_sheet(sheet, headers, sample_data):
-    if not sheet.get_all_values():
-        sheet.append_row(headers)
-        for row in sample_data:
-            sheet.append_row(row)
-        logger.info(f"Initialized {sheet.title} with headers and sample data.")
-
-def connect_to_sheets():
+
+# Constants
+SCOPES = ['https://www.googleapis.com/auth/spreadsheets', 'https://www.googleapis.com/auth/drive']
+SPREADSHEET_NAME = "AI Email Assistant Data"
+WORKSHEET_NAMES = ["Sender Profiles", "Receiver Profiles", "Email Templates"]
+HEADERS = {
+    "Sender Profiles": ["Type", "ID", "Name", "Email", "Position", "Company", "Context"],
+    "Receiver Profiles": ["Type", "ID", "Name", "Email", "Position", "Company", "Context"],
+    "Email Templates": ["Type", "ID", "Name", "Subject", "Body"]
+}
+SAMPLE_DATA = {
+    "Sender Profiles": ["Sender Profile", "PROF_1", "John Doe", "john.doe@example.com", "Manager", "Example Corp", "Sample context for John Doe"],
+    "Receiver Profiles": ["Receiver Profile", "PROF_2", "Jane Smith", "jane.smith@example.com", "Developer", "Example Inc", "Sample context for Jane Smith"],
+    "Email Templates": ["Template", "TEMP_1", "Welcome Email", "Welcome to our service", "Hello, welcome to our service. We are glad to have you."]
+}
+
+def load_config():
+    load_dotenv()
+    return {
+        'google_sheets_credentials_file': os.getenv('GOOGLE_SHEETS_CREDENTIALS_FILE')
+    }
+
+def get_credentials():
+    config = load_config()
+    if not config:
+        return None
+    
+    creds_file = config.get('google_sheets_credentials_file')
+    if not creds_file:
+        logging.error("Google Sheets credentials file path not found in .env file")
+        return None
+    
     try:
-        sender_sheet = spreadsheet.worksheet("Sender Profiles")
-    except gspread.exceptions.WorksheetNotFound:
-        sender_sheet = spreadsheet.add_worksheet(title="Sender Profiles", rows="100", cols="20")
+        return Credentials.from_service_account_file(creds_file, scopes=SCOPES)
+    except Exception as e:
+        logging.error("Error creating credentials: %s", str(e))
+        return None
+
+def get_client():
+    creds = get_credentials()
+    if not creds:
+        logging.error("Failed to obtain credentials")
+        return None
+    return gspread.authorize(creds)
+
+def get_or_create_spreadsheet():
+    gc = get_client()
+    if not gc:
+        logging.error("Failed to get Google Sheets client")
+        return None
+    
+    max_retries = 3
+    retry_delay = 5  # seconds
+
+    for attempt in range(max_retries):
+        try:
+            sh = gc.open(SPREADSHEET_NAME)
+            logging.info(f"Opened existing spreadsheet: {SPREADSHEET_NAME}")
+            return sh
+        except gspread.SpreadsheetNotFound:
+            try:
+                sh = gc.create(SPREADSHEET_NAME)
+                logging.info(f"Created new spreadsheet: {SPREADSHEET_NAME}")
+                return sh
+            except Exception as e:
+                logging.error(f"Failed to create spreadsheet: {str(e)}")
+                return None
+        except (gspread.exceptions.APIError, TransportError) as e:
+            logging.error(f"API Error (attempt {attempt + 1}/{max_retries}): {str(e)}")
+            if attempt < max_retries - 1:
+                logging.info(f"Retrying in {retry_delay} seconds...")
+                time.sleep(retry_delay)
+            else:
+                logging.error("Max retries reached. Unable to connect to Google Sheets.")
+                return None
     
+    # Ensure all required worksheets exist
+    existing_worksheets = [worksheet.title for worksheet in sh.worksheets()]
+    for worksheet_name in WORKSHEET_NAMES:
+        if worksheet_name not in existing_worksheets:
+            try:
+                worksheet = sh.add_worksheet(title=worksheet_name, rows=1, cols=len(HEADERS[worksheet_name]))
+                worksheet.append_row(HEADERS[worksheet_name])
+                worksheet.append_row(SAMPLE_DATA[worksheet_name])
+                logging.info(f"Created worksheet: {worksheet_name}")
+            except Exception as e:
+                logging.error(f"Failed to create worksheet {worksheet_name}: {str(e)}")
+    
+    return sh
+
+def get_profiles_from_sheet(worksheet):
+    try:
+        records = worksheet.get_all_records()
+        return records
+    except Exception as e:
+        logging.error("Error getting profiles from worksheet: %s", str(e))
+        return []
+
+def save_profile(worksheet, profile_data):
+    try:
+        worksheet.append_row(profile_data)
+        logging.info("Profile saved successfully")
+        return True
+    except Exception as e:
+        logging.error("Error saving profile: %s", str(e))
+        return False
+
+def delete_profile_from_sheet(worksheet, profile_id):
+    try:
+        cell = worksheet.find(profile_id)
+        worksheet.delete_rows(cell.row)  # Use delete_rows instead of delete_row
+        logging.info(f"Profile {profile_id} deleted successfully")
+        return True
+    except Exception as e:
+        logging.error(f"Error deleting profile {profile_id}: {str(e)}")
+        return False
+
+def get_templates(worksheet):
+    try:
+        records = worksheet.get_all_records()
+        return records
+    except Exception as e:
+        logging.error(f"Error getting templates: {str(e)}")
+        return []
+
+def save_template(worksheet, template_id, name, template_type, subject, body):
+    try:
+        template_data = [template_type, template_id, name, subject, body]
+        worksheet.append_row(template_data)
+        logging.info(f"Template saved successfully with ID: {template_id}")
+        return f"Template saved successfully with ID: {template_id}"
+    except Exception as e:
+        logging.error(f"Error saving template: {str(e)}")
+        return f"Error saving template: {str(e)}"
+
+def delete_template_from_sheet(worksheet, template_id):
+    try:
+        cell = worksheet.find(template_id)
+        worksheet.delete_rows(cell.row)  # Use delete_rows instead of delete_row
+        logging.info(f"Template {template_id} deleted successfully")
+        return f"Template {template_id} deleted successfully"
+    except Exception as e:
+        logging.error(f"Error deleting template {template_id}: {str(e)}")
+        return f"Error deleting template {template_id}: {str(e)}"
+
+def update_profile_in_sheet(worksheet, profile_id, updated_data):
     try:
-        receiver_sheet = spreadsheet.worksheet("Receiver Profiles")
-    except gspread.exceptions.WorksheetNotFound:
-        receiver_sheet = spreadsheet.add_worksheet(title="Receiver Profiles", rows="100", cols="20")
+        cell = worksheet.find(profile_id)
+        for idx, value in enumerate(updated_data):
+            worksheet.update_cell(cell.row, idx + 1, value)
+        logging.info(f"Profile {profile_id} updated successfully")
+        return True
+    except Exception as e:
+        logging.error(f"Error updating profile {profile_id}: {str(e)}")
+        return False
+
+def get_templates_from_sheet(worksheet):
+    try:
+        # Get all records from the worksheet
+        records = worksheet.get_all_records()
+        
+        # Convert records to a list of dictionaries
+        templates = []
+        for record in records:
+            template = {
+                "Name": record.get("Name", ""),
+                "Type": record.get("Type", ""),
+                "ID": record.get("ID", ""),
+                "Subject": record.get("Subject", ""),
+                "Body": record.get("Body", "")
+            }
+            templates.append(template)
+        
+        return templates
     
+    except Exception as e:
+        print(f"An error occurred while fetching templates: {str(e)}")
+        return []
+
+def get_profile_summaries(worksheet, profile_type):
+    try:
+        profiles = worksheet.get_all_records()
+        return [f"{profile['Name']} ({profile_type})" for profile in profiles]
+    except Exception as e:
+        logging.error(f"Error getting profile summaries: {str(e)}")
+        return []
+
+def get_template_summaries(worksheet):
     try:
-        template_sheet = spreadsheet.worksheet("Email Templates")
-    except gspread.exceptions.WorksheetNotFound:
-        template_sheet = spreadsheet.add_worksheet(title="Email Templates", rows="100", cols="20")
-
-    # Initialize sheets with headers and sample data if they're empty
-    profile_headers = ["Type", "ID", "Name", "Email", "Position", "Company", "Context"]
-    sender_sample = [
-        ["Sender", "SEND_1", "John Doe", "john@example.com", "Sales Manager", "ABC Corp", "Professional"],
-        ["Sender", "SEND_2", "Jane Smith", "jane@example.com", "Marketing Director", "XYZ Inc", "Professional"]
-    ]
-    receiver_sample = [
-        ["Receiver", "REC_1", "Alice Johnson", "alice@example.com", "CEO", "123 Industries", "Professional"],
-        ["Receiver", "REC_2", "Bob Brown", "bob@example.com", "HR Manager", "456 Corp", "Professional"]
-    ]
-    initialize_sheet(sender_sheet, profile_headers, sender_sample)
-    initialize_sheet(receiver_sheet, profile_headers, receiver_sample)
-
-    template_headers = ["Type", "ID", "Name", "Subject", "Content", "Sender Profile", "Receiver Profile"]
-    template_sample = [
-        ["Template", "TEMP_1", "Sales Pitch", "Exciting Offer!", "Dear {receiver_name},\n\nWe have an exciting offer for {receiver_company}...", "John Doe", "Alice Johnson"],
-        ["Template", "TEMP_2", "Follow-up", "Following up on our meeting", "Hello {receiver_name},\n\nI hope this email finds you well. I wanted to follow up on our recent meeting...", "Jane Smith", "Bob Brown"]
-    ]
-    initialize_sheet(template_sheet, template_headers, template_sample)
-
-    logger.info("Successfully connected to all sheets.")
-    return sender_sheet, receiver_sheet, template_sheet
-
-def get_profiles_from_sheet(sheet):
-    data = sheet.get_all_values()
-    return data[1:]  # Exclude header row
-
-def save_profile(sheet, profile_data):
-    new_row = [
-        "Profile",
-        f"PROF_{sheet.row_count}",
-        profile_data['name'],
-        profile_data['email'],
-        profile_data['position'],
-        profile_data['company'],
-        profile_data['context']
-    ]
-    sheet.append_row(new_row)
-
-def delete_profile_from_sheet(sheet, profile_id):
-    cell = sheet.find(profile_id)
-    if cell:
-        sheet.delete_row(cell.row)
-
-def update_profile(sheet, profile_id, profile_data):
-    cell = sheet.find(profile_id)
-    if cell:
+        records = worksheet.get_all_records()
+        summaries = [{"Name": record["Name"], "ID": record["ID"]} for record in records]
+        return summaries
+    except Exception as e:
+        logging.error(f"Error getting template summaries: {str(e)}")
+        return []
+
+# Additional utility functions can be added here as needed
+
+def generate_template_id():
+    return f"TEMP_{uuid.uuid4().hex[:8].upper()}"
+
+def generate_profile_id():
+    return f"PROF_{uuid.uuid4().hex[:8].upper()}"
+
+def update_template(worksheet, template_id, name, template_type, subject, body):
+    try:
+        cell = worksheet.find(template_id)
         row = cell.row
-        sheet.update_cell(row, 3, profile_data['name'])
-        sheet.update_cell(row, 4, profile_data['email'])
-        sheet.update_cell(row, 5, profile_data['position'])
-        sheet.update_cell(row, 6, profile_data['company'])
-        sheet.update_cell(row, 7, profile_data['context'])
-
-def get_templates(sheet):
-    data = sheet.get_all_values()
-    return data[1:]  # Exclude header row
-
-def save_template(sheet, template_data):
-    new_row = [
-        "Template",
-        f"TEMP_{sheet.row_count}",
-        template_data['name'],
-        template_data['subject'],
-        template_data['content'],
-        template_data['sender_profile'],
-        template_data['receiver_profile']
-    ]
-    sheet.append_row(new_row)
-
-def delete_template_from_sheet(sheet, template_id):
-    cell = sheet.find(template_id)
-    if cell:
-        sheet.delete_row(cell.row)
+        worksheet.update(f'A{row}:E{row}', [[template_type, template_id, name, subject, body]])
+        logging.info(f"Template {template_id} updated successfully")
         return True
-    return False
+    except Exception as e:
+        logging.error(f"Error updating template {template_id}: {str(e)}")
+        return False
 
-def update_template(sheet, template_id, template_data):
-    cell = sheet.find(template_id)
-    if cell:
-        row = cell.row
-        sheet.update_cell(row, 3, template_data['name'])
-        sheet.update_cell(row, 4, template_data['subject'])
-        sheet.update_cell(row, 5, template_data['content'])
-        sheet.update_cell(row, 6, template_data['sender_profile'])
-        sheet.update_cell(row, 7, template_data['receiver_profile'])
+def get_profile_by_id(worksheet, profile_id):
+    try:
+        cell = worksheet.find(profile_id)
+        row = worksheet.row_values(cell.row)
+        profile_data = dict(zip(HEADERS[worksheet.title], row))
+        return profile_data
+    except Exception as e:
+        logging.error(f"Error fetching profile {profile_id}: {str(e)}")
+        return None
+
+def get_template_by_id(worksheet, template_id):
+    try:
+        cell = worksheet.find(template_id)
+        row = worksheet.row_values(cell.row)
+        template_data = dict(zip(HEADERS[worksheet.title], row))
+        return template_data
+    except Exception as e:
+        logging.error(f"Error fetching template {template_id}: {str(e)}")
+        return None
+
+def update_template_in_sheet(worksheet, template_id, updated_data):
+    try:
+        cell = worksheet.find(template_id)
+        for idx, value in enumerate(updated_data):
+            worksheet.update_cell(cell.row, idx + 1, value)
+        logging.info(f"Template {template_id} updated successfully")
+        return True
+    except Exception as e:
+        logging.error(f"Error updating template {template_id}: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    # Test the functions
+    print("Testing Google Sheets integration...")
+    sh = get_or_create_spreadsheet()
+    if sh:
+        print(f"Successfully connected to spreadsheet: {sh.title}")
+        print("Worksheets:", [worksheet.title for worksheet in sh.worksheets()])
+    else:
+        print("Failed to connect to Google Sheets")

groq_client.py

@@ -3,13 +3,18 @@
 # Interfaces with the Groq API for AI-powered responses
 
 import os
-from dotenv import load_dotenv
+import json
 from groq import Groq
+from dotenv import load_dotenv
 
-# Load environment variables
-load_dotenv()
+def load_config():
+    load_dotenv()
+    return {
+        'groq_api_key': os.getenv('GROQ_API_KEY')
+    }
 
-api_key = os.getenv('GROQ_API_KEY')
+config = load_config()
+api_key = config.get('groq_api_key')
 client = Groq(api_key=api_key) if api_key else None
 
 def set_api_key(api_key):
@@ -18,7 +23,7 @@ def set_api_key(api_key):
 
 def get_ai_response(message, system_prompt, context=""):
     if not client:
-        raise ValueError("Groq API key not set. Please check your .env file.")
+        raise ValueError("Groq API key not set. Please check your config.json file.")
 
     messages = [
         {"role": "system", "content": system_prompt},

profile_management.py

@@ -3,98 +3,169 @@
 # Handles sender and receiver profile management
 
 import gradio as gr
-from google_sheets_utils import get_profiles_from_sheet, save_profile, delete_profile_from_sheet
+from google_sheets_utils import (
+    get_profiles_from_sheet,
+    save_profile,
+    delete_profile_from_sheet,
+    update_profile_in_sheet,
+    generate_profile_id,
+)
+import logging
 
-def get_profile_summaries(sheet):
-    profiles = get_profiles_from_sheet(sheet)
-    return [profile[2] for profile in profiles]  # Assuming the name is in the third column
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
 
-def create_profile_management_interface(sheet, profile_type, current_profile):
-    with gr.Group():
-        gr.Markdown(f"## {profile_type} Profile Management")
+def create_profile_management_interface(spreadsheet, profile_type, current_profile):
+    with gr.Blocks() as profile_management_block:
+        gr.Markdown(f"## {profile_type} Management")
         
-        name = gr.Textbox(label="Name")
-        email = gr.Textbox(label="Email")
-        position = gr.Textbox(label="Position")
-        company = gr.Textbox(label="Company")
-        context = gr.Dropdown(["Professional", "Personal"], label="Context")
+        prefix = "s_" if profile_type == "Sender Profiles" else "r_"
+        
+        name = gr.Textbox(label="Name", elem_id=f"{prefix}name")
+        email = gr.Textbox(label="Email", elem_id=f"{prefix}email")
+        position = gr.Textbox(label="Position", elem_id=f"{prefix}position")
+        company = gr.Textbox(label="Company", elem_id=f"{prefix}company")
+        context = gr.Dropdown(["Professional", "Personal", "Other"], label="Context", allow_custom_value=True, elem_id=f"{prefix}context")
+        profile_id = gr.Textbox(label="Profile ID", interactive=False, elem_id=f"{prefix}profile_id")
+        
+        worksheet = spreadsheet.worksheet(profile_type)
+        
+        headers = ["Type", "ID", "Name", "Email", "Position", "Company", "Context"]
         
-        create_btn = gr.Button(f"Create {profile_type} Profile")
-
         profiles_list = gr.Dataframe(
-            headers=["Type", "ID", "Name", "Email", "Position", "Company", "Context"],
-            label=f"Existing {profile_type} Profiles",
-            value=get_profiles_from_sheet(sheet),
-            interactive=False
+            headers=headers,
+            label=f"{profile_type} List",
+            interactive=False,
+            elem_id=f"{prefix}profiles_list"
         )
-
-        delete_btn = gr.Button(f"Delete Selected {profile_type} Profile")
-        load_btn = gr.Button(f"Load Selected {profile_type} Profile")
-
-        def create_profile_action():
-            profile_data = {
-                "name": name.value,
-                "email": email.value,
-                "position": position.value,
-                "company": company.value,
-                "context": context.value
-            }
-            save_profile(sheet, profile_data)
-            return get_profiles_from_sheet(sheet)
-
-        def load_profile(evt: gr.SelectData):
-            if evt.value:
-                selected_profile = profiles_list.value[evt.index[0]]
-                current_profile.value = selected_profile[2]  # Set the current profile to the selected name
+        
+        add_btn = gr.Button("Add New Profile", elem_id=f"{prefix}add_btn")
+        update_btn = gr.Button("Update Existing Profile", elem_id=f"{prefix}update_btn")
+        delete_btn = gr.Button("Delete Profile", elem_id=f"{prefix}delete_btn")
+        clear_btn = gr.Button("Clear Fields", elem_id=f"{prefix}clear_btn")
+        
+        message_output = gr.HTML(elem_id=f"{prefix}message_output")
+        
+        def refresh_profiles():
+            profiles = get_profiles_from_sheet(worksheet)
+            return [[profile.get(h, "") for h in headers] for profile in profiles]
+        
+        def add_profile(name, email, position, company, context):
+            # Check for empty fields
+            if not name or not email or not position or not company or not context:
+                gr.Error("All fields are required. Please fill in all details before saving.")
+                return refresh_profiles()
+            new_id = generate_profile_id()
+            profile_data = [
+                profile_type,  # Type
+                new_id,        # ID
+                name,
+                email,
+                position,
+                company,
+                context
+            ]
+            result = save_profile(worksheet, profile_data)
+            message = gr.Info("Profile added successfully.") if result else gr.Error("Failed to add profile.")
+            return gr.update(), message, refresh_profiles()
+        
+        def update_profile(profile_id, name, email, position, company, context):
+            # Check for empty fields
+            if not profile_id:
+                return gr.update(), gr.Error("No profile selected. Please select a profile to update."), refresh_profiles()
+            if not name or not email or not position or not company or not context:
+                return gr.update(), gr.Error("All fields are required. Please fill in all details before updating."), refresh_profiles()
+            updated_data = [
+                profile_type,  # Type
+                profile_id,
+                name,
+                email,
+                position,
+                company,
+                context
+            ]
+            result = update_profile_in_sheet(worksheet, profile_id, updated_data)
+            message = gr.Info("Profile updated successfully.") if result else gr.Error("Failed to update profile.")
+            return gr.update(), message, refresh_profiles()
+        
+        def delete_profile(profile_id):
+            result = delete_profile_from_sheet(worksheet, profile_id)
+            gr.Info("Profile deleted successfully" if result else "Failed to delete profile")
+            return refresh_profiles()
+        
+        def clear_fields():
+            return [""] * 6  # Clear all 6 fields
+        
+        def load_profile(evt: gr.SelectData, current_name, current_email, current_position, 
+                         current_company, current_context, current_profile_id):
+            profiles = get_profiles_from_sheet(worksheet)
+            selected_row = evt.index[0]
+            selected_profile = profiles[selected_row]
+            
+            logger.debug(f"Selected {profile_type} Profile: {selected_profile}")
+            
+            # Check if ANY field (including profile_id) is non-empty
+            fields = [current_name, current_email, current_position, current_company, current_context, current_profile_id]
+            non_empty_fields = any(field and field.strip() != "" for field in fields)
+            
+            logger.debug(f"Any {profile_type} field non-empty: {non_empty_fields}")
+            
+            if non_empty_fields:
+                logger.warning(f"{profile_type} fields not empty, showing warning")
+                gr.Warning(f"Please clear all fields before loading a {profile_type[:-1]} profile.")
+                return [gr.update() for _ in range(6)]  # Don't update any fields
+            
+            logger.info(f"Loading selected {profile_type} profile")
+            try:
                 return (
-                    selected_profile[2],  # Name
-                    selected_profile[3],  # Email
-                    selected_profile[4],  # Position
-                    selected_profile[5],  # Company
-                    selected_profile[6],  # Context
+                    selected_profile["Name"],
+                    selected_profile["Email"],
+                    selected_profile["Position"],
+                    selected_profile["Company"],
+                    selected_profile["Context"],
+                    selected_profile["ID"]
                 )
-            return [gr.update() for _ in range(5)]
-
-        def delete_profile(evt: gr.SelectData):
-            if evt.value:
-                profile_id = profiles_list.value[evt.index[0]][1]
-                delete_profile_from_sheet(sheet, profile_id)
-                return get_profiles_from_sheet(sheet)
-            return profiles_list.value
-
-        create_btn.click(create_profile_action, outputs=[profiles_list])
-        load_btn.click(load_profile, outputs=[name, email, position, company, context])
-        delete_btn.click(delete_profile, outputs=[profiles_list])
-
-        refresh_btn = gr.Button(f"Refresh {profile_type} Profiles")
-        refresh_btn.click(lambda: get_profiles_from_sheet(sheet), outputs=[profiles_list])
-
-    return name, email, position, company, context, create_btn, profiles_list, delete_btn, load_btn, refresh_btn
-
-# Implement get_profiles, create_profile, update_profile, delete_profile functions
-def get_profiles(sheet):
-    return get_profiles_from_sheet(sheet)
-
-def create_profile(sheet, name, email, position, company, context):
-    profile_data = {
-        "name": name,
-        "email": email,
-        "position": position,
-        "company": company,
-        "context": context
-    }
-    return save_profile(sheet, profile_data)
-
-def update_profile(sheet, profile_id, name, email, position, company, context):
-    profile_data = {
-        "id": profile_id,
+            except KeyError as e:
+                logger.error(f"Error loading profile: missing key {e}")
+                gr.Error(f"Error loading profile: missing information")
+                return [gr.update() for _ in range(6)]
+        
+        # Attach event handlers
+        add_btn.click(
+            add_profile,
+            inputs=[name, email, position, company, context],
+            outputs=[message_output, profiles_list]
+        )
+        update_btn.click(
+            update_profile,
+            inputs=[profile_id, name, email, position, company, context],
+            outputs=[message_output, profiles_list]
+        )
+        delete_btn.click(
+            delete_profile,
+            inputs=[profile_id],
+            outputs=[profiles_list]
+        )
+        clear_btn.click(clear_fields, outputs=[name, email, position, company, context, profile_id])
+        profiles_list.select(
+            load_profile,
+            inputs=[name, email, position, company, context, profile_id],
+            outputs=[name, email, position, company, context, profile_id]
+        )
+        
+        # Refresh profiles on component creation
+        profiles_list.value = refresh_profiles()
+    
+    # Return a dictionary containing the block and required components/functions
+    return {
+        "block": profile_management_block,
         "name": name,
         "email": email,
         "position": position,
         "company": company,
-        "context": context
-    }
-    return save_profile(sheet, profile_data)
-
-def delete_profile(sheet, profile_id):
-    return delete_profile_from_sheet(sheet, profile_id)
+        "context": context,
+        "profile_id": profile_id,
+        "profiles_list": profiles_list,
+        "refresh_profiles": refresh_profiles,
+        "load_profile": load_profile,  # Add other components/functions as needed
+    }

requirements.txt

@@ -2,10 +2,16 @@
 # This file is autogenerated by pip-compile with Python 3.12
 # by the following command:
 #
-#    pip-compile
+#    pip-compile --output-file=requirements.txt requirements.in
 #
 aiofiles==23.2.1
     # via gradio
+aiohappyeyeballs==2.4.3
+    # via aiohttp
+aiohttp==3.10.9
+    # via langchain
+aiosignal==1.3.1
+    # via aiohttp
 annotated-types==0.7.0
     # via pydantic
 anyio==4.6.0
@@ -14,6 +20,8 @@ anyio==4.6.0
     #   groq
     #   httpx
     #   starlette
+attrs==24.2.0
+    # via aiohttp
 cachetools==5.5.0
     # via google-auth
 certifi==2024.8.30
@@ -48,6 +56,10 @@ filelock==3.16.1
     # via huggingface-hub
 fonttools==4.53.1
     # via matplotlib
+frozenlist==1.4.1
+    # via
+    #   aiohttp
+    #   aiosignal
 fsspec==2024.9.0
     # via
     #   gradio-client
@@ -63,8 +75,12 @@ gradio==4.44.0
     # via -r requirements.in
 gradio-client==1.3.0
     # via gradio
+greenlet==3.1.1
+    # via sqlalchemy
 groq==0.11.0
-    # via -r requirements.in
+    # via
+    #   -r requirements.in
+    #   langchain-groq
 gspread==6.1.2
     # via -r requirements.in
 h11==0.14.0
@@ -78,6 +94,7 @@ httpx==0.27.2
     #   gradio
     #   gradio-client
     #   groq
+    #   langsmith
 huggingface-hub==0.25.1
     # via
     #   gradio
@@ -87,12 +104,32 @@ idna==3.10
     #   anyio
     #   httpx
     #   requests
+    #   yarl
 importlib-resources==6.4.5
     # via gradio
 jinja2==3.1.4
     # via gradio
+jsonpatch==1.33
+    # via langchain-core
+jsonpointer==3.0.0
+    # via jsonpatch
 kiwisolver==1.4.7
     # via matplotlib
+langchain==0.3.0
+    # via -r requirements.in
+langchain-core==0.3.9
+    # via
+    #   langchain
+    #   langchain-groq
+    #   langchain-text-splitters
+langchain-groq==0.2.0
+    # via -r requirements.in
+langchain-text-splitters==0.3.0
+    # via langchain
+langsmith==0.1.131
+    # via
+    #   langchain
+    #   langchain-core
 markdown-it-py==3.0.0
     # via rich
 markupsafe==2.1.5
@@ -103,21 +140,29 @@ matplotlib==3.9.2
     # via gradio
 mdurl==0.1.2
     # via markdown-it-py
-numpy==2.1.1
+multidict==6.1.0
+    # via
+    #   aiohttp
+    #   yarl
+numpy==1.26.4
     # via
     #   contourpy
     #   gradio
+    #   langchain
     #   matplotlib
     #   pandas
 oauthlib==3.2.2
     # via requests-oauthlib
 orjson==3.10.7
-    # via gradio
+    # via
+    #   gradio
+    #   langsmith
 packaging==24.1
     # via
     #   gradio
     #   gradio-client
     #   huggingface-hub
+    #   langchain-core
     #   matplotlib
 pandas==2.2.3
     # via gradio
@@ -138,6 +183,9 @@ pydantic==2.9.2
     #   fastapi
     #   gradio
     #   groq
+    #   langchain
+    #   langchain-core
+    #   langsmith
 pydantic-core==2.23.4
     # via pydantic
 pydub==0.25.1
@@ -160,12 +208,19 @@ pyyaml==6.0.2
     # via
     #   gradio
     #   huggingface-hub
+    #   langchain
+    #   langchain-core
 requests==2.32.3
     # via
     #   huggingface-hub
+    #   langchain
+    #   langsmith
     #   requests-oauthlib
+    #   requests-toolbelt
 requests-oauthlib==2.0.0
     # via google-auth-oauthlib
+requests-toolbelt==1.0.0
+    # via langsmith
 rich==13.8.1
     # via typer
 rsa==4.9
@@ -183,8 +238,14 @@ sniffio==1.3.1
     #   anyio
     #   groq
     #   httpx
+sqlalchemy==2.0.35
+    # via langchain
 starlette==0.38.6
     # via fastapi
+tenacity==8.5.0
+    # via
+    #   langchain
+    #   langchain-core
 tomlkit==0.12.0
     # via gradio
 tqdm==4.66.5
@@ -198,8 +259,10 @@ typing-extensions==4.12.2
     #   gradio-client
     #   groq
     #   huggingface-hub
+    #   langchain-core
     #   pydantic
     #   pydantic-core
+    #   sqlalchemy
     #   typer
 tzdata==2024.1
     # via pandas
@@ -211,3 +274,5 @@ uvicorn==0.30.6
     # via gradio
 websockets==12.0
     # via gradio-client
+yarl==1.13.1
+    # via aiohttp

system_prompt.txt

@@ -1,65 +1,50 @@
-You are an AI-driven email assistant designed to help users generate and refine personalized emails for various scenarios, including professional and personal contexts. Your goal is to gather necessary information through natural conversation and then create tailored emails. Adapt your role based on the email type, switching between casual assistant and professional content generator as needed. Follow these guidelines:
-1. Initial Interaction:
-   - Greet the user warmly and briefly explain your purpose.
-   - Ask an open-ended question about the type of email they need help with.
-   - Example: "Hello! I'm here to help you craft the perfect email. What kind of email are you looking to write today?"
-2. Information Gathering:
-   - Based on the user's response, ask relevant follow-up questions to gather necessary details.
-   - Adapt your questions to various email scenarios, including:
-     a) Professional emails: sales pitch, follow-up, introduction, product launch, partnership proposal
-     b) Personal emails: friendly correspondence, family updates
-     c) Transactional emails: customer support, shipping information, order confirmation
-     d) Formal communications: complaint to a company, job application, resignation letter
-   - Keep questions concise and conversational.
-   - For professional emails, gather additional relevant information:
-     a) Sender's details: name, job title, company, industry
-     b) Recipient's details: name, job title, company (if known)
-     c) Specific purpose: e.g., introducing a new product, following up on a sales call
-     d) Key points: e.g., 3 main features of a product, unique selling propositions
-     e) Any prior communication or context
-     f) Call-to-action or desired outcome
-   - For personal or transactional emails, adjust questions accordingly to gather relevant details.
-3. Background Checklist:
-   - Maintain an internal checklist of essential information for different email types.
-   - Discreetly check off items as you gather information.
-   - If crucial information is missing, naturally work it into the conversation.
-4. Information Confirmation:
-   - Summarize the gathered information concisely.
-   - Ask if anything is missing or needs changing.
-5. Role Adaptation:
-   - Based on the email type, adapt your role:
-     a) For professional emails: Take on the role of a professional content generator. Use industry-specific language, maintain a formal tone, and focus on creating compelling, persuasive content.
-     b) For personal emails: Maintain a friendly, conversational tone and focus on personal details and emotional context.
-     c) For transactional emails: Adopt a clear, concise, and informative tone, ensuring all necessary details are included.
-6. Email Generation:
-   - Create a personalized draft based on the confirmed information and your adapted role.
-   - Ensure the email is appropriate for the specific scenario and recipient.
-   - For professional emails, incorporate:
-     a) A strong, attention-grabbing opening
-     b) Clear presentation of key points or features
-     c) Relevant data or statistics to support your message
-     d) A clear call-to-action
-   - For personal or transactional emails, focus on clarity, warmth, or informativeness as appropriate.
-7. Refinement and Feedback:
-   - Present the draft to the user.
-   - Ask for overall impressions and any specific areas needing adjustment.
-   - Offer to make changes based on feedback.
-8. Iterative Improvement:
-   - Make requested adjustments promptly.
-   - Continue refining until the user is satisfied.
-9. Final Touches:
-   - Suggest additions like professional signatures, legal disclaimers, or attachment reminders if appropriate.
-   - Perform a final check for clarity, grammar, coherence, and appropriateness for the intended audience.
-10. Completion and Next Steps:
-    - Present the final version.
-    - Offer to save as a template or start a new email if needed.
-11. Adaptability:
-    - Remember user preferences within the session.
-    - Adjust your approach based on the user's communication style and the email context.
-12. Clarity and Error Handling:
-    - If confused, ask for clarification naturally.
-    - Guide users clearly if they seem unsure about the process.
-13. Privacy Reminder:
-    - Tactfully remind users not to share sensitive personal information.
-    - Mention that information isn't stored between sessions.
-Always aim for clear, relevant, and engaging responses. Adapt your personality and language to match the user's tone and the email's purpose. Your goal is to make the email creation process smooth, efficient, and tailored to each unique situation, whether it's a high-stakes professional communication or a casual personal message.
+You are an AI Email Assistant designed to help users manage email profiles, create templates, and draft personalized emails for various scenarios. Your primary role is to engage in conversation, gather information, and guide users through the email creation process.
+
+In addition to conversing with the user, you have access to a set of backend functions (tools) that can perform specific actions such as managing profiles, templates, and performing web searches. When appropriate, you can use these tools to assist the user effectively.
+
+Key Responsibilities:
+1. Engage in natural conversation to understand user needs.
+2. Gather necessary information for email drafting.
+3. Determine when a backend action is necessary to fulfill the user's request.
+4. Use the available tools to perform backend actions when needed.
+5. Interpret and communicate results of backend actions to the user.
+6. Provide guidance on email structure and content.
+7. Offer suggestions and refinements for email drafts.
+
+Interaction Guidelines:
+1. **Identify when to use tools**: When the user requests an action that requires backend processing (e.g., saving a profile, fetching templates), use the appropriate tool.
+2. **Ask for user confirmation** before executing any action that modifies data (e.g., creating, updating, or deleting profiles/templates).
+3. **Use the exact tool names and parameters as specified.**
+4. **Communicate action results**: After using a tool, explain the outcome to the user in user-friendly terms.
+5. **Maintain a seamless conversation**, relating the action results to the user's original request.
+6. Always prioritize user privacy and obtain clear consent before any action that involves storing or retrieving user data.
+7. Maintain a helpful, friendly, and professional tone throughout the conversation.
+
+Available Tools:
+
+Profile Management:
+- get_profile_summaries(profile_type)
+  - `profile_type`: "Sender Profiles" or "Receiver Profiles"
+- get_profile_by_id(profile_type, profile_id)
+- create_profile(profile_type, name, email, position, company, context)
+- update_profile(profile_type, profile_id, name, email, position, company, context)
+- delete_profile(profile_type, profile_id)
+
+Template Management:
+- get_template_summaries()
+- get_template_by_id(template_id)
+- create_template(name, template_type, subject, body)
+- update_template(template_id, name, template_type, subject, body)
+- delete_template(template_id)
+
+Web Search:
+- search_web(query)
+
+Guidelines for Tools:
+1. Use the exact function names and parameters as specified above.
+2. Do not modify the function call syntax or add any additional text.
+3. Process the context provided and use the appropriate tool when necessary.
+4. Interpret the results of the tool and communicate them to the user in a natural, conversational manner.
+5. Do not engage in conversation or provide explanations about the function calls themselves.
+
+Remember: Your role is to assist the user effectively while maintaining a natural conversation flow. Use the tools when needed, but focus on understanding and addressing the user's needs in a helpful and friendly manner.