Update app.py

app.py

@@ -70,11 +70,13 @@ def load_initial_greeting(filepath="greeting_prompt.txt") -> str:
 
 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):
     """
+    Chat function that handles both 'messages' and 'tuples' format for compatibility
+    
     Args:
         user_input (str): The user's input message
-        history (dict): The history of the conversation in gradio
+        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
-        uuid (UUID): The unique identifier for the current conversation. This can be used in conjunction with langgraph or for memory
+        uuid (UUID): The unique identifier for the current conversation
         prompt (str): The system prompt
     Yields:
         str: The output message
@@ -188,6 +190,56 @@ async def chat_fn(user_input: str, history: dict, input_graph_state: dict, uuid:
         user_error_message = "There was an error processing your request. Please try again."
         yield user_error_message, 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):
+        return []
+        
+    tuples = []
+    user_msg = None
+    
+    for msg in messages_list:
+        if isinstance(msg, dict):
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+            
+            if role == "user":
+                user_msg = content
+            elif role == "assistant":
+                if user_msg is not None:
+                    tuples.append((user_msg, content))
+                    user_msg = None
+                else:
+                    # Assistant message without user message, add empty user message
+                    tuples.append((None, content))
+        elif isinstance(msg, tuple) and len(msg) == 2:
+            # Already in tuple format
+            tuples.append(msg)
+    
+    # If there's a hanging user message, add it with empty assistant response
+    if user_msg is not None:
+        tuples.append((user_msg, ""))
+    
+    return tuples
+
+
+def convert_from_tuples_format(tuples_list):
+    """Convert tuples format to messages format"""
+    if not isinstance(tuples_list, list):
+        return []
+        
+    messages = []
+    for item in tuples_list:
+        if isinstance(item, tuple) and len(item) == 2:
+            user_msg, assistant_msg = item
+            if user_msg:
+                messages.append({"role": "user", "content": user_msg})
+            if assistant_msg:
+                messages.append({"role": "assistant", "content": assistant_msg})
+    
+    return messages
+
 def clear():
     """Clear the current conversation state"""
     return dict(), uuid4()
@@ -204,8 +256,14 @@ async def populate_followup_questions(end_of_chat_response: bool, messages: dict
     if not end_of_chat_response or not messages or len(messages) == 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 messages[-1]["role"] != "assistant":
+    if not messages or (isinstance(messages[-1], dict) and messages[-1].get("role") != "assistant"):
         return *[gr.skip() for _ in range(FOLLOWUP_QUESTION_NUMBER)], False
         
     try:
@@ -240,13 +298,21 @@ async def summarize_chat(end_of_chat_response: bool, messages: dict, sidebar_sum
         not end_of_chat_response or
         not messages or
         len(messages) == 0 or
-        messages[-1]["role"] != "assistant" or
         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()
+
     # Filter valid messages
     filtered_messages = []
     for msg in messages:
@@ -300,7 +366,25 @@ async def new_tab(uuid, gradio_graph, messages, tabs, prompt, sidebar_summaries)
     
     # Load initial greeting for new chat
     greeting_text = load_initial_greeting()
-    new_chat_messages_for_display = [{"role": "assistant", "content": greeting_text}]
+    
+    # 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_prompt = prompt if prompt else "You are a helpful DIY assistant."
     
@@ -461,6 +545,18 @@ if __name__ == "__main__":
     else:
         print("💾 Using persistent browser state (data persists after refresh)")
     
+    # Log available Gradio components for debugging
+    available_components = []
+    for attr_name in dir(gr):
+        if attr_name[0].isupper() and not attr_name.startswith('_'):
+            available_components.append(attr_name)
+    
+    logger.info(f"Available Gradio components: {len(available_components)} components detected")
+    key_components = ['ChatInterface', 'Sidebar', 'BrowserState', 'MultimodalTextbox']
+    for component in key_components:
+        status = "✅" if hasattr(gr, component) else "❌"
+        logger.info(f"  {status} {component}")
+    
     print()  # Add spacing
     
     with gr.Blocks(title="DIYO - DIY Assistant", fill_height=True, css=CSS, elem_id="main-app") as demo:
@@ -639,7 +735,7 @@ if __name__ == "__main__":
                     chatbot_kwargs["type"] = "messages"
                     logger.info("Using 'messages' type for chatbot")
                 else:
-                    logger.warning("Chatbot 'type' parameter not supported, using default")
+                    logger.warning("Chatbot 'type' parameter not supported, will use deprecated 'tuples' format")
                 
                 # Check if 'show_copy_button' parameter is supported  
                 if 'show_copy_button' in init_params:
@@ -651,12 +747,8 @@ if __name__ == "__main__":
                     
             except Exception as e:
                 logger.warning(f"Error checking Chatbot parameters: {e}")
-                # Use minimal parameters as fallback, but try to set type to avoid warning
+                # Use minimal parameters as fallback
                 chatbot_kwargs = {"height": 400}
-                try:
-                    chatbot_kwargs["type"] = "messages"
-                except:
-                    pass
             
             chatbot = gr.Chatbot(**chatbot_kwargs)
             
@@ -812,41 +904,120 @@ if __name__ == "__main__":
         # Clear functionality - implement manually since chatbot.clear() is not available in older Gradio versions
         # We'll handle clearing through the clear chat button instead
         
-        # Main chat interface - with compatibility checks
+        # Main chat interface - with extensive compatibility checks
+        # Start with minimal required parameters
         chat_interface_kwargs = {
             "chatbot": chatbot,
             "fn": chat_fn,
-            "additional_inputs": [
-                current_langgraph_state,
-                current_uuid_state,
-                prompt_textbox,
-                checkbox_search_enabled,
-                checkbox_download_website_text,
-            ],
-            "additional_outputs": [
-                current_langgraph_state,
-                end_of_assistant_response_state
-            ],
             "textbox": textbox,
         }
         
         # Check if newer ChatInterface parameters are supported
         try:
             init_params = gr.ChatInterface.__init__.__code__.co_varnames
+            logger.info(f"ChatInterface supported parameters: {list(init_params)}")
+            
+            # Check each parameter individually
+            if 'additional_inputs' in init_params:
+                chat_interface_kwargs["additional_inputs"] = [
+                    current_langgraph_state,
+                    current_uuid_state,
+                    prompt_textbox,
+                    checkbox_search_enabled,
+                    checkbox_download_website_text,
+                ]
+                logger.info("Added additional_inputs to ChatInterface")
+                
+            if 'additional_outputs' in init_params:
+                chat_interface_kwargs["additional_outputs"] = [
+                    current_langgraph_state,
+                    end_of_assistant_response_state
+                ]
+                logger.info("Added additional_outputs to ChatInterface")
+            else:
+                logger.warning("ChatInterface 'additional_outputs' not supported - some features may be limited")
             
             # Check if 'type' parameter is supported
             if 'type' in init_params:
                 chat_interface_kwargs["type"] = "messages"
+                logger.info("Added type='messages' to ChatInterface")
                 
             # Check if 'multimodal' parameter is supported
             if 'multimodal' in init_params:
                 chat_interface_kwargs["multimodal"] = multimodal
+                logger.info(f"Added multimodal={multimodal} to ChatInterface")
                 
         except Exception as e:
             logger.warning(f"Error checking ChatInterface parameters: {e}")
             # Keep minimal parameters as fallback
         
-        chat_interface = gr.ChatInterface(**chat_interface_kwargs)
+        # Try to create ChatInterface with compatibility handling
+        try:
+            chat_interface = gr.ChatInterface(**chat_interface_kwargs)
+            logger.info("ChatInterface created successfully")
+        except TypeError as e:
+            logger.error(f"ChatInterface creation failed: {e}")
+            logger.info("Falling back to minimal ChatInterface configuration")
+            
+            # Fallback to absolute minimal configuration
+            try:
+                minimal_kwargs = {
+                    "chatbot": chatbot,
+                    "fn": lambda message, history: (message + " (processed)", history + [(message, message + " (processed)")]),
+                    "textbox": textbox,
+                }
+                chat_interface = gr.ChatInterface(**minimal_kwargs)
+                logger.warning("Using minimal ChatInterface - advanced features disabled")
+            except Exception as fallback_error:
+                logger.error(f"Even minimal ChatInterface failed: {fallback_error}")
+                # Create manual chat functionality as last resort
+                chat_interface = None
+                logger.info("Creating manual chat interface as fallback")
+                
+                # Manual chat submit function
+                def manual_chat_submit(message, history, graph_state, uuid_val, prompt, search_enabled, download_enabled):
+                    """Manual chat submission when ChatInterface is not available"""
+                    try:
+                        if not message.strip():
+                            return history, "", graph_state
+                            
+                        # Add user message
+                        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
+                        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)
+                        
+                        return history, "", graph_state
+                    except Exception as e:
+                        logger.error(f"Error in manual chat: {e}")
+                        if not isinstance(history, list):
+                            history = []
+                        history.append((message, f"Error: {str(e)}"))
+                        return history, "", graph_state
+                
+                # Set up manual chat button
+                textbox.submit(
+                    fn=manual_chat_submit,
+                    inputs=[
+                        textbox,
+                        chatbot,
+                        current_langgraph_state,
+                        current_uuid_state,
+                        prompt_textbox,
+                        checkbox_search_enabled,
+                        checkbox_download_website_text
+                    ],
+                    outputs=[chatbot, textbox, current_langgraph_state]
+                )
 
         # New chat button functionality
         new_chat_button.click(
@@ -894,15 +1065,34 @@ if __name__ == "__main__":
             buttons = [gr.Button(visible=False) for _ in range(len(followup_question_buttons))]
             return btn, *buttons
 
-        for btn in followup_question_buttons:
-            btn.click(
-                fn=click_followup_button,
-                inputs=[btn],
-                outputs=[
-                    chat_interface.textbox,
-                    *followup_question_buttons
-                ]
-            ).success(lambda: None, js=TRIGGER_CHATINTERFACE_BUTTON)
+        # Handle followup buttons based on whether ChatInterface is available
+        if chat_interface is not None:
+            for btn in followup_question_buttons:
+                try:
+                    btn.click(
+                        fn=click_followup_button,
+                        inputs=[btn],
+                        outputs=[
+                            chat_interface.textbox if hasattr(chat_interface, 'textbox') else textbox,
+                            *followup_question_buttons
+                        ]
+                    ).success(lambda: None, js=TRIGGER_CHATINTERFACE_BUTTON)
+                except Exception as e:
+                    logger.warning(f"Error setting up followup button: {e}")
+                    # Fallback to basic button functionality
+                    btn.click(
+                        fn=click_followup_button,
+                        inputs=[btn],
+                        outputs=[textbox, *followup_question_buttons]
+                    )
+        else:
+            logger.warning("ChatInterface not available - followup buttons will have limited functionality")
+            for btn in followup_question_buttons:
+                btn.click(
+                    fn=click_followup_button,
+                    inputs=[btn],
+                    outputs=[textbox, *followup_question_buttons]
+                )
 
         # Event handlers for chatbot changes - with compatibility checks
         def setup_change_handler(fn, inputs, outputs, trigger_mode=None):
@@ -970,10 +1160,17 @@ if __name__ == "__main__":
                 """Handle initial greeting when the app loads"""
                 if current_is_new_user_flag:
                     greeting_message_text = load_initial_greeting()
-                    greeting_entry = {"role": "assistant", "content": greeting_message_text}
                     
                     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}
                         
                     updated_chat_history = [greeting_entry] + existing_chat_history
                     updated_is_new_user_flag = False
@@ -1004,7 +1201,8 @@ if __name__ == "__main__":
             def load_initial_greeting():
                 """Load initial greeting for users without BrowserState"""
                 greeting_text = load_initial_greeting()
-                return [{"role": "assistant", "content": greeting_text}]
+                # Use tuples format for older Gradio versions without BrowserState
+                return [(None, greeting_text)]
 
     # Launch the application
     demo.launch(debug=True, share=True)