Update app.py

app.py

@@ -9,13 +9,12 @@ from typing import List, Tuple, Optional
 import requests
 from PIL import Image, ImageFile, UnidentifiedImageError
 import gradio as gr
-import asyncio
-import threading
+# import asyncio # Not used
+# import threading # Not directly used for core logic, implicit in Gradio's max_threads
 import time
 import atexit
 from requests.exceptions import RequestException, HTTPError # Import for rate limiting
 
-
 # --- Configuration and Globals ---
 DEFAULT_KEY = os.getenv("MISTRAL_API_KEY", "")
 PIXTRAL_MODEL = "pixtral-12b-2409"
@@ -37,10 +36,23 @@ SYSTEM_INSTRUCTION = (
 ImageFile.LOAD_TRUNCATED_IMAGES = True
 Image.MAX_IMAGE_PIXELS = 10000 * 10000
 
+# Add a default User-Agent header for external requests to improve compatibility
+DEFAULT_HEADERS = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"}
+
 try:
     from mistralai import Mistral
-except Exception:
+    from mistralai.exceptions import MistralAPIException # Import for better error handling
+except ImportError: # Use ImportError for module import issues
     Mistral = None
+    # Define a mock MistralAPIException for type hinting and to avoid NameError
+    class MistralAPIException(Exception):
+        def __init__(self, message, status_code=None, *args, **kwargs):
+            super().__init__(message, *args)
+            self.status_code = status_code
+        @property
+        def message(self):
+            return self.args[0] if self.args else "An unknown Mistral API error occurred (mistralai library not installed)."
+
 
 # --- Temporary File Cleanup ---
 _temp_preview_files_to_delete = []
@@ -84,13 +96,13 @@ def ext_from_src(src: str) -> str:
 
 def safe_head(url: str, timeout: int = 6):
     try:
-        r = requests.head(url, timeout=timeout, allow_redirects=True)
+        r = requests.head(url, timeout=timeout, allow_redirects=True, headers=DEFAULT_HEADERS)
         return None if r.status_code >= 400 else r
     except Exception:
         return None
 
 def safe_get(url: str, timeout: int = 15):
-    r = requests.get(url, timeout=timeout)
+    r = requests.get(url, timeout=timeout, headers=DEFAULT_HEADERS)
     r.raise_for_status()
     return r
 
@@ -111,6 +123,10 @@ def _temp_file(data: bytes, suffix: str) -> str:
     return path
 
 def fetch_bytes(src: str, stream_threshold: int = STREAM_THRESHOLD, timeout: int = 60, progress=None) -> bytes:
+    """
+    Fetches bytes from a local path or remote URL, handling large files by streaming to a temp file.
+    Returns the content as bytes.
+    """
     if progress is not None:
         progress(0.05, desc="Checking remote/local source...")
     if is_remote(src):
@@ -121,24 +137,26 @@ def fetch_bytes(src: str, stream_threshold: int = STREAM_THRESHOLD, timeout: int
                 if cl and int(cl) > stream_threshold:
                     if progress is not None:
                         progress(0.1, desc="Streaming large remote file...")
-                    with requests.get(src, timeout=timeout, stream=True) as r:
-                        r.raise_for_status()
-                        fd, p = tempfile.mkstemp()
-                        os.close(fd)
-                        try:
+                    fd, p = tempfile.mkstemp(suffix=ext_from_src(src) or ".tmp")
+                    os.close(fd)
+                    # This temp file is only for streaming download, and will be read back.
+                    # It's not intended for final preview display or analysis directly.
+                    try:
+                        with requests.get(src, timeout=timeout, stream=True, headers=DEFAULT_HEADERS) as r:
+                            r.raise_for_status()
                             with open(p, "wb") as fh:
                                 for chunk in r.iter_content(8192):
                                     if chunk:
                                         fh.write(chunk)
-                            with open(p, "rb") as fh:
-                                return fh.read()
-                        finally:
-                            # This temp file is only for streaming download, not for final preview
-                            try: os.remove(p)
-                            except Exception: pass
-            except Exception:
+                        with open(p, "rb") as fh:
+                            return fh.read()
+                    finally:
+                        try: os.remove(p)
+                        except Exception as e: print(f"Error during streaming temp file cleanup {p}: {e}")
+            except Exception as e:
+                print(f"Warning: Streaming download failed for {src}: {e}. Falling back to non-streaming.")
                 pass # Fallback to non-streaming download if streaming fails
-        r = safe_get(src, timeout=timeout)
+        r = safe_get(src, timeout=timeout) # safe_get uses DEFAULT_HEADERS
         if progress is not None:
             progress(0.25, desc="Downloaded remote content")
         return r.content
@@ -213,31 +231,42 @@ def _get_video_info_and_timestamps(media_path: str, sample_count: int) -> Tuple[
 
     timestamps: List[float] = []
     if duration > 0 and sample_count > 0:
-        step = duration / (sample_count + 1)
-        timestamps = [step * (i + 1) for i in range(sample_count)]
-    else:
-        timestamps = [0.5, 1.0, 2.0, 3.0, 4.0][:sample_count] # Fallback to fixed times
+        # Ensure we don't go past the video duration, or request too many samples
+        actual_sample_count = min(sample_count, int(duration)) # Limit samples to integer seconds
+        if actual_sample_count > 0:
+            step = duration / (actual_sample_count + 1)
+            timestamps = [step * (i + 1) for i in range(actual_sample_count)]
+
+    # If no timestamps generated or duration is 0, fall back to fixed times
+    if not timestamps:
+        timestamps = [0.5, 1.0, 2.0, 3.0, 4.0][:sample_count] 
+
     return info, timestamps
 
-def extract_frames_for_model_and_gallery(media_path: str, sample_count: int = 5, timeout_extract: int = 15, gallery_base_h: int = 128, progress=None) -> Tuple[List[bytes], List[str]]:
+def extract_frames_for_model_and_gallery(media_path: str, sample_count: int = 5, timeout_extract: int = 15, gallery_base_h: int = 256, progress=None) -> Tuple[List[bytes], List[str]]:
     """
     Extracts frames from a video, processes them for both model input (high-res JPEG bytes)
     and gallery display (smaller JPEG temp file paths), in a single pass.
+    Increased gallery_base_h for better quality.
     """
     frames_for_model: List[bytes] = [] # List of JPEG bytes for model input
     frame_paths_for_gallery: List[str] = [] # List of temp JPEG file paths for gallery
 
     if not FFMPEG_BIN or not os.path.exists(media_path):
+        print(f"Warning: FFMPEG not found or media path does not exist: {media_path}. Cannot extract frames.")
         return frames_for_model, frame_paths_for_gallery
 
     if progress is not None:
         progress(0.05, desc="Preparing frame extraction...")
 
     _, timestamps = _get_video_info_and_timestamps(media_path, sample_count)
+    if not timestamps:
+        print(f"Warning: No valid timestamps generated for {media_path}. Cannot extract frames.")
+        return frames_for_model, frame_paths_for_gallery
 
     for i, t in enumerate(timestamps):
         if progress is not None:
-            progress(0.1 + (i / max(1, sample_count)) * 0.2, desc=f"Extracting frame {i+1}/{sample_count}...")
+            progress(0.1 + (i / max(1, sample_count)) * 0.2, desc=f"Extracting frame {i+1}/{sample_count} at {t:.1f}s...")
 
         # Extract to a temp PNG first for best quality, then process with PIL
         fd_raw, tmp_png_path = tempfile.mkstemp(suffix=f"_frame_{i}.png")
@@ -261,7 +290,7 @@ def extract_frames_for_model_and_gallery(media_path: str, sample_count: int = 5,
                     frames_for_model.append(jpeg_model_bytes)
 
                 # For gallery: convert to smaller JPEG bytes and save as new temp file
-                jpeg_gallery_bytes = convert_to_jpeg_bytes(raw_frame_bytes, base_h=gallery_base_h)
+                jpeg_gallery_bytes = convert_to_jpeg_bytes(raw_frame_bytes, base_h=gallery_base_h) # Higher base_h
                 if jpeg_gallery_bytes: # Only create temp file if conversion was successful
                     temp_jpeg_path = _temp_file(jpeg_gallery_bytes, suffix=f"_gallery_{i}.jpg") # _temp_file tracks this for cleanup
                     if temp_jpeg_path: # Only add to gallery if temp file was successfully created
@@ -292,7 +321,7 @@ def chat_complete(client, model: str, messages, timeout: int = 120, progress=Non
 
             # Prefer using the Mistral client if available and functional
             if hasattr(client, "chat") and hasattr(client.chat, "complete"):
-                res = client.chat.complete(model=model, messages=messages, stream=False, timeout_ms=timeout * 1000) # FIX: use timeout_ms
+                res = client.chat.complete(model=model, messages=messages, stream=False, timeout_ms=timeout * 1000)
             else:
                 api_key = getattr(client, "api_key", "") or DEFAULT_KEY
                 if not api_key:
@@ -315,14 +344,21 @@ def chat_complete(client, model: str, messages, timeout: int = 120, progress=Non
             content = (msg.get("content") if isinstance(msg, dict) else getattr(msg, "content", None))
             return content.strip() if isinstance(content, str) else str(content)
 
-        except HTTPError as e:
+        except MistralAPIException as e: # Catch Mistral client's specific API exceptions
+            if e.status_code == 429 and attempt < max_retries - 1:
+                delay = initial_delay * (2 ** attempt)
+                print(f"MistralAPIException: Rate limit exceeded (429). Retrying in {delay:.2f}s...")
+                time.sleep(delay)
+            else:
+                return f"Error: Mistral API error occurred with status {e.status_code}: {e.message}"
+        except HTTPError as e: # For direct requests calls
             if e.response.status_code == 429 and attempt < max_retries - 1:
                 delay = initial_delay * (2 ** attempt)
                 print(f"Rate limit exceeded (429). Retrying in {delay:.2f}s...")
                 time.sleep(delay)
             else:
                 return f"Error: API request failed with status {e.response.status_code}: {e.response.text}"
-        except RequestException as e:
+        except RequestException as e: # For direct requests calls
             if attempt < max_retries - 1:
                 delay = initial_delay * (2 ** attempt)
                 print(f"Network/API request failed: {e}. Retrying in {delay:.2f}s...")
@@ -332,7 +368,7 @@ def chat_complete(client, model: str, messages, timeout: int = 120, progress=Non
         except Exception as e:
             return f"Error during model call: {e}"
 
-    return "Error: Maximum retries reached for API call." # Should ideally not be reached if handled gracefully
+    return "Error: Maximum retries reached for API call."
 
 def upload_file_to_mistral(client, path: str, filename: str | None = None, purpose: str = "batch", timeout: int = 120, progress=None) -> str:
     fname = filename or os.path.basename(path)
@@ -347,8 +383,10 @@ def upload_file_to_mistral(client, path: str, filename: str | None = None, purpo
                 with open(path, "rb") as fh:
                     res = client.files.upload(file={"file_name": fname, "content": fh}, purpose=purpose)
                 fid = getattr(res, "id", None) or (res.get("id") if isinstance(res, dict) else None)
-                if not fid: # Older API responses might nest id in 'data'
+                if not fid and isinstance(res, dict) and "data" in res and res["data"]: # Older API responses might nest id in 'data'
                     fid = res["data"][0]["id"]
+                if not fid:
+                    raise RuntimeError(f"Mistral API upload response missing file ID: {res}")
                 if progress is not None:
                     progress(0.6, desc="Upload complete")
                 return fid
@@ -367,6 +405,13 @@ def upload_file_to_mistral(client, path: str, filename: str | None = None, purpo
                     if progress is not None:
                         progress(0.65, desc="Upload complete (REST)")
                     return jr.get("id") or jr.get("data", [{}])[0].get("id")
+        except MistralAPIException as e: # Catch Mistral client's specific API exceptions
+            if e.status_code == 429 and attempt < max_retries - 1:
+                delay = initial_delay * (2 ** attempt)
+                print(f"MistralAPIException: Upload rate limit exceeded (429). Retrying in {delay:.2f}s...")
+                time.sleep(delay)
+            else:
+                raise RuntimeError(f"Mistral API file upload failed with status {e.status_code}: {e.message}") from e
         except HTTPError as e:
             if e.response.status_code == 429 and attempt < max_retries - 1:
                 delay = initial_delay * (2 ** attempt)
@@ -392,7 +437,7 @@ def determine_media_type(src: str, progress=None) -> Tuple[bool, bool]:
 
     if ext in IMAGE_EXTS:
         is_image = True
-    elif ext in VIDEO_EXTS: # Use elif to prioritize video if both extensions are possible (unlikely but safe)
+    elif ext in VIDEO_EXTS:
         is_video = True
 
     if is_remote(src):
@@ -405,7 +450,7 @@ def determine_media_type(src: str, progress=None) -> Tuple[bool, bool]:
                 is_video, is_image = True, False
 
     if progress is not None:
-        progress(0.02, desc="Determined media type")
+        progress(0.02, desc="Determined media type (initial hint)")
     return is_image, is_video
 
 def analyze_image_structured(client, img_bytes: bytes, prompt: str, progress=None) -> str:
@@ -451,7 +496,7 @@ def analyze_video_cohesive(client, video_path: str, prompt: str, progress=None)
         # If successful upload, still extract frames for gallery display
         # Use the combined function for gallery frames
         _, gallery_frame_paths = extract_frames_for_model_and_gallery(
-            video_path, sample_count=6, gallery_base_h=128, progress=progress
+            video_path, sample_count=6, gallery_base_h=256, progress=progress # Increased gallery_base_h
         )
         return result, gallery_frame_paths
     except Exception as e:
@@ -460,7 +505,7 @@ def analyze_video_cohesive(client, video_path: str, prompt: str, progress=None)
 
         # Use the combined extraction function for both model input and gallery display
         frames_for_model_bytes, gallery_frame_paths = extract_frames_for_model_and_gallery(
-            video_path, sample_count=6, gallery_base_h=128, progress=progress
+            video_path, sample_count=6, gallery_base_h=256, progress=progress # Increased gallery_base_h
         )
 
         if not frames_for_model_bytes:
@@ -469,7 +514,6 @@ def analyze_video_cohesive(client, video_path: str, prompt: str, progress=None)
         image_entries = []
         for i, fb in enumerate(frames_for_model_bytes, start=1):
             if progress is not None:
-                # Update progress description to reflect that frames are already prepared as JPEGs
                 progress(0.4 + (i / len(frames_for_model_bytes)) * 0.2, desc=f"Adding frame {i}/{len(frames_for_model_bytes)} to model input...")
             image_entries.append(
                 {
@@ -505,7 +549,7 @@ def _convert_video_for_preview_if_needed(path: str) -> str:
             if video_streams and any(s.get("codec_name") in ("h264", "h265", "avc1") for s in video_streams):
                 return path # Already playable
 
-    out_path = _temp_file(b"", suffix=".mp4") # Create an empty temp file and add to cleanup list (will return "" if data is b"")
+    out_path = _temp_file(b"", suffix=".mp4") # Create an empty temp file and add to cleanup list
     if not out_path: # If _temp_file returned empty path
         print(f"Error: Could not create temporary file for video conversion from {path}.")
         return path # Fallback to original path
@@ -540,26 +584,34 @@ def _get_playable_preview_path_from_raw(src_url: str, raw_bytes: bytes, is_image
         return ""
 
     # Determine media type (prioritizing hints, then byte analysis)
+    # This logic aims to be somewhat lenient for preview display
     is_actually_image = False
     is_actually_video = False
 
-    if is_image_hint:
+    # Try to determine from bytes first, if hints are ambiguous or absent
+    try:
+        Image.open(BytesIO(raw_bytes)).verify()
         is_actually_image = True
-    elif is_video_hint:
-        is_actually_video = True
-    else: # If hints are not definitive, try to determine from bytes
-        try:
-            # Attempt to open as image
-            # We don't need to load the whole image, just verify format.
-            Image.open(BytesIO(raw_bytes)).verify()
-            is_actually_image = True
-        except UnidentifiedImageError:
-            # Not an identifiable image by PIL, assume video
-            is_actually_video = True
-        except Exception as e:
-            # Other PIL errors, assume video as a fallback for preview
-            print(f"Warning: Generic error during image check for {src_url}: {e}. Falling back to video preview attempt.")
+    except UnidentifiedImageError:
+        # Not an identifiable image by PIL. Now consider hints or default to video.
+        is_actually_image = False
+        if is_video_hint:
             is_actually_video = True
+        elif is_image_hint: # If hinted as image but PIL failed, still prefer image for error clarity
+            print(f"Warning: Hinted as image but PIL failed for {src_url}. Assuming image for preview attempt.")
+            is_actually_image = True
+        else:
+            is_actually_video = True # No strong hint, not an image, assume video
+    except Exception as e:
+        print(f"Warning: Generic error during image check for {src_url}: {e}. Falling back to video preview attempt.")
+        is_actually_image = False # Clear image flag
+        is_actually_video = True # Assume video as a fallback for preview
+
+    # If still neither, use original hints as last resort
+    if not is_actually_image and not is_actually_video:
+        is_actually_image = is_image_hint
+        is_actually_video = is_video_hint
+
 
     # --- Attempt Image Preview ---
     if is_actually_image:
@@ -597,69 +649,6 @@ def _get_playable_preview_path_from_raw(src_url: str, raw_bytes: bytes, is_image
     return ""
 
 
-def _fetch_with_retries_bytes(src: str, timeout: int = 15, max_retries: int = 3) -> bytes:
-    attempt = 0
-    delay = 1.0
-    while True:
-        attempt += 1
-        try:
-            if is_remote(src):
-                # Using requests.get without stream and directly returning content for simplicity here,
-                # as stream logic is primarily handled in fetch_bytes for large files.
-                # For preview, we often need the full file quickly.
-                r = requests.get(src, timeout=timeout)
-                r.raise_for_status()
-                return r.content
-            else:
-                with open(src, "rb") as fh:
-                    return fh.read()
-        except requests.exceptions.RequestException as e:
-            if attempt >= max_retries:
-                raise RuntimeError(f"Failed to fetch {src} after {max_retries} attempts: {e}")
-            print(f"Retrying fetch for {src} ({attempt}/{max_retries}). Delaying {delay:.1f}s...")
-            time.sleep(delay)
-            delay *= 2
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Local path not found: {src}")
-        except Exception as e:
-            if attempt >= max_retries:
-                raise RuntimeError(f"Failed to fetch {src} after {max_retries} attempts due to unexpected error: {e}")
-            print(f"Retrying fetch for {src} ({attempt}/{max_retries}). Delaying {delay:.1f}s...")
-            time.sleep(delay)
-            delay *= 2
-
-def _save_local_playable_preview(src: str, is_image_hint: bool, is_video_hint: bool) -> Optional[str]:
-    """
-    Fetches remote content or reads local, then ensures it's in a playable format
-    for Gradio preview components, using media type hints.
-    Returns None if no playable preview could be generated.
-    """
-    if not src:
-        return None
-
-    if not is_remote(src):
-        if os.path.exists(src):
-            if is_video_hint:
-                return _convert_video_for_preview_if_needed(src)
-            return src # For local images, return the path directly.
-        return None
-
-    # Remote source
-    try:
-        raw_bytes = _fetch_with_retries_bytes(src, timeout=15, max_retries=3)
-        if not raw_bytes: # Handle case where fetch_bytes returns empty
-            print(f"Error: Failed to fetch any bytes for {src}.")
-            return None
-
-        playable_path = _get_playable_preview_path_from_raw(src, raw_bytes, is_image_hint, is_video_hint)
-        if not playable_path: # Handle case where _get_playable_preview_path_from_raw couldn't create a path
-            print(f"Error: No playable preview path generated for {src}.")
-            return None
-        return playable_path
-    except Exception as e:
-        print(f"Error creating local playable preview from {src}: {e}")
-        return None
-
 # --- Gradio Interface Logic ---
 css = ".preview_media img, .preview_media video { max-width: 100%; height: auto; border-radius:6px; }"
 
@@ -694,13 +683,16 @@ def create_demo():
                 main_preview_path_state = gr.State("")
                 # State to hold the list of screenshot paths for the gallery
                 screenshot_paths_state = gr.State([])
+                # New state to hold the path to the raw downloaded media file for analysis
+                raw_media_path_state = gr.State("")
+
 
         def clear_all_files_and_ui():
             """
             Cleans up all tracked temporary files and resets all relevant UI components.
             This function is meant to be called at the start of any new processing
             or when the user explicitly clicks "Clear".
-            Returns 10 values for the 10 output components.
+            Returns values for all 11 output components.
             """
             for f_path in list(_temp_preview_files_to_delete):
                 if os.path.exists(f_path):
@@ -708,9 +700,9 @@ def create_demo():
                         os.remove(f_path)
                     except Exception as e:
                         print(f"Error during proactive cleanup of {f_path}: {e}")
-            _temp_preview_files_to_delete.clear() 
+            _temp_preview_files_to_delete.clear()
 
-            # Return exactly 10 values to match the outputs list
+            # Return exactly 11 values to match the outputs list
             return "", \
                    gr.update(value=None, visible=False), \
                    gr.update(value=None, visible=False), \
@@ -720,7 +712,9 @@ def create_demo():
                    "", \
                    "", \
                    [], \
-                   gr.update(value="", visible=True)
+                   gr.update(value="", visible=True), \
+                   "" # For raw_media_path_state
+
 
         clear_btn.click(
             fn=clear_all_files_and_ui,
@@ -735,39 +729,62 @@ def create_demo():
                 output_md,
                 main_preview_path_state,
                 screenshot_paths_state,
-                preview_status
+                preview_status,
+                raw_media_path_state # Clear the raw media path state as well
             ]
         )
 
         # Function to handle URL input change and update main preview
-        def load_main_preview_and_clear_old(url: str):
+        def load_main_preview_and_clear_old(url: str, progress=gr.Progress()):
             # First, clear all existing temporary files and reset UI components
-            # This ensures a clean slate before loading new content
-            # The unpacking now expects 10 values, correctly.
             _, img_update_clear, video_update_clear, gallery_update_clear, _, _, _, \
-            main_path_clear, screenshot_paths_clear, status_update_clear = clear_all_files_and_ui() # Call the cleanup function
+            main_path_clear, screenshot_paths_clear, status_update_clear, raw_media_path_clear = clear_all_files_and_ui()
 
             if not url:
                 return img_update_clear, video_update_clear, gallery_update_clear, \
-                       gr.update(value="", visible=True), main_path_clear, screenshot_paths_clear
-
-            # Determine media type once for preview loading
-            is_img_initial, is_vid_initial = determine_media_type(url)
+                       gr.update(value="", visible=True), main_path_clear, screenshot_paths_clear, raw_media_path_clear
 
+            raw_bytes_for_analysis = b""
+            temp_raw_path_for_analysis = ""
             try:
-                # Pass determined types to _save_local_playable_preview
-                local_playable_path = _save_local_playable_preview(url, is_img_initial, is_vid_initial) 
+                # 1. Fetch raw bytes once for both preview and analysis
+                progress(0.01, desc="Downloading media for preview and analysis...")
+                raw_bytes_for_analysis = fetch_bytes(url, timeout=60, progress=progress)
+                if not raw_bytes_for_analysis:
+                    return img_update_clear, video_update_clear, gallery_update_clear, \
+                           gr.update(value="Preview load failed: No media bytes fetched.", visible=True), \
+                           main_path_clear, screenshot_paths_clear, raw_media_path_clear
+
+                # Store raw bytes in a temp file for potential analysis (especially video uploads or large image processing)
+                # This file is tracked for cleanup by _temp_file
+                temp_raw_path_for_analysis = _temp_file(raw_bytes_for_analysis, suffix=ext_from_src(url) or ".tmp")
+                if not temp_raw_path_for_analysis:
+                    return img_update_clear, video_update_clear, gallery_update_clear, \
+                           gr.update(value="Preview load failed: Could not save raw media to temp file.", visible=True), \
+                           main_path_clear, screenshot_paths_clear, raw_media_path_clear
+
+                progress(0.05, desc="Generating playable preview...")
+                # 2. Determine initial media type based on URL/headers (hints for preview generation)
+                is_img_initial, is_vid_initial = determine_media_type(url)
+
+                # 3. Generate playable path from the fetched raw bytes and hints
+                local_playable_path = _get_playable_preview_path_from_raw(url, raw_bytes_for_analysis, is_img_initial, is_vid_initial)
+
                 if not local_playable_path:
+                    # If preview failed, cleanup the temp_raw_path_for_analysis as well
+                    if temp_raw_path_for_analysis in _temp_preview_files_to_delete:
+                        _temp_preview_files_to_delete.remove(temp_raw_path_for_analysis)
+                    try: os.remove(temp_raw_path_for_analysis)
+                    except Exception as e: print(f"Error during cleanup of raw temp file {temp_raw_path_for_analysis}: {e}")
                     return img_update_clear, video_update_clear, gallery_update_clear, \
-                           gr.update(value="Preview load failed: could not fetch resource or make playable.", visible=True), \
-                           "", []
+                           gr.update(value="Preview load failed: could not make content playable.", visible=True), \
+                           main_path_clear, screenshot_paths_clear, raw_media_path_clear
 
-                # Re-evaluate media type from the local_playable_path if it's different from the original URL
-                # This handles cases where _save_local_playable_preview might have converted a generic file.
+                # 4. Re-evaluate actual type for Gradio display from the *playable path*
+                # This is important as _get_playable_preview_path_from_raw might have converted the format
                 is_img_preview = False
                 is_vid_preview = False
 
-                # Check actual file extension
                 ext = ext_from_src(local_playable_path)
                 if ext in IMAGE_EXTS:
                     is_img_preview = True
@@ -780,132 +797,108 @@ def create_demo():
                         Image.open(local_playable_path).verify()
                         is_img_preview = True
                     except Exception:
-                        # If not an image, assume it might be a video (or non-playable)
+                        # If not an image, assume it might be a video (or non-playable for Gradio)
                         is_vid_preview = True # Flag as video for Gradio component decision
 
                 if is_img_preview:
                     return gr.update(value=local_playable_path, visible=True), gr.update(value=None, visible=False), \
                            gr.update(value=[], visible=False), gr.update(value="Image preview loaded.", visible=True), \
-                           local_playable_path, []
+                           local_playable_path, [], temp_raw_path_for_analysis # Update raw_media_path_state
                 elif is_vid_preview: # Assume video if not image
                     return gr.update(value=None, visible=False), gr.update(value=local_playable_path, visible=True), \
                            gr.update(value=[], visible=False), gr.update(value="Video preview loaded.", visible=True), \
-                           local_playable_path, []
+                           local_playable_path, [], temp_raw_path_for_analysis # Update raw_media_path_state
                 else:
-                    return gr.update(value=None, visible=False), gr.update(value=None, visible=False), \
-                           gr.update(value=[], visible=False), gr.update(value="Preview load failed: unknown playable format.", visible=True), \
-                           "", []
+                    return img_update_clear, video_update_clear, gallery_update_clear, \
+                           gr.update(value="Preview load failed: unknown playable format.", visible=True), \
+                           main_path_clear, screenshot_paths_clear, raw_media_path_clear
 
 
             except Exception as e:
-                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), \
-                       gr.update(value=[], visible=False), gr.update(value=f"Preview load failed: {e}", visible=True), \
-                       "", []
+                # Cleanup temp_raw_path_for_analysis on error
+                if temp_raw_path_for_analysis in _temp_preview_files_to_delete:
+                    _temp_preview_files_to_delete.remove(temp_raw_path_for_analysis)
+                try: os.remove(temp_raw_path_for_analysis)
+                except Exception as ex: print(f"Error during cleanup of raw temp file {temp_raw_path_for_analysis} on error: {ex}")
+                return img_update_clear, video_update_clear, gallery_update_clear, \
+                       gr.update(value=f"Preview load failed: {e}", visible=True), \
+                       main_path_clear, screenshot_paths_clear, raw_media_path_clear
+
 
         url_input.change(
             fn=load_main_preview_and_clear_old,
             inputs=[url_input],
-            outputs=[preview_image, preview_video, screenshot_gallery, preview_status, main_preview_path_state, screenshot_paths_state]
+            outputs=[preview_image, preview_video, screenshot_gallery, preview_status, main_preview_path_state, screenshot_paths_state, raw_media_path_state]
         )
 
-        def worker(url: str, prompt: str, key: str, progress=gr.Progress()):
+        def worker(url: str, prompt: str, key: str, current_main_preview_path: str, raw_media_path: str, progress=gr.Progress()):
             """
-            Performs the media analysis.
+            Performs the media analysis using the pre-downloaded raw media.
             Returns (status, markdown_output, main_preview_path_for_state, screenshot_paths_for_state).
             """
-            temp_media_file_for_analysis = None
-            generated_main_preview_path = "" 
-            generated_screenshot_paths: List[str] = [] 
+            generated_screenshot_paths: List[str] = []
             result_text = ""
 
             try:
-                if not url:
-                    return "error", "**Error:** No URL provided.", "", []
+                if not raw_media_path or not os.path.exists(raw_media_path):
+                    return "error", "**Error:** No raw media file available for analysis. Please load a URL first.", current_main_preview_path, []
 
-                progress(0.01, desc="Starting media processing")
-                progress(0.02, desc="Checking URL / content‑type")
-                # Determine type once at the start of worker
-                is_img_worker, is_vid_worker = determine_media_type(url, progress=progress)
+                # Read raw bytes from the stored temp file
+                with open(raw_media_path, "rb") as f:
+                    raw_bytes_for_analysis = f.read()
 
-                client = get_client(key)
-
-                raw_bytes = None
+                if not raw_bytes_for_analysis:
+                    return "error", "**Error:** Raw media file is empty for analysis.", current_main_preview_path, []
 
-                # Fetch bytes regardless of type to enable fallback
-                progress(0.05, desc="Downloading media for analysis")
-                raw_bytes = fetch_bytes(url, timeout=120, progress=progress)
-                if not raw_bytes:
-                    return "error", "Failed to download media bytes.", "", []
+                progress(0.01, desc="Starting media analysis...")
 
-                # Determine type more definitively using raw bytes
-                # This step is now more robustly handled inside _get_playable_preview_path_from_raw itself for preview,
-                # but we need it here for deciding analysis path (image model vs. video model)
-                is_actually_image_for_analysis = is_img_worker
-                is_actually_video_for_analysis = is_vid_worker
-
-                if not is_actually_image_for_analysis and not is_actually_video_for_analysis:
-                    try:
-                        # Attempt to open as image
-                        Image.open(BytesIO(raw_bytes)).verify()
-                        is_actually_image_for_analysis = True
-                    except UnidentifiedImageError:
-                        is_actually_video_for_analysis = True # Not an image, assume video
-                    except Exception as e:
-                        print(f"Warning: Could not definitively determine media type for {url} based on bytes: {e}. Attempting video analysis.")
-                        is_actually_video_for_analysis = True # Generic error, fallback to video
+                # Determine actual media type for analysis using the raw bytes
+                is_actually_image_for_analysis = False
+                is_actually_video_for_analysis = False
 
-                # Get playable preview path (this internally handles image/video decision and conversion for preview)
-                generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes, is_actually_image_for_analysis, is_actually_video_for_analysis)
-                if not generated_main_preview_path:
-                    print(f"Error: Could not generate main preview for analysis: {url}") # Log this specific failure point
-                    return "error", "Could not generate a playable preview for display.", "", []
+                try:
+                    # Try as image first, using actual bytes
+                    Image.open(BytesIO(raw_bytes_for_analysis)).verify()
+                    is_actually_image_for_analysis = True
+                except UnidentifiedImageError:
+                    is_actually_video_for_analysis = True # Not an identifiable image
+                except Exception as e:
+                    print(f"Warning: PIL error during image verification for raw analysis media ({raw_media_path}): {e}. Falling back to video.")
+                    is_actually_video_for_analysis = True # Other PIL error, treat as video
 
+                client = get_client(key)
 
                 # --- Video Processing Path ---
                 if is_actually_video_for_analysis:
-                    temp_media_file_for_analysis = _temp_file(raw_bytes, suffix=ext_from_src(url) or ".mp4")
-                    if not temp_media_file_for_analysis: # Handle if _temp_file failed
-                        return "error", "Failed to create temporary video file for analysis.", "", []
                     progress(0.25, desc="Running full‑video analysis")
-                    result_text, generated_screenshot_paths = analyze_video_cohesive(client, temp_media_file_for_analysis, prompt, progress=progress)
+                    result_text, generated_screenshot_paths = analyze_video_cohesive(client, raw_media_path, prompt, progress=progress)
 
                 # --- Image Processing Path ---
                 elif is_actually_image_for_analysis:
                     progress(0.20, desc="Running image analysis")
-                    result_text = analyze_image_structured(client, raw_bytes, prompt, progress=progress)
+                    result_text = analyze_image_structured(client, raw_bytes_for_analysis, prompt, progress=progress)
                     # No screenshots for images
 
-                # --- Fallback if still no clear analysis path (should be rare with refined logic) ---
                 else:
-                    # This block should ideally not be reached if previous type determination is robust.
-                    # As a final fallback, treat as video for analysis.
-                    print(f"Warning: No definitive analysis type determined for {url} after all checks. Attempting video analysis fallback.")
-                    temp_media_file_for_analysis = _temp_file(raw_bytes, suffix=ext_from_src(url) or ".mp4")
-                    if not temp_media_file_for_analysis:
-                        return "error", "Failed to create temporary video file for final analysis fallback.", "", []
-                    progress(0.25, desc="Running video analysis (final fallback for unknown type)")
-                    result_text, generated_screenshot_paths = analyze_video_cohesive(client, temp_media_file_for_analysis, prompt, progress=progress)
+                    return "error", "Error: Could not definitively determine media type for analysis after byte inspection.", current_main_preview_path, []
 
 
                 status = "done" if not (isinstance(result_text, str) and result_text.lower().startswith("error")) else "error"
 
-                return status, result_text, generated_main_preview_path, generated_screenshot_paths
+                # The main_preview_path_state should already hold the path to the main preview from load_main_preview_and_clear_old
+                return status, result_text, current_main_preview_path, generated_screenshot_paths
 
             except Exception as exc:
-                return "error", f"Unexpected worker error: {exc}", "", []
+                return "error", f"Unexpected worker error: {exc}", current_main_preview_path, []
             finally:
-                # Cleanup temporary file used for video analysis if it was created.
-                # Files for previews and gallery are tracked by _temp_file and cleaned up by atexit.
-                if temp_media_file_for_analysis and os.path.exists(temp_media_file_for_analysis):
-                    if temp_media_file_for_analysis in _temp_preview_files_to_delete:
-                        _temp_preview_files_to_delete.remove(temp_media_file_for_analysis)
-                    try: os.remove(temp_media_file_for_analysis)
-                    except Exception as e: print(f"Error cleaning up analysis temp file {temp_media_file_for_analysis}: {e}")
+                # raw_media_path is a temp file tracked by _temp_file and cleaned up by atexit/clear_all_files_and_ui
+                # No specific cleanup needed here.
+                pass
 
         # Worker output changed to include screenshot_paths_state
         submit_btn.click(
             fn=worker,
-            inputs=[url_input, custom_prompt, api_key],
+            inputs=[url_input, custom_prompt, api_key, main_preview_path_state, raw_media_path_state],
             outputs=[status_state, output_md, main_preview_path_state, screenshot_paths_state],
             show_progress="full",
             show_progress_on=progress_md,
@@ -920,7 +913,6 @@ def create_demo():
         status_state.change(fn=status_to_progress_text, inputs=[status_state], outputs=[progress_md])
 
         # This function updates the UI components based on the state values.
-        # It should *not* perform cleanup, as that's handled by clear_all_files_and_ui or load_main_preview_and_clear_old.
         def _update_preview_components(current_main_preview_path: str, current_screenshot_paths: List[str]):
             img_update = gr.update(value=None, visible=False)
             video_update = gr.update(value=None, visible=False)
@@ -937,7 +929,7 @@ def create_demo():
                     elif ext in VIDEO_EXTS:
                         is_vid_preview = True
 
-                    # Fallback to PIL check if extension is ambiguous or unknown
+                    # Fallback to PIL check if extension is ambiguous or unknown, and if it's an actual file
                     if not is_img_preview and not is_vid_preview and os.path.exists(current_main_preview_path):
                         try:
                             Image.open(current_main_preview_path).verify()