one more time

app.py

@@ -597,54 +597,24 @@ def process_two_videos(
 
 
 
-# Custom CSS for collapsible sidebar
-custom_css = """
-#sidebar-toggle {
-    position: sticky;
-    top: 10px;
-    z-index: 1000;
-    margin-bottom: 10px;
-}
-
-/* Make sidebar full height */
-.gradio-container .gradio-row:has(#sidebar-column) {
-    min-height: calc(100vh - 200px);
-}
-
-/* Smooth transition for sidebar (if supported) */
-#sidebar-column {
-    transition: width 0.3s ease;
-}
-"""
-
 # Create Gradio interface
 try:
     # Try with theme (Gradio 4.0+)
-    demo = gr.Blocks(title="RFM Evaluation Server", theme=gr.themes.Soft(), css=custom_css)
+    demo = gr.Blocks(title="RFM Evaluation Server", theme=gr.themes.Soft())
 except TypeError:
     # Fallback for older Gradio versions without theme support
-    try:
-        demo = gr.Blocks(title="RFM Evaluation Server", css=custom_css)
-    except TypeError:
-        # Even older versions may not support css parameter
-        demo = gr.Blocks(title="RFM Evaluation Server")
+    demo = gr.Blocks(title="RFM Evaluation Server")
 
 with demo:
-    # Header with title and toggle button
-    with gr.Row():
-        sidebar_toggle_btn = gr.Button("☰ Hide Sidebar", variant="secondary", size="sm", elem_id="sidebar-toggle", scale=0)
-        with gr.Column(scale=1):
-            gr.Markdown(
-                """
-                # RFM (Reward Foundation Model) Evaluation Server
-                """,
-                elem_id="main-title",
-            )
+    gr.Markdown(
+        """
+        # RFM (Reward Foundation Model) Evaluation Server
+        """
+    )
 
     # Hidden state to store server URL and model mapping (define before use)
     server_url_state = gr.State(value=None)
     model_url_mapping_state = gr.State(value={})  # Maps model_name -> server_url
-    sidebar_visible_state = gr.State(value=True)  # Track sidebar visibility
 
     # Function definitions for event handlers
     def discover_and_select_models(base_url: str):
@@ -727,812 +697,789 @@ with demo:
             server_url,
         )
 
-    # Toggle function for sidebar
-    def toggle_sidebar(visible):
-        """Toggle sidebar visibility."""
-        new_visible = not visible
-        button_text = "☰ Show Sidebar" if not new_visible else "☰ Hide Sidebar"
-        return (
-            new_visible,  # Update state
-            gr.update(visible=new_visible),  # Update sidebar visibility
-            gr.update(value=button_text),  # Update button text
+    # Use Gradio's built-in Sidebar component (collapsible by default)
+    with gr.Sidebar():
+        gr.Markdown("### 🔧 Model Configuration")
+        
+        base_url_input = gr.Textbox(
+            label="Base Server URL",
+            placeholder="http://40.119.56.66",
+            value="http://40.119.56.66",
+            interactive=True,
+        )
+        
+        discover_btn = gr.Button("🔍 Discover Models", variant="primary", size="lg")
+        
+        model_dropdown = gr.Dropdown(
+            label="Select Model",
+            choices=[],
+            value=None,
+            interactive=True,
+            info="Models will be discovered on ports 8000-8010",
+        )
+        
+        server_status = gr.Markdown(
+            "Click 'Discover Models' to find available models"
+        )
+        
+        gr.Markdown("---")
+        gr.Markdown("### 📋 Model Information")
+        model_info_display = gr.Markdown("")
+
+        # Event handlers for sidebar
+        discover_btn.click(
+            fn=discover_and_select_models,
+            inputs=[base_url_input],
+            outputs=[model_dropdown, server_status, model_info_display, server_url_state, model_url_mapping_state],
         )
 
-    # Main layout with sidebar and content area
-    with gr.Row():
-        # Sidebar for model selection and info (controlled by visibility state)
-        sidebar_column = gr.Column(scale=1, min_width=300, visible=True, elem_id="sidebar-column")
-        with sidebar_column:
-            gr.Markdown("### 🔧 Model Configuration")
-            
-            base_url_input = gr.Textbox(
-                label="Base Server URL",
-                placeholder="http://40.119.56.66",
-                value="http://40.119.56.66",
-                interactive=True,
-            )
-            
-            discover_btn = gr.Button("🔍 Discover Models", variant="primary", size="lg")
-            
-            model_dropdown = gr.Dropdown(
-                label="Select Model",
-                choices=[],
-                value=None,
-                interactive=True,
-                info="Models will be discovered on ports 8000-8010",
-            )
-            
-            server_status = gr.Markdown(
-                "Click 'Discover Models' to find available models",
-                visible=True,
-            )
-            
-            gr.Markdown("---")
-            gr.Markdown("### 📋 Model Information")
-            model_info_display = gr.Markdown("", visible=True)
-
-            # Event handlers for sidebar
-            discover_btn.click(
-                fn=discover_and_select_models,
-                inputs=[base_url_input],
-                outputs=[model_dropdown, server_status, model_info_display, server_url_state, model_url_mapping_state],
-            )
-
-            model_dropdown.change(
-                fn=on_model_selected,
-                inputs=[model_dropdown, model_url_mapping_state],
-                outputs=[server_status, model_info_display, server_url_state],
-            )
-
-        # Main content area with tabs
-        with gr.Column(scale=4):
-            with gr.Tabs():
-                with gr.Tab("Progress Prediction"):
-                    gr.Markdown("### Progress & Success Prediction")
-                    gr.Markdown("Upload a video or select one from a dataset to get progress predictions.")
-
-                    with gr.Row():
-                        with gr.Column():
-                            single_video_input = gr.Video(label="Upload Video", height=300)
-                            task_text_input = gr.Textbox(
-                                label="Task Description",
-                                placeholder="Describe the task (e.g., 'Pick up the red block')",
-                                value="Complete the task",
-                            )
-                            fps_input_single = gr.Slider(
-                                label="FPS (Frames Per Second)",
-                                minimum=0.1,
-                                maximum=10.0,
-                                value=1.0,
-                                step=0.1,
-                                info="Frames per second to extract from video (higher = more frames)",
-                            )
-                            analyze_single_btn = gr.Button("Analyze Video", variant="primary")
-
-                            gr.Markdown("---")
-                            gr.Markdown("**OR Select from Dataset**")
-                            gr.Markdown("---")
-
-                            with gr.Accordion("📁 Select from Dataset", open=False):
-                                dataset_name_single = gr.Dropdown(
-                                    choices=PREDEFINED_DATASETS,
-                                    value="jesbu1/oxe_rfm",
-                                    label="Dataset Name",
-                                    allow_custom_value=True,
-                                )
-                                config_name_single = gr.Dropdown(
-                                    choices=[], value="", label="Configuration Name", allow_custom_value=True
-                                )
-                                with gr.Row():
-                                    refresh_configs_btn = gr.Button("🔄 Refresh Configs", variant="secondary", size="sm")
-                                    load_dataset_btn = gr.Button("Load Dataset", variant="secondary", size="sm")
-
-                                dataset_status_single = gr.Markdown("", visible=False)
-                                with gr.Row():
-                                    prev_traj_btn = gr.Button("⬅️ Prev", variant="secondary", size="sm")
-                                    trajectory_slider = gr.Slider(
-                                        minimum=0, maximum=0, step=1, value=0, label="Trajectory Index", interactive=True
-                                    )
-                                    next_traj_btn = gr.Button("Next ➡️", variant="secondary", size="sm")
-                                trajectory_metadata = gr.Markdown("", visible=False)
-                                use_dataset_video_btn = gr.Button("Use Selected Video", variant="secondary")
-
-                        with gr.Column():
-                            progress_plot = gr.Image(label="Progress & Success Prediction", height=400)
-                            info_output = gr.Markdown("")
-
-                    # State variables for dataset
-                    current_dataset_single = gr.State(None)
-
-                    def update_config_choices_single(dataset_name):
-                        """Update config choices when dataset changes."""
-                        if not dataset_name:
-                            return gr.update(choices=[], value="")
-                        try:
-                            configs = get_available_configs(dataset_name)
-                            if configs:
-                                return gr.update(choices=configs, value=configs[0])
-                            else:
-                                return gr.update(choices=[], value="")
-                        except Exception as e:
-                            logger.warning(f"Could not fetch configs: {e}")
-                            return gr.update(choices=[], value="")
-
-                    def load_dataset_single(dataset_name, config_name):
-                        """Load dataset and update slider."""
-                        dataset, status = load_rfm_dataset(dataset_name, config_name)
-                        if dataset is not None:
-                            max_index = len(dataset) - 1
-                            return (
-                                dataset,
-                                gr.update(value=status, visible=True),
-                                gr.update(
-                                    maximum=max_index, value=0, interactive=True, label=f"Trajectory Index (0 to {max_index})"
-                                ),
-                            )
-                        else:
-                            return None, gr.update(value=status, visible=True), gr.update(maximum=0, value=0, interactive=False)
-
-                    def use_dataset_video(dataset, index, dataset_name):
-                        """Load video from dataset and update inputs."""
-                        if dataset is None:
-                            return (
-                                None,
-                                "Complete the task",
-                                gr.update(value="No dataset loaded", visible=True),
-                                gr.update(visible=False),
-                            )
-
-                        video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
-                        if video_path:
-                            # Build metadata text
-                            metadata_lines = []
-                            if quality_label:
-                                metadata_lines.append(f"**Quality Label:** {quality_label}")
-                            if partial_success is not None:
-                                metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-
-                            metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
-                            status_text = f"✅ Loaded trajectory {index} from dataset"
-                            if metadata_text:
-                                status_text += f"\n\n{metadata_text}"
-
-                            return (
-                                video_path,
-                                task,
-                                gr.update(value=status_text, visible=True),
-                                gr.update(value=metadata_text, visible=bool(metadata_text)),
-                            )
-                        else:
-                            return (
-                                None,
-                                "Complete the task",
-                                gr.update(value="❌ Error loading trajectory", visible=True),
-                                gr.update(visible=False),
-                            )
+        model_dropdown.change(
+            fn=on_model_selected,
+            inputs=[model_dropdown, model_url_mapping_state],
+            outputs=[server_status, model_info_display, server_url_state],
+        )
 
-                    def next_trajectory(dataset, current_idx, dataset_name):
-                        """Go to next trajectory."""
-                        if dataset is None:
-                            return 0, None, "Complete the task", gr.update(visible=False), gr.update(visible=False)
-                        next_idx = min(current_idx + 1, len(dataset) - 1)
-                        video_path, task, quality_label, partial_success = get_trajectory_video_path(
-                            dataset, next_idx, dataset_name
+    # Main content area with tabs
+    with gr.Tabs():
+        with gr.Tab("Progress Prediction"):
+            gr.Markdown("### Progress & Success Prediction")
+            gr.Markdown("Upload a video or select one from a dataset to get progress predictions.")
+
+            with gr.Row():
+                with gr.Column():
+                    single_video_input = gr.Video(label="Upload Video", height=300)
+                    task_text_input = gr.Textbox(
+                        label="Task Description",
+                        placeholder="Describe the task (e.g., 'Pick up the red block')",
+                        value="Complete the task",
+                    )
+                    fps_input_single = gr.Slider(
+                        label="FPS (Frames Per Second)",
+                        minimum=0.1,
+                        maximum=10.0,
+                        value=1.0,
+                        step=0.1,
+                        info="Frames per second to extract from video (higher = more frames)",
+                    )
+                    analyze_single_btn = gr.Button("Analyze Video", variant="primary")
+
+                    gr.Markdown("---")
+                    gr.Markdown("**OR Select from Dataset**")
+                    gr.Markdown("---")
+
+                    with gr.Accordion("📁 Select from Dataset", open=False):
+                        dataset_name_single = gr.Dropdown(
+                            choices=PREDEFINED_DATASETS,
+                            value="jesbu1/oxe_rfm",
+                            label="Dataset Name",
+                            allow_custom_value=True,
                         )
-
-                        if video_path:
-                            # Build metadata text
-                            metadata_lines = []
-                            if quality_label:
-                                metadata_lines.append(f"**Quality Label:** {quality_label}")
-                            if partial_success is not None:
-                                metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-
-                            metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
-                            return (
-                                next_idx,
-                                video_path,
-                                task,
-                                gr.update(value=metadata_text, visible=bool(metadata_text)),
-                                gr.update(value=f"✅ Trajectory {next_idx}/{len(dataset) - 1}", visible=True),
-                            )
-                        else:
-                            return current_idx, None, "Complete the task", gr.update(visible=False), gr.update(visible=False)
-
-                    def prev_trajectory(dataset, current_idx, dataset_name):
-                        """Go to previous trajectory."""
-                        if dataset is None:
-                            return 0, None, "Complete the task", gr.update(visible=False), gr.update(visible=False)
-                        prev_idx = max(current_idx - 1, 0)
-                        video_path, task, quality_label, partial_success = get_trajectory_video_path(
-                            dataset, prev_idx, dataset_name
+                        config_name_single = gr.Dropdown(
+                            choices=[], value="", label="Configuration Name", allow_custom_value=True
                         )
-
-                        if video_path:
-                            # Build metadata text
-                            metadata_lines = []
-                            if quality_label:
-                                metadata_lines.append(f"**Quality Label:** {quality_label}")
-                            if partial_success is not None:
-                                metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-
-                            metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
-                            return (
-                                prev_idx,
-                                video_path,
-                                task,
-                                gr.update(value=metadata_text, visible=bool(metadata_text)),
-                                gr.update(value=f"✅ Trajectory {prev_idx}/{len(dataset) - 1}", visible=True),
-                            )
-                        else:
-                            return current_idx, None, "Complete the task", gr.update(visible=False), gr.update(visible=False)
-
-                    def update_trajectory_on_slider_change(dataset, index, dataset_name):
-                        """Update trajectory metadata when slider changes."""
-                        if dataset is None:
-                            return gr.update(visible=False), gr.update(visible=False)
-
-                        video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
-                        if video_path:
-                            # Build metadata text
-                            metadata_lines = []
-                            if quality_label:
-                                metadata_lines.append(f"**Quality Label:** {quality_label}")
-                            if partial_success is not None:
-                                metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-
-                            metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
-                            return (
-                                gr.update(value=metadata_text, visible=bool(metadata_text)),
-                                gr.update(value=f"Trajectory {index}/{len(dataset) - 1}", visible=True),
+                        with gr.Row():
+                            refresh_configs_btn = gr.Button("🔄 Refresh Configs", variant="secondary", size="sm")
+                            load_dataset_btn = gr.Button("Load Dataset", variant="secondary", size="sm")
+
+                        dataset_status_single = gr.Markdown("", visible=False)
+                        with gr.Row():
+                            prev_traj_btn = gr.Button("⬅️ Prev", variant="secondary", size="sm")
+                            trajectory_slider = gr.Slider(
+                                minimum=0, maximum=0, step=1, value=0, label="Trajectory Index", interactive=True
                             )
-                        else:
-                            return gr.update(visible=False), gr.update(visible=False)
+                            next_traj_btn = gr.Button("Next ➡️", variant="secondary", size="sm")
+                        trajectory_metadata = gr.Markdown("", visible=False)
+                        use_dataset_video_btn = gr.Button("Use Selected Video", variant="secondary")
 
-                    # Dataset selection handlers
-                    dataset_name_single.change(
-                        fn=update_config_choices_single, inputs=[dataset_name_single], outputs=[config_name_single]
-                    )
+                with gr.Column():
+                    progress_plot = gr.Image(label="Progress & Success Prediction", height=400)
+                    info_output = gr.Markdown("")
 
-                    refresh_configs_btn.click(
-                        fn=update_config_choices_single, inputs=[dataset_name_single], outputs=[config_name_single]
-                    )
+            # State variables for dataset
+            current_dataset_single = gr.State(None)
 
-                    load_dataset_btn.click(
-                        fn=load_dataset_single,
-                        inputs=[dataset_name_single, config_name_single],
-                        outputs=[current_dataset_single, dataset_status_single, trajectory_slider],
+            def update_config_choices_single(dataset_name):
+                """Update config choices when dataset changes."""
+                if not dataset_name:
+                    return gr.update(choices=[], value="")
+                try:
+                    configs = get_available_configs(dataset_name)
+                    if configs:
+                        return gr.update(choices=configs, value=configs[0])
+                    else:
+                        return gr.update(choices=[], value="")
+                except Exception as e:
+                    logger.warning(f"Could not fetch configs: {e}")
+                    return gr.update(choices=[], value="")
+
+            def load_dataset_single(dataset_name, config_name):
+                """Load dataset and update slider."""
+                dataset, status = load_rfm_dataset(dataset_name, config_name)
+                if dataset is not None:
+                    max_index = len(dataset) - 1
+                    return (
+                        dataset,
+                        gr.update(value=status, visible=True),
+                        gr.update(
+                            maximum=max_index, value=0, interactive=True, label=f"Trajectory Index (0 to {max_index})"
+                        ),
                     )
-
-                    use_dataset_video_btn.click(
-                        fn=use_dataset_video,
-                        inputs=[current_dataset_single, trajectory_slider, dataset_name_single],
-                        outputs=[single_video_input, task_text_input, dataset_status_single, trajectory_metadata],
+                else:
+                    return None, gr.update(value=status, visible=True), gr.update(maximum=0, value=0, interactive=False)
+
+            def use_dataset_video(dataset, index, dataset_name):
+                """Load video from dataset and update inputs."""
+                if dataset is None:
+                    return (
+                        None,
+                        "Complete the task",
+                        gr.update(value="No dataset loaded", visible=True),
+                        gr.update(visible=False),
                     )
 
-                    # Navigation buttons
-                    next_traj_btn.click(
-                        fn=next_trajectory,
-                        inputs=[current_dataset_single, trajectory_slider, dataset_name_single],
-                        outputs=[
-                            trajectory_slider,
-                            single_video_input,
-                            task_text_input,
-                            trajectory_metadata,
-                            dataset_status_single,
-                        ],
+                video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
+                if video_path:
+                    # Build metadata text
+                    metadata_lines = []
+                    if quality_label:
+                        metadata_lines.append(f"**Quality Label:** {quality_label}")
+                    if partial_success is not None:
+                        metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
+
+                    metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
+                    status_text = f"✅ Loaded trajectory {index} from dataset"
+                    if metadata_text:
+                        status_text += f"\n\n{metadata_text}"
+
+                    return (
+                        video_path,
+                        task,
+                        gr.update(value=status_text, visible=True),
+                        gr.update(value=metadata_text, visible=bool(metadata_text)),
                     )
-
-                    prev_traj_btn.click(
-                        fn=prev_trajectory,
-                        inputs=[current_dataset_single, trajectory_slider, dataset_name_single],
-                        outputs=[
-                            trajectory_slider,
-                            single_video_input,
-                            task_text_input,
-                            trajectory_metadata,
-                            dataset_status_single,
-                        ],
+                else:
+                    return (
+                        None,
+                        "Complete the task",
+                        gr.update(value="❌ Error loading trajectory", visible=True),
+                        gr.update(visible=False),
                     )
 
-                    # Update metadata when slider changes
-                    trajectory_slider.change(
-                        fn=update_trajectory_on_slider_change,
-                        inputs=[current_dataset_single, trajectory_slider, dataset_name_single],
-                        outputs=[trajectory_metadata, dataset_status_single],
+            def next_trajectory(dataset, current_idx, dataset_name):
+                """Go to next trajectory."""
+                if dataset is None:
+                    return 0, None, "Complete the task", gr.update(visible=False), gr.update(visible=False)
+                next_idx = min(current_idx + 1, len(dataset) - 1)
+                video_path, task, quality_label, partial_success = get_trajectory_video_path(
+                    dataset, next_idx, dataset_name
+                )
+
+                if video_path:
+                    # Build metadata text
+                    metadata_lines = []
+                    if quality_label:
+                        metadata_lines.append(f"**Quality Label:** {quality_label}")
+                    if partial_success is not None:
+                        metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
+
+                    metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
+                    return (
+                        next_idx,
+                        video_path,
+                        task,
+                        gr.update(value=metadata_text, visible=bool(metadata_text)),
+                        gr.update(value=f"✅ Trajectory {next_idx}/{len(dataset) - 1}", visible=True),
                     )
-
-                    analyze_single_btn.click(
-                        fn=process_single_video,
-                        inputs=[single_video_input, task_text_input, server_url_state, fps_input_single],
-                        outputs=[progress_plot, info_output],
-                        api_name="process_single_video",
+                else:
+                    return current_idx, None, "Complete the task", gr.update(visible=False), gr.update(visible=False)
+
+            def prev_trajectory(dataset, current_idx, dataset_name):
+                """Go to previous trajectory."""
+                if dataset is None:
+                    return 0, None, "Complete the task", gr.update(visible=False), gr.update(visible=False)
+                prev_idx = max(current_idx - 1, 0)
+                video_path, task, quality_label, partial_success = get_trajectory_video_path(
+                    dataset, prev_idx, dataset_name
+                )
+
+                if video_path:
+                    # Build metadata text
+                    metadata_lines = []
+                    if quality_label:
+                        metadata_lines.append(f"**Quality Label:** {quality_label}")
+                    if partial_success is not None:
+                        metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
+
+                    metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
+                    return (
+                        prev_idx,
+                        video_path,
+                        task,
+                        gr.update(value=metadata_text, visible=bool(metadata_text)),
+                        gr.update(value=f"✅ Trajectory {prev_idx}/{len(dataset) - 1}", visible=True),
+                    )
+                else:
+                    return current_idx, None, "Complete the task", gr.update(visible=False), gr.update(visible=False)
+
+            def update_trajectory_on_slider_change(dataset, index, dataset_name):
+                """Update trajectory metadata when slider changes."""
+                if dataset is None:
+                    return gr.update(visible=False), gr.update(visible=False)
+
+                video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
+                if video_path:
+                    # Build metadata text
+                    metadata_lines = []
+                    if quality_label:
+                        metadata_lines.append(f"**Quality Label:** {quality_label}")
+                    if partial_success is not None:
+                        metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
+
+                    metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
+                    return (
+                        gr.update(value=metadata_text, visible=bool(metadata_text)),
+                        gr.update(value=f"Trajectory {index}/{len(dataset) - 1}", visible=True),
                     )
+                else:
+                    return gr.update(visible=False), gr.update(visible=False)
 
-                with gr.Tab("Preference/Similarity Analysis"):
-                    gr.Markdown("### Preference & Similarity Prediction")
-                    with gr.Row():
-                        with gr.Column():
-                            video_a_input = gr.Video(label="Video A", height=250)
-                            video_b_input = gr.Video(label="Video B", height=250)
-                            task_text_dual = gr.Textbox(
-                                label="Task Description",
-                                placeholder="Describe the task",
-                                value="Complete the task",
-                            )
-                            prediction_type = gr.Radio(
-                                choices=["preference", "similarity", "progress"],
-                                value="preference",
-                                label="Prediction Type",
-                            )
-                            fps_input_dual = gr.Slider(
-                                label="FPS (Frames Per Second)",
-                                minimum=0.1,
-                                maximum=10.0,
-                                value=1.0,
-                                step=0.1,
-                                info="Frames per second to extract from videos (higher = more frames)",
-                            )
-                            analyze_dual_btn = gr.Button("Compare Videos", variant="primary")
-
-                            gr.Markdown("---")
-                            gr.Markdown("**OR Select from Dataset**")
-                            gr.Markdown("---")
-
-                            with gr.Accordion("📁 Video A - Select from Dataset", open=False):
-                                dataset_name_a = gr.Dropdown(
-                                    choices=PREDEFINED_DATASETS,
-                                    value="jesbu1/oxe_rfm",
-                                    label="Dataset Name",
-                                    allow_custom_value=True,
-                                )
-                                config_name_a = gr.Dropdown(
-                                    choices=[], value="", label="Configuration Name", allow_custom_value=True
-                                )
-                                with gr.Row():
-                                    refresh_configs_btn_a = gr.Button("🔄 Refresh Configs", variant="secondary", size="sm")
-                                    load_dataset_btn_a = gr.Button("Load Dataset", variant="secondary", size="sm")
-
-                                dataset_status_a = gr.Markdown("", visible=False)
-                                with gr.Row():
-                                    prev_traj_btn_a = gr.Button("⬅️ Prev", variant="secondary", size="sm")
-                                    trajectory_slider_a = gr.Slider(
-                                        minimum=0, maximum=0, step=1, value=0, label="Trajectory Index", interactive=True
-                                    )
-                                    next_traj_btn_a = gr.Button("Next ➡️", variant="secondary", size="sm")
-                                trajectory_metadata_a = gr.Markdown("", visible=False)
-                                use_dataset_video_btn_a = gr.Button("Use Selected Video for A", variant="secondary")
-
-                            with gr.Accordion("📁 Video B - Select from Dataset", open=False):
-                                dataset_name_b = gr.Dropdown(
-                                    choices=PREDEFINED_DATASETS,
-                                    value="jesbu1/oxe_rfm",
-                                    label="Dataset Name",
-                                    allow_custom_value=True,
-                                )
-                                config_name_b = gr.Dropdown(
-                                    choices=[], value="", label="Configuration Name", allow_custom_value=True
-                                )
-                                with gr.Row():
-                                    refresh_configs_btn_b = gr.Button("🔄 Refresh Configs", variant="secondary", size="sm")
-                                    load_dataset_btn_b = gr.Button("Load Dataset", variant="secondary", size="sm")
-
-                                dataset_status_b = gr.Markdown("", visible=False)
-                                with gr.Row():
-                                    prev_traj_btn_b = gr.Button("⬅️ Prev", variant="secondary", size="sm")
-                                    trajectory_slider_b = gr.Slider(
-                                        minimum=0, maximum=0, step=1, value=0, label="Trajectory Index", interactive=True
-                                    )
-                                    next_traj_btn_b = gr.Button("Next ➡️", variant="secondary", size="sm")
-                                trajectory_metadata_b = gr.Markdown("", visible=False)
-                                use_dataset_video_btn_b = gr.Button("Use Selected Video for B", variant="secondary")
-
-                        with gr.Column():
-                            # Videos displayed side by side
-                            with gr.Row():
-                                video_a_display = gr.Video(label="Video A", height=400)
-                                video_b_display = gr.Video(label="Video B", height=400)
-                            
-                            # Result text at the bottom
-                            result_text = gr.Markdown("")
-
-                    # State variables for datasets
-                    current_dataset_a = gr.State(None)
-                    current_dataset_b = gr.State(None)
-
-                    # Helper functions for Video A
-                    def update_config_choices_a(dataset_name):
-                        """Update config choices for Video A when dataset changes."""
-                        if not dataset_name:
-                            return gr.update(choices=[], value="")
-                        try:
-                            configs = get_available_configs(dataset_name)
-                            if configs:
-                                return gr.update(choices=configs, value=configs[0])
-                            else:
-                                return gr.update(choices=[], value="")
-                        except Exception as e:
-                            logger.warning(f"Could not fetch configs: {e}")
-                            return gr.update(choices=[], value="")
-
-                    def load_dataset_a(dataset_name, config_name):
-                        """Load dataset A and update slider."""
-                        dataset, status = load_rfm_dataset(dataset_name, config_name)
-                        if dataset is not None:
-                            max_index = len(dataset) - 1
-                            return (
-                                dataset,
-                                gr.update(value=status, visible=True),
-                                gr.update(
-                                    maximum=max_index, value=0, interactive=True, label=f"Trajectory Index (0 to {max_index})"
-                                ),
-                            )
-                        else:
-                            return None, gr.update(value=status, visible=True), gr.update(maximum=0, value=0, interactive=False)
-
-                    def use_dataset_video_a(dataset, index, dataset_name):
-                        """Load video A from dataset and update input."""
-                        if dataset is None:
-                            return (
-                                None,
-                                gr.update(value="No dataset loaded", visible=True),
-                                gr.update(visible=False),
-                            )
+            # Dataset selection handlers
+            dataset_name_single.change(
+                fn=update_config_choices_single, inputs=[dataset_name_single], outputs=[config_name_single]
+            )
 
-                        video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
-                        if video_path:
-                            # Build metadata text
-                            metadata_lines = []
-                            if quality_label:
-                                metadata_lines.append(f"**Quality Label:** {quality_label}")
-                            if partial_success is not None:
-                                metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-
-                            metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
-                            status_text = f"✅ Loaded trajectory {index} from dataset for Video A"
-                            if metadata_text:
-                                status_text += f"\n\n{metadata_text}"
-
-                            return (
-                                video_path,
-                                gr.update(value=status_text, visible=True),
-                                gr.update(value=metadata_text, visible=bool(metadata_text)),
-                            )
-                        else:
-                            return (
-                                None,
-                                gr.update(value="❌ Error loading trajectory", visible=True),
-                                gr.update(visible=False),
-                            )
+            refresh_configs_btn.click(
+                fn=update_config_choices_single, inputs=[dataset_name_single], outputs=[config_name_single]
+            )
 
-                    def next_trajectory_a(dataset, current_idx, dataset_name):
-                        """Go to next trajectory for Video A."""
-                        if dataset is None:
-                            return 0, None, gr.update(visible=False), gr.update(visible=False)
-                        next_idx = min(current_idx + 1, len(dataset) - 1)
-                        video_path, task, quality_label, partial_success = get_trajectory_video_path(
-                            dataset, next_idx, dataset_name
-                        )
+            load_dataset_btn.click(
+                fn=load_dataset_single,
+                inputs=[dataset_name_single, config_name_single],
+                outputs=[current_dataset_single, dataset_status_single, trajectory_slider],
+            )
 
-                        if video_path:
-                            # Build metadata text
-                            metadata_lines = []
-                            if quality_label:
-                                metadata_lines.append(f"**Quality Label:** {quality_label}")
-                            if partial_success is not None:
-                                metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-
-                            metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
-                            return (
-                                next_idx,
-                                video_path,
-                                gr.update(value=metadata_text, visible=bool(metadata_text)),
-                                gr.update(value=f"✅ Trajectory {next_idx}/{len(dataset) - 1}", visible=True),
-                            )
-                        else:
-                            return current_idx, None, gr.update(visible=False), gr.update(visible=False)
-
-                    def prev_trajectory_a(dataset, current_idx, dataset_name):
-                        """Go to previous trajectory for Video A."""
-                        if dataset is None:
-                            return 0, None, gr.update(visible=False), gr.update(visible=False)
-                        prev_idx = max(current_idx - 1, 0)
-                        video_path, task, quality_label, partial_success = get_trajectory_video_path(
-                            dataset, prev_idx, dataset_name
-                        )
+            use_dataset_video_btn.click(
+                fn=use_dataset_video,
+                inputs=[current_dataset_single, trajectory_slider, dataset_name_single],
+                outputs=[single_video_input, task_text_input, dataset_status_single, trajectory_metadata],
+            )
 
-                        if video_path:
-                            # Build metadata text
-                            metadata_lines = []
-                            if quality_label:
-                                metadata_lines.append(f"**Quality Label:** {quality_label}")
-                            if partial_success is not None:
-                                metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-
-                            metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
-                            return (
-                                prev_idx,
-                                video_path,
-                                gr.update(value=metadata_text, visible=bool(metadata_text)),
-                                gr.update(value=f"✅ Trajectory {prev_idx}/{len(dataset) - 1}", visible=True),
-                            )
-                        else:
-                            return current_idx, None, gr.update(visible=False), gr.update(visible=False)
-
-                    def update_trajectory_on_slider_change_a(dataset, index, dataset_name):
-                        """Update trajectory metadata when slider changes for Video A."""
-                        if dataset is None:
-                            return gr.update(visible=False), gr.update(visible=False)
-
-                        video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
-                        if video_path:
-                            # Build metadata text
-                            metadata_lines = []
-                            if quality_label:
-                                metadata_lines.append(f"**Quality Label:** {quality_label}")
-                            if partial_success is not None:
-                                metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-
-                            metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
-                            return (
-                                gr.update(value=metadata_text, visible=bool(metadata_text)),
-                                gr.update(value=f"Trajectory {index}/{len(dataset) - 1}", visible=True),
-                            )
-                        else:
-                            return gr.update(visible=False), gr.update(visible=False)
-
-                    # Helper functions for Video B (same as Video A)
-                    def update_config_choices_b(dataset_name):
-                        """Update config choices for Video B when dataset changes."""
-                        if not dataset_name:
-                            return gr.update(choices=[], value="")
-                        try:
-                            configs = get_available_configs(dataset_name)
-                            if configs:
-                                return gr.update(choices=configs, value=configs[0])
-                            else:
-                                return gr.update(choices=[], value="")
-                        except Exception as e:
-                            logger.warning(f"Could not fetch configs: {e}")
-                            return gr.update(choices=[], value="")
-
-                    def load_dataset_b(dataset_name, config_name):
-                        """Load dataset B and update slider."""
-                        dataset, status = load_rfm_dataset(dataset_name, config_name)
-                        if dataset is not None:
-                            max_index = len(dataset) - 1
-                            return (
-                                dataset,
-                                gr.update(value=status, visible=True),
-                                gr.update(
-                                    maximum=max_index, value=0, interactive=True, label=f"Trajectory Index (0 to {max_index})"
-                                ),
-                            )
-                        else:
-                            return None, gr.update(value=status, visible=True), gr.update(maximum=0, value=0, interactive=False)
-
-                    def use_dataset_video_b(dataset, index, dataset_name):
-                        """Load video B from dataset and update input."""
-                        if dataset is None:
-                            return (
-                                None,
-                                gr.update(value="No dataset loaded", visible=True),
-                                gr.update(visible=False),
-                            )
+            # Navigation buttons
+            next_traj_btn.click(
+                fn=next_trajectory,
+                inputs=[current_dataset_single, trajectory_slider, dataset_name_single],
+                outputs=[
+                    trajectory_slider,
+                    single_video_input,
+                    task_text_input,
+                    trajectory_metadata,
+                    dataset_status_single,
+                ],
+            )
 
-                        video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
-                        if video_path:
-                            # Build metadata text
-                            metadata_lines = []
-                            if quality_label:
-                                metadata_lines.append(f"**Quality Label:** {quality_label}")
-                            if partial_success is not None:
-                                metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-
-                            metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
-                            status_text = f"✅ Loaded trajectory {index} from dataset for Video B"
-                            if metadata_text:
-                                status_text += f"\n\n{metadata_text}"
-
-                            return (
-                                video_path,
-                                gr.update(value=status_text, visible=True),
-                                gr.update(value=metadata_text, visible=bool(metadata_text)),
-                            )
-                        else:
-                            return (
-                                None,
-                                gr.update(value="❌ Error loading trajectory", visible=True),
-                                gr.update(visible=False),
-                            )
+            prev_traj_btn.click(
+                fn=prev_trajectory,
+                inputs=[current_dataset_single, trajectory_slider, dataset_name_single],
+                outputs=[
+                    trajectory_slider,
+                    single_video_input,
+                    task_text_input,
+                    trajectory_metadata,
+                    dataset_status_single,
+                ],
+            )
 
-                    def next_trajectory_b(dataset, current_idx, dataset_name):
-                        """Go to next trajectory for Video B."""
-                        if dataset is None:
-                            return 0, None, gr.update(visible=False), gr.update(visible=False)
-                        next_idx = min(current_idx + 1, len(dataset) - 1)
-                        video_path, task, quality_label, partial_success = get_trajectory_video_path(
-                            dataset, next_idx, dataset_name
-                        )
+            # Update metadata when slider changes
+            trajectory_slider.change(
+                fn=update_trajectory_on_slider_change,
+                inputs=[current_dataset_single, trajectory_slider, dataset_name_single],
+                outputs=[trajectory_metadata, dataset_status_single],
+            )
 
-                        if video_path:
-                            # Build metadata text
-                            metadata_lines = []
-                            if quality_label:
-                                metadata_lines.append(f"**Quality Label:** {quality_label}")
-                            if partial_success is not None:
-                                metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-
-                            metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
-                            return (
-                                next_idx,
-                                video_path,
-                                gr.update(value=metadata_text, visible=bool(metadata_text)),
-                                gr.update(value=f"✅ Trajectory {next_idx}/{len(dataset) - 1}", visible=True),
-                            )
-                        else:
-                            return current_idx, None, gr.update(visible=False), gr.update(visible=False)
-
-                    def prev_trajectory_b(dataset, current_idx, dataset_name):
-                        """Go to previous trajectory for Video B."""
-                        if dataset is None:
-                            return 0, None, gr.update(visible=False), gr.update(visible=False)
-                        prev_idx = max(current_idx - 1, 0)
-                        video_path, task, quality_label, partial_success = get_trajectory_video_path(
-                            dataset, prev_idx, dataset_name
-                        )
+            analyze_single_btn.click(
+                fn=process_single_video,
+                inputs=[single_video_input, task_text_input, server_url_state, fps_input_single],
+                outputs=[progress_plot, info_output],
+                api_name="process_single_video",
+            )
 
-                        if video_path:
-                            # Build metadata text
-                            metadata_lines = []
-                            if quality_label:
-                                metadata_lines.append(f"**Quality Label:** {quality_label}")
-                            if partial_success is not None:
-                                metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-
-                            metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
-                            return (
-                                prev_idx,
-                                video_path,
-                                gr.update(value=metadata_text, visible=bool(metadata_text)),
-                                gr.update(value=f"✅ Trajectory {prev_idx}/{len(dataset) - 1}", visible=True),
+        with gr.Tab("Preference/Similarity Analysis"):
+            gr.Markdown("### Preference & Similarity Prediction")
+            with gr.Row():
+                with gr.Column():
+                    video_a_input = gr.Video(label="Video A", height=250)
+                    video_b_input = gr.Video(label="Video B", height=250)
+                    task_text_dual = gr.Textbox(
+                        label="Task Description",
+                        placeholder="Describe the task",
+                        value="Complete the task",
+                    )
+                    prediction_type = gr.Radio(
+                        choices=["preference", "similarity", "progress"],
+                        value="preference",
+                        label="Prediction Type",
+                    )
+                    fps_input_dual = gr.Slider(
+                        label="FPS (Frames Per Second)",
+                        minimum=0.1,
+                        maximum=10.0,
+                        value=1.0,
+                        step=0.1,
+                        info="Frames per second to extract from videos (higher = more frames)",
+                    )
+                    analyze_dual_btn = gr.Button("Compare Videos", variant="primary")
+
+                    gr.Markdown("---")
+                    gr.Markdown("**OR Select from Dataset**")
+                    gr.Markdown("---")
+
+                    with gr.Accordion("📁 Video A - Select from Dataset", open=False):
+                        dataset_name_a = gr.Dropdown(
+                            choices=PREDEFINED_DATASETS,
+                            value="jesbu1/oxe_rfm",
+                            label="Dataset Name",
+                            allow_custom_value=True,
+                        )
+                        config_name_a = gr.Dropdown(
+                            choices=[], value="", label="Configuration Name", allow_custom_value=True
+                        )
+                        with gr.Row():
+                            refresh_configs_btn_a = gr.Button("🔄 Refresh Configs", variant="secondary", size="sm")
+                            load_dataset_btn_a = gr.Button("Load Dataset", variant="secondary", size="sm")
+
+                        dataset_status_a = gr.Markdown("", visible=False)
+                        with gr.Row():
+                            prev_traj_btn_a = gr.Button("⬅️ Prev", variant="secondary", size="sm")
+                            trajectory_slider_a = gr.Slider(
+                                minimum=0, maximum=0, step=1, value=0, label="Trajectory Index", interactive=True
                             )
-                        else:
-                            return current_idx, None, gr.update(visible=False), gr.update(visible=False)
-
-                    def update_trajectory_on_slider_change_b(dataset, index, dataset_name):
-                        """Update trajectory metadata when slider changes for Video B."""
-                        if dataset is None:
-                            return gr.update(visible=False), gr.update(visible=False)
-
-                        video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
-                        if video_path:
-                            # Build metadata text
-                            metadata_lines = []
-                            if quality_label:
-                                metadata_lines.append(f"**Quality Label:** {quality_label}")
-                            if partial_success is not None:
-                                metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
-
-                            metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
-                            return (
-                                gr.update(value=metadata_text, visible=bool(metadata_text)),
-                                gr.update(value=f"Trajectory {index}/{len(dataset) - 1}", visible=True),
+                            next_traj_btn_a = gr.Button("Next ➡️", variant="secondary", size="sm")
+                        trajectory_metadata_a = gr.Markdown("", visible=False)
+                        use_dataset_video_btn_a = gr.Button("Use Selected Video for A", variant="secondary")
+
+                    with gr.Accordion("📁 Video B - Select from Dataset", open=False):
+                        dataset_name_b = gr.Dropdown(
+                            choices=PREDEFINED_DATASETS,
+                            value="jesbu1/oxe_rfm",
+                            label="Dataset Name",
+                            allow_custom_value=True,
+                        )
+                        config_name_b = gr.Dropdown(
+                            choices=[], value="", label="Configuration Name", allow_custom_value=True
+                        )
+                        with gr.Row():
+                            refresh_configs_btn_b = gr.Button("🔄 Refresh Configs", variant="secondary", size="sm")
+                            load_dataset_btn_b = gr.Button("Load Dataset", variant="secondary", size="sm")
+
+                        dataset_status_b = gr.Markdown("", visible=False)
+                        with gr.Row():
+                            prev_traj_btn_b = gr.Button("⬅️ Prev", variant="secondary", size="sm")
+                            trajectory_slider_b = gr.Slider(
+                                minimum=0, maximum=0, step=1, value=0, label="Trajectory Index", interactive=True
                             )
-                        else:
-                            return gr.update(visible=False), gr.update(visible=False)
+                            next_traj_btn_b = gr.Button("Next ➡️", variant="secondary", size="sm")
+                        trajectory_metadata_b = gr.Markdown("", visible=False)
+                        use_dataset_video_btn_b = gr.Button("Use Selected Video for B", variant="secondary")
 
-                    # Video A dataset selection handlers
-                    dataset_name_a.change(
-                        fn=update_config_choices_a, inputs=[dataset_name_a], outputs=[config_name_a]
+                with gr.Column():
+                    # Videos displayed side by side
+                    with gr.Row():
+                        video_a_display = gr.Video(label="Video A", height=400)
+                        video_b_display = gr.Video(label="Video B", height=400)
+                    
+                    # Result text at the bottom
+                    result_text = gr.Markdown("")
+
+            # State variables for datasets
+            current_dataset_a = gr.State(None)
+            current_dataset_b = gr.State(None)
+
+            # Helper functions for Video A
+            def update_config_choices_a(dataset_name):
+                """Update config choices for Video A when dataset changes."""
+                if not dataset_name:
+                    return gr.update(choices=[], value="")
+                try:
+                    configs = get_available_configs(dataset_name)
+                    if configs:
+                        return gr.update(choices=configs, value=configs[0])
+                    else:
+                        return gr.update(choices=[], value="")
+                except Exception as e:
+                    logger.warning(f"Could not fetch configs: {e}")
+                    return gr.update(choices=[], value="")
+
+            def load_dataset_a(dataset_name, config_name):
+                """Load dataset A and update slider."""
+                dataset, status = load_rfm_dataset(dataset_name, config_name)
+                if dataset is not None:
+                    max_index = len(dataset) - 1
+                    return (
+                        dataset,
+                        gr.update(value=status, visible=True),
+                        gr.update(
+                            maximum=max_index, value=0, interactive=True, label=f"Trajectory Index (0 to {max_index})"
+                        ),
                     )
-
-                    refresh_configs_btn_a.click(
-                        fn=update_config_choices_a, inputs=[dataset_name_a], outputs=[config_name_a]
+                else:
+                    return None, gr.update(value=status, visible=True), gr.update(maximum=0, value=0, interactive=False)
+
+            def use_dataset_video_a(dataset, index, dataset_name):
+                """Load video A from dataset and update input."""
+                if dataset is None:
+                    return (
+                        None,
+                        gr.update(value="No dataset loaded", visible=True),
+                        gr.update(visible=False),
                     )
 
-                    load_dataset_btn_a.click(
-                        fn=load_dataset_a,
-                        inputs=[dataset_name_a, config_name_a],
-                        outputs=[current_dataset_a, dataset_status_a, trajectory_slider_a],
+                video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
+                if video_path:
+                    # Build metadata text
+                    metadata_lines = []
+                    if quality_label:
+                        metadata_lines.append(f"**Quality Label:** {quality_label}")
+                    if partial_success is not None:
+                        metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
+
+                    metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
+                    status_text = f"✅ Loaded trajectory {index} from dataset for Video A"
+                    if metadata_text:
+                        status_text += f"\n\n{metadata_text}"
+
+                    return (
+                        video_path,
+                        gr.update(value=status_text, visible=True),
+                        gr.update(value=metadata_text, visible=bool(metadata_text)),
                     )
-
-                    use_dataset_video_btn_a.click(
-                        fn=use_dataset_video_a,
-                        inputs=[current_dataset_a, trajectory_slider_a, dataset_name_a],
-                        outputs=[video_a_input, dataset_status_a, trajectory_metadata_a],
+                else:
+                    return (
+                        None,
+                        gr.update(value="❌ Error loading trajectory", visible=True),
+                        gr.update(visible=False),
                     )
 
-                    next_traj_btn_a.click(
-                        fn=next_trajectory_a,
-                        inputs=[current_dataset_a, trajectory_slider_a, dataset_name_a],
-                        outputs=[
-                            trajectory_slider_a,
-                            video_a_input,
-                            trajectory_metadata_a,
-                            dataset_status_a,
-                        ],
+            def next_trajectory_a(dataset, current_idx, dataset_name):
+                """Go to next trajectory for Video A."""
+                if dataset is None:
+                    return 0, None, gr.update(visible=False), gr.update(visible=False)
+                next_idx = min(current_idx + 1, len(dataset) - 1)
+                video_path, task, quality_label, partial_success = get_trajectory_video_path(
+                    dataset, next_idx, dataset_name
+                )
+
+                if video_path:
+                    # Build metadata text
+                    metadata_lines = []
+                    if quality_label:
+                        metadata_lines.append(f"**Quality Label:** {quality_label}")
+                    if partial_success is not None:
+                        metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
+
+                    metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
+                    return (
+                        next_idx,
+                        video_path,
+                        gr.update(value=metadata_text, visible=bool(metadata_text)),
+                        gr.update(value=f"✅ Trajectory {next_idx}/{len(dataset) - 1}", visible=True),
                     )
-
-                    prev_traj_btn_a.click(
-                        fn=prev_trajectory_a,
-                        inputs=[current_dataset_a, trajectory_slider_a, dataset_name_a],
-                        outputs=[
-                            trajectory_slider_a,
-                            video_a_input,
-                            trajectory_metadata_a,
-                            dataset_status_a,
-                        ],
+                else:
+                    return current_idx, None, gr.update(visible=False), gr.update(visible=False)
+
+            def prev_trajectory_a(dataset, current_idx, dataset_name):
+                """Go to previous trajectory for Video A."""
+                if dataset is None:
+                    return 0, None, gr.update(visible=False), gr.update(visible=False)
+                prev_idx = max(current_idx - 1, 0)
+                video_path, task, quality_label, partial_success = get_trajectory_video_path(
+                    dataset, prev_idx, dataset_name
+                )
+
+                if video_path:
+                    # Build metadata text
+                    metadata_lines = []
+                    if quality_label:
+                        metadata_lines.append(f"**Quality Label:** {quality_label}")
+                    if partial_success is not None:
+                        metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
+
+                    metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
+                    return (
+                        prev_idx,
+                        video_path,
+                        gr.update(value=metadata_text, visible=bool(metadata_text)),
+                        gr.update(value=f"✅ Trajectory {prev_idx}/{len(dataset) - 1}", visible=True),
                     )
-
-                    trajectory_slider_a.change(
-                        fn=update_trajectory_on_slider_change_a,
-                        inputs=[current_dataset_a, trajectory_slider_a, dataset_name_a],
-                        outputs=[trajectory_metadata_a, dataset_status_a],
+                else:
+                    return current_idx, None, gr.update(visible=False), gr.update(visible=False)
+
+            def update_trajectory_on_slider_change_a(dataset, index, dataset_name):
+                """Update trajectory metadata when slider changes for Video A."""
+                if dataset is None:
+                    return gr.update(visible=False), gr.update(visible=False)
+
+                video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
+                if video_path:
+                    # Build metadata text
+                    metadata_lines = []
+                    if quality_label:
+                        metadata_lines.append(f"**Quality Label:** {quality_label}")
+                    if partial_success is not None:
+                        metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
+
+                    metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
+                    return (
+                        gr.update(value=metadata_text, visible=bool(metadata_text)),
+                        gr.update(value=f"Trajectory {index}/{len(dataset) - 1}", visible=True),
                     )
+                else:
+                    return gr.update(visible=False), gr.update(visible=False)
 
-                    # Video B dataset selection handlers
-                    dataset_name_b.change(
-                        fn=update_config_choices_b, inputs=[dataset_name_b], outputs=[config_name_b]
+            # Helper functions for Video B (same as Video A)
+            def update_config_choices_b(dataset_name):
+                """Update config choices for Video B when dataset changes."""
+                if not dataset_name:
+                    return gr.update(choices=[], value="")
+                try:
+                    configs = get_available_configs(dataset_name)
+                    if configs:
+                        return gr.update(choices=configs, value=configs[0])
+                    else:
+                        return gr.update(choices=[], value="")
+                except Exception as e:
+                    logger.warning(f"Could not fetch configs: {e}")
+                    return gr.update(choices=[], value="")
+
+            def load_dataset_b(dataset_name, config_name):
+                """Load dataset B and update slider."""
+                dataset, status = load_rfm_dataset(dataset_name, config_name)
+                if dataset is not None:
+                    max_index = len(dataset) - 1
+                    return (
+                        dataset,
+                        gr.update(value=status, visible=True),
+                        gr.update(
+                            maximum=max_index, value=0, interactive=True, label=f"Trajectory Index (0 to {max_index})"
+                        ),
                     )
-
-                    refresh_configs_btn_b.click(
-                        fn=update_config_choices_b, inputs=[dataset_name_b], outputs=[config_name_b]
+                else:
+                    return None, gr.update(value=status, visible=True), gr.update(maximum=0, value=0, interactive=False)
+
+            def use_dataset_video_b(dataset, index, dataset_name):
+                """Load video B from dataset and update input."""
+                if dataset is None:
+                    return (
+                        None,
+                        gr.update(value="No dataset loaded", visible=True),
+                        gr.update(visible=False),
                     )
 
-                    load_dataset_btn_b.click(
-                        fn=load_dataset_b,
-                        inputs=[dataset_name_b, config_name_b],
-                        outputs=[current_dataset_b, dataset_status_b, trajectory_slider_b],
+                video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
+                if video_path:
+                    # Build metadata text
+                    metadata_lines = []
+                    if quality_label:
+                        metadata_lines.append(f"**Quality Label:** {quality_label}")
+                    if partial_success is not None:
+                        metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
+
+                    metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
+                    status_text = f"✅ Loaded trajectory {index} from dataset for Video B"
+                    if metadata_text:
+                        status_text += f"\n\n{metadata_text}"
+
+                    return (
+                        video_path,
+                        gr.update(value=status_text, visible=True),
+                        gr.update(value=metadata_text, visible=bool(metadata_text)),
                     )
-
-                    use_dataset_video_btn_b.click(
-                        fn=use_dataset_video_b,
-                        inputs=[current_dataset_b, trajectory_slider_b, dataset_name_b],
-                        outputs=[video_b_input, dataset_status_b, trajectory_metadata_b],
+                else:
+                    return (
+                        None,
+                        gr.update(value="❌ Error loading trajectory", visible=True),
+                        gr.update(visible=False),
                     )
 
-                    next_traj_btn_b.click(
-                        fn=next_trajectory_b,
-                        inputs=[current_dataset_b, trajectory_slider_b, dataset_name_b],
-                        outputs=[
-                            trajectory_slider_b,
-                            video_b_input,
-                            trajectory_metadata_b,
-                            dataset_status_b,
-                        ],
+            def next_trajectory_b(dataset, current_idx, dataset_name):
+                """Go to next trajectory for Video B."""
+                if dataset is None:
+                    return 0, None, gr.update(visible=False), gr.update(visible=False)
+                next_idx = min(current_idx + 1, len(dataset) - 1)
+                video_path, task, quality_label, partial_success = get_trajectory_video_path(
+                    dataset, next_idx, dataset_name
+                )
+
+                if video_path:
+                    # Build metadata text
+                    metadata_lines = []
+                    if quality_label:
+                        metadata_lines.append(f"**Quality Label:** {quality_label}")
+                    if partial_success is not None:
+                        metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
+
+                    metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
+                    return (
+                        next_idx,
+                        video_path,
+                        gr.update(value=metadata_text, visible=bool(metadata_text)),
+                        gr.update(value=f"✅ Trajectory {next_idx}/{len(dataset) - 1}", visible=True),
                     )
-
-                    prev_traj_btn_b.click(
-                        fn=prev_trajectory_b,
-                        inputs=[current_dataset_b, trajectory_slider_b, dataset_name_b],
-                        outputs=[
-                            trajectory_slider_b,
-                            video_b_input,
-                            trajectory_metadata_b,
-                            dataset_status_b,
-                        ],
+                else:
+                    return current_idx, None, gr.update(visible=False), gr.update(visible=False)
+
+            def prev_trajectory_b(dataset, current_idx, dataset_name):
+                """Go to previous trajectory for Video B."""
+                if dataset is None:
+                    return 0, None, gr.update(visible=False), gr.update(visible=False)
+                prev_idx = max(current_idx - 1, 0)
+                video_path, task, quality_label, partial_success = get_trajectory_video_path(
+                    dataset, prev_idx, dataset_name
+                )
+
+                if video_path:
+                    # Build metadata text
+                    metadata_lines = []
+                    if quality_label:
+                        metadata_lines.append(f"**Quality Label:** {quality_label}")
+                    if partial_success is not None:
+                        metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
+
+                    metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
+                    return (
+                        prev_idx,
+                        video_path,
+                        gr.update(value=metadata_text, visible=bool(metadata_text)),
+                        gr.update(value=f"✅ Trajectory {prev_idx}/{len(dataset) - 1}", visible=True),
                     )
-
-                    trajectory_slider_b.change(
-                        fn=update_trajectory_on_slider_change_b,
-                        inputs=[current_dataset_b, trajectory_slider_b, dataset_name_b],
-                        outputs=[trajectory_metadata_b, dataset_status_b],
+                else:
+                    return current_idx, None, gr.update(visible=False), gr.update(visible=False)
+
+            def update_trajectory_on_slider_change_b(dataset, index, dataset_name):
+                """Update trajectory metadata when slider changes for Video B."""
+                if dataset is None:
+                    return gr.update(visible=False), gr.update(visible=False)
+
+                video_path, task, quality_label, partial_success = get_trajectory_video_path(dataset, index, dataset_name)
+                if video_path:
+                    # Build metadata text
+                    metadata_lines = []
+                    if quality_label:
+                        metadata_lines.append(f"**Quality Label:** {quality_label}")
+                    if partial_success is not None:
+                        metadata_lines.append(f"**Partial Success:** {partial_success:.3f}")
+
+                    metadata_text = "\n".join(metadata_lines) if metadata_lines else ""
+                    return (
+                        gr.update(value=metadata_text, visible=bool(metadata_text)),
+                        gr.update(value=f"Trajectory {index}/{len(dataset) - 1}", visible=True),
                     )
+                else:
+                    return gr.update(visible=False), gr.update(visible=False)
 
-                    analyze_dual_btn.click(
-                        fn=process_two_videos,
-                        inputs=[video_a_input, video_b_input, task_text_dual, prediction_type, server_url_state, fps_input_dual],
-                        outputs=[result_text, video_a_display, video_b_display],
-                        api_name="process_two_videos",
-                    )
+            # Video A dataset selection handlers
+            dataset_name_a.change(
+                fn=update_config_choices_a, inputs=[dataset_name_a], outputs=[config_name_a]
+            )
 
-    # Wire up the sidebar toggle button (can be anywhere in the demo block)
-    sidebar_toggle_btn.click(
-        fn=toggle_sidebar,
-        inputs=[sidebar_visible_state],
-        outputs=[sidebar_visible_state, sidebar_column, sidebar_toggle_btn],
-    )
+            refresh_configs_btn_a.click(
+                fn=update_config_choices_a, inputs=[dataset_name_a], outputs=[config_name_a]
+            )
+
+            load_dataset_btn_a.click(
+                fn=load_dataset_a,
+                inputs=[dataset_name_a, config_name_a],
+                outputs=[current_dataset_a, dataset_status_a, trajectory_slider_a],
+            )
+
+            use_dataset_video_btn_a.click(
+                fn=use_dataset_video_a,
+                inputs=[current_dataset_a, trajectory_slider_a, dataset_name_a],
+                outputs=[video_a_input, dataset_status_a, trajectory_metadata_a],
+            )
+
+            next_traj_btn_a.click(
+                fn=next_trajectory_a,
+                inputs=[current_dataset_a, trajectory_slider_a, dataset_name_a],
+                outputs=[
+                    trajectory_slider_a,
+                    video_a_input,
+                    trajectory_metadata_a,
+                    dataset_status_a,
+                ],
+            )
+
+            prev_traj_btn_a.click(
+                fn=prev_trajectory_a,
+                inputs=[current_dataset_a, trajectory_slider_a, dataset_name_a],
+                outputs=[
+                    trajectory_slider_a,
+                    video_a_input,
+                    trajectory_metadata_a,
+                    dataset_status_a,
+                ],
+            )
+
+            trajectory_slider_a.change(
+                fn=update_trajectory_on_slider_change_a,
+                inputs=[current_dataset_a, trajectory_slider_a, dataset_name_a],
+                outputs=[trajectory_metadata_a, dataset_status_a],
+            )
+
+            # Video B dataset selection handlers
+            dataset_name_b.change(
+                fn=update_config_choices_b, inputs=[dataset_name_b], outputs=[config_name_b]
+            )
+
+            refresh_configs_btn_b.click(
+                fn=update_config_choices_b, inputs=[dataset_name_b], outputs=[config_name_b]
+            )
+
+            load_dataset_btn_b.click(
+                fn=load_dataset_b,
+                inputs=[dataset_name_b, config_name_b],
+                outputs=[current_dataset_b, dataset_status_b, trajectory_slider_b],
+            )
+
+            use_dataset_video_btn_b.click(
+                fn=use_dataset_video_b,
+                inputs=[current_dataset_b, trajectory_slider_b, dataset_name_b],
+                outputs=[video_b_input, dataset_status_b, trajectory_metadata_b],
+            )
+
+            next_traj_btn_b.click(
+                fn=next_trajectory_b,
+                inputs=[current_dataset_b, trajectory_slider_b, dataset_name_b],
+                outputs=[
+                    trajectory_slider_b,
+                    video_b_input,
+                    trajectory_metadata_b,
+                    dataset_status_b,
+                ],
+            )
+
+            prev_traj_btn_b.click(
+                fn=prev_trajectory_b,
+                inputs=[current_dataset_b, trajectory_slider_b, dataset_name_b],
+                outputs=[
+                    trajectory_slider_b,
+                    video_b_input,
+                    trajectory_metadata_b,
+                    dataset_status_b,
+                ],
+            )
+
+            trajectory_slider_b.change(
+                fn=update_trajectory_on_slider_change_b,
+                inputs=[current_dataset_b, trajectory_slider_b, dataset_name_b],
+                outputs=[trajectory_metadata_b, dataset_status_b],
+            )
+
+            analyze_dual_btn.click(
+                fn=process_two_videos,
+                inputs=[video_a_input, video_b_input, task_text_dual, prediction_type, server_url_state, fps_input_dual],
+                outputs=[result_text, video_a_display, video_b_display],
+                api_name="process_two_videos",
+            )
 
 
 def main():