some

app.py

@@ -102,6 +102,16 @@ def analyze_and_update_single_repo(repo_id: str) -> Tuple[str, str, pd.DataFrame
         error_summary = f"Error analyzing repo: {e}"
         return "", error_summary, read_csv_to_dataframe()
 
+# --- NEW: Helper for Chat History Conversion ---
+def convert_messages_to_tuples(history: List[Dict[str, str]]) -> List[Tuple[str, str]]:
+    """Converts Gradio's 'messages' format to the old 'tuple' format for compatibility."""
+    tuple_history = []
+    # Assumes a strict user-assistant-user-assistant turn structure.
+    for i in range(0, len(history), 2):
+        if i + 1 < len(history) and history[i]['role'] == 'user' and history[i+1]['role'] == 'assistant':
+            tuple_history.append((history[i]['content'], history[i+1]['content']))
+    return tuple_history
+
 # --- Gradio UI ---
 
 def create_ui() -> gr.Blocks:
@@ -156,7 +166,7 @@ def create_ui() -> gr.Blocks:
             with gr.TabItem("3. Find Repos with AI", id="chatbot_tab"):
                 gr.Markdown("## Chat with an Assistant to Find Repositories")
                 chatbot = gr.Chatbot(
-                    value=[(None, CHATBOT_INITIAL_MESSAGE)],
+                    value=[{"role": "assistant", "content": CHATBOT_INITIAL_MESSAGE}],
                     label="Chat with Assistant",
                     height=400,
                     type="messages"
@@ -218,23 +228,36 @@ def create_ui() -> gr.Blocks:
 
             return content, summary, df, next_idx, status
 
-        def handle_user_message(user_message: str, history: List[List[str]]) -> Tuple[List[List[str]], str]:
-            """Handles sending a user message to the chatbot."""
-            history.append([user_message, None])
+        def handle_user_message(user_message: str, history: List[Dict[str, str]]) -> Tuple[List[Dict[str, str]], str]:
+            """Appends the user's message to the history, preparing for the bot's response."""
+            if user_message:
+                history.append({"role": "user", "content": user_message})
             return history, ""
 
-        def handle_bot_response(history: List[List[str]]) -> List[List[str]]:
-            """Generates and displays the bot's response."""
-            user_message = history[-1][0]
-            response = chat_with_user(user_message, history[:-1], CHATBOT_SYSTEM_PROMPT)
-            history[-1][1] = response
+        def handle_bot_response(history: List[Dict[str, str]]) -> List[Dict[str, str]]:
+            """Generates and appends the bot's response using the compatible history format."""
+            if not history or history[-1]["role"] != "user":
+                return history
+            
+            user_message = history[-1]["content"]
+            # Convert all messages *before* the last user message into tuples for the API
+            tuple_history_for_api = convert_messages_to_tuples(history[:-1])
+            
+            response = chat_with_user(user_message, tuple_history_for_api, CHATBOT_SYSTEM_PROMPT)
+            history.append({"role": "assistant", "content": response})
             return history
 
-        def handle_end_chat(history: List[List[str]]) -> Tuple[str, str]:
+        def handle_end_chat(history: List[Dict[str, str]]) -> Tuple[str, str]:
             """Ends the chat and extracts keywords from the conversation."""
             if not history:
                 return "", "Status: Chat is empty, nothing to analyze."
-            keywords_str = extract_keywords_from_conversation(history)
+            
+            # Convert the full, valid history for the extraction logic
+            tuple_history = convert_messages_to_tuples(history)
+            if not tuple_history:
+                return "", "Status: No completed conversations to analyze."
+                
+            keywords_str = extract_keywords_from_conversation(tuple_history)
             status = "Status: Keywords extracted. You can now use them to search."
             return keywords_str, status
 

chatbot_page.py

@@ -69,29 +69,46 @@ def extract_keywords_from_conversation(history):
 
 with gr.Blocks() as chatbot_demo:
     gr.Markdown("## Repo Recommendation Chatbot")
-    chatbot = gr.Chatbot()
+    chatbot = gr.Chatbot(type="messages", label="Chatbot")
     # Initial assistant message only
     initial_message = "Hello! Please tell me about your ideal Hugging Face repo. What use case, preferred language, or features are you looking for?"
-    state = gr.State([["", initial_message]])  # Only the initial assistant message
+    state = gr.State([{"role": "assistant", "content": initial_message}])
     user_input = gr.Textbox(label="Your message", placeholder="Describe your ideal repo or answer the assistant's questions...")
     send_btn = gr.Button("Send")
     end_btn = gr.Button("End Chat and Extract Keywords")
     keywords_output = gr.Textbox(label="Extracted Keywords for Repo Search", interactive=False)
 
-    def user_send(user_message, history):
-        assistant_reply = chat_with_user(user_message, history)
-        history = history + [[user_message, assistant_reply]]
-        return history, history, ""
+    def user_send(user_message, history_messages):
+        # Add user message to the UI
+        history_messages.append({"role": "user", "content": user_message})
+        
+        # Convert to tuple format for the API call
+        tuple_history = []
+        for i in range(0, len(history_messages) -1, 2): # Exclude the last user message
+             if i + 1 < len(history_messages):
+                tuple_history.append((history_messages[i]['content'], history_messages[i+1]['content']))
 
-    def end_chat(history):
-        keywords = extract_keywords_from_conversation(history)
+        # Get bot response and add to UI
+        assistant_reply = chat_with_user(user_message, tuple_history)
+        history_messages.append({"role": "assistant", "content": assistant_reply})
+        
+        return history_messages, ""
+
+    def end_chat(history_messages):
+        # Convert to tuple format for the API call
+        tuple_history = []
+        for i in range(0, len(history_messages), 2):
+            if i + 1 < len(history_messages):
+                tuple_history.append((history_messages[i]['content'], history_messages[i+1]['content']))
+        
+        keywords = extract_keywords_from_conversation(tuple_history)
         return keywords
 
     # Reset state to initial message when chatbot page is loaded
     def reset_chat_state():
-        return [["", initial_message]]
+        return [{"role": "assistant", "content": initial_message}]
 
-    send_btn.click(user_send, inputs=[user_input, state], outputs=[chatbot, state, user_input])
+    send_btn.click(user_send, inputs=[user_input, state], outputs=[chatbot, user_input])
     end_btn.click(end_chat, inputs=state, outputs=keywords_output)
     chatbot_demo.load(reset_chat_state, inputs=None, outputs=state)