Add support for multiple prompts (#2)

- add support for multi prompt (a00bf1798a9a3a6de9331ae637d4d739a1b63874)


Co-authored-by: Yoni Gozlan <[email protected]>

app.py

@@ -1,4 +1,3 @@
-import os
 import colorsys
 import gc
 import os
@@ -10,8 +9,10 @@ import numpy as np
 import torch
 from gradio.themes import Soft
 from PIL import Image, ImageDraw, ImageFont
+
 from transformers import Sam3TrackerVideoModel, Sam3TrackerVideoProcessor, Sam3VideoModel, Sam3VideoProcessor
 
+
 def get_device_and_dtype() -> tuple[str, torch.dtype]:
     device = "cuda" if torch.cuda.is_available() else "cpu"
     dtype = torch.bfloat16
@@ -87,6 +88,23 @@ def pastel_color_for_object(obj_id: int) -> tuple[int, int, int]:
     return int(r_f * 255), int(g_f * 255), int(b_f * 255)
 
 
+def pastel_color_for_prompt(prompt_text: str) -> tuple[int, int, int]:
+    """Generate a consistent color for a prompt text using a deterministic hash."""
+    # Use a deterministic hash by summing character codes
+    # This ensures the same prompt always gets the same color
+    char_sum = sum(ord(c) for c in prompt_text)
+
+    # Use the sum to generate a hue that's well-distributed across the color spectrum
+    # Multiply by a large prime to spread values out
+    hue = ((char_sum * 2654435761) % 360) / 360.0
+
+    # Use pastel colors (lower saturation, high value)
+    saturation = 0.5
+    value = 0.95
+    r_f, g_f, b_f = colorsys.hsv_to_rgb(hue, saturation, value)
+    return int(r_f * 255), int(g_f * 255), int(b_f * 255)
+
+
 class AppState:
     def __init__(self):
         self.reset()
@@ -97,6 +115,7 @@ class AppState:
         self.video_fps: float | None = None
         self.masks_by_frame: dict[int, dict[int, np.ndarray]] = {}
         self.color_by_obj: dict[int, tuple[int, int, int]] = {}
+        self.color_by_prompt: dict[str, tuple[int, int, int]] = {}
         self.clicks_by_frame_obj: dict[int, dict[int, list[tuple[int, int, int]]]] = {}
         self.boxes_by_frame_obj: dict[int, dict[int, list[tuple[int, int, int, int]]]] = {}
         self.text_prompts_by_frame_obj: dict[int, dict[int, str]] = {}
@@ -119,14 +138,13 @@ class AppState:
         return len(self.video_frames)
 
 
-
-
 def init_video_session(
     GLOBAL_STATE: gr.State, video: str | dict, active_tab: str = "point_box"
 ) -> tuple[AppState, int, int, Image.Image, str]:
     GLOBAL_STATE.video_frames = []
     GLOBAL_STATE.masks_by_frame = {}
     GLOBAL_STATE.color_by_obj = {}
+    GLOBAL_STATE.color_by_prompt = {}
     GLOBAL_STATE.text_prompts_by_frame_obj = {}
     GLOBAL_STATE.clicks_by_frame_obj = {}
     GLOBAL_STATE.boxes_by_frame_obj = {}
@@ -180,11 +198,10 @@ def init_video_session(
         GLOBAL_STATE.inference_session = processor.init_video_session(
             video=raw_video,
             inference_device=device,
-            video_storage_device=device,
-            processing_device=device,
+            video_storage_device="cpu",
+            processing_device="cpu",
             inference_state_device=device,
             dtype=dtype,
-            max_vision_features_cache_size=1,
         )
 
     first_frame = frames[0]
@@ -248,7 +265,36 @@ def compose_frame(state: AppState, frame_idx: int) -> Image.Image:
 
     if text_prompts_by_obj and len(masks) > 0:
         draw = ImageDraw.Draw(out_img)
-        font = ImageFont.load_default()
+
+        # Calculate scale factor based on image size (reference: 720p height = 720)
+        img_width, img_height = out_img.size
+        reference_height = 720.0
+        scale_factor = img_height / reference_height
+
+        # Scale font size (base size ~13 pixels for default font, scale proportionally)
+        base_font_size = 13
+        font_size = max(10, int(base_font_size * scale_factor))
+
+        # Try to load a scalable font, fall back to default if not available
+        try:
+            # Try common system fonts
+            font_paths = [
+                "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+                "/System/Library/Fonts/Helvetica.ttc",
+                "arial.ttf",
+            ]
+            font = None
+            for font_path in font_paths:
+                try:
+                    font = ImageFont.truetype(font_path, font_size)
+                    break
+                except (OSError, IOError):
+                    continue
+            if font is None:
+                # Fallback to default font
+                font = ImageFont.load_default()
+        except Exception:
+            font = ImageFont.load_default()
 
         for obj_id, text_prompt in text_prompts_by_obj.items():
             obj_mask = masks.get(obj_id)
@@ -261,15 +307,17 @@ def compose_frame(state: AppState, frame_idx: int) -> Image.Image:
                         y_min, y_max = np.where(rows)[0][[0, -1]]
                         x_min, x_max = np.where(cols)[0][[0, -1]]
                         label_x = int(x_min)
-                        label_y = int(y_min) - 20
-                        label_y = max(5, label_y)
+                        # Scale vertical offset and padding
+                        vertical_offset = int(20 * scale_factor)
+                        padding = max(2, int(4 * scale_factor))
+                        label_y = int(y_min) - vertical_offset
+                        label_y = max(int(5 * scale_factor), label_y)
 
                         obj_color = state.color_by_obj.get(obj_id, (255, 255, 255))
 
                         # Include object ID in the label
-                        label_text = f"{text_prompt} (ID: {obj_id})"
+                        label_text = f"{text_prompt} - ID {obj_id}"
                         bbox = draw.textbbox((label_x, label_y), label_text, font=font)
-                        padding = 4
                         draw.rectangle(
                             [(bbox[0] - padding, bbox[1] - padding), (bbox[2] + padding, bbox[3] + padding)],
                             fill=obj_color,
@@ -292,8 +340,38 @@ def update_frame_display(state: AppState, frame_idx: int) -> Image.Image:
     return compose_frame(state, frame_idx)
 
 
+def _get_prompt_for_obj(state: AppState, obj_id: int) -> Optional[str]:
+    """Get the prompt text associated with an object ID."""
+    # Priority 1: Check text_prompts_by_frame_obj (most reliable)
+    for frame_texts in state.text_prompts_by_frame_obj.values():
+        if obj_id in frame_texts:
+            return frame_texts[obj_id].strip()
+
+    # Priority 2: Check inference session mapping
+    if state.inference_session is not None:
+        if (
+            hasattr(state.inference_session, "obj_id_to_prompt_id")
+            and obj_id in state.inference_session.obj_id_to_prompt_id
+        ):
+            prompt_id = state.inference_session.obj_id_to_prompt_id[obj_id]
+            if hasattr(state.inference_session, "prompts") and prompt_id in state.inference_session.prompts:
+                return state.inference_session.prompts[prompt_id].strip()
+
+    return None
+
+
 def _ensure_color_for_obj(state: AppState, obj_id: int):
-    if obj_id not in state.color_by_obj:
+    """Assign color to object based on its prompt if available, otherwise use object ID."""
+    prompt_text = _get_prompt_for_obj(state, obj_id)
+
+    if prompt_text is not None:
+        # Ensure prompt has a color assigned
+        if prompt_text not in state.color_by_prompt:
+            state.color_by_prompt[prompt_text] = pastel_color_for_prompt(prompt_text)
+        # Always update to prompt-based color
+        state.color_by_obj[obj_id] = state.color_by_prompt[prompt_text]
+    elif obj_id not in state.color_by_obj:
+        # Fallback to object ID-based color (for point/box prompting mode)
         state.color_by_obj[obj_id] = pastel_color_for_object(obj_id)
 
 
@@ -414,21 +492,29 @@ def on_text_prompt(
     state: AppState,
     frame_idx: int,
     text_prompt: str,
-) -> tuple[Image.Image, str]:
+) -> tuple[Image.Image, str, str]:
     if state is None or state.inference_session is None:
-        return None, "Upload a video and enter text prompt."
+        return None, "Upload a video and enter text prompt.", "**Active prompts:** None"
 
     model = _GLOBAL_TEXT_VIDEO_MODEL
     processor = _GLOBAL_TEXT_VIDEO_PROCESSOR
 
     if not text_prompt or not text_prompt.strip():
-        return update_frame_display(state, int(frame_idx)), "Please enter a text prompt."
+        active_prompts = _get_active_prompts_display(state)
+        return update_frame_display(state, int(frame_idx)), "Please enter a text prompt.", active_prompts
 
     frame_idx = int(np.clip(frame_idx, 0, len(state.video_frames) - 1))
 
+    # Parse comma-separated prompts or single prompt
+    prompt_texts = [p.strip() for p in text_prompt.split(",") if p.strip()]
+    if not prompt_texts:
+        active_prompts = _get_active_prompts_display(state)
+        return update_frame_display(state, int(frame_idx)), "Please enter a valid text prompt.", active_prompts
+
+    # Add text prompt(s) - supports both single string and list of strings
     state.inference_session = processor.add_text_prompt(
         inference_session=state.inference_session,
-        text=text_prompt.strip(),
+        text=prompt_texts,  # Pass as list to add multiple at once
     )
 
     masks_for_frame = state.masks_by_frame.setdefault(frame_idx, {})
@@ -436,6 +522,8 @@ def on_text_prompt(
 
     num_objects = 0
     detected_obj_ids = []
+    prompt_to_obj_ids_summary = {}
+
     with torch.no_grad():
         for model_outputs in model.propagate_in_video_iterator(
             inference_session=state.inference_session,
@@ -452,6 +540,15 @@ def on_text_prompt(
                 object_ids = processed_outputs["object_ids"]
                 masks = processed_outputs["masks"]
                 scores = processed_outputs["scores"]
+                prompt_to_obj_ids = processed_outputs.get("prompt_to_obj_ids", {})
+
+                # Update prompt_to_obj_ids summary for status message
+                for prompt, obj_ids in prompt_to_obj_ids.items():
+                    if prompt not in prompt_to_obj_ids_summary:
+                        prompt_to_obj_ids_summary[prompt] = []
+                    prompt_to_obj_ids_summary[prompt].extend(
+                        [int(oid) for oid in obj_ids if int(oid) not in prompt_to_obj_ids_summary[prompt]]
+                    )
 
                 num_objects = len(object_ids)
                 if num_objects > 0:
@@ -463,22 +560,54 @@ def on_text_prompt(
                     for mask_idx in sorted_indices:
                         current_obj_id = int(object_ids[mask_idx].item())
                         detected_obj_ids.append(current_obj_id)
-                        _ensure_color_for_obj(state, current_obj_id)
                         mask_2d = masks[mask_idx].float().cpu().numpy()
                         if mask_2d.ndim == 3:
                             mask_2d = mask_2d.squeeze()
                         mask_2d = (mask_2d > 0.0).astype(np.float32)
                         masks_for_frame[current_obj_id] = mask_2d
-                        frame_texts[current_obj_id] = text_prompt.strip()
+
+                        # Find which prompt detected this object
+                        detected_prompt = None
+                        for prompt, obj_ids in prompt_to_obj_ids.items():
+                            if current_obj_id in obj_ids:
+                                detected_prompt = prompt
+                                break
+
+                        # Store prompt and assign color
+                        if detected_prompt:
+                            frame_texts[current_obj_id] = detected_prompt.strip()
+                        _ensure_color_for_obj(state, current_obj_id)
 
     state.composited_frames.pop(frame_idx, None)
 
+    # Build status message with prompt breakdown
     if detected_obj_ids:
-        obj_ids_str = ", ".join(map(str, detected_obj_ids))
-        status = f"Processed text prompt '{text_prompt.strip()}' on frame {frame_idx}. Found {num_objects} object(s) with IDs: {obj_ids_str}."
+        status_parts = [f"Processed text prompt(s) on frame {frame_idx}. Found {num_objects} object(s):"]
+        for prompt, obj_ids in prompt_to_obj_ids_summary.items():
+            if obj_ids:
+                obj_ids_str = ", ".join(map(str, sorted(obj_ids)))
+                status_parts.append(f"  • '{prompt}': {len(obj_ids)} object(s) (IDs: {obj_ids_str})")
+        status = "\n".join(status_parts)
     else:
-        status = f"Processed text prompt '{text_prompt.strip()}' on frame {frame_idx}. No objects detected."
-    return update_frame_display(state, int(frame_idx)), status
+        prompts_str = ", ".join([f"'{p}'" for p in prompt_texts])
+        status = f"Processed text prompt(s) {prompts_str} on frame {frame_idx}. No objects detected."
+
+    active_prompts = _get_active_prompts_display(state)
+    return update_frame_display(state, int(frame_idx)), status, active_prompts
+
+
+def _get_active_prompts_display(state: AppState) -> str:
+    """Get a formatted string showing all active prompts in the inference session."""
+    if state is None or state.inference_session is None:
+        return "**Active prompts:** None"
+
+    if hasattr(state.inference_session, "prompts") and state.inference_session.prompts:
+        prompts_list = sorted(set(state.inference_session.prompts.values()))
+        if prompts_list:
+            prompts_str = ", ".join([f"'{p}'" for p in prompts_list])
+            return f"**Active prompts:** {prompts_str}"
+
+    return "**Active prompts:** None"
 
 
 def propagate_masks(GLOBAL_STATE: gr.State):
@@ -504,6 +633,7 @@ def propagate_masks(GLOBAL_STATE: gr.State):
             model = _GLOBAL_TEXT_VIDEO_MODEL
             processor = _GLOBAL_TEXT_VIDEO_PROCESSOR
 
+            # Collect all unique prompts from existing frame annotations
             text_prompt_to_obj_ids = {}
             for frame_idx, frame_texts in GLOBAL_STATE.text_prompts_by_frame_obj.items():
                 for obj_id, text_prompt in frame_texts.items():
@@ -512,6 +642,12 @@ def propagate_masks(GLOBAL_STATE: gr.State):
                     if obj_id not in text_prompt_to_obj_ids[text_prompt]:
                         text_prompt_to_obj_ids[text_prompt].append(obj_id)
 
+            # Also check if there are prompts already in the inference session
+            if hasattr(GLOBAL_STATE.inference_session, "prompts") and GLOBAL_STATE.inference_session.prompts:
+                for prompt_text in GLOBAL_STATE.inference_session.prompts.values():
+                    if prompt_text not in text_prompt_to_obj_ids:
+                        text_prompt_to_obj_ids[prompt_text] = []
+
             for text_prompt in text_prompt_to_obj_ids:
                 text_prompt_to_obj_ids[text_prompt].sort()
 
@@ -519,6 +655,7 @@ def propagate_masks(GLOBAL_STATE: gr.State):
                 yield GLOBAL_STATE, "No text prompts found. Please add a text prompt first.", gr.update()
                 return
 
+            # Add all prompts to the inference session (processor handles deduplication)
             for text_prompt in text_prompt_to_obj_ids.keys():
                 GLOBAL_STATE.inference_session = processor.add_text_prompt(
                     inference_session=GLOBAL_STATE.inference_session,
@@ -548,6 +685,7 @@ def propagate_masks(GLOBAL_STATE: gr.State):
                 object_ids = processed_outputs["object_ids"]
                 masks = processed_outputs["masks"]
                 scores = processed_outputs["scores"]
+                prompt_to_obj_ids = processed_outputs.get("prompt_to_obj_ids", {})
 
                 masks_for_frame = GLOBAL_STATE.masks_by_frame.setdefault(frame_idx, {})
                 frame_texts = GLOBAL_STATE.text_prompts_by_frame_obj.setdefault(frame_idx, {})
@@ -561,24 +699,23 @@ def propagate_masks(GLOBAL_STATE: gr.State):
 
                     for mask_idx in sorted_indices:
                         current_obj_id = int(object_ids[mask_idx].item())
-                        _ensure_color_for_obj(GLOBAL_STATE, current_obj_id)
                         mask_2d = masks[mask_idx].float().cpu().numpy()
                         if mask_2d.ndim == 3:
                             mask_2d = mask_2d.squeeze()
                         mask_2d = (mask_2d > 0.0).astype(np.float32)
                         masks_for_frame[current_obj_id] = mask_2d
 
+                        # Find which prompt detected this object
                         found_prompt = None
-                        for existing_frame_idx, existing_frame_texts in GLOBAL_STATE.text_prompts_by_frame_obj.items():
-                            if current_obj_id in existing_frame_texts:
-                                found_prompt = existing_frame_texts[current_obj_id]
+                        for prompt, obj_ids in prompt_to_obj_ids.items():
+                            if current_obj_id in obj_ids:
+                                found_prompt = prompt
                                 break
 
-                        if found_prompt is None and text_prompt_to_obj_ids:
-                            found_prompt = list(text_prompt_to_obj_ids.keys())[0]
-
+                        # Store prompt and assign color
                         if found_prompt:
-                            frame_texts[current_obj_id] = found_prompt
+                            frame_texts[current_obj_id] = found_prompt.strip()
+                        _ensure_color_for_obj(GLOBAL_STATE, current_obj_id)
 
                 GLOBAL_STATE.composited_frames.pop(frame_idx, None)
                 last_frame_idx = frame_idx
@@ -620,9 +757,76 @@ def propagate_masks(GLOBAL_STATE: gr.State):
     yield GLOBAL_STATE, text, gr.update(value=last_frame_idx)
 
 
-def reset_session(GLOBAL_STATE: gr.State) -> tuple[AppState, Image.Image, int, int, str]:
+def reset_prompts(GLOBAL_STATE: gr.State) -> tuple[AppState, Image.Image, str, str]:
+    """Reset prompts and all outputs, but keep processed frames and cached vision features."""
+    if GLOBAL_STATE is None or GLOBAL_STATE.inference_session is None:
+        active_prompts = _get_active_prompts_display(GLOBAL_STATE)
+        return GLOBAL_STATE, None, "No active session to reset.", active_prompts
+
+    if GLOBAL_STATE.active_tab != "text":
+        active_prompts = _get_active_prompts_display(GLOBAL_STATE)
+        return GLOBAL_STATE, None, "Reset prompts is only available for text prompting mode.", active_prompts
+
+    # Reset inference session tracking data but keep cache and processed frames
+    if hasattr(GLOBAL_STATE.inference_session, "reset_tracking_data"):
+        GLOBAL_STATE.inference_session.reset_tracking_data()
+
+    # Manually clear prompts (reset_tracking_data doesn't clear prompts themselves)
+    if hasattr(GLOBAL_STATE.inference_session, "prompts"):
+        GLOBAL_STATE.inference_session.prompts.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "prompt_input_ids"):
+        GLOBAL_STATE.inference_session.prompt_input_ids.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "prompt_embeddings"):
+        GLOBAL_STATE.inference_session.prompt_embeddings.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "prompt_attention_masks"):
+        GLOBAL_STATE.inference_session.prompt_attention_masks.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "obj_id_to_prompt_id"):
+        GLOBAL_STATE.inference_session.obj_id_to_prompt_id.clear()
+
+    # Reset detection-tracking fusion state
+    if hasattr(GLOBAL_STATE.inference_session, "obj_id_to_score"):
+        GLOBAL_STATE.inference_session.obj_id_to_score.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "obj_id_to_tracker_score_frame_wise"):
+        GLOBAL_STATE.inference_session.obj_id_to_tracker_score_frame_wise.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "obj_id_to_last_occluded"):
+        GLOBAL_STATE.inference_session.obj_id_to_last_occluded.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "max_obj_id"):
+        GLOBAL_STATE.inference_session.max_obj_id = -1
+    if hasattr(GLOBAL_STATE.inference_session, "obj_first_frame_idx"):
+        GLOBAL_STATE.inference_session.obj_first_frame_idx.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "unmatched_frame_inds"):
+        GLOBAL_STATE.inference_session.unmatched_frame_inds.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "overlap_pair_to_frame_inds"):
+        GLOBAL_STATE.inference_session.overlap_pair_to_frame_inds.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "trk_keep_alive"):
+        GLOBAL_STATE.inference_session.trk_keep_alive.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "removed_obj_ids"):
+        GLOBAL_STATE.inference_session.removed_obj_ids.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "suppressed_obj_ids"):
+        GLOBAL_STATE.inference_session.suppressed_obj_ids.clear()
+    if hasattr(GLOBAL_STATE.inference_session, "hotstart_removed_obj_ids"):
+        GLOBAL_STATE.inference_session.hotstart_removed_obj_ids.clear()
+
+    # Clear all app state outputs
+    GLOBAL_STATE.masks_by_frame.clear()
+    GLOBAL_STATE.text_prompts_by_frame_obj.clear()
+    GLOBAL_STATE.composited_frames.clear()
+    GLOBAL_STATE.color_by_obj.clear()
+    GLOBAL_STATE.color_by_prompt.clear()
+
+    # Update display
+    current_idx = int(getattr(GLOBAL_STATE, "current_frame_idx", 0))
+    current_idx = max(0, min(current_idx, GLOBAL_STATE.num_frames - 1))
+    preview_img = update_frame_display(GLOBAL_STATE, current_idx)
+    active_prompts = _get_active_prompts_display(GLOBAL_STATE)
+    status = "Prompts and outputs reset. Processed frames and cached vision features preserved."
+
+    return GLOBAL_STATE, preview_img, status, active_prompts
+
+
+def reset_session(GLOBAL_STATE: gr.State) -> tuple[AppState, Image.Image, int, int, str, str]:
     if not GLOBAL_STATE.video_frames:
-        return GLOBAL_STATE, None, 0, 0, "Session reset. Load a new video."
+        return GLOBAL_STATE, None, 0, 0, "Session reset. Load a new video.", "**Active prompts:** None"
 
     if GLOBAL_STATE.active_tab == "text":
         if GLOBAL_STATE.video_frames:
@@ -645,11 +849,9 @@ def reset_session(GLOBAL_STATE: gr.State) -> tuple[AppState, Image.Image, int, i
             GLOBAL_STATE.inference_session = processor.init_video_session(
                 video=raw_video,
                 inference_device=_GLOBAL_DEVICE,
-                video_storage_device=_GLOBAL_DEVICE,
-                processing_device=_GLOBAL_DEVICE,
-                inference_state_device=_GLOBAL_DEVICE,
+                video_storage_device="cpu",
+                processing_device="cpu",
                 dtype=_GLOBAL_DTYPE,
-                max_vision_features_cache_size=1,
             )
 
     GLOBAL_STATE.masks_by_frame.clear()
@@ -657,6 +859,8 @@ def reset_session(GLOBAL_STATE: gr.State) -> tuple[AppState, Image.Image, int, i
     GLOBAL_STATE.boxes_by_frame_obj.clear()
     GLOBAL_STATE.text_prompts_by_frame_obj.clear()
     GLOBAL_STATE.composited_frames.clear()
+    GLOBAL_STATE.color_by_obj.clear()
+    GLOBAL_STATE.color_by_prompt.clear()
     GLOBAL_STATE.pending_box_start = None
     GLOBAL_STATE.pending_box_start_frame_idx = None
     GLOBAL_STATE.pending_box_start_obj_id = None
@@ -669,7 +873,8 @@ def reset_session(GLOBAL_STATE: gr.State) -> tuple[AppState, Image.Image, int, i
     slider_minmax = gr.update(minimum=0, maximum=max(GLOBAL_STATE.num_frames - 1, 0), interactive=True)
     slider_value = gr.update(value=current_idx)
     status = "Session reset. Prompts cleared; video preserved."
-    return GLOBAL_STATE, preview_img, slider_minmax, slider_value, status
+    active_prompts = _get_active_prompts_display(GLOBAL_STATE)
+    return GLOBAL_STATE, preview_img, slider_minmax, slider_value, status, active_prompts
 
 
 def _on_video_change_pointbox(GLOBAL_STATE: gr.State, video):
@@ -684,11 +889,13 @@ def _on_video_change_pointbox(GLOBAL_STATE: gr.State, video):
 
 def _on_video_change_text(GLOBAL_STATE: gr.State, video):
     GLOBAL_STATE, min_idx, max_idx, first_frame, status = init_video_session(GLOBAL_STATE, video, "text")
+    active_prompts = _get_active_prompts_display(GLOBAL_STATE)
     return (
         GLOBAL_STATE,
         gr.update(minimum=min_idx, maximum=max_idx, value=min_idx, interactive=True),
         first_frame,
         status,
+        active_prompts,
     )
 
 
@@ -712,7 +919,7 @@ with gr.Blocks(title="SAM3", theme=theme) as demo:
                         """
                         **Quick start**
                         - **Load a video**: Upload your own or pick an example below.
-                        - Select a frame and enter a text description to segment objects (e.g., "red car", "penguin"). The text prompt will return all the instances of the object in the frame and not specific ones (e.g. not "penguin on the left" but "penguin").
+                        - Select a frame and enter text description(s) to segment objects (e.g., "red car", "penguin"). You can add multiple prompts separated by commas (e.g., "person, bed, lamp") or add them one by one. The text prompt will return all the instances of the object in the frame and not specific ones (e.g. not "penguin on the left" but "penguin").
                         """
                     )
                 with gr.Column():
@@ -741,11 +948,14 @@ with gr.Blocks(title="SAM3", theme=theme) as demo:
                             propagate_status_text = gr.Markdown(visible=True)
                     with gr.Row():
                         text_prompt_input = gr.Textbox(
-                            label="Text Prompt",
-                            placeholder="Enter a text description (e.g., 'person', 'red car', 'short hair')",
+                            label="Text Prompt(s)",
+                            placeholder="Enter text description(s) (e.g., 'person' or 'person, bed, lamp' for multiple)",
                             lines=2,
                         )
-                        text_apply_btn = gr.Button("Apply Text Prompt", variant="primary")
+                        with gr.Column(scale=0):
+                            text_apply_btn = gr.Button("Apply Text Prompt(s)", variant="primary")
+                            reset_prompts_btn = gr.Button("Reset Prompts", variant="secondary")
+                    active_prompts_display = gr.Markdown("**Active prompts:** None", visible=True)
                     text_status = gr.Markdown(visible=True)
 
             with gr.Row():
@@ -762,7 +972,7 @@ with gr.Blocks(title="SAM3", theme=theme) as demo:
                     examples=examples_list_text,
                     inputs=[GLOBAL_STATE, video_in_text],
                     fn=_on_video_change_text,
-                    outputs=[GLOBAL_STATE, frame_slider_text, preview_text, load_status_text],
+                    outputs=[GLOBAL_STATE, frame_slider_text, preview_text, load_status_text, active_prompts_display],
                     label="Examples",
                     cache_examples=False,
                     examples_per_page=5,
@@ -790,7 +1000,9 @@ with gr.Blocks(title="SAM3", theme=theme) as demo:
 
             with gr.Row():
                 with gr.Column(scale=1):
-                    video_in_pointbox = gr.Video(label="Upload video", sources=["upload", "webcam"], interactive=True, max_length=7)
+                    video_in_pointbox = gr.Video(
+                        label="Upload video", sources=["upload", "webcam"], interactive=True, max_length=7
+                    )
                     load_status_pointbox = gr.Markdown(visible=True)
                     reset_btn_pointbox = gr.Button("Reset Session", variant="secondary")
                 with gr.Column(scale=2):
@@ -850,7 +1062,7 @@ with gr.Blocks(title="SAM3", theme=theme) as demo:
     video_in_text.change(
         _on_video_change_text,
         inputs=[GLOBAL_STATE, video_in_text],
-        outputs=[GLOBAL_STATE, frame_slider_text, preview_text, load_status_text],
+        outputs=[GLOBAL_STATE, frame_slider_text, preview_text, load_status_text, active_prompts_display],
         show_progress=True,
     )
 
@@ -903,13 +1115,19 @@ with gr.Blocks(title="SAM3", theme=theme) as demo:
     )
 
     def _on_text_apply(state: AppState, frame_idx: int, text: str):
-        img, status = on_text_prompt(state, frame_idx, text)
-        return img, status
+        img, status, active_prompts = on_text_prompt(state, frame_idx, text)
+        return img, status, active_prompts
 
     text_apply_btn.click(
         _on_text_apply,
         inputs=[GLOBAL_STATE, frame_slider_text, text_prompt_input],
-        outputs=[preview_text, text_status],
+        outputs=[preview_text, text_status, active_prompts_display],
+    )
+
+    reset_prompts_btn.click(
+        reset_prompts,
+        inputs=[GLOBAL_STATE],
+        outputs=[GLOBAL_STATE, preview_text, text_status, active_prompts_display],
     )
 
     def _render_video(s: AppState):
@@ -962,7 +1180,14 @@ with gr.Blocks(title="SAM3", theme=theme) as demo:
     reset_btn_text.click(
         reset_session,
         inputs=GLOBAL_STATE,
-        outputs=[GLOBAL_STATE, preview_text, frame_slider_text, frame_slider_text, load_status_text],
+        outputs=[
+            GLOBAL_STATE,
+            preview_text,
+            frame_slider_text,
+            frame_slider_text,
+            load_status_text,
+            active_prompts_display,
+        ],
     )