update

app.py

@@ -609,40 +609,14 @@ with demo:
     gr.Markdown(
         """
         # RFM (Reward Foundation Model) Evaluation Server
-        
-        Select a model from the dropdown below. The app will automatically discover available models.
         """
     )
 
-    # Model selector at the top
-    with gr.Row():
-        with gr.Column(scale=4):
-            base_url_input = gr.Textbox(
-                label="Base Server URL",
-                placeholder="http://40.119.56.66",
-                value="http://40.119.56.66",
-                interactive=True,
-            )
-            model_dropdown = gr.Dropdown(
-                label="Select Model",
-                choices=[],
-                value=None,
-                interactive=True,
-                info="Click 'Discover Models' to find available models on ports 8000-8010",
-            )
-        with gr.Column(scale=1):
-            discover_btn = gr.Button("🔍 Discover Models", variant="primary", size="lg")
-    
-    with gr.Row():
-        server_status = gr.Markdown("Click 'Discover Models' to find available models", visible=True)
-    
-    with gr.Accordion("📋 Model Information", open=False) as model_info_accordion:
-        model_info_display = gr.Markdown("", visible=True)
-
-    # Hidden state to store server URL and model mapping
+    # 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
 
+    # Function definitions for event handlers
     def discover_and_select_models(base_url: str):
         """Discover models and update dropdown."""
         if not base_url:
@@ -723,757 +697,793 @@ with demo:
             server_url,
         )
 
-    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],
-    )
-
-    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():
-                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")
-
-                gr.Markdown("---")
-                gr.Markdown("**OR**")
-                gr.Markdown("---")
-
-                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")
-
-            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),
-                )
-
-        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 layout with sidebar and content area
+    with gr.Row():
+        # Sidebar for model selection and info
+        with gr.Column(scale=1, min_width=300):
+            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,
             )
-
-            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
+            
+            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],
             )
 
-            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)
-
-        # Dataset selection handlers
-        dataset_name_single.change(
-            fn=update_config_choices_single, inputs=[dataset_name_single], outputs=[config_name_single]
-        )
+            model_dropdown.change(
+                fn=on_model_selected,
+                inputs=[model_dropdown, model_url_mapping_state],
+                outputs=[server_status, model_info_display, server_url_state],
+            )
 
-        refresh_configs_btn.click(
-            fn=update_config_choices_single, inputs=[dataset_name_single], outputs=[config_name_single]
-        )
+        # 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.")
 
-        load_dataset_btn.click(
-            fn=load_dataset_single,
-            inputs=[dataset_name_single, config_name_single],
-            outputs=[current_dataset_single, dataset_status_single, trajectory_slider],
-        )
+                    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),
+                            )
+
+                    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
+                        )
 
-        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 (
+                                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
+                        )
 
-        # 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,
-            ],
-        )
+                        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)
+
+                    # Dataset selection handlers
+                    dataset_name_single.change(
+                        fn=update_config_choices_single, inputs=[dataset_name_single], outputs=[config_name_single]
+                    )
 
-        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,
-            ],
-        )
+                    refresh_configs_btn.click(
+                        fn=update_config_choices_single, inputs=[dataset_name_single], outputs=[config_name_single]
+                    )
 
-        # 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],
-        )
+                    load_dataset_btn.click(
+                        fn=load_dataset_single,
+                        inputs=[dataset_name_single, config_name_single],
+                        outputs=[current_dataset_single, dataset_status_single, trajectory_slider],
+                    )
 
-        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",
-        )
+                    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],
+                    )
 
-    with gr.Tab("Preference/Similarity Analysis"):
-        gr.Markdown("### Preference & Similarity Prediction")
-        with gr.Row():
-            with gr.Column():
-                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,
+                    # 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,
+                        ],
                     )
-                    config_name_a = gr.Dropdown(
-                        choices=[], value="", label="Configuration Name", allow_custom_value=True
+
+                    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,
+                        ],
                     )
-                    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,
+                    # 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],
                     )
-                    config_name_b = gr.Dropdown(
-                        choices=[], value="", label="Configuration Name", allow_custom_value=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",
                     )
-                    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.Tab("Preference/Similarity Analysis"):
+                    gr.Markdown("### Preference & Similarity Prediction")
                     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
+                        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),
+                            )
+
+                        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),
+                            )
+
+                    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
                         )
-                        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")
-
-                gr.Markdown("---")
-                gr.Markdown("**OR Upload Videos Directly**")
-                gr.Markdown("---")
-
-                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")
-
-            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),
-                )
-
-            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),
-                )
-
-        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),
-                )
-            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),
-                )
-            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),
-                )
-
-            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),
-                )
-
-        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),
+                            )
+                        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 (
-                    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
-            )
+                        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),
+                            )
+
+                        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),
+                            )
+
+                    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 (
-                    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_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)
+                        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
+                        )
 
-        # Video A dataset selection handlers
-        dataset_name_a.change(
-            fn=update_config_choices_a, inputs=[dataset_name_a], outputs=[config_name_a]
-        )
+                        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_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)
+
+                    # Video A dataset selection handlers
+                    dataset_name_a.change(
+                        fn=update_config_choices_a, inputs=[dataset_name_a], outputs=[config_name_a]
+                    )
 
-        refresh_configs_btn_a.click(
-            fn=update_config_choices_a, inputs=[dataset_name_a], outputs=[config_name_a]
-        )
+                    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],
-        )
+                    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],
-        )
+                    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,
-            ],
-        )
+                    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,
-            ],
-        )
+                    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],
-        )
+                    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]
-        )
+                    # 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]
-        )
+                    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],
-        )
+                    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],
-        )
+                    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,
-            ],
-        )
+                    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,
-            ],
-        )
+                    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],
-        )
+                    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",
-        )
+                    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():