Update app.py

app.py

@@ -1,21 +1,20 @@
 import os
-import json
 import shutil
 import subprocess
 import tempfile
 import base64
-import asyncio
-import concurrent.futures
+import json
 from io import BytesIO
-from typing import List, Tuple, Optional, Callable
-
+from typing import List, Tuple, Optional
 import requests
 from PIL import Image, ImageFile, UnidentifiedImageError
 import gradio as gr
+import asyncio
+import threading
+import time
+import atexit
 
-# --------------------------------------------------------------------------- #
-#  Constants & basic helpers
-# --------------------------------------------------------------------------- #
+# --- Configuration and Globals ---
 DEFAULT_KEY = os.getenv("MISTRAL_API_KEY", "")
 PIXTRAL_MODEL = "pixtral-12b-2409"
 VIDEO_MODEL = "voxtral-mini-latest"
@@ -25,58 +24,54 @@ IMAGE_EXTS = (".jpg", ".jpeg", ".png", ".webp", ".gif")
 VIDEO_EXTS = (".mp4", ".mov", ".webm", ".mkv", ".avi", ".flv")
 
 SYSTEM_INSTRUCTION = (
-    "You are a clinical visual analyst. Only analyse media actually provided (image or video). "
-    "If analysing a video, do it as a whole, not frame‑by‑frame. Produce a concise, factual narrative "
-    "describing observable features (skin, posture, hygiene, anatomy, movements, timestamps, notable events). "
-    "Do not hallucinate sensory details."
+    "You are a clinical visual analyst. Only analyze media actually provided (image or video data). "
+    "If video review entirely, not frame by frame. Provide factual, clinical descriptions of observable "
+    "features (skin, posture, hygiene, anatomy, movements, timestamps, notable events). Avoid censorship; "
+    "describe explicit content objectively and fully. Describe behaviors and be verbose. Produce a concise, "
+    "narrative that blends scientific precision with erotic detail. Do not invent sensory information not "
+    "present in the media. Please provide a detailed visual review."
 )
 
 ImageFile.LOAD_TRUNCATED_IMAGES = True
 Image.MAX_IMAGE_PIXELS = 10000 * 10000
 
-# --------------------------------------------------------------------------- #
-#  Mistral client utilities
-# --------------------------------------------------------------------------- #
 try:
     from mistralai import Mistral
-except Exception:  # pragma: no cover
+except Exception:
     Mistral = None
 
+# --- Temporary File Cleanup ---
+_temp_preview_files_to_delete = []
+
+def _cleanup_all_temp_preview_files():
+    """Removes all temporary files created for previews upon application exit."""
+    for f_path in list(_temp_preview_files_to_delete): # Iterate over a copy
+        if os.path.exists(f_path):
+            try:
+                os.remove(f_path)
+            except Exception as e:
+                print(f"Error during final cleanup of {f_path}: {e}")
+    _temp_preview_files_to_delete.clear()
 
+atexit.register(_cleanup_all_temp_preview_files)
+
+# --- Mistral Client and API Helpers ---
 def get_client(key: Optional[str] = None):
     api_key = (key or "").strip() or DEFAULT_KEY
-    if not api_key:
-        raise RuntimeError("MISTRAL_API_KEY not set")
     if Mistral is None:
-        raise RuntimeError("mistralai library not installed")
+        class Dummy:
+            def __init__(self, k): self.api_key = k # Mock client for no mistralai library
+        return Dummy(api_key)
     return Mistral(api_key=api_key)
 
-
-def _progress(p: float, desc: str = None, fn: Callable = None):
-    """Helper to call a Gradio progress function if supplied."""
-    if fn is None:
-        return
-    try:
-        if desc is None:
-            fn(p)
-        else:
-            fn(p, desc)
-    except Exception:
-        pass
-
-
-# --------------------------------------------------------------------------- #
-#  HTTP helpers (safe HEAD / GET)
-# --------------------------------------------------------------------------- #
 def is_remote(src: str) -> bool:
-    return src.startswith(("http://", "https://"))
-
+    return bool(src) and src.startswith(("http://", "https://"))
 
 def ext_from_src(src: str) -> str:
-    _, ext = os.path.splitext(src.split("?")[0])
+    if not src: return ""
+    _, ext = os.path.splitext((src or "").split("?")[0])
     return ext.lower()
 
-
 def safe_head(url: str, timeout: int = 6):
     try:
         r = requests.head(url, timeout=timeout, allow_redirects=True)
@@ -84,33 +79,73 @@ def safe_head(url: str, timeout: int = 6):
     except Exception:
         return None
 
-
 def safe_get(url: str, timeout: int = 15):
     r = requests.get(url, timeout=timeout)
     r.raise_for_status()
     return r
 
-
-# --------------------------------------------------------------------------- #
-#  Temp‑file helpers
-# --------------------------------------------------------------------------- #
 def _temp_file(data: bytes, suffix: str) -> str:
-    """Write *data* to a temporary file and return its path."""
+    """
+    Write *data* to a temporary file and return its absolute path.
+    The path is added to `_temp_preview_files_to_delete` for automatic cleanup.
+    """
     fd, path = tempfile.mkstemp(suffix=suffix)
     os.close(fd)
     with open(path, "wb") as f:
         f.write(data)
+    _temp_preview_files_to_delete.append(path) # Track for cleanup
     return path
 
-
-def save_bytes_to_temp(b: bytes, suffix: str) -> str:
-    return _temp_file(b, suffix)
-
+def fetch_bytes(src: str, stream_threshold: int = STREAM_THRESHOLD, timeout: int = 60, progress=None) -> bytes:
+    if progress is not None:
+        progress(0.05, desc="Checking remote/local source...")
+    if is_remote(src):
+        head = safe_head(src)
+        if head is not None:
+            cl = head.headers.get("content-length")
+            try:
+                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:
+                            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:
+                pass
+        r = safe_get(src, timeout=timeout)
+        if progress is not None:
+            progress(0.25, desc="Downloaded remote content")
+        return r.content
+    else:
+        if not os.path.exists(src):
+            raise FileNotFoundError(f"Local path does not exist: {src}")
+        if progress is not None:
+            progress(0.05, desc="Reading local file...")
+        with open(src, "rb") as f:
+            data = f.read()
+        if progress is not None:
+            progress(0.15, desc="Read local file")
+        return data
 
 def convert_to_jpeg_bytes(img_bytes: bytes, base_h: int = 480) -> bytes:
     img = Image.open(BytesIO(img_bytes))
-    if getattr(img, "is_animated", False):
-        img.seek(0)
+    try:
+        if getattr(img, "is_animated", False):
+            img.seek(0)
+    except Exception:
+        pass
     if img.mode != "RGB":
         img = img.convert("RGB")
     h = base_h
@@ -120,952 +155,563 @@ def convert_to_jpeg_bytes(img_bytes: bytes, base_h: int = 480) -> bytes:
     img.save(buf, format="JPEG", quality=85)
     return buf.getvalue()
 
-
 def b64_bytes(b: bytes, mime: str = "image/jpeg") -> str:
-    return f"data:{mime};base64," + base64.b64encode(b).decode()
-
-
-# --------------------------------------------------------------------------- #
-#  Media‑type detection
-# --------------------------------------------------------------------------- #
-def determine_media_type(src: str, progress: Callable = None) -> Tuple[bool, bool]:
-    is_img = ext_from_src(src) in IMAGE_EXTS
-    is_vid = ext_from_src(src) in VIDEO_EXTS
-    if is_remote(src):
-        head = safe_head(src)
-        if head:
-            ct = (head.headers.get("content-type") or "").lower()
-            if ct.startswith("image/"):
-                is_img, is_vid = True, False
-            elif ct.startswith("video/"):
-                is_vid, is_img = True, False
-    _progress(0.02, "Determined media type", progress)
-    return is_img, is_vid
-
-
-# --------------------------------------------------------------------------- #
-#  Download helpers – stream large files directly to a temp file
-# --------------------------------------------------------------------------- #
-def download_to_temp(src: str, progress: Callable = None) -> str:
-    """Return a temporary file path containing the downloaded content."""
-    _progress(0.05, "Downloading...", progress)
-    if is_remote(src):
-        # stream to avoid loading huge files into RAM
-        r = requests.get(src, stream=True, timeout=60)
-        r.raise_for_status()
-        suffix = ext_from_src(src) or ".bin"
-        fd, path = tempfile.mkstemp(suffix=suffix)
+    return f"data:{mime};base64," + base64.b64encode(b).decode("utf-8")
+
+def extract_best_frames_bytes(media_path: str, sample_count: int = 5, timeout_extract: int = 15, progress=None) -> List[bytes]:
+    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...")
+    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}.jpg")
         os.close(fd)
-        with open(path, "wb") as f:
-            for chunk in r.iter_content(8192):
-                if chunk:
-                    f.write(chunk)
-        return path
-    else:
-        if not os.path.exists(src):
-            raise FileNotFoundError(f"Local path does not exist: {src}")
-        return src
-
-
-# --------------------------------------------------------------------------- #
-#  ffprobe / conversion helpers (browser‑playable video)
-# --------------------------------------------------------------------------- #
-def _ffprobe_streams(path: str) -> Optional[dict]:
-    if not FFMPEG_BIN:
-        return None
-    ffprobe = FFMPEG_BIN.replace("ffmpeg", "ffprobe")
-    if not shutil.which(ffprobe):
-        ffprobe = "ffprobe"
-    cmd = [
-        ffprobe,
-        "-v",
-        "error",
-        "-print_format",
-        "json",
-        "-show_streams",
-        "-show_format",
-        path,
-    ]
-    try:
-        out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
-        return json.loads(out)
-    except Exception:
-        return None
-
-
-def _is_browser_playable(path: str) -> bool:
-    """True if the file is MP4 (or MOV) with an H.264/H.265 video stream."""
-    if not path:
-        return False
-    ext = path.lower()
-    if any(ext.endswith(e) for e in (".mp4", ".m4v", ".mov")):
-        info = _ffprobe_streams(path)
-        if not info:
-            return ext.endswith(".mp4")
-        for s in info.get("streams", []):
-            if s.get("codec_type") == "video" and s.get("codec_name") in (
-                "h264",
-                "h265",
-                "avc1",
-            ):
-                return True
-    # fallback: any video stream is acceptable
-    info = _ffprobe_streams(path)
-    if not info:
-        return False
-    return any(s.get("codec_type") == "video" for s in info.get("streams", []))
-
-
-def _convert_video_for_preview_if_needed(path: str, progress: Callable = None) -> str:
-    """Return a path that Gradio can play (MP4 + H.264/AAC)."""
-    if not FFMPEG_BIN or not os.path.exists(path):
-        return path
-    if _is_browser_playable(path):
-        return path
-
-    _progress(0.70, "Re‑encoding video for preview", progress)
-    out_fd, out_path = tempfile.mkstemp(suffix=".mp4")
-    os.close(out_fd)
-    cmd = [
-        FFMPEG_BIN,
-        "-y",
-        "-i",
-        path,
-        "-c:v",
-        "libx264",
-        "-preset",
-        "veryfast",
-        "-crf",
-        "28",
-        "-c:a",
-        "aac",
-        "-movflags",
-        "+faststart",
-        out_path,
-    ]
-    try:
-        subprocess.run(
-            cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=60
-        )
-        return out_path
-    except Exception:
+        _temp_preview_files_to_delete.append(tmp) # Track for cleanup
+        cmd = [
+            FFMPEG_BIN,
+            "-nostdin",
+            "-y",
+            "-ss",
+            str(t),
+            "-i",
+            media_path,
+            "-frames:v",
+            "1",
+            "-q:v",
+            "2",
+            tmp,
+        ]
         try:
-            os.remove(out_path)
+            if progress is not None:
+                progress(0.1 + (i / max(1, sample_count)) * 0.2, desc=f"Extracting frame {i+1}/{sample_count}...")
+            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
-        return path
-
-
-# --------------------------------------------------------------------------- #
-#  Mistral interaction (upload + chat)
-# --------------------------------------------------------------------------- #
-def upload_file_to_mistral(
-    client,
-    path: str,
-    filename: str | None = None,
-    purpose: str = "batch",
-    progress: Callable = None,
-) -> str:
-    """Upload a file via the REST endpoint and return its file‑id."""
-    fname = filename or os.path.basename(path)
-
-    # Build a short list of plausible purposes
-    purposes = [purpose]
-    ext = os.path.splitext(fname)[1].lower()
-    if ext in {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".tiff"}:
-        purposes.append("image")
-    for p in ("batch", "fine-tune", "image"):
-        if p not in purposes:
-            purposes.append(p)
-
-    api_key = getattr(client, "api_key", "") or DEFAULT_KEY
-    if not api_key:
-        raise RuntimeError("MISTRAL_API_KEY missing")
-
-    url = "https://api.mistral.ai/v1/files"
-    headers = {"Authorization": f"Bearer {api_key}"}
-
-    last_err = None
-    for cur_purpose in purposes:
-        try:
-            with open(path, "rb") as fh:
-                files = {"file": (fname, fh)}
-                data = {"purpose": cur_purpose}
-                resp = requests.post(
-                    url, headers=headers, files=files, data=data, timeout=120
-                )
-                resp.raise_for_status()
-                payload = resp.json()
-                fid = payload.get("id") or payload.get("data", [{}])[0].get("id")
-                if fid:
-                    _progress(0.65, f"Uploaded (purpose={cur_purpose})", progress)
-                    return fid
-                raise RuntimeError("Upload succeeded but no file id returned")
-        except requests.exceptions.HTTPError as he:
-            if he.response.status_code == 422:
-                last_err = he
-                continue
-            raise RuntimeError(f"Upload failed: {he}") from he
-        except Exception as e:
-            last_err = e
-            raise RuntimeError(f"Upload failed: {e}") from e
-
-    raise RuntimeError(f"All upload attempts failed. Last error: {last_err}")
-
+        finally:
+            # frame is read into memory, temp file can be removed early if not already done by atexit
+            try:
+                if tmp in _temp_preview_files_to_delete:
+                    _temp_preview_files_to_delete.remove(tmp)
+                os.remove(tmp)
+            except Exception: pass
+    if progress is not None:
+        progress(0.45, desc=f"Extracted {len(frames)} frames")
+    return frames
 
-def chat_complete(client, model: str, messages, progress: Callable = None) -> str:
-    """Send a chat request (non‑streaming) and return the model’s text response."""
-    _progress(0.60, "Calling model", progress)
+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"):
-            try:
-                res = client.chat.complete(
-                    model=model, messages=messages, timeout=120, stream=False
-                )
-            except TypeError:
-                # SDK variations
-                res = client.chat.complete(
-                    model=model, messages=messages, request_timeout=120, stream=False
-                )
+            res = client.chat.complete(model=model, messages=messages, stream=False)
         else:
-            # raw REST fallback
             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",
-            }
-            r = requests.post(
-                url,
-                json={"model": model, "messages": messages},
-                headers=headers,
-                timeout=120,
-            )
+            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}"
 
-    _progress(0.80, "Parsing response", progress)
-    choices = getattr(res, "choices", None) or (
-        res.get("choices") if isinstance(res, dict) else []
-    )
-    if not choices:
-        return f"Empty response: {res}"
-    first = choices[0]
-    msg = (
-        first.get("message")
-        if isinstance(first, dict)
-        else getattr(first, "message", {})
-    )
-    content = (
-        msg.get("content") if isinstance(msg, dict) else getattr(msg, "content", "")
-    )
-    return content.strip() if isinstance(content, str) else str(content)
-
-
-# --------------------------------------------------------------------------- #
-#  Analysis functions (image & video)
-# --------------------------------------------------------------------------- #
-def analyze_image_structured(
-    client, img_bytes: bytes, prompt: str, progress: Callable = None
-) -> str:
-    _progress(0.30, "Preparing image", progress)
-    jpeg = convert_to_jpeg_bytes(img_bytes, base_h=1024)
-    tmp = save_bytes_to_temp(jpeg, ".jpg")
+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:
-        fid = upload_file_to_mistral(
-            client, tmp, filename="image.jpg", purpose="image", progress=progress
-        )
-    finally:
-        try:
-            os.remove(tmp)
-        except Exception:
-            pass
+        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
 
-    messages = [
-        {"role": "system", "content": SYSTEM_INSTRUCTION},
-        {
-            "role": "user",
-            "content": [
+    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()
+            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}")
+
+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:
+        is_video = True
+    if is_remote(src):
+        head = safe_head(src)
+        if head:
+            ctype = (head.headers.get("content-type") or "").lower()
+            if ctype.startswith("image/"):
+                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
+
+def analyze_image_structured(client, img_bytes: bytes, prompt: str, progress=None) -> str:
+    try:
+        if progress is not None:
+            progress(0.3, desc="Preparing image for analysis...")
+        jpeg = convert_to_jpeg_bytes(img_bytes, base_h=1024)
+        data_url = b64_bytes(jpeg, mime="image/jpeg")
+        messages = [
+            {"role": "system", "content": SYSTEM_INSTRUCTION},
+            {"role": "user", "content": [
                 {"type": "text", "text": prompt},
-                {"type": "file", "file_id": fid},
-            ],
-        },
-    ]
-    return chat_complete(client, PIXTRAL_MODEL, messages, progress=progress)
-
+                {"type": "image_url", "image_url": data_url},
+            ]},
+        ]
+        return chat_complete(client, PIXTRAL_MODEL, messages, progress=progress)
+    except UnidentifiedImageError:
+        return "Error: provided file is not a valid image."
+    except Exception as e:
+        return f"Error analyzing image: {e}"
 
-def analyze_video_cohesive(
-    client,
-    video_path: str,
-    prompt: str,
-    progress: Callable = None,
-    model: str = VIDEO_MODEL,
-) -> str:
-    """Full‑video analysis; falls back to frame‑based analysis on upload failure."""
+def analyze_video_cohesive(client, video_path: str, prompt: str, progress=None) -> str:
     try:
-        _progress(0.30, "Uploading video", progress)
-        fid = upload_file_to_mistral(
-            client,
-            video_path,
-            filename=os.path.basename(video_path),
-            purpose="batch",
-            progress=progress,
+        if progress is not None:
+            progress(0.3, desc="Uploading video for full analysis...")
+        file_id = upload_file_to_mistral(client, video_path, filename=os.path.basename(video_path), progress=progress)
+        extra_msg = (
+            f"Uploaded video file id: {file_id}\n\n"
+            "Instruction: Analyze the entire video and produce a single cohesive narrative describing consistent observations."
         )
         messages = [
             {"role": "system", "content": SYSTEM_INSTRUCTION},
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": f"{prompt}\n\nAnalyze the whole video and produce a single cohesive narrative.",
-                    },
-                    {"type": "file", "file_id": fid},
-                ],
-            },
+            {"role": "user", "content": extra_msg + "\n\n" + prompt},
         ]
-        return chat_complete(client, model, messages, progress=progress)
-
-    except Exception as exc:
-        # ---- fallback: extract a few representative frames --------------------
-        _progress(0.35, "Upload failed – extracting frames", progress)
-        frames = extract_best_frames_bytes(
-            video_path, sample_count=6, progress=progress
-        )
+        return chat_complete(client, VIDEO_MODEL, messages, progress=progress)
+    except Exception as e:
+        if progress is not None:
+            progress(0.35, desc="Upload failed, extracting frames as fallback...")
+        frames = extract_best_frames_bytes(video_path, sample_count=6, progress=progress)
         if not frames:
-            return f"Error: upload failed and no frames could be extracted ({exc})"
-
-        # upload each frame and build the message payload
-        frame_files = []
-        for i, raw in enumerate(frames, 1):
-            _progress(
-                0.40 + i / len(frames) * 0.15,
-                f"Uploading frame {i}/{len(frames)}",
-                progress,
-            )
-            tmp = save_bytes_to_temp(convert_to_jpeg_bytes(raw, base_h=720), ".jpg")
+            return f"Error: could not upload video and no frames could be extracted. ({e})"
+        image_entries = []
+        for i, fb in enumerate(frames, start=1):
             try:
-                fid = upload_file_to_mistral(
-                    client, tmp, f"frame_{i}.jpg", purpose="image", progress=progress
+                if progress is not None:
+                    progress(0.4 + (i / len(frames)) * 0.2, desc=f"Preparing frame {i}/{len(frames)}...")
+                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},
+                    }
                 )
-                frame_files.append({"type": "file", "file_id": fid})
-            finally:
-                os.remove(tmp)
-
+            except Exception:
+                continue
+        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},
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": f"{prompt}\n\nConsolidate observations across the provided frames into a single narrative.",
-                    },
-                    *frame_files,
-                ],
-            },
+            {"role": "user", "content": content},
         ]
         return chat_complete(client, PIXTRAL_MODEL, messages, progress=progress)
 
+# --- FFmpeg Helpers for Preview ---
+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
+    cmd = [
+        ffprobe, "-v", "error", "-print_format", "json", "-show_streams", "-show_format", path
+    ]
+    try:
+        out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
+        return json.loads(out)
+    except Exception:
+        return None
 
-# --------------------------------------------------------------------------- #
-#  Gradio UI helpers
-# --------------------------------------------------------------------------- #
-css = ".preview_media img, .preview_media video {max-width:100%;height:auto;border-radius:6px;}"
-
-
-def _make_preview(url: str, raw: bytes, cache: dict) -> str:
-    """Create (or reuse) a preview file – image → JPEG, video → MP4 (browser‑playable)."""
-    if url in cache:
-        return cache[url]
-
-    if determine_media_type(url)[1]:  # video
-        tmp = _temp_file(raw, suffix=ext_from_src(url) or ".mp4")
-        preview = _convert_video_for_preview_if_needed(tmp)
-        os.remove(tmp)  # the converted file is a separate temp file
-    else:  # image
-        preview = _temp_file(convert_to_jpeg_bytes(raw, base_h=1024), suffix=".jpg")
-    cache[url] = preview
-    return preview
+def _convert_video_for_preview_if_needed(path: str) -> str:
+    """
+    Returns a path that the Gradio video component can play.
+    If the original file is already browser-compatible (e.g., MP4 with H.264),
+    the original path is returned. Otherwise, the file is re-encoded to MP4
+    (H.264 + AAC) and a new temporary path is returned.
+    """
+    if not FFMPEG_BIN or not os.path.exists(path):
+        return path # Cannot convert, return original
 
+    # Quick check for MP4 and common codecs
+    if path.lower().endswith((".mp4", ".m4v", ".mov")):
+        info = _ffprobe_streams(path)
+        if info:
+            video_streams = [s for s in info.get("streams", []) if s.get("codec_type") == "video"]
+            if video_streams and any(s.get("codec_name") in ("h264", "h265", "avc1") for s in video_streams):
+                return path # Already playable
 
-def apply_preview(path: str, last_path: str):
-    """Return Gradio updates for image/video components and a status string."""
-    if not path or path == last_path:
-        return gr.update(), gr.update(), ""
+    # Need conversion → write to a new temp MP4
+    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,
+        "-map_metadata", "-1" # Remove metadata
+    ]
+    try:
+        subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=60)
+        return out_path
+    except Exception:
+        # 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)
+        try: os.remove(out_path)
+        except Exception: pass
+        return path # Gradio will show its own warning if not playable
+
+# --- Preview Generation Logic ---
+def _get_playable_preview_path_from_raw(src_url: str, raw_bytes: bytes) -> str:
+    """
+    Generates a playable preview file from raw bytes.
+    Creates and tracks a new temporary file.
+    """
+    is_img, is_vid = determine_media_type(src_url)
+
+    if is_vid:
+        # Save raw video bytes to a temp file for potential conversion
+        temp_raw_video_path = _temp_file(raw_bytes, suffix=ext_from_src(src_url) or ".mp4")
+
+        # Convert it for browser playback if necessary; this might return a new temp path or the original
+        playable_path = _convert_video_for_preview_if_needed(temp_raw_video_path)
+
+        # If a new path was created by conversion, the original temp_raw_video_path is no longer needed
+        # and should be explicitly removed if it's no longer tracked or if it's tracked separately
+        if playable_path != temp_raw_video_path and os.path.exists(temp_raw_video_path):
+            if temp_raw_video_path in _temp_preview_files_to_delete:
+                _temp_preview_files_to_delete.remove(temp_raw_video_path)
+            try: os.remove(temp_raw_video_path)
+            except Exception: pass
+        return playable_path
+    else: # Assume image or unknown treated as image for preview
+        # Convert image bytes to JPEG and save as temp file
+        return _temp_file(convert_to_jpeg_bytes(raw_bytes, base_h=1024), suffix=".jpg")
+
+def _fetch_with_retries_bytes(src: str, timeout: int = 15, max_retries: int = 3):
+    attempt = 0
+    delay = 1.0
+    while True:
+        attempt += 1
+        try:
+            if is_remote(src):
+                r = requests.get(src, timeout=timeout, stream=True)
+                if r.status_code == 200:
+                    return r.content
+                if r.status_code == 429: # Rate limit
+                    ra = r.headers.get("Retry-After")
+                    try: delay = float(ra) if ra is not None else delay
+                    except Exception: pass
+                r.raise_for_status()
+            else:
+                with open(src, "rb") as fh:
+                    return fh.read()
+        except requests.exceptions.RequestException:
+            if attempt >= max_retries: raise
+            time.sleep(delay)
+            delay *= 2
+        except FileNotFoundError:
+            raise
+        except Exception:
+            if attempt >= max_retries: raise
+            time.sleep(delay)
+            delay *= 2
+
+def _save_local_playable_preview(src: str) -> Optional[str]:
+    """
+    Fetches remote content or reads local, then ensures it's in a playable format
+    for Gradio preview components.
+    """
+    if not src:
+        return None
 
-    if any(path.lower().endswith(ext) for ext in IMAGE_EXTS):
-        return (
-            gr.update(value=path, visible=True),
-            gr.update(value=None, visible=False),
-            "Preview updated.",
-        )
-    if any(path.lower().endswith(ext) for ext in VIDEO_EXTS):
-        return (
-            gr.update(value=None, visible=False),
-            gr.update(value=path, visible=True),
-            "Preview updated.",
-        )
+    if not is_remote(src):
+        if os.path.exists(src):
+            is_img, is_vid = determine_media_type(src)
+            if is_vid:
+                return _convert_video_for_preview_if_needed(src)
+            return src # Local image, return as is
+        return None # Local path does not exist
 
-    # fallback – try to open as image
+    # Remote source
     try:
-        Image.open(path).verify()
-        return (
-            gr.update(value=path, visible=True),
-            gr.update(value=None, visible=False),
-            "Preview updated.",
-        )
-    except Exception:
-        return (
-            gr.update(value=None, visible=False),
-            gr.update(value=None, visible=False),
-            "",
-        )
+        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)
+    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; }"
 
+def _btn_label_for_status(status: str) -> str:
+    """Provides dynamic labels for the submit button based on processing status."""
+    return {"idle": "Submit", "busy": "Processing…", "done": "Done!", "error": "Retry"}.get(status, "Submit")
 
 def create_demo():
     with gr.Blocks(title="Flux Multimodal", css=css) as demo:
         with gr.Row():
             with gr.Column(scale=1):
-                preview_image = gr.Image(
-                    label="Preview Image",
-                    type="filepath",
-                    elem_classes="preview_media",
-                    visible=False,
-                )
-                preview_video = gr.Video(
-                    label="Preview Video",
-                    elem_classes="preview_media",
-                    visible=False,
-                    format="mp4",
-                )
-                preview_status = gr.Textbox(
-                    label="Preview status",
-                    interactive=False,
-                    lines=1,
-                    value="",
-                    visible=True,
-                )
+                preview_image = gr.Image(label="Preview Image", type="filepath", elem_classes="preview_media", visible=False)
+                preview_video = gr.Video(label="Preview Video", elem_classes="preview_media", visible=False, format="mp4")
+                preview_status = gr.Textbox(label="Preview status", interactive=False, lines=1, value="", visible=True)
             with gr.Column(scale=2):
-                url_input = gr.Textbox(
-                    label="Image / Video URL", placeholder="https://...", lines=1
-                )
+                url_input = gr.Textbox(label="Image / Video URL", placeholder="https://...", lines=1)
                 with gr.Accordion("Prompt (optional)", open=False):
                     custom_prompt = gr.Textbox(label="Prompt", lines=4, value="")
                 with gr.Accordion("Mistral API Key (optional)", open=False):
-                    api_key = gr.Textbox(
-                        label="Mistral API Key", type="password", max_lines=1
-                    )
+                    api_key = gr.Textbox(label="Mistral API Key", type="password", max_lines=1)
                 with gr.Row():
                     submit_btn = gr.Button("Submit")
                     clear_btn = gr.Button("Clear")
                 progress_md = gr.Markdown("Idle")
                 output_md = gr.Markdown("")
+
+                # State to track overall processing status (idle, busy, done, error)
                 status_state = gr.State("idle")
-                # hidden state to pass preview path from worker to frontend
+                # State to hold the current path of the file being used for preview (whether from URL input or worker)
                 preview_path_state = gr.State("")
 
-        # small helper: fetch URL into bytes with retries and respect Retry-After
-        def _fetch_with_retries_bytes(
-            src: str, timeout: int = 15, max_retries: int = 3
-        ):
-            attempt = 0
-            delay = 1.0
-            while True:
-                attempt += 1
-                try:
-                    if is_remote(src):
-                        r = requests.get(src, timeout=timeout, stream=True)
-                        if r.status_code == 200:
-                            return r.content
-                        if r.status_code == 429:
-                            ra = r.headers.get("Retry-After")
-                            try:
-                                delay = float(ra) if ra is not None else delay
-                            except Exception:
-                                pass
-                        r.raise_for_status()
-                    else:
-                        with open(src, "rb") as fh:
-                            return fh.read()
-                except requests.exceptions.RequestException:
-                    if attempt >= max_retries:
-                        raise
-                    time.sleep(delay)
-                    delay *= 2
-                except FileNotFoundError:
-                    raise
-                except Exception:
-                    if attempt >= max_retries:
-                        raise
-                    time.sleep(delay)
-                    delay *= 2
-
-        # create a local temp file for a remote URL and return local path (or None)
-        def _save_preview_local(src: str) -> Optional[str]:
-            if not src:
-                return None
-            if not is_remote(src):
-                return src if os.path.exists(src) else None
-            try:
-                b = _fetch_with_retries_bytes(src, timeout=15, max_retries=3)
-                ext = ext_from_src(src) or ".bin"
-                fd, tmp = tempfile.mkstemp(suffix=ext)
-                os.close(fd)
-                with open(tmp, "wb") as fh:
-                    fh.write(b)
-                return tmp
-            except Exception:
-                return None
-
+        # Function to handle URL input change and update preview
         def load_preview(url: str):
-            # returns (preview_image_path, preview_video_path, status_msg)
+            """
+            Loads a preview for the given URL and updates the preview components.
+            Returns (image_update, video_update, status_message, new_preview_path_for_state).
+            """
             if not url:
-                return (
-                    gr.update(value=None, visible=False),
-                    gr.update(value=None, visible=False),
-                    gr.update(value=""),
-                )
+                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value=""), ""
+
             try:
-                if is_remote(url):
-                    head = safe_head(url)
-                    if head:
-                        ctype = (head.headers.get("content-type") or "").lower()
-                        if ctype.startswith("video/") or any(
-                            url.lower().endswith(ext) for ext in VIDEO_EXTS
-                        ):
-                            local = _save_preview_local(url)
-                            if local:
-                                return (
-                                    gr.update(value=None, visible=False),
-                                    gr.update(value=local, visible=True),
-                                    gr.update(
-                                        value=f"Remote video detected (content-type={ctype}). Showing preview if browser-playable."
-                                    ),
-                                )
-                            else:
-                                return (
-                                    gr.update(value=None, visible=False),
-                                    gr.update(value=None, visible=False),
-                                    gr.update(
-                                        value=f"Remote video detected but preview download failed (content-type={ctype})."
-                                    ),
-                                )
-                local = _save_preview_local(url)
-                if not local:
-                    return (
-                        gr.update(value=None, visible=False),
-                        gr.update(value=None, visible=False),
-                        gr.update(
-                            value="Preview load failed: could not fetch resource."
-                        ),
-                    )
+                local_playable_path = _save_local_playable_preview(url)
+                if not local_playable_path:
+                    return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value="Preview load failed: could not fetch resource or make playable."), ""
+
+                # Determine if it's an image or video for display
+                is_img_preview = False
                 try:
-                    img = Image.open(local)
-                    if getattr(img, "is_animated", False):
-                        img.seek(0)
-                    return (
-                        gr.update(value=local, visible=True),
-                        gr.update(value=None, visible=False),
-                        gr.update(value="Image preview loaded."),
-                    )
-                except UnidentifiedImageError:
-                    if any(local.lower().endswith(ext) for ext in VIDEO_EXTS) or True:
-                        return (
-                            gr.update(value=None, visible=False),
-                            gr.update(value=local, visible=True),
-                            gr.update(
-                                value="Non-image file — showing as video preview if playable."
-                            ),
-                        )
-                    return (
-                        gr.update(value=None, visible=False),
-                        gr.update(value=None, visible=False),
-                        gr.update(
-                            value="Preview load failed: file is not a valid image."
-                        ),
-                    )
+                    Image.open(local_playable_path).verify()
+                    is_img_preview = True
+                except Exception:
+                    pass # Not an image, treat as video
+
+                if is_img_preview:
+                    return gr.update(value=local_playable_path, visible=True), gr.update(value=None, visible=False), gr.update(value="Image preview loaded."), local_playable_path
+                else: # Assume video (Gradio will render if playable)
+                    return gr.update(value=None, visible=False), gr.update(value=local_playable_path, visible=True), gr.update(value="Video preview loaded."), local_playable_path
+
             except Exception as e:
-                return (
-                    gr.update(value=None, visible=False),
-                    gr.update(value=None, visible=False),
-                    gr.update(value=f"Preview load failed: {e}"),
-                )
+                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value=f"Preview load failed: {e}"), ""
 
+        # Bind load_preview to the URL input change event
         url_input.change(
             fn=load_preview,
             inputs=[url_input],
-            outputs=[preview_image, preview_video, preview_status],
+            outputs=[preview_image, preview_video, preview_status, preview_path_state]
         )
 
-        def clear_all():
-            return "", None, None, "idle", "Idle", "", ""
+        # Function to clear all inputs and outputs
+        def clear_all(current_preview_path: str):
+            """Clears all inputs/outputs and cleans up the currently displayed preview file."""
+            if current_preview_path and os.path.exists(current_preview_path) and current_preview_path in _temp_preview_files_to_delete:
+                try:
+                    os.remove(current_preview_path)
+                    _temp_preview_files_to_delete.remove(current_preview_path)
+                except Exception as e:
+                    print(f"Error cleaning up on clear: {e}")
+
+            return "", None, None, "idle", "Idle", "", "" # url_input, preview_image, preview_video, status_state, progress_md, output_md, preview_path_state
 
         clear_btn.click(
             fn=clear_all,
-            inputs=[],
-            outputs=[
-                url_input,
-                preview_image,
-                preview_video,
-                status_state,
-                progress_md,
-                output_md,
-                preview_path_state,
-            ],
+            inputs=[preview_path_state], # Pass current preview path for cleanup
+            outputs=[url_input, preview_image, preview_video, status_state, progress_md, output_md, preview_path_state]
         )
 
-        def _convert_video_for_preview(path: str) -> str:
-            if not FFMPEG_BIN or not os.path.exists(FFMPEG_BIN):
-                return path
-            out_fd, out_path = tempfile.mkstemp(suffix=".mp4")
-            os.close(out_fd)
-            cmd = [
-                FFMPEG_BIN,
-                "-nostdin",
-                "-y",
-                "-i",
-                path,
-                "-c:v",
-                "libx264",
-                "-preset",
-                "veryfast",
-                "-crf",
-                "28",
-                "-c:a",
-                "aac",
-                "-movflags",
-                "+faststart",
-                out_path,
-            ]
-            try:
-                subprocess.run(
-                    cmd,
-                    stdout=subprocess.DEVNULL,
-                    stderr=subprocess.DEVNULL,
-                    timeout=60,
-                )
-                return out_path
-            except Exception:
-                try:
-                    os.remove(out_path)
-                except Exception:
-                    pass
-                return path
-
-        # --- Helper: probe codecs via ffprobe; returns dict with streams info or None on failure
-        def _ffprobe_streams(path: str) -> Optional[dict]:
-            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"
-            cmd = [
-                ffprobe,
-                "-v",
-                "error",
-                "-print_format",
-                "json",
-                "-show_streams",
-                "-show_format",
-                path,
-            ]
-            try:
-                out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
-                return json.loads(out)
-            except Exception:
-                return None
-
-        # --- Helper: is file already browser-playable (mp4 container with h264 video and aac audio OR at least playable video)
-        def _is_browser_playable(path: str) -> bool:
-            try:
-                ext = (path or "").lower().split("?")[0]
-                if any(ext.endswith(e) for e in [".mp4", ".m4v", ".mov"]):
-                    info = _ffprobe_streams(path)
-                    if not info:
-                        # fallback: trust .mp4 if probe failed
-                        return ext.endswith(".mp4")
-                    streams = info.get("streams", [])
-                    v_ok = any(
-                        s.get("codec_name") in ("h264", "h265", "avc1")
-                        and s.get("codec_type") == "video"
-                        for s in streams
-                    )
-                    # audio optional for preview
-                    return bool(v_ok)
-                # other extensions: probe and accept if any video stream present
-                info = _ffprobe_streams(path)
-                if not info:
-                    return False
-                streams = info.get("streams", [])
-                return any(s.get("codec_type") == "video" for s in streams)
-            except Exception:
-                return False
-
-        # --- Convert only if not browser-playable
-        def _convert_video_for_preview_if_needed(path: str) -> str:
+        # Main worker function for analysis
+        def worker(url: str, prompt: str, key: str, progress=gr.Progress()):
             """
-            Return a path that the Gradio video component can play.
-            If the original file is already MP4 with H.264 (or another browser‑compatible codec),
-            the original path is returned unchanged.
-            Otherwise the file is re‑encoded to MP4 (H.264 + AAC) and the new path is returned.
+            Performs the media analysis.
+            Returns (status, markdown_output, new_preview_path_for_state).
             """
-            if not FFMPEG_BIN or not os.path.exists(path):
-                return path
-
-            # Quick check: extension + ffprobe for codecs
-            if path.lower().endswith((".mp4", ".m4v", ".mov")):
-                info = _ffprobe_streams(path)
-                if info:
-                    codecs = {
-                        s.get("codec_name")
-                        for s in info.get("streams", [])
-                        if s.get("codec_type") == "video"
-                    }
-                    if "h264" in codecs or "h265" in codecs:
-                        return path  # already playable
-
-            # Need conversion → write to a new temp MP4
-            out_fd, out_path = tempfile.mkstemp(suffix=".mp4")
-            os.close(out_fd)
-            cmd = [
-                FFMPEG_BIN,
-                "-y",
-                "-i",
-                path,
-                "-c:v",
-                "libx264",
-                "-preset",
-                "veryfast",
-                "-crf",
-                "28",
-                "-c:a",
-                "aac",
-                "-movflags",
-                "+faststart",
-                out_path,
-            ]
-            try:
-                subprocess.run(
-                    cmd,
-                    stdout=subprocess.DEVNULL,
-                    stderr=subprocess.DEVNULL,
-                    timeout=60,
-                )
-                return out_path
-            except Exception:
-                # If conversion fails, fall back to the original (Gradio will show its own warning)
-                try:
-                    os.remove(out_path)
-                except Exception:
-                    pass
-                return path
-
-        def worker(url: str, prompt: str, key: str, progress=gr.Progress()):
-            """Return (status, markdown_output, preview_path)."""
+            temp_media_file_for_analysis = None # Temporary file for analysis (video-only for voxtral)
+            generated_preview_path = "" # Path for the Gradio preview components
             try:
                 if not url:
                     return "error", "**Error:** No URL provided.", ""
 
+                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)
 
                 client = get_client(key)
-                preview_path = ""
 
+                raw_bytes = None
+
+                # --- Video Processing Path ---
                 if is_vid:
-                    progress(0.05, desc="Downloading video")
-                    raw = fetch_bytes(url, timeout=120, progress=progress)
-                    if not raw:
+                    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.", ""
 
-                    # write with a proper video extension
-                    tmp_video = _temp_file(
-                        raw, suffix="." + (ext_from_src(url) or "mp4")
-                    )
-                    progress(0.15, desc="Preparing preview")
-                    preview_path = _make_preview(url, raw)
+                    # Create a temporary file for analysis (Mistral API needs a path for video upload)
+                    temp_media_file_for_analysis = _temp_file(raw_bytes, suffix=ext_from_src(url) or ".mp4")
 
-                    progress(0.25, desc="Running full‑video analysis")
-                    result = analyze_video_cohesive(
-                        client, tmp_video, prompt, progress=progress
-                    )
+                    progress(0.15, desc="Preparing video preview")
+                    generated_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes)
 
-                    # clean‑up the *raw* temp file (preview may be a different file)
-                    try:
-                        os.remove(tmp_video)
-                    except Exception:
-                        pass
+                    progress(0.25, desc="Running full‑video analysis")
+                    result = analyze_video_cohesive(client, temp_media_file_for_analysis, prompt, progress=progress)
 
+                # --- Image Processing Path ---
                 elif is_img:
-                    progress(0.05, desc="Downloading image")
-                    raw = fetch_bytes(url, progress=progress)
+                    progress(0.05, desc="Downloading image for analysis")
+                    raw_bytes = fetch_bytes(url, progress=progress)
 
-                    # preview image (always JPEG for consistency)
-                    preview_path = _make_preview(url, raw)
+                    progress(0.15, desc="Preparing image preview")
+                    generated_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes)
 
                     progress(0.20, desc="Running image analysis")
-                    result = analyze_image_structured(
-                        client, raw, prompt, progress=progress
-                    )
+                    result = analyze_image_structured(client, raw_bytes, prompt, progress=progress)
 
+                # --- Unknown Media Type (Fallback) ---
                 else:
-                    progress(0.07, desc="Downloading unknown media")
-                    raw = fetch_bytes(url, timeout=120, progress=progress)
+                    progress(0.07, desc="Downloading unknown media for type determination")
+                    raw_bytes = fetch_bytes(url, timeout=120, progress=progress)
 
-                    # try to open as image
+                    # Try to open as image first
+                    is_definitely_img = False
                     try:
-                        Image.open(BytesIO(raw)).verify()
-                        is_img = True
+                        Image.open(BytesIO(raw_bytes)).verify()
+                        is_definitely_img = True
                     except Exception:
-                        is_img = False
-
-                    if is_img:
-                        preview_path = _temp_file(
-                            convert_to_jpeg_bytes(raw, base_h=1024), suffix=".jpg"
-                        )
-                        result = analyze_image_structured(
-                            client, raw, prompt, progress=progress
-                        )
-                    else:
-                        tmp_vid = _temp_file(raw, suffix=ext_from_src(url) or ".mp4")
-                        preview_path = _convert_video_for_preview_if_needed(tmp_vid)
-                        result = analyze_video_cohesive(
-                            client, tmp_vid, prompt, progress=progress
-                        )
-                        try:
-                            os.remove(tmp_vid)
-                        except Exception:
-                            pass
-
-                status = (
-                    "done"
-                    if not (
-                        isinstance(result, str) and result.lower().startswith("error")
-                    )
-                    else "error"
-                )
-                return (
-                    status,
-                    result if isinstance(result, str) else str(result),
-                    preview_path or "",
-                )
+                        pass
 
-            except Exception as exc:
-                return "error", f"Unexpected worker error: {exc}", ""
+                    if is_definitely_img:
+                        progress(0.15, desc="Preparing image preview (fallback)")
+                        generated_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes)
+                        progress(0.20, desc="Running image analysis (fallback)")
+                        result = 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_preview_path = _get_playable_preview_path_from_raw(url, raw_bytes)
+                        progress(0.25, desc="Running video analysis (fallback)")
+                        result = analyze_video_cohesive(client, temp_media_file_for_analysis, prompt, progress=progress)
+
+                status = "done" if not (isinstance(result, str) and result.lower().startswith("error")) else "error"
 
-        def _start_processing(url, prompt, key):
-            return "busy", None, None
+                return status, result if isinstance(result, str) else str(result), generated_preview_path
 
+            except Exception as exc:
+                return "error", f"Unexpected worker error: {exc}", ""
+            finally:
+                # Clean up the file used for analysis, if it was a temporary file
+                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) # Remove from list if also added there
+                    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}")
+
+        # Bind worker function to submit button click
         submit_btn.click(
             fn=worker,
             inputs=[url_input, custom_prompt, api_key],
-            outputs=[status_state, output_md, preview_path_state],
+            outputs=[status_state, output_md, preview_path_state], # Worker updates preview_path_state
             show_progress="full",
             show_progress_on=progress_md,
         )
 
-        def _btn_label_for_status(s):
-            labels = {
-                "idle": "Submit",
-                "busy": "Processing...",
-                "done": "Done!",
-                "error": "Retry",
-            }
-            return labels.get(s, "Submit")
-
-        status_state.change(
-            fn=lambda s: _btn_label_for_status(s),
-            inputs=[status_state],
-            outputs=[submit_btn],
-        )
+        # Dynamic update of submit button label based on status
+        status_state.change(fn=_btn_label_for_status, inputs=[status_state], outputs=[submit_btn])
 
+        # Dynamic update of progress text based on status
         def status_to_progress_text(s):
-            return {
-                "idle": "Idle",
-                "busy": "Processing…",
-                "done": "Completed",
-                "error": "Error — see output",
-            }.get(s, s)
-
-        status_state.change(
-            fn=status_to_progress_text, inputs=[status_state], outputs=[progress_md]
-        )
+            return {"idle": "Idle", "busy": "Processing…", "done": "Completed", "error": "Error — see output"}.get(s, s)
+        status_state.change(fn=status_to_progress_text, inputs=[status_state], outputs=[progress_md])
 
-        preview_cache = {}
-
-        def _make_preview(url: str, raw: bytes) -> str:
-            if url in preview_cache:
-                return preview_cache[url][0]
-
-            if determine_media_type(url)[1]:
-                tmp = _temp_file(raw, suffix=ext_from_src(url) or ".mp4")
-                preview = _convert_video_for_preview_if_needed(tmp)
-                preview_cache[url] = (preview, True)
-            else:
-                preview = _temp_file(
-                    convert_to_jpeg_bytes(raw, base_h=1024), suffix=".jpg"
-                )
-                preview_cache[url] = (preview, False)
-            return preview
-
-        preview_path_state = gr.State("")
-        prev_preview_state = gr.State("")
-
-        def apply_preview(path: str, last_path: str):
-            if path == last_path:
-                return gr.update(), gr.update(), ""
+        # Function to react to changes in preview_path_state and update the UI
+        def apply_preview_change(new_path: str, old_path: str):
+            """
+            Handles updating the preview_image/preview_video components and cleaning up old files.
+            `old_path` is implicitly passed by Gradio for State components.
+            """
+            # Clean up the OLD preview file if it was a temporary file managed by us
+            if old_path and os.path.exists(old_path) and old_path in _temp_preview_files_to_delete:
+                try:
+                    os.remove(old_path)
+                    _temp_preview_files_to_delete.remove(old_path) # Remove from tracking list
+                except Exception as e:
+                    print(f"Error cleaning up old preview file {old_path}: {e}")
 
-            if not path:
-                return gr.update(), gr.update(), ""
+            # If new_path is empty, clear both components and status
+            if not new_path:
+                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value="")
 
+            # Determine if new_path is an image or video and update components
             try:
-                if any(path.lower().endswith(ext) for ext in IMAGE_EXTS):
-                    return (
-                        gr.update(value=path, visible=True),
-                        gr.update(value=None, visible=False),
-                        "Preview updated.",
-                    )
-
-                if any(path.lower().endswith(ext) for ext in VIDEO_EXTS):
-                    return (
-                        gr.update(value=None, visible=False),
-                        gr.update(value=path, visible=True),
-                        "Preview updated.",
-                    )
-
-                img = Image.open(path)
-                img.verify()
-                return (
-                    gr.update(value=path, visible=True),
-                    gr.update(value=None, visible=False),
-                    "Preview updated.",
-                )
+                is_img_preview = False
+                try:
+                    Image.open(new_path).verify()
+                    is_img_preview = True
+                except Exception:
+                    pass # Not an image, treat as video
 
+                if is_img_preview:
+                    return gr.update(value=new_path, visible=True), gr.update(value=None, visible=False), gr.update(value="Preview updated.")
+                else: # Assume video (Gradio will render if playable)
+                    return gr.update(value=None, visible=False), gr.update(value=new_path, visible=True), gr.update(value="Preview updated.")
             except Exception as e:
-                print(f"Failed to update preview: {e}")
-                return (
-                    gr.update(value=None, visible=False),
-                    gr.update(value=None, visible=False),
-                    "",
-                )
+                print(f"Error applying new preview from path {new_path}: {e}")
+                return gr.update(value=None, visible=False), gr.update(value=None, visible=False), gr.update(value=f"Preview failed for path: {e}")
 
+        # Register the change event for preview_path_state
+        # Gradio will automatically pass the new value as the first argument and the old value as the second.
         preview_path_state.change(
-            fn=apply_preview,
-            inputs=[preview_path_state, prev_preview_state],
-            outputs=[preview_image, preview_video, preview_status],
+            fn=apply_preview_change,
+            inputs=[preview_path_state], # `preview_path_state` will be `new_path`. `old_path` is passed implicitly.
+            outputs=[preview_image, preview_video, preview_status]
         )
 
     return demo
 
-
 if __name__ == "__main__":
-    create_demo().launch(
-        share=False, server_name="0.0.0.0", server_port=7860, max_threads=8
-    )
+    create_demo().launch(share=False, server_name="0.0.0.0", server_port=7860, max_threads=8)