Refactor session picker to radio with label and value pairs; fix rename and delete reliability.

Switch the session picker back to a Radio component using (label, value) pairs. Each entry shows the chat title and part of its key, but the radio's value is the full key. refresh_sessions builds these pairs and selects the active key. load_session now directly receives the selected key. This ensures that renaming a chat updates the sidebar correctly and deleting a chat switches to the next one without issues.

app.py

@@ -478,12 +478,21 @@ Chat with the assistant to brainstorm your course idea. Use the panel on the lef
     
     # Define layout with a sidebar for sessions and a main panel for chat
     with gr.Row():
+        # Sidebar: manage chat sessions. We use a Dropdown instead of a Radio to allow custom
+        # labels separate from the underlying chat keys. Each option will display the
+        # chat title with a short portion of its key, but the actual value will be the
+        # chat key itself. This makes renaming and deleting sessions more reliable.
         with gr.Column(scale=1, min_width=220):
-            session_picker = gr.Radio(label="Your Chats", choices=[], interactive=True)
+            # Use a Radio component for session selection. Each choice will be a tuple
+            # (label, value) where label is the human-readable title and value is
+            # the underlying chat key. The value returned when a choice is
+            # selected will be the chat key, which we can use to load the session.
+            session_picker = gr.Radio(label="Your Chats", choices=[], value=None, interactive=True)
             new_chat_btn = gr.Button("New Chat")
             rename_input = gr.Textbox(label="Rename chat", placeholder="New title", lines=1)
             rename_btn = gr.Button("Rename")
             delete_btn = gr.Button("Delete Chat")
+        # Main panel: chat, outline and generation actions
         with gr.Column(scale=4):
             chatbot = gr.Chatbot(label="Conversation", height=400)
             msg_input = gr.Textbox(
@@ -502,57 +511,53 @@ Chat with the assistant to brainstorm your course idea. Use the panel on the lef
         """Refresh the list of chat sessions for the sidebar.
 
         Each chat will be displayed by its title (or "Untitled" if none) followed by a short
-        portion of its key in parentheses. The actual radio choice value will be this
-        formatted string so that we can extract the chat key later on when the user
-        selects a session. The currently active chat will be pre-selected.
+        portion of its key in parentheses. The actual value of each dropdown choice will be
+        the full chat key, while the displayed label will be this formatted string. The
+        currently active chat key will be selected when possible.
 
         Returns:
-            A gradio update for the ``session_picker`` radio component.
+            A gradio update for the ``session_picker`` dropdown component.
         """
         chats = list_chats()
-        choices = []
-        current_label = None
+        # Build a list of (label, value) tuples for the Radio. Each label shows
+        # the chat title and a short portion of the key, while the value is the
+        # full chat key. When a user selects an option, the value (chat key)
+        # will be returned.
+        options: list[tuple[str, str]] = []
         current_key = state_chat_key.value
+        selected_key = None
         for c in chats:
             title = c.get("title") or "Untitled"
             key = c.get("key")
-            # Build a display label that includes a short portion of the key so it
-            # remains unique even if multiple chats share the same title.
             label = f"{title} ({key[:8]})"
-            choices.append(label)
+            options.append((label, key))
             if key == current_key:
-                current_label = label
-        # If the current chat isn't found (e.g. after deletion), select the first chat
-        if not current_label and choices:
-            current_label = choices[0]
-        return gr.update(choices=choices, value=current_label)
+                selected_key = key
+        # If current chat not found (e.g. after deletion), pick the first one
+        if not selected_key and options:
+            selected_key = options[0][1]
+        return gr.update(choices=options, value=selected_key)
 
     # Load the selected chat into memory and return display pairs/history
-    def load_session(selected_value):
+    def load_session(selected_key):
         """Load a chat session when selected in the sidebar.
 
-        The session_picker returns a formatted label that includes the chat key in
-        parentheses. Extract the chat key from this label and then load the
-        conversation messages from the database. The chat history and pair lists
-        are reconstructed for display in the Chatbot, while sources, plan and
-        resource_cache are reset.
+        The session_picker dropdown returns the chat key directly. Load the
+        conversation messages from the database and reconstruct the history and
+        pairs for display. Sources, plan and resource_cache are reset.
 
         Args:
-            selected_value: The radio selection value from session_picker, which is
-                a string like ``"Title (abcdef12)"``. If None, returns empty state.
+            selected_key: The chat key selected from the dropdown. If None,
+                returns empty state.
 
         Returns:
             Tuple of (chatbot_pairs, chat_history, chat_pairs, sources, plan, resource_cache).
         """
-        if not selected_value:
+        if not selected_key:
             return [], [], [], [], "", {}
-        # Extract the chat key from the label. It is enclosed in parentheses at the end.
-        key = selected_value
-        if "(" in selected_value and selected_value.endswith(")"):
-            key = selected_value[selected_value.rfind("(") + 1 : -1]
         # Update the global state for the current chat key
-        state_chat_key.value = key
-        msgs = load_chat(key)
+        state_chat_key.value = selected_key
+        msgs = load_chat(selected_key)
         history = []
         pairs = []
         buffer = []