Update app.py

app.py

@@ -68,23 +68,26 @@ def load_initial_greeting(filepath="greeting_prompt.txt") -> str:
         logger.warning(f"Warning: Prompt file '{filepath}' not found.")
         return "Welcome to DIYO! I'm here to help you create amazing DIY projects. What would you like to build today?"
 
-async def chat_fn(user_input: str, history: dict, input_graph_state: dict, uuid: UUID, prompt: str, search_enabled: bool, download_website_text_enabled: bool):
+async def chat_fn(user_input: str, history: list, input_graph_state: dict, uuid: UUID, prompt: str, search_enabled: bool, download_website_text_enabled: bool):
     """
-    Chat function that handles both 'messages' and 'tuples' format for compatibility
+    Chat function that works with tuples format for maximum compatibility
     
     Args:
         user_input (str): The user's input message
-        history (dict): The history of the conversation in gradio (format depends on chatbot type)
-        input_graph_state (dict): The current state of the graph. This includes tool call history
+        history (list): The history of the conversation in tuples format [(user_msg, bot_msg), ...]
+        input_graph_state (dict): The current state of the graph
         uuid (UUID): The unique identifier for the current conversation
         prompt (str): The system prompt
     Yields:
-        str: The output message
-        dict|Any: The final state of the graph
-        bool|Any: Whether to trigger follow up questions
+        list: Updated history in tuples format
+        dict: The final state of the graph
+        bool: Whether to trigger follow up questions
     """
     try:
         logger.info(f"Processing user input: {user_input[:100]}...")
+        logger.info(f"History format: {type(history)}, length: {len(history) if history else 0}")
+        if history:
+            logger.info(f"Sample history entry: {history[0] if len(history) > 0 else 'None'}")
         
         # Initialize input_graph_state if None
         if input_graph_state is None:
@@ -97,8 +100,16 @@ async def chat_fn(user_input: str, history: dict, input_graph_state: dict, uuid:
         if prompt:
             input_graph_state["prompt"] = prompt
 
+        # Convert tuples history to internal messages format for graph processing
+        if not isinstance(history, list):
+            history = []
+
+        # Convert history to messages format for graph processing
+        internal_messages = convert_from_tuples_format(history)
+        logger.info(f"Converted {len(history)} tuples to {len(internal_messages)} internal messages")
+
         if input_graph_state.get("awaiting_human_input"):
-            input_graph_state["messages"].append(
+            internal_messages.append(
                 ToolMessage(
                     tool_call_id=input_graph_state.pop("human_assistance_tool_id"),
                     content=user_input
@@ -107,12 +118,12 @@ async def chat_fn(user_input: str, history: dict, input_graph_state: dict, uuid:
             input_graph_state["awaiting_human_input"] = False
         else:
             # New user message
-            if "messages" not in input_graph_state:
-                input_graph_state["messages"] = []
-            input_graph_state["messages"].append(
+            internal_messages.append(
                 HumanMessage(user_input[:USER_INPUT_MAX_LENGTH])
             )
-            input_graph_state["messages"] = input_graph_state["messages"][-TRIM_MESSAGE_LENGTH:]
+
+        # Store internal messages in graph state
+        input_graph_state["messages"] = internal_messages[-TRIM_MESSAGE_LENGTH:]
 
         config = RunnableConfig(
             recursion_limit=20,
@@ -121,8 +132,12 @@ async def chat_fn(user_input: str, history: dict, input_graph_state: dict, uuid:
         )
 
         output: str = ""
-        final_state: dict | Any = {}
+        final_state: dict = {}
         waiting_output_seq: list[str] = []
+        
+        # Add user message to history immediately
+        updated_history = history + [(user_input, "")]
+        logger.info(f"Updated history length: {len(updated_history)}")
 
         async for stream_mode, chunk in graph.astream(
                     input_graph_state,
@@ -140,12 +155,17 @@ async def chat_fn(user_input: str, history: dict, input_graph_state: dict, uuid:
                             if tool_name == "tavily_search_results_json":
                                 query = msg_tool_call['args']['query']
                                 waiting_output_seq.append(f"🔍 Searching for '{query}'...")
-                                yield "\n".join(waiting_output_seq), gr.skip(), gr.skip()
+                                # Update the last tuple with current status
+                                if updated_history:
+                                    updated_history[-1] = (user_input, "\n".join(waiting_output_seq))
+                                yield updated_history, gr.skip(), gr.skip()
 
                             elif tool_name == "download_website_text":
                                 url = msg_tool_call['args']['url']
                                 waiting_output_seq.append(f"📥 Downloading text from '{url}'...")
-                                yield "\n".join(waiting_output_seq), gr.skip(), gr.skip()
+                                if updated_history:
+                                    updated_history[-1] = (user_input, "\n".join(waiting_output_seq))
+                                yield updated_history, gr.skip(), gr.skip()
 
                             elif tool_name == "human_assistance":
                                 query = msg_tool_call["args"]["query"]
@@ -155,13 +175,17 @@ async def chat_fn(user_input: str, history: dict, input_graph_state: dict, uuid:
                                 final_state["awaiting_human_input"] = True
                                 final_state["human_assistance_tool_id"] = msg_tool_call["id"]
 
-                                # Indicate that human input is needed
-                                yield "\n".join(waiting_output_seq), final_state, True
+                                # Update history and indicate that human input is needed
+                                if updated_history:
+                                    updated_history[-1] = (user_input, "\n".join(waiting_output_seq))
+                                yield updated_history, final_state, True
                                 return  # Pause execution, resume in next call
 
                             else:
                                 waiting_output_seq.append(f"🔧 Running {tool_name}...")
-                                yield "\n".join(waiting_output_seq), gr.skip(), gr.skip()
+                                if updated_history:
+                                    updated_history[-1] = (user_input, "\n".join(waiting_output_seq))
+                                yield updated_history, gr.skip(), gr.skip()
 
             elif stream_mode == "messages":
                 msg, metadata = chunk
@@ -180,20 +204,30 @@ async def chat_fn(user_input: str, history: dict, input_graph_state: dict, uuid:
 
                     if current_chunk_text:
                         output += current_chunk_text
-                        yield output, gr.skip(), gr.skip()
+                        # Update the last tuple with accumulated output
+                        if updated_history:
+                            updated_history[-1] = (user_input, output)
+                        yield updated_history, gr.skip(), gr.skip()
 
         # Final yield with complete response
-        yield output + " ", dict(final_state), True
+        if updated_history:
+            updated_history[-1] = (user_input, output + " ")
+        logger.info(f"Final response: {output[:100]}...")
+        yield updated_history, dict(final_state), True
         
     except Exception as e:
         logger.exception("Exception occurred in chat_fn")
-        user_error_message = "There was an error processing your request. Please try again."
-        yield user_error_message, gr.skip(), False
+        error_message = "There was an error processing your request. Please try again."
+        if not isinstance(history, list):
+            history = []
+        error_history = history + [(user_input, error_message)]
+        yield error_history, gr.skip(), False
 
 
 def convert_to_tuples_format(messages_list):
     """Convert messages format to tuples format for older Gradio versions"""
     if not isinstance(messages_list, list):
+        logger.warning(f"Expected list for messages conversion, got {type(messages_list)}")
         return []
         
     tuples = []
@@ -221,23 +255,29 @@ def convert_to_tuples_format(messages_list):
     if user_msg is not None:
         tuples.append((user_msg, ""))
     
+    logger.info(f"Converted {len(messages_list)} messages to {len(tuples)} tuples")
     return tuples
 
 
 def convert_from_tuples_format(tuples_list):
     """Convert tuples format to messages format"""
     if not isinstance(tuples_list, list):
+        logger.warning(f"Expected list for tuples conversion, got {type(tuples_list)}")
         return []
         
     messages = []
     for item in tuples_list:
         if isinstance(item, tuple) and len(item) == 2:
             user_msg, assistant_msg = item
-            if user_msg:
+            if user_msg and user_msg.strip():
                 messages.append({"role": "user", "content": user_msg})
-            if assistant_msg:
+            if assistant_msg and assistant_msg.strip():
                 messages.append({"role": "assistant", "content": assistant_msg})
+        elif isinstance(item, dict):
+            # Already in messages format
+            messages.append(item)
     
+    logger.info(f"Converted {len(tuples_list)} tuples to {len(messages)} messages")
     return messages
 
 def clear():
@@ -248,25 +288,29 @@ class FollowupQuestions(BaseModel):
     """Model for langchain to use for structured output for followup questions"""
     questions: list[str]
 
-async def populate_followup_questions(end_of_chat_response: bool, messages: dict[str, str], uuid: UUID):
+async def populate_followup_questions(end_of_chat_response: bool, history: list, uuid: UUID):
     """
-    This function gets called a lot due to the asynchronous nature of streaming
-    Only populate followup questions if streaming has completed and the message is coming from the assistant
+    Generate followup questions based on chat history in tuples format
+    
+    Args:
+        end_of_chat_response (bool): Whether the chat response has ended
+        history (list): Chat history in tuples format [(user, bot), ...]
+        uuid (UUID): Session UUID
     """
-    if not end_of_chat_response or not messages or len(messages) == 0:
+    if not end_of_chat_response or not history or len(history) == 0:
         return *[gr.skip() for _ in range(FOLLOWUP_QUESTION_NUMBER)], False
     
-    # Convert tuples format to messages format if needed
-    if isinstance(messages, list) and len(messages) > 0:
-        if isinstance(messages[0], tuple):
-            # Convert from tuples to messages format
-            messages = convert_from_tuples_format(messages)
-    
-    # Check if the last message is from assistant
-    if not messages or (isinstance(messages[-1], dict) and messages[-1].get("role") != "assistant"):
+    # Check if the last tuple has a bot response
+    if not history[-1][1]:  # No bot response in the last tuple
         return *[gr.skip() for _ in range(FOLLOWUP_QUESTION_NUMBER)], False
         
     try:
+        # Convert tuples format to messages format for LLM processing
+        messages = convert_from_tuples_format(history)
+        
+        if not messages:
+            return *[gr.skip() for _ in range(FOLLOWUP_QUESTION_NUMBER)], False
+        
         config = RunnableConfig(
             run_name="populate_followup_questions",
             configurable={"thread_id": str(uuid)}
@@ -292,26 +336,21 @@ async def populate_followup_questions(end_of_chat_response: bool, messages: dict
         logger.error(f"Error generating followup questions: {e}")
         return *[gr.Button(visible=False) for _ in range(FOLLOWUP_QUESTION_NUMBER)], False
 
-async def summarize_chat(end_of_chat_response: bool, messages: dict, sidebar_summaries: dict, uuid: UUID):
-    """Summarize chat for tab names"""
+async def summarize_chat(end_of_chat_response: bool, history: list, sidebar_summaries: dict, uuid: UUID):
+    """Summarize chat for tab names using tuples format"""
     should_return = (
         not end_of_chat_response or
-        not messages or
-        len(messages) == 0 or
+        not history or
+        len(history) == 0 or
+        not history[-1][1] or  # No bot response in last tuple
         isinstance(sidebar_summaries, type(lambda x: x)) or
         uuid in sidebar_summaries
     )
     if should_return:
         return gr.skip(), gr.skip()
 
-    # Convert tuples format to messages format if needed
-    if isinstance(messages, list) and len(messages) > 0:
-        if isinstance(messages[0], tuple):
-            messages = convert_from_tuples_format(messages)
-
-    # Check if the last message is from assistant
-    if not messages or (isinstance(messages[-1], dict) and messages[-1].get("role") != "assistant"):
-        return gr.skip(), gr.skip()
+    # Convert tuples format to messages format for processing
+    messages = convert_from_tuples_format(history)
 
     # Filter valid messages
     filtered_messages = []
@@ -346,58 +385,40 @@ async def summarize_chat(end_of_chat_response: bool, messages: dict, sidebar_sum
     
     return sidebar_summaries, False
 
-async def new_tab(uuid, gradio_graph, messages, tabs, prompt, sidebar_summaries):
+async def new_tab(uuid, gradio_graph, history, tabs, prompt, sidebar_summaries):
     """Create a new chat tab"""
     new_uuid = uuid4()
     new_graph = {}
     
     # Save current tab if it has content
-    if messages and len(messages) > 0:
+    if history and len(history) > 0:
         if uuid not in sidebar_summaries:
-            sidebar_summaries, _ = await summarize_chat(True, messages, sidebar_summaries, uuid)
+            sidebar_summaries, _ = await summarize_chat(True, history, sidebar_summaries, uuid)
         tabs[uuid] = {
             "graph": gradio_graph,
-            "messages": messages,
+            "messages": history,  # Store history as-is (tuples format)
             "prompt": prompt,
         }
     
     # Clear suggestion buttons
     suggestion_buttons = [gr.Button(visible=False) for _ in range(FOLLOWUP_QUESTION_NUMBER)]
     
-    # Load initial greeting for new chat
+    # Load initial greeting for new chat in tuples format
     greeting_text = load_initial_greeting()
-    
-    # Determine format based on current chatbot configuration
-    # Check if we're using tuples format (older Gradio) or messages format
-    try:
-        # Try to detect the format from existing messages
-        uses_tuples_format = True
-        if messages and len(messages) > 0:
-            if isinstance(messages[0], dict) and "role" in messages[0]:
-                uses_tuples_format = False
-        
-        if uses_tuples_format:
-            new_chat_messages_for_display = [(None, greeting_text)]
-        else:
-            new_chat_messages_for_display = [{"role": "assistant", "content": greeting_text}]
-            
-    except Exception as e:
-        logger.warning(f"Error determining chat format: {e}")
-        # Default to tuples format for older Gradio
-        new_chat_messages_for_display = [(None, greeting_text)]
+    new_chat_history = [(None, greeting_text)]
     
     new_prompt = prompt if prompt else "You are a helpful DIY assistant."
     
-    return new_uuid, new_graph, new_chat_messages_for_display, tabs, new_prompt, sidebar_summaries, *suggestion_buttons
+    return new_uuid, new_graph, new_chat_history, tabs, new_prompt, sidebar_summaries, *suggestion_buttons
 
-def switch_tab(selected_uuid, tabs, gradio_graph, uuid, messages, prompt):
+def switch_tab(selected_uuid, tabs, gradio_graph, uuid, history, prompt):
     """Switch to a different chat tab"""
     try:
         # Save current state if there are messages
-        if messages and len(messages) > 0:
+        if history and len(history) > 0:
             tabs[uuid] = {
                 "graph": gradio_graph if gradio_graph else {},
-                "messages": messages,
+                "messages": history,  # Store history as-is (tuples format)
                 "prompt": prompt
             }
 
@@ -407,12 +428,12 @@ def switch_tab(selected_uuid, tabs, gradio_graph, uuid, messages, prompt):
             
         selected_tab_state = tabs[selected_uuid]
         selected_graph = selected_tab_state.get("graph", {})
-        selected_messages = selected_tab_state.get("messages", [])
+        selected_history = selected_tab_state.get("messages", [])  # This should be tuples format
         selected_prompt = selected_tab_state.get("prompt", "You are a helpful DIY assistant.")
         
         suggestion_buttons = [gr.Button(visible=False) for _ in range(FOLLOWUP_QUESTION_NUMBER)]
         
-        return selected_graph, selected_uuid, selected_messages, tabs, selected_prompt, *suggestion_buttons
+        return selected_graph, selected_uuid, selected_history, tabs, selected_prompt, *suggestion_buttons
         
     except Exception as e:
         logger.error(f"Error switching tabs: {e}")
@@ -420,11 +441,11 @@ def switch_tab(selected_uuid, tabs, gradio_graph, uuid, messages, prompt):
 
 def delete_tab(current_chat_uuid, selected_uuid, sidebar_summaries, tabs):
     """Delete a chat tab"""
-    output_messages = gr.skip()
+    output_history = gr.skip()
     
     # If deleting the current tab, clear the chatbot
     if current_chat_uuid == selected_uuid:
-        output_messages = []
+        output_history = []  # Empty tuples list
         
     # Remove from storage
     if selected_uuid in tabs:
@@ -432,7 +453,7 @@ def delete_tab(current_chat_uuid, selected_uuid, sidebar_summaries, tabs):
     if selected_uuid in sidebar_summaries:
         del sidebar_summaries[selected_uuid]
         
-    return sidebar_summaries, tabs, output_messages
+    return sidebar_summaries, tabs, output_history
 
 def submit_edit_tab(selected_uuid, sidebar_summaries, text):
     """Submit edited tab name"""
@@ -730,12 +751,17 @@ if __name__ == "__main__":
                 # Check parameter availability without creating test instance
                 init_params = gr.Chatbot.__init__.__code__.co_varnames
                 
-                # Always try to set type="messages" to avoid the deprecation warning
+                # For older Gradio versions, don't try to set type parameter
+                # Let it default to 'tuples' format to avoid compatibility issues
                 if 'type' in init_params:
-                    chatbot_kwargs["type"] = "messages"
-                    logger.info("Using 'messages' type for chatbot")
+                    # Try to set type, but if it fails, let it default
+                    try:
+                        chatbot_kwargs["type"] = "tuples"  # Use tuples for maximum compatibility
+                        logger.info("Using 'tuples' type for chatbot (compatibility mode)")
+                    except:
+                        logger.warning("Could not set chatbot type, using default")
                 else:
-                    logger.warning("Chatbot 'type' parameter not supported, will use deprecated 'tuples' format")
+                    logger.info("Chatbot 'type' parameter not supported, using default 'tuples' format")
                 
                 # Check if 'show_copy_button' parameter is supported  
                 if 'show_copy_button' in init_params:
@@ -937,10 +963,10 @@ if __name__ == "__main__":
             else:
                 logger.warning("ChatInterface 'additional_outputs' not supported - some features may be limited")
             
-            # Check if 'type' parameter is supported
+            # Use tuples format to match the Chatbot for compatibility
             if 'type' in init_params:
-                chat_interface_kwargs["type"] = "messages"
-                logger.info("Added type='messages' to ChatInterface")
+                chat_interface_kwargs["type"] = "tuples"
+                logger.info("Added type='tuples' to ChatInterface (matching Chatbot format)")
                 
             # Check if 'multimodal' parameter is supported
             if 'multimodal' in init_params:
@@ -981,20 +1007,13 @@ if __name__ == "__main__":
                         if not message.strip():
                             return history, "", graph_state
                             
-                        # Add user message
+                        # Add user message in tuples format
                         if not isinstance(history, list):
                             history = []
                             
-                        # Use tuples format for older Gradio
-                        history.append((message, "Processing..."))
-                        
-                        # TODO: Integrate with your actual graph processing here
-                        # For now, provide a simple response
+                        # Create response tuple
                         response = f"Manual chat mode: {message} (ChatInterface not available in this Gradio version)"
-                        
-                        # Update the last tuple with the response
-                        if history:
-                            history[-1] = (message, response)
+                        history.append((message, response))
                         
                         return history, "", graph_state
                     except Exception as e:
@@ -1045,7 +1064,7 @@ if __name__ == "__main__":
         def clear_current_chat():
             """Clear the current chat and reset state"""
             new_state, new_uuid = clear()
-            # Clear followup buttons
+            # Clear followup buttons and return empty tuples list
             cleared_buttons = [gr.Button(visible=False) for _ in range(FOLLOWUP_QUESTION_NUMBER)]
             return [], new_state, new_uuid, *cleared_buttons
         
@@ -1164,17 +1183,11 @@ if __name__ == "__main__":
                     if not isinstance(existing_chat_history, list):
                         existing_chat_history = []
                     
-                    # Detect format and add greeting accordingly
-                    if existing_chat_history and isinstance(existing_chat_history[0], tuple):
-                        # Tuples format
-                        greeting_entry = (None, greeting_message_text)
-                    else:
-                        # Messages format
-                        greeting_entry = {"role": "assistant", "content": greeting_message_text}
-                        
+                    # Always use tuples format for compatibility
+                    greeting_entry = (None, greeting_message_text)
                     updated_chat_history = [greeting_entry] + existing_chat_history
                     updated_is_new_user_flag = False
-                    logger.info("Greeting added for new user.")
+                    logger.info("Greeting added for new user (tuples format).")
                     return updated_chat_history, updated_is_new_user_flag
                 else:
                     logger.info("Not a new user or already greeted.")
@@ -1183,10 +1196,10 @@ if __name__ == "__main__":
                     return existing_chat_history, False
 
             @demo.load(inputs=[chatbot_message_storage], outputs=[chatbot])
-            def load_messages(messages):
+            def load_messages(history):
                 """Load stored messages into chatbot"""
-                if isinstance(messages, list):
-                    return messages
+                if isinstance(history, list):
+                    return history
                 return []
 
             @demo.load(inputs=[current_prompt_state], outputs=[prompt_textbox])
@@ -1201,7 +1214,7 @@ if __name__ == "__main__":
             def load_initial_greeting():
                 """Load initial greeting for users without BrowserState"""
                 greeting_text = load_initial_greeting()
-                # Use tuples format for older Gradio versions without BrowserState
+                # Use tuples format for maximum compatibility
                 return [(None, greeting_text)]
 
     # Launch the application