Update app.py

app.py

@@ -13,6 +13,8 @@ import asyncio
 import threading
 import time
 import atexit
+from requests.exceptions import RequestException, HTTPError # Import for rate limiting
+
 
 # --- Configuration and Globals ---
 DEFAULT_KEY = os.getenv("MISTRAL_API_KEY", "")
@@ -59,8 +61,16 @@ atexit.register(_cleanup_all_temp_preview_files)
 def get_client(key: Optional[str] = None):
     api_key = (key or "").strip() or DEFAULT_KEY
     if Mistral is None:
-        class Dummy:
-            def __init__(self, k): self.api_key = k # Mock client for no mistralai library
+        class Dummy: # Mock client for no mistralai library or no key
+            def __init__(self, k): self.api_key = k
+            class Chat:
+                def complete(self, **kwargs):
+                    raise RuntimeError("Mistral client library not installed or API key missing.")
+            chat = Chat()
+            class Files:
+                def upload(self, **kwargs):
+                    raise RuntimeError("Mistral client library not installed or API key missing.")
+            files = Files()
         return Dummy(api_key)
     return Mistral(api_key=api_key)
 
@@ -123,7 +133,7 @@ def fetch_bytes(src: str, stream_threshold: int = STREAM_THRESHOLD, timeout: int
                             try: os.remove(p)
                             except Exception: pass
             except Exception:
-                pass
+                pass # Fallback to non-streaming download if streaming fails
         r = safe_get(src, timeout=timeout)
         if progress is not None:
             progress(0.25, desc="Downloaded remote content")
@@ -142,15 +152,17 @@ def fetch_bytes(src: str, stream_threshold: int = STREAM_THRESHOLD, timeout: int
 def convert_to_jpeg_bytes(img_bytes: bytes, base_h: int = 480) -> bytes:
     img = Image.open(BytesIO(img_bytes))
     try:
-        if getattr(img, "is_animated", False):
+        if getattr(img, "is_animated", False): # Handles animated GIFs by taking first frame
             img.seek(0)
     except Exception:
-        pass
+        pass # Not an animated image
+
     if img.mode != "RGB":
         img = img.convert("RGB")
-    h = base_h
-    w = max(1, int(img.width * (h / img.height)))
-    img = img.resize((w, h), Image.LANCZOS)
+
+    # Calculate new width preserving aspect ratio
+    w = max(1, int(img.width * (base_h / img.height)))
+    img = img.resize((w, base_h), Image.LANCZOS)
     buf = BytesIO()
     img.save(buf, format="JPEG", quality=85)
     return buf.getvalue()
@@ -162,11 +174,14 @@ def _ffprobe_streams(path: str) -> Optional[dict]:
     """Probes video codecs via ffprobe; returns dict with streams info or None on failure."""
     if not FFMPEG_BIN:
         return None
-    ffprobe = FFMPEG_BIN.replace("ffmpeg", "ffprobe") if "ffmpeg" in FFMPEG_BIN else "ffprobe"
-    if not shutil.which(ffprobe):
-        ffprobe = "ffprobe" # Try system PATH
+    ffprobe_path = FFMPEG_BIN.replace("ffmpeg", "ffprobe") if "ffmpeg" in FFMPEG_BIN else "ffprobe"
+    if not shutil.which(ffprobe_path):
+        ffprobe_path = "ffprobe" # Try system PATH
+        if not shutil.which(ffprobe_path):
+            return None # ffprobe not found
+
     cmd = [
-        ffprobe, "-v", "error", "-print_format", "json", "-show_streams", "-show_format", path
+        ffprobe_path, "-v", "error", "-print_format", "json", "-show_streams", "-show_format", path
     ]
     try:
         out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
@@ -174,18 +189,10 @@ def _ffprobe_streams(path: str) -> Optional[dict]:
     except Exception:
         return None
 
-def extract_best_frames_bytes(media_path: str, sample_count: int = 5, timeout_extract: int = 15, progress=None) -> List[bytes]:
-    """
-    Extracts frames as bytes for model input. These temp files are immediately deleted.
-    """
-    frames: List[bytes] = []
-    if not FFMPEG_BIN or not os.path.exists(media_path):
-        return frames
-    if progress is not None:
-        progress(0.05, desc="Preparing frame extraction for model...")
-
-    duration = 0.0
+def _get_video_info_and_timestamps(media_path: str, sample_count: int) -> Tuple[Optional[dict], List[float]]:
+    """Helper to get video info and calculate timestamps once."""
     info = _ffprobe_streams(media_path)
+    duration = 0.0
     if info and "format" in info and "duration" in info["format"]:
         try:
             duration = float(info["format"]["duration"])
@@ -194,81 +201,36 @@ def extract_best_frames_bytes(media_path: str, sample_count: int = 5, timeout_ex
 
     timestamps: List[float] = []
     if duration > 0 and sample_count > 0:
-        # Sample evenly across the video
         step = duration / (sample_count + 1)
         timestamps = [step * (i + 1) for i in range(sample_count)]
     else:
-        # Fallback to fixed timestamps
-        timestamps = [0.5, 1.0, 2.0, 3.0, 4.0][:sample_count] 
-
-    for i, t in enumerate(timestamps):
-        fd, tmp = tempfile.mkstemp(suffix=f"_{i}_model.jpg")
-        os.close(fd)
-        # This temp file is for immediate read and deletion, not persistent tracking
-
-        cmd = [
-            FFMPEG_BIN,
-            "-nostdin",
-            "-y",
-            "-ss",
-            str(t),
-            "-i",
-            media_path,
-            "-frames:v",
-            "1",
-            "-q:v",
-            "2", # High quality JPEG
-            tmp,
-        ]
-        try:
-            if progress is not None:
-                progress(0.1 + (i / max(1, sample_count)) * 0.2, desc=f"Extracting frame {i+1}/{sample_count} for model...")
-            subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout_extract)
-            if os.path.exists(tmp) and os.path.getsize(tmp) > 0:
-                with open(tmp, "rb") as f:
-                    frames.append(f.read())
-        except Exception:
-            pass
-        finally:
-            try: os.remove(tmp)
-            except Exception: pass
-    if progress is not None:
-        progress(0.45, desc=f"Extracted {len(frames)} frames for model")
-    return frames
+        timestamps = [0.5, 1.0, 2.0, 3.0, 4.0][:sample_count] # Fallback to fixed times
+    return info, timestamps
 
-def extract_and_save_frames_for_gallery(media_path: str, sample_count: int = 5, timeout_extract: int = 15, base_h: int = 128, progress=None) -> List[str]:
+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]]:
     """
-    Extracts frames from a video, converts them to small JPEGs, saves them as temp files
-    (tracked for cleanup), and returns a list of paths to these temporary files for gallery display.
+    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.
     """
-    frame_paths: List[str] = []
+    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):
-        return frame_paths
+        return frames_for_model, frame_paths_for_gallery
 
-    duration = 0.0
-    info = _ffprobe_streams(media_path)
-    if info and "format" in info and "duration" in info["format"]:
-        try:
-            duration = float(info["format"]["duration"])
-        except ValueError:
-            pass
+    if progress is not None:
+        progress(0.05, desc="Preparing frame extraction...")
 
-    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
+    _, timestamps = _get_video_info_and_timestamps(media_path, sample_count)
 
     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} for gallery...")
+            progress(0.1 + (i / max(1, sample_count)) * 0.2, desc=f"Extracting frame {i+1}/{sample_count}...")
 
         # Extract to a temp PNG first for best quality, then process with PIL
-        fd_raw, tmp_png_path = tempfile.mkstemp(suffix=".png")
+        fd_raw, tmp_png_path = tempfile.mkstemp(suffix=f"_frame_{i}.png")
         os.close(fd_raw)
 
-        # Command to extract frame to PNG
         cmd_extract = [
             FFMPEG_BIN, "-nostdin", "-y", "-ss", str(t), "-i", media_path,
             "-frames:v", "1", "-pix_fmt", "rgb24", tmp_png_path,
@@ -278,90 +240,142 @@ def extract_and_save_frames_for_gallery(media_path: str, sample_count: int = 5,
             subprocess.run(cmd_extract, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout_extract)
 
             if os.path.exists(tmp_png_path) and os.path.getsize(tmp_png_path) > 0:
-                # Convert extracted PNG to a smaller JPEG and save as new temp file
-                jpeg_bytes = convert_to_jpeg_bytes(open(tmp_png_path, "rb").read(), base_h=base_h)
-                temp_jpeg_path = _temp_file(jpeg_bytes, suffix=f"_gallery_{i}.jpg") # _temp_file tracks this for cleanup
-                frame_paths.append(temp_jpeg_path)
+                with open(tmp_png_path, "rb") as f:
+                    raw_frame_bytes = f.read()
+
+                # For model: convert to high-res JPEG bytes (model expects this)
+                jpeg_model_bytes = convert_to_jpeg_bytes(raw_frame_bytes, base_h=720) # Keep higher res for model
+                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)
+                temp_jpeg_path = _temp_file(jpeg_gallery_bytes, suffix=f"_gallery_{i}.jpg") # _temp_file tracks this for cleanup
+                frame_paths_for_gallery.append(temp_jpeg_path)
 
         except Exception as e:
-            print(f"Error processing frame {i+1} for gallery: {e}")
+            print(f"Error processing frame {i+1} for model/gallery: {e}")
         finally:
             if os.path.exists(tmp_png_path):
                 try: os.remove(tmp_png_path)
                 except Exception: pass
 
     if progress is not None:
-        progress(0.45, desc=f"Extracted {len(frame_paths)} frames for gallery")
-    return frame_paths
+        progress(0.45, desc=f"Extracted {len(frames_for_model)} frames for analysis and gallery")
+    return frames_for_model, frame_paths_for_gallery
 
 def chat_complete(client, model: str, messages, timeout: int = 120, progress=None) -> str:
-    try:
-        if progress is not None:
-            progress(0.6, desc="Sending request to model...")
-        if hasattr(client, "chat") and hasattr(client.chat, "complete"):
-            res = client.chat.complete(model=model, messages=messages, stream=False)
-        else:
-            api_key = getattr(client, "api_key", "") or DEFAULT_KEY
-            url = "https://api.mistral.ai/v1/chat/completions"
-            headers = ({"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"} if api_key else {"Content-Type": "application/json"})
-            r = requests.post(url, json={"model": model, "messages": messages}, headers=headers, timeout=timeout)
-            r.raise_for_status()
-            res = r.json()
-        if progress is not None:
-            progress(0.8, desc="Model responded, parsing...")
-        choices = getattr(res, "choices", None) or (res.get("choices") if isinstance(res, dict) else [])
-        if not choices:
-            return f"Empty response from model: {res}"
-        first = choices[0]
-        msg = (first.message if hasattr(first, "message") else (first.get("message") if isinstance(first, dict) else first))
-        content = (msg.get("content") if isinstance(msg, dict) else getattr(msg, "content", None))
-        return content.strip() if isinstance(content, str) else str(content)
-    except requests.exceptions.RequestException as e:
-        return f"Error: network/API request failed: {e}"
-    except Exception as e:
-        return f"Error during model call: {e}"
+    max_retries = 5
+    initial_delay = 1.0 # seconds
+    for attempt in range(max_retries):
+        try:
+            if progress is not None:
+                progress(0.6 + 0.01 * attempt, desc=f"Sending request to model (attempt {attempt+1}/{max_retries})...")
+
+            # 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=timeout)
+            else:
+                api_key = getattr(client, "api_key", "") or DEFAULT_KEY
+                if not api_key:
+                    return "Error: Mistral API key is not set."
+                url = "https://api.mistral.ai/v1/chat/completions"
+                headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+                r = requests.post(url, json={"model": model, "messages": messages}, headers=headers, timeout=timeout)
+                r.raise_for_status() # Raises HTTPError for bad responses (4xx or 5xx)
+                res = r.json()
 
-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)
-    try:
-        if progress is not None:
-            progress(0.5, desc="Uploading file to model service...")
-        if hasattr(client, "files") and hasattr(client.files, "upload"):
-            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'
-                fid = res["data"][0]["id"]
             if progress is not None:
-                progress(0.6, desc="Upload complete")
-            return fid
-    except Exception:
-        pass # Fallback to manual requests if client.files.upload fails
+                progress(0.8, desc="Model responded, parsing...")
+
+            choices = getattr(res, "choices", None) or (res.get("choices") if isinstance(res, dict) else [])
+            if not choices:
+                return f"Empty response from model: {res}"
+
+            first = choices[0]
+            msg = (first.message if hasattr(first, "message") else (first.get("message") if isinstance(first, dict) else first))
+            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:
+            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:
+            if attempt < max_retries - 1:
+                delay = initial_delay * (2 ** attempt)
+                print(f"Network/API request failed: {e}. Retrying in {delay:.2f}s...")
+                time.sleep(delay)
+            else:
+                return f"Error: network/API request failed after {max_retries} attempts: {e}"
+        except Exception as e:
+            return f"Error during model call: {e}"
 
-    api_key = getattr(client, "api_key", "") or DEFAULT_KEY
-    url = "https://api.mistral.ai/v1/files"
-    headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
-    try:
-        with open(path, "rb") as fh:
-            files = {"file": (fname, fh)}
-            data = {"purpose": purpose}
-            r = requests.post(url, headers=headers, files=files, data=data, timeout=timeout)
-            r.raise_for_status()
-            jr = r.json()
+    return "Error: Maximum retries reached for API call." # Should ideally not be reached if handled gracefully
+
+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)
+    max_retries = 3
+    initial_delay = 1.0
+    for attempt in range(max_retries):
+        try:
             if progress is not None:
-                progress(0.65, desc="Upload complete (REST)")
-            return jr.get("id") or jr.get("data", [{}])[0].get("id")
-    except requests.exceptions.RequestException as e:
-        raise RuntimeError(f"File upload failed: {e}")
+                progress(0.5 + 0.01 * attempt, desc=f"Uploading file to model service (attempt {attempt+1}/{max_retries})...")
+
+            if hasattr(client, "files") and hasattr(client.files, "upload"):
+                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'
+                    fid = res["data"][0]["id"]
+                if progress is not None:
+                    progress(0.6, desc="Upload complete")
+                return fid
+            else: # Fallback to manual requests if client.files.upload fails or Mistral is mocked
+                api_key = getattr(client, "api_key", "") or DEFAULT_KEY
+                if not api_key:
+                    raise RuntimeError("Mistral API key is not set for file upload.")
+                url = "https://api.mistral.ai/v1/files"
+                headers = {"Authorization": f"Bearer {api_key}"}
+                with open(path, "rb") as fh:
+                    files = {"file": (fname, fh)}
+                    data = {"purpose": purpose}
+                    r = requests.post(url, headers=headers, files=files, data=data, timeout=timeout)
+                    r.raise_for_status()
+                    jr = r.json()
+                    if progress is not None:
+                        progress(0.65, desc="Upload complete (REST)")
+                    return jr.get("id") or jr.get("data", [{}])[0].get("id")
+        except HTTPError as e:
+            if e.response.status_code == 429 and attempt < max_retries - 1:
+                delay = initial_delay * (2 ** attempt)
+                print(f"Upload rate limit exceeded (429). Retrying in {delay:.2f}s...")
+                time.sleep(delay)
+            else:
+                raise RuntimeError(f"File upload failed with status {e.response.status_code}: {e.response.text}") from e
+        except RequestException as e:
+            if attempt < max_retries - 1:
+                delay = initial_delay * (2 ** attempt)
+                print(f"Upload network/API request failed: {e}. Retrying in {delay:.2f}s...")
+                time.sleep(delay)
+            else:
+                raise RuntimeError(f"File upload failed after {max_retries} attempts: {e}") from e
+        except Exception as e:
+            raise RuntimeError(f"File upload failed unexpectedly: {e}") from e
+    raise RuntimeError("File upload failed: Maximum retries reached.")
 
 def determine_media_type(src: str, progress=None) -> Tuple[bool, bool]:
     is_image = False
     is_video = False
     ext = ext_from_src(src)
+
     if ext in IMAGE_EXTS:
         is_image = True
-    if ext in VIDEO_EXTS:
+    elif ext in VIDEO_EXTS: # Use elif to prioritize video if both extensions are possible (unlikely but safe)
         is_video = True
+
     if is_remote(src):
         head = safe_head(src)
         if head:
@@ -370,6 +384,7 @@ def determine_media_type(src: str, progress=None) -> Tuple[bool, bool]:
                 is_image, is_video = True, False
             elif ctype.startswith("video/"):
                 is_video, is_image = True, False
+
     if progress is not None:
         progress(0.02, desc="Determined media type")
     return is_image, is_video
@@ -413,36 +428,35 @@ def analyze_video_cohesive(client, video_path: str, prompt: str, progress=None)
         ]
         result = chat_complete(client, VIDEO_MODEL, messages, progress=progress)
         # If successful upload, still extract frames for gallery display
-        gallery_frame_paths = extract_and_save_frames_for_gallery(video_path, sample_count=6, base_h=128, progress=progress)
+        # 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
+        )
         return result, gallery_frame_paths
     except Exception as e:
         if progress is not None:
-            progress(0.35, desc="Upload failed, extracting frames as fallback...")
-
-        # Extract frames for model input (bytes)
-        frames_for_model_bytes = extract_best_frames_bytes(video_path, sample_count=6, progress=progress)
+            progress(0.35, desc=f"Upload failed for video ({e}). Extracting frames as fallback...")
 
-        # Extract and save frames for gallery display (paths)
-        gallery_frame_paths = extract_and_save_frames_for_gallery(video_path, sample_count=6, base_h=128, progress=progress)
+        # 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
+        )
 
         if not frames_for_model_bytes:
             return f"Error: could not upload video and no frames could be extracted. ({e})", []
 
         image_entries = []
         for i, fb in enumerate(frames_for_model_bytes, start=1):
-            try:
-                if progress is not None:
-                    progress(0.4 + (i / len(frames_for_model_bytes)) * 0.2, desc=f"Preparing frame {i}/{len(frames_for_model_bytes)} for model...")
-                j = convert_to_jpeg_bytes(fb, base_h=720)
-                image_entries.append(
-                    {
-                        "type": "image_url",
-                        "image_url": b64_bytes(j, mime="image/jpeg"),
-                        "meta": {"frame_index": i},
-                    }
-                )
-            except Exception:
-                continue
+            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(
+                {
+                    "type": "image_url",
+                    "image_url": b64_bytes(fb, mime="image/jpeg"), # `fb` is already JPEG bytes
+                    "meta": {"frame_index": i},
+                }
+            )
         content = [{"type": "text", "text": prompt + "\n\nPlease consolidate observations across these frames into a single cohesive narrative."}] + image_entries
         messages = [
             {"role": "system", "content": SYSTEM_INSTRUCTION},
@@ -462,6 +476,7 @@ def _convert_video_for_preview_if_needed(path: str) -> str:
     if not FFMPEG_BIN or not os.path.exists(path):
         return path # Cannot convert, return original
 
+    # Check if the video is already likely browser-compatible (MP4 with H.264/H.265)
     if path.lower().endswith((".mp4", ".m4v", ".mov")):
         info = _ffprobe_streams(path)
         if info:
@@ -472,14 +487,16 @@ def _convert_video_for_preview_if_needed(path: str) -> str:
     out_path = _temp_file(b"", suffix=".mp4") # Create an empty temp file and add to cleanup list
     cmd = [
         FFMPEG_BIN, "-y", "-i", path,
-        "-c:v", "libx264", "-preset", "veryfast", "-crf", "28",
-        "-c:a", "aac", "-movflags", "+faststart", out_path,
+        "-c:v", "libx264", "-preset", "veryfast", "-crf", "28", # H.264 video codec
+        "-c:a", "aac", "-b:a", "128k", # AAC audio codec
+        "-movflags", "+faststart", out_path, # Optimize for web streaming
         "-map_metadata", "-1" # Remove metadata
     ]
     try:
         subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=60)
         return out_path
-    except Exception:
+    except Exception as e:
+        print(f"Error converting video for preview: {e}")
         # If conversion fails, remove the created temp file and fall back to the original
         if out_path in _temp_preview_files_to_delete:
             _temp_preview_files_to_delete.remove(out_path)
@@ -488,14 +505,12 @@ def _convert_video_for_preview_if_needed(path: str) -> str:
         return path 
 
 # --- Preview Generation Logic ---
-def _get_playable_preview_path_from_raw(src_url: str, raw_bytes: bytes) -> str:
+def _get_playable_preview_path_from_raw(src_url: str, raw_bytes: bytes, is_image_hint: bool, is_video_hint: bool) -> str:
     """
-    Generates a playable preview file from raw bytes.
+    Generates a playable preview file from raw bytes, using pre-determined media type hints.
     Creates and tracks a new temporary file.
     """
-    is_img, is_vid = determine_media_type(src_url)
-
-    if is_vid:
+    if is_video_hint: # Use the passed hint
         temp_raw_video_path = _temp_file(raw_bytes, suffix=ext_from_src(src_url) or ".mp4")
         playable_path = _convert_video_for_preview_if_needed(temp_raw_video_path)
 
@@ -506,8 +521,22 @@ def _get_playable_preview_path_from_raw(src_url: str, raw_bytes: bytes) -> str:
             try: os.remove(temp_raw_video_path)
             except Exception: pass
         return playable_path
-    else: 
+    elif is_image_hint: # Use the passed hint
         return _temp_file(convert_to_jpeg_bytes(raw_bytes, base_h=1024), suffix=".jpg")
+    else:
+        # Fallback if hints are unclear, try image first, then video
+        try:
+            # Attempt to open as image
+            img_bytes_io = BytesIO(raw_bytes)
+            Image.open(img_bytes_io).verify()
+            img_bytes_io.seek(0) # Reset stream position after verify
+            return _temp_file(convert_to_jpeg_bytes(img_bytes_io.read(), base_h=1024), suffix=".jpg")
+        except UnidentifiedImageError:
+            # If not an image, assume it's a video for preview purposes
+            print(f"Warning: Unknown media type for {src_url}, falling back to video preview attempt.")
+            temp_raw_video_path = _temp_file(raw_bytes, suffix=ext_from_src(src_url) or ".mp4")
+            playable_path = _convert_video_for_preview_if_needed(temp_raw_video_path)
+            return playable_path # This may return original path if conversion fails
 
 def _fetch_with_retries_bytes(src: str, timeout: int = 15, max_retries: int = 3):
     attempt = 0
@@ -529,7 +558,7 @@ def _fetch_with_retries_bytes(src: str, timeout: int = 15, max_retries: int = 3)
             time.sleep(delay)
             delay *= 2
         except FileNotFoundError:
-            raise
+            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}")
@@ -537,27 +566,28 @@ def _fetch_with_retries_bytes(src: str, timeout: int = 15, max_retries: int = 3)
             time.sleep(delay)
             delay *= 2
 
-def _save_local_playable_preview(src: str) -> Optional[str]:
+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.
+    for Gradio preview components, using media type hints.
     """
     if not src:
         return None
 
     if not is_remote(src):
         if os.path.exists(src):
-            is_img, is_vid = determine_media_type(src)
-            if is_vid:
+            if is_video_hint:
                 return _convert_video_for_preview_if_needed(src)
-            return src # Local image, return as is (assuming Gradio can display it)
+            # For local images, return the path directly. If it was mis-hinted,
+            # _get_playable_preview_path_from_raw's internal checks would handle it.
+            return src 
         return None
 
     # Remote source
     try:
         raw_bytes = _fetch_with_retries_bytes(src, timeout=15, max_retries=3)
         if not raw_bytes: return None
-        return _get_playable_preview_path_from_raw(src, raw_bytes)
+        return _get_playable_preview_path_from_raw(src, raw_bytes, is_image_hint, is_video_hint)
     except Exception as e:
         print(f"Error creating local playable preview from {src}: {e}")
         return None
@@ -602,6 +632,7 @@ def create_demo():
             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.
             """
             for f_path in list(_temp_preview_files_to_delete):
                 if os.path.exists(f_path):
@@ -611,22 +642,40 @@ def create_demo():
                         print(f"Error during proactive cleanup of {f_path}: {e}")
             _temp_preview_files_to_delete.clear() 
 
+            # Return exactly 10 values to match the outputs list
             return "", \
                    gr.update(value=None, visible=False), \
                    gr.update(value=None, visible=False), \
                    gr.update(value=[], visible=False), \
-                   "idle", "Idle", "", "", "", [], gr.update(value="", visible=True) # url_input, preview_image, preview_video, screenshot_gallery, status_state, progress_md, output_md, main_preview_path_state, screenshot_paths_state, preview_status
+                   "idle", \
+                   "Idle", \
+                   "", \
+                   "", \
+                   [], \
+                   gr.update(value="", visible=True)
 
         clear_btn.click(
             fn=clear_all_files_and_ui,
             inputs=[],
-            outputs=[url_input, preview_image, preview_video, screenshot_gallery, status_state, progress_md, output_md, main_preview_path_state, screenshot_paths_state, preview_status]
+            outputs=[
+                url_input,
+                preview_image,
+                preview_video,
+                screenshot_gallery,
+                status_state,
+                progress_md,
+                output_md,
+                main_preview_path_state,
+                screenshot_paths_state,
+                preview_status
+            ]
         )
 
         # Function to handle URL input change and update main preview
         def load_main_preview_and_clear_old(url: str):
             # 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
 
@@ -634,28 +683,51 @@ def create_demo():
                 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)
+
             try:
-                local_playable_path = _save_local_playable_preview(url) # This adds to _temp_preview_files_to_delete
+                # Pass determined types to _save_local_playable_preview
+                local_playable_path = _save_local_playable_preview(url, is_img_initial, is_vid_initial) 
                 if not local_playable_path:
                     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), \
                            "", []
 
+                # 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.
                 is_img_preview = False
-                try:
-                    Image.open(local_playable_path).verify()
+                is_vid_preview = False
+
+                # Check actual file extension
+                ext = ext_from_src(local_playable_path)
+                if ext in IMAGE_EXTS:
                     is_img_preview = True
-                except Exception:
-                    pass
+                elif ext in VIDEO_EXTS:
+                    is_vid_preview = True
+
+                # Fallback to PIL check if extension is ambiguous or unknown
+                if not is_img_preview and not is_vid_preview and os.path.exists(local_playable_path):
+                    try:
+                        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)
+                        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, []
-                else: # Assume video
+                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, []
+                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), \
+                           "", []
+
 
             except Exception as e:
                 return gr.update(value=None, visible=False), gr.update(value=None, visible=False), \
@@ -674,8 +746,8 @@ def create_demo():
             Returns (status, markdown_output, main_preview_path_for_state, screenshot_paths_for_state).
             """
             temp_media_file_for_analysis = None
-            generated_main_preview_path = "" # This should reflect the preview that was loaded by load_main_preview_and_clear_old
-            generated_screenshot_paths: List[str] = [] # List of paths for gallery
+            generated_main_preview_path = "" 
+            generated_screenshot_paths: List[str] = [] 
             result_text = ""
 
             try:
@@ -684,60 +756,54 @@ def create_demo():
 
                 progress(0.01, desc="Starting media processing")
                 progress(0.02, desc="Checking URL / content‑type")
-                is_img, is_vid = determine_media_type(url, progress=progress)
+                # Determine type once at the start of worker
+                is_img_worker, is_vid_worker = determine_media_type(url, progress=progress)
 
                 client = get_client(key)
 
                 raw_bytes = None
 
-                # --- Video Processing Path ---
-                if is_vid:
-                    progress(0.05, desc="Downloading video for analysis")
-                    raw_bytes = fetch_bytes(url, timeout=120, progress=progress)
-                    if not raw_bytes:
-                        return "error", "Failed to download video bytes.", "", []
+                # 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.", "", []
+
+                # Check for image type with PIL if initial determination was uncertain
+                if not is_img_worker and not is_vid_worker:
+                    try:
+                        Image.open(BytesIO(raw_bytes)).verify()
+                        is_img_worker = True
+                    except Exception:
+                        pass # Not an image, proceed to video or generic fallback
 
+                # --- Video Processing Path ---
+                if is_vid_worker:
                     temp_media_file_for_analysis = _temp_file(raw_bytes, suffix=ext_from_src(url) or ".mp4")
-                    generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes) # This generates the main video preview path
+                    # Pass determined types to _get_playable_preview_path_from_raw
+                    generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes, is_img_worker, is_vid_worker) 
 
                     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)
 
                 # --- Image Processing Path ---
-                elif is_img:
-                    progress(0.05, desc="Downloading image for analysis")
-                    raw_bytes = fetch_bytes(url, progress=progress)
-
-                    progress(0.15, desc="Preparing image preview")
-                    generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes) # This generates the main image preview path
+                elif is_img_worker:
+                    # Pass determined types to _get_playable_preview_path_from_raw
+                    generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes, is_img_worker, is_vid_worker) 
 
                     progress(0.20, desc="Running image analysis")
                     result_text = analyze_image_structured(client, raw_bytes, prompt, progress=progress)
                     # No screenshots for images
 
-                # --- Unknown Media Type (Fallback) ---
+                # --- Unknown Media Type (Fallback to Video) ---
                 else:
-                    progress(0.07, desc="Downloading unknown media for type determination")
-                    raw_bytes = fetch_bytes(url, timeout=120, progress=progress)
-
-                    is_definitely_img = False
-                    try:
-                        Image.open(BytesIO(raw_bytes)).verify()
-                        is_definitely_img = True
-                    except Exception:
-                        pass
-
-                    if is_definitely_img:
-                        progress(0.15, desc="Preparing image preview (fallback)")
-                        generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes)
-                        progress(0.20, desc="Running image analysis (fallback)")
-                        result_text = analyze_image_structured(client, raw_bytes, prompt, progress=progress)
-                    else: # Treat as video fallback
-                        progress(0.15, desc="Preparing video preview (fallback)")
-                        temp_media_file_for_analysis = _temp_file(raw_bytes, suffix=ext_from_src(url) or ".mp4")
-                        generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes)
-                        progress(0.25, desc="Running video analysis (fallback)")
-                        result_text, generated_screenshot_paths = analyze_video_cohesive(client, temp_media_file_for_analysis, prompt, progress=progress)
+                    # If after all checks, it's still unknown, treat as video by default for analysis.
+                    print(f"Warning: Could not definitively determine media type for {url}. Attempting video analysis.")
+                    temp_media_file_for_analysis = _temp_file(raw_bytes, suffix=ext_from_src(url) or ".mp4")
+                    # Even though type is 'unknown', we'll hint as video for preview creation if it's not an image
+                    generated_main_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes, False, True) 
+                    progress(0.25, desc="Running video analysis (fallback for unknown type)")
+                    result_text, generated_screenshot_paths = analyze_video_cohesive(client, temp_media_file_for_analysis, prompt, progress=progress)
 
                 status = "done" if not (isinstance(result_text, str) and result_text.lower().startswith("error")) else "error"
 
@@ -746,6 +812,8 @@ def create_demo():
             except Exception as exc:
                 return "error", f"Unexpected worker error: {exc}", "", []
             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)
@@ -778,15 +846,26 @@ def create_demo():
             if current_main_preview_path:
                 try:
                     is_img_preview = False
-                    try:
-                        Image.open(current_main_preview_path).verify()
+                    is_vid_preview = False
+
+                    # Determine type based on file extension
+                    ext = ext_from_src(current_main_preview_path)
+                    if ext in IMAGE_EXTS:
                         is_img_preview = True
-                    except Exception:
-                        pass # Not an image, treat as video
+                    elif ext in VIDEO_EXTS:
+                        is_vid_preview = True
+
+                    # Fallback to PIL check if extension is ambiguous or unknown
+                    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()
+                            is_img_preview = True
+                        except Exception:
+                            is_vid_preview = True # If not image, assume video for display purposes
 
                     if is_img_preview:
                         img_update = gr.update(value=current_main_preview_path, visible=True)
-                    else:
+                    elif is_vid_preview:
                         video_update = gr.update(value=current_main_preview_path, visible=True)
                 except Exception as e:
                     print(f"Error setting main preview from path {current_main_preview_path}: {e}")