Implement code changes to enhance functionality and improve performance

app.py

@@ -15,13 +15,18 @@ from abc import ABC, abstractmethod
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from concurrent.futures import TimeoutError as FuturesTimeoutError
 from collections import defaultdict
+import tempfile # Added for robust temporary directory management
 
 try:
     import google.generativeai as genai
-    from google.generativeai.types import GenerationConfig
+    from google.generativeai.types import GenerationConfig, HarmCategory, HarmBlockThreshold, FinishReason, HarmProbability
 except ImportError:
     genai = None
     GenerationConfig = None
+    HarmCategory = None # Added for safety settings/finish reason details
+    HarmBlockThreshold = None # Added for safety settings
+    FinishReason = None # Added for checking candidate finish reason
+    HarmProbability = None # Added for checking safety ratings probability
     print("WARNING: google-generativeai library not found. Install with: pip install google-generativeai")
 
 try:
@@ -65,7 +70,7 @@ except ImportError:
     print("WARNING: librosa library not found. Audio processing may be impaired. Install with: pip install librosa")
 
 try:
-    import openpyxl 
+    import openpyxl
 except ImportError:
     openpyxl = None
     print("WARNING: openpyxl library not found. .xlsx file processing might fail. Install with: pip install openpyxl")
@@ -103,28 +108,28 @@ GOOGLE_GEMINI_API_KEY = os.getenv("GOOGLE_GEMINI_API_KEY")
 TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")
 
 AGENT_DEFAULT_TIMEOUT = 15
-MAX_CONTEXT_LENGTH_LLM = 30000 
+MAX_CONTEXT_LENGTH_LLM = 30000
 
-MAX_FILE_SIZE = 5 * 1024 * 1024 
+MAX_FILE_SIZE = 5 * 1024 * 1024
 CSV_SAMPLE_ROWS = 10
-MAX_FILE_CONTEXT_LENGTH = 10000 
+MAX_FILE_CONTEXT_LENGTH = 10000
 
 # Global instances for video analysis pipelines
 video_object_detector_pipeline: Optional[Any] = None
 video_vqa_pipeline: Optional[Any] = None # Changed from species_classifier to VQA
 
-VIDEO_ANALYSIS_DEVICE: int = -1 
+VIDEO_ANALYSIS_DEVICE: int = -1
 VIDEO_ANALYSIS_OBJECT_MODEL = "facebook/detr-resnet-50"
 VIDEO_ANALYSIS_VQA_MODEL = "Salesforce/blip-vqa-capfilt-large" # Using a VQA model
 
-VIDEO_MAX_FRAMES_TO_PROCESS = 120 
+VIDEO_MAX_FRAMES_TO_PROCESS = 120
 VIDEO_CONFIDENCE_THRESHOLD_BIRD = 0.6
 VIDEO_VQA_MIN_ANSWER_LENGTH = 3 # Minimum length for a VQA answer to be considered a species
-VIDEO_VQA_CONFIDENCE_THRESHOLD = 0.3 
+VIDEO_VQA_CONFIDENCE_THRESHOLD = 0.3
 
 asr_pipeline_instance: Optional[Any] = None
-ASR_MODEL_NAME = "openai/whisper-tiny" 
-ASR_PROCESSING_TIMEOUT_SECONDS = 1024 
+ASR_MODEL_NAME = "openai/whisper-tiny"
+ASR_PROCESSING_TIMEOUT_SECONDS = 1024
 
 
 DEFAULT_RAG_CONFIG = {
@@ -136,7 +141,7 @@ DEFAULT_RAG_CONFIG = {
         'tavily_api_key': TAVILY_API_KEY,
         'default_max_results': 3, 'retry_attempts': 2, 'retry_delay': 2,
         'google_timeout': 8, 'tavily_depth': "basic",
-        'max_query_length_tavily': 380 
+        'max_query_length_tavily': 380
     },
     'processing': {
         'trusted_sources': {'wikipedia.org': 0.8, 'reuters.com': 0.75, 'apnews.com': 0.75},
@@ -165,7 +170,7 @@ def _get_video_object_detector():
             # Simplified device selection, consistent with FileProcessor's ASR
             device_id = 0 if torch.cuda.is_available() else -1
             if VIDEO_ANALYSIS_DEVICE == -1 : VIDEO_ANALYSIS_DEVICE = device_id # Set global if not user-overridden
-            
+
             target_device = VIDEO_ANALYSIS_DEVICE if VIDEO_ANALYSIS_DEVICE != -1 else device_id
 
             video_object_detector_pipeline = hf_transformers_pipeline(
@@ -185,7 +190,7 @@ def _get_video_vqa_pipeline(): # Renamed and changed to load VQA
         try:
             device_id = 0 if torch.cuda.is_available() else -1
             if VIDEO_ANALYSIS_DEVICE == -1: VIDEO_ANALYSIS_DEVICE = device_id
-            
+
             target_device = VIDEO_ANALYSIS_DEVICE if VIDEO_ANALYSIS_DEVICE != -1 else device_id
 
             video_vqa_pipeline = hf_transformers_pipeline(
@@ -205,7 +210,7 @@ class FileProcessor:
         global asr_pipeline_instance
         if asr_pipeline_instance is None and hf_transformers_pipeline and torch:
             try:
-                device = -1 
+                device = -1
                 asr_pipeline_instance = hf_transformers_pipeline(
                     "automatic-speech-recognition",
                     model=ASR_MODEL_NAME,
@@ -287,7 +292,7 @@ class FileProcessor:
                 f"Columns: {', '.join(df.columns)}\nFirst {min(CSV_SAMPLE_ROWS, len(df))} sample rows:\n{df.head(CSV_SAMPLE_ROWS).to_markdown(index=False)}"
             )
             return FileProcessor._truncate_text(summary, filename, "CSV")
-        except Exception as e: 
+        except Exception as e:
             if "tabulate" in str(e).lower() and df is not None:
                 gaia_logger.error(f"CSV to_markdown error for '{filename}' (missing tabulate): {e}", exc_info=False)
                 try:
@@ -330,7 +335,7 @@ class FileProcessor:
                     break
                 except UnicodeDecodeError: continue
             if text is None: text = content.decode('utf-8', errors='ignore')
-            
+
             summary = f"Text Document: '{filename}':\n{text}"
             return FileProcessor._truncate_text(summary, filename, "Text")
         except Exception as e:
@@ -341,13 +346,13 @@ class FileProcessor:
         gaia_logger.info(f"Processing Excel file: {filename}")
         if not openpyxl: return f"Error: Excel processing skipped for '{filename}', openpyxl library not available."
         xls = None
-        df_list_for_fallback = [] 
+        df_list_for_fallback = []
         try:
             xls = pd.ExcelFile(io.BytesIO(content), engine='openpyxl')
             summary_parts = [f"Excel Document Summary: '{filename}'"]
             for sheet_name in xls.sheet_names:
                 df = xls.parse(sheet_name)
-                df_list_for_fallback.append((sheet_name, df)) 
+                df_list_for_fallback.append((sheet_name, df))
                 sheet_summary = (
                     f"\n---\nSheet: '{sheet_name}' ({len(df)} rows, {len(df.columns)} columns):\n"
                     f"Columns: {', '.join(df.columns)}\nFirst {min(CSV_SAMPLE_ROWS, len(df))} sample rows:\n{df.head(CSV_SAMPLE_ROWS).to_markdown(index=False)}"
@@ -358,19 +363,20 @@ class FileProcessor:
                     break
             full_summary = "".join(summary_parts)
             return FileProcessor._truncate_text(full_summary, filename, "Excel")
-        except Exception as e: 
+        except Exception as e:
             if "tabulate" in str(e).lower():
                 gaia_logger.error(f"Excel to_markdown error for '{filename}' (missing tabulate): {e}", exc_info=False)
                 try:
                     summary_parts_fallback = [f"Excel Document Summary: '{filename}'"]
-                    if not df_list_for_fallback and xls: 
+                    if not df_list_for_fallback and xls:
                          for sheet_name in xls.sheet_names:
                             df_list_for_fallback.append((sheet_name, xls.parse(sheet_name)))
-                    elif not xls and not df_list_for_fallback:
+                    elif not xls and not df_list_for_fallback: # Ensure df_list_for_fallback is populated if xls parsing failed early
                         temp_xls = pd.ExcelFile(io.BytesIO(content), engine='openpyxl')
                         for sheet_name in temp_xls.sheet_names:
                             df_list_for_fallback.append((sheet_name, temp_xls.parse(sheet_name)))
 
+
                     for sheet_name_fb, df_fb in df_list_for_fallback:
                         sheet_summary_fallback = (
                             f"\n---\nSheet: '{sheet_name_fb}' ({len(df_fb)} rows, {len(df_fb.columns)} columns):\n"
@@ -400,7 +406,7 @@ class FileProcessor:
                         page_text = page.extract_text()
                         if page_text:
                             text_content += page_text + "\n"
-                        if len(text_content) > MAX_FILE_CONTEXT_LENGTH * 1.2:
+                        if len(text_content) > MAX_FILE_CONTEXT_LENGTH * 1.2: # Check slightly over to allow truncation logic to handle it
                             break
             if not text_content:
                 return f"PDF Document: '{filename}'. No text could be extracted or PDF is empty."
@@ -412,7 +418,7 @@ class FileProcessor:
     @staticmethod
     def _perform_asr_transcription(asr_pipeline_ref, audio_data_np, filename_for_log):
         gaia_logger.info(f"ASR: Starting transcription for {filename_for_log} in thread.")
-        
+
         return asr_pipeline_ref(audio_data_np, chunk_length_s=30, return_timestamps=False, generate_kwargs={"language": "en"})
 
 
@@ -424,11 +430,11 @@ class FileProcessor:
             return f"Error: Audio processing skipped for '{filename}', ASR pipeline not available."
         if not librosa:
             return f"Error: Audio processing skipped for '{filename}', librosa library not available."
-        
+
         try:
             with io.BytesIO(content) as audio_buffer:
                 y, sr = librosa.load(audio_buffer, sr=16000, mono=True)
-            
+
             duration_seconds = len(y) / sr
             gaia_logger.info(f"Audio file: {filename}, Duration: {duration_seconds:.2f} seconds. Timeout set to: {ASR_PROCESSING_TIMEOUT_SECONDS}s")
             start_time = time.time()
@@ -442,7 +448,7 @@ class FileProcessor:
                 except FuturesTimeoutError:
                     gaia_logger.warning(f"ASR transcription for '{filename}' timed out after {ASR_PROCESSING_TIMEOUT_SECONDS} seconds.")
                     return f"Error: Audio transcription for '{filename}' timed out after {ASR_PROCESSING_TIMEOUT_SECONDS}s."
-                except Exception as e_thread: 
+                except Exception as e_thread:
                     gaia_logger.error(f"ASR transcription thread for '{filename}' failed: {e_thread}", exc_info=True)
                     if "3000 mel input features" in str(e_thread) or "return_timestamps" in str(e_thread):
                          return f"Error processing Audio file '{filename}': Transcription failed due to long-form audio issue (mel features/timestamps). Original error: {str(e_thread)}"
@@ -453,7 +459,7 @@ class FileProcessor:
 
             if not transcribed_text.strip():
                 return f"Audio Document: '{filename}'. Transcription result was empty or ASR failed."
-            
+
             summary = f"Audio Document (Transcription): '{filename}':\n{transcribed_text}"
             return FileProcessor._truncate_text(summary, filename, "Audio Transcription")
 
@@ -472,7 +478,7 @@ class FileProcessor:
         except Exception:
             return f"File with Unknown Content Type: '{filename}'. Content is likely binary and cannot be displayed as text."
 
-class CacheManager: 
+class CacheManager:
     def __init__(self, ttl: int = 300, max_size: int = 100, name: str = "Cache"):
         self.ttl = ttl; self.max_size = max_size
         self._cache: Dict[Any, Any] = {}; self._timestamps: Dict[Any, float] = {}
@@ -483,31 +489,31 @@ class CacheManager:
             try:
                 self._access_order.remove(key); self._access_order.append(key)
                 return copy.deepcopy(self._cache[key])
-            except (ValueError, TypeError) as e:
+            except (ValueError, TypeError) as e: # pragma: no cover
                 self.delete(key); return None
-        elif key in self._cache:
+        elif key in self._cache: # Expired
             self.delete(key)
         return None
     def set(self, key: Any, value: Any):
-        if key in self._cache: self.delete(key)
+        if key in self._cache: self.delete(key) # Remove to update timestamp and order
         while len(self._cache) >= self.max_size and self._access_order:
             old_key = self._access_order.pop(0)
-            if old_key in self._cache:
+            if old_key in self._cache: # Should always be true
                 del self._cache[old_key]; del self._timestamps[old_key]
         try: self._cache[key] = copy.deepcopy(value)
-        except TypeError: self._cache[key] = value 
+        except TypeError: self._cache[key] = value # For non-deep-copyable items
         self._timestamps[key] = time.time(); self._access_order.append(key)
     def delete(self, key: Any):
         if key in self._cache:
             try:
                 del self._cache[key]; del self._timestamps[key]
                 if key in self._access_order: self._access_order.remove(key)
-            except (ValueError, KeyError): pass
+            except (ValueError, KeyError): pass # pragma: no cover
     def clear(self): self._cache.clear();self._timestamps.clear();self._access_order.clear();gaia_logger.info(f"[{self.name}] Cleared.")
     def __len__(self): return len(self._cache)
     def __contains__(self, key): return key in self._cache and (time.time()-self._timestamps.get(key,0)<self.ttl)
 
-class SearchProvider(ABC): 
+class SearchProvider(ABC):
     def __init__(self, config_dict: Dict):
         self.provider_config = config_dict.get('search', {})
         self._enabled = False
@@ -532,7 +538,7 @@ class SearchProvider(ABC):
         return self._perform_search(query, max_results)
     def available(self) -> bool: return self._enabled
 
-class GoogleProvider(SearchProvider): 
+class GoogleProvider(SearchProvider):
     @property
     def provider_name(self) -> str: return "Google"
     def __init__(self, config_dict: Dict):
@@ -554,7 +560,7 @@ class GoogleProvider(SearchProvider):
         except requests.exceptions.RequestException as e: gaia_logger.warning(f"[{self.provider_name}] RequestEx: '{query[:70]}': {e}"); return None
         except Exception as e: gaia_logger.error(f"[{self.provider_name}] Error: '{query[:70]}': {e}", exc_info=True); return None
 
-class TavilyProvider(SearchProvider): 
+class TavilyProvider(SearchProvider):
     @property
     def provider_name(self) -> str: return "Tavily"
     def __init__(self, config_dict: Dict):
@@ -579,7 +585,7 @@ class TavilyProvider(SearchProvider):
             return [{'href': h.get('url'), 'title': h.get('title',''), 'body': h.get('content','')} for h in hits]
         except Exception as e: gaia_logger.warning(f"[{self.provider_name}] Search fail: '{query[:70]}': {e}"); return None
 
-class DuckDuckGoProvider(SearchProvider): 
+class DuckDuckGoProvider(SearchProvider):
     @property
     def provider_name(self) -> str: return "DuckDuckGo"
     def __init__(self, config_dict: Dict):
@@ -596,9 +602,9 @@ class DuckDuckGoProvider(SearchProvider):
             return [{'href': r.get('href'), 'title': r.get('title',''), 'body': r.get('body','')} for r in hits]
         except Exception as e: gaia_logger.warning(f"[{self.provider_name}] Search fail: '{query[:70]}': {e}"); return None
 
-class CompositeSearchClient: 
+class CompositeSearchClient:
     def __init__(self, config_dict: Dict):
-        self.config = config_dict 
+        self.config = config_dict
         self._search_config = config_dict.get('search', {})
         self.providers = self._init_providers(config_dict)
         self.cache = CacheManager(
@@ -634,24 +640,24 @@ class CompositeSearchClient:
                     results = prov.search(q, actual_r)
                     if results is not None: self.cache.set(cache_key, results); return results
                     if attempt < self._retry_att: time.sleep(self._retry_del)
-                except Exception as e:
+                except Exception as e: # pragma: no cover
                     if attempt < self._retry_att: time.sleep(self._retry_del)
         self.cache.set(cache_key, [])
         return []
 
-class GaiaQueryBuilder: 
+class GaiaQueryBuilder:
     def __init__(self, base_query: str, config_dict: Dict):
         self.base_query = base_query.strip()
         self.config = config_dict
     def get_queries(self) -> Dict[str, List[Tuple[str, str]]]:
         return {'primary': [(self.base_query, 'GENERAL')]} if self.base_query else {'primary': []}
 
-class ResultProcessor: 
+class ResultProcessor:
     def __init__(self, config_dict: Dict):
         self.proc_config = config_dict.get('processing', {})
         self.trusted_sources = self.proc_config.get('trusted_sources', {})
         self.seen_urls: Set[str] = set()
-        self.date_pattern = DEFAULT_RAG_CONFIG['processing'].get('date_pattern', r'\b\d{4}\b') 
+        self.date_pattern = DEFAULT_RAG_CONFIG['processing'].get('date_pattern', r'\b\d{4}\b')
     def process_batch(self, results: List[Dict], query_tag: str, initial_cat: str='GENERAL') -> List[Dict]:
         processed: List[Dict] = []
         if not results: return processed
@@ -675,7 +681,7 @@ class ResultProcessor:
         result['temporal_relevance'] = temporal_r
         result['combined_score'] = (source_q * 0.6 + temporal_r * 0.4)
 
-class ContentEnricher: 
+class ContentEnricher:
     def __init__(self, config_dict: Dict):
         self.enrich_config = config_dict.get('enrichment', {})
         self._enabled = self.enrich_config.get('enabled', False) and bool(BeautifulSoup)
@@ -717,7 +723,7 @@ class ContentEnricher:
         except Exception as e: result['enrichment_failed'] = type(e).__name__
         return result
 
-class GeneralRAGPipeline: 
+class GeneralRAGPipeline:
     def __init__(self, config_dict: Optional[Dict] = None):
         self.config = config_dict if config_dict is not None else DEFAULT_RAG_CONFIG
         self.search_client = CompositeSearchClient(self.config)
@@ -735,13 +741,13 @@ class GeneralRAGPipeline:
         max_r_pq = cfg_search.get('default_max_results', 3)
         cache_key = (q, max_r_pq, total_lim, enrich_en, enrich_cnt)
         if not force_refresh and (cached := self.pipeline_cache.get(cache_key)) is not None: return cached
-        if force_refresh: self.search_client.cache.clear();
-        if self.enricher: self.enricher.cache.clear()
+        if force_refresh: self.search_client.cache.clear(); # Clears underlying search client cache
+        if self.enricher and force_refresh: self.enricher.cache.clear() # Clear enricher cache if force_refresh
         all_res, res_proc = [], ResultProcessor(self.config)
         staged_qs = GaiaQueryBuilder(q, self.config).get_queries()
         for stage, qs_in_stage in staged_qs.items():
             for query_s, cat in qs_in_stage:
-                if len(all_res) >= total_lim * 2: break
+                if len(all_res) >= total_lim * 2: break # Fetch more initially to allow for better selection
                 s_res = self.search_client.search(query_s, max_results=max_r_pq, force_refresh=force_refresh)
                 all_res.extend(res_proc.process_batch(s_res or [], query_s, initial_cat=cat))
         all_res.sort(key=lambda x: x.get('combined_score', 0), reverse=True)
@@ -758,36 +764,46 @@ class GaiaLevel1Agent:
         self.api_url = api_url
         self.llm_model: Optional[Any] = None
         self.rag_pipeline = GeneralRAGPipeline(DEFAULT_RAG_CONFIG)
-        
+
         if genai and GOOGLE_GEMINI_API_KEY:
             try:
                 genai.configure(api_key=GOOGLE_GEMINI_API_KEY)
                 model_name = 'gemini-2.5-flash-preview-05-20' 
+                
+
                 self.llm_model = genai.GenerativeModel(model_name)
                 gaia_logger.info(f"Gemini LLM ('{model_name}') initialized.")
             except Exception as e:
                 gaia_logger.error(f"Error initializing Gemini LLM: {e}", exc_info=True)
+                # Attempt fallback if specific model fails (e.g. not available in region, or name typo)
+                try:
+                    gaia_logger.info("Attempting fallback to 'gemini-1.0-pro' for LLM.")
+                    self.llm_model = genai.GenerativeModel('gemini-1.0-pro') # A common, generally available model
+                    gaia_logger.info("Gemini LLM ('gemini-1.0-pro') initialized as fallback.")
+                except Exception as e_fallback:
+                    gaia_logger.error(f"Fallback LLM initialization also failed: {e_fallback}", exc_info=True)
+
         else:
             gaia_logger.warning("Gemini LLM dependencies or API key missing.")
-        
+
         if not self.llm_model:
             gaia_logger.warning("LLM (Gemini) unavailable. Limited capabilities.")
-        
+
         _get_video_object_detector()
-        _get_video_vqa_pipeline() 
+        _get_video_vqa_pipeline()
 
         gaia_logger.info(f"GaiaLevel1Agent (RAG, FileProcessor, VideoAnalysis) initialized. API: {self.api_url}")
 
     @lru_cache(maxsize=32)
     def _fetch_and_process_file_content(self, task_id: str) -> Optional[str]:
-        
+
         file_url = f"{self.api_url}/files/{task_id}"
-        for attempt in range(2):
+        for attempt in range(2): # Retry once
             try:
                 response = requests.get(file_url, timeout=AGENT_DEFAULT_TIMEOUT)
                 response.raise_for_status()
-                
-                filename = FileProcessor._get_filename_from_url(response.url)
+
+                filename = FileProcessor._get_filename_from_url(response.url) # Fallback from URL
                 content_disposition = response.headers.get('Content-Disposition')
                 if content_disposition:
                     header_filename = FileProcessor._get_filename_from_url(content_disposition)
@@ -800,7 +816,7 @@ class GaiaLevel1Agent:
             except requests.exceptions.HTTPError as e:
                 if e.response.status_code == 404:
                     gaia_logger.warning(f"File not found for task {task_id}: {file_url}")
-                    return None
+                    return None # No point retrying 404
                 gaia_logger.warning(f"HTTP error fetching file {task_id}: {e}")
             except requests.exceptions.Timeout:
                 gaia_logger.warning(f"Timeout fetching file {task_id}")
@@ -813,37 +829,37 @@ class GaiaLevel1Agent:
     def _clean_vqa_species_answer(self, answer_text: str) -> str:
         """Cleans and normalizes VQA answer to extract a potential species name."""
         if not answer_text: return ""
-        
+
         cleaned = answer_text.lower().strip()
-        
+
         # Remove common prefixes
         prefixes_to_remove = [
-            "a type of ", "a variety of ", "it's a ", "it is a ", "an ", "a ", "the ", 
+            "a type of ", "a variety of ", "it's a ", "it is a ", "an ", "a ", "the ",
             "this is a ", "this bird is a ", "it appears to be a ", "looks like a ",
             "it's an ", "it is an ", "this is an ", "this bird is an ", "it appears to be an ", "looks like an "
         ]
         for prefix in prefixes_to_remove:
             if cleaned.startswith(prefix):
                 cleaned = cleaned[len(prefix):]
-        
+
         # Remove common suffixes
         suffixes_to_remove = [" bird", " species"]
         for suffix in suffixes_to_remove:
             if cleaned.endswith(suffix):
                 cleaned = cleaned[:-len(suffix)]
-        
+
         # Remove parenthetical content or descriptive clauses if simple
         cleaned = re.sub(r"\s*\(.*\)\s*$", "", cleaned).strip() # e.g. "robin (american)" -> "robin"
         cleaned = re.sub(r",\s*which is.*$", "", cleaned).strip() # e.g. "sparrow, which is small" -> "sparrow"
 
         # Basic character filtering (allow letters, numbers for things like "Type 2", spaces, hyphens)
         cleaned = re.sub(r"[^a-z0-9\s\-]", "", cleaned).strip()
-        
+
         # Normalize whitespace
         cleaned = " ".join(cleaned.split())
-        
+
         # Filter out very generic or uncertain answers post-cleaning
-        uncertain_terms = ["unknown", "not sure", "unclear", "difficult to say", "generic", "common bird"]
+        uncertain_terms = ["unknown", "not sure", "unclear", "difficult to say", "generic", "common bird", "no bird", "not a bird"]
         if any(term in cleaned for term in uncertain_terms) or len(cleaned) < VIDEO_VQA_MIN_ANSWER_LENGTH:
             return "" # Return empty if too generic or short
 
@@ -858,45 +874,48 @@ class GaiaLevel1Agent:
              return "Video analysis skipped: Pillow library not available."
 
         detector = _get_video_object_detector()
-        vqa_model = _get_video_vqa_pipeline() # Get VQA model
+        vqa_model = _get_video_vqa_pipeline()
 
         if not detector or not vqa_model:
             return "Video analysis skipped: ML pipelines (detector or VQA) not available."
 
-        video_file_path = None
-        temp_dir = "temp_video_files_gaia_" + str(time.time()).replace(".","") # More unique temp dir
-        os.makedirs(temp_dir, exist_ok=True)
+        video_file_path: Optional[str] = None
+        temp_dir_obj: Optional[tempfile.TemporaryDirectory] = None
+        cap: Optional[cv2.VideoCapture] = None
+
 
         try:
+            temp_dir_obj = tempfile.TemporaryDirectory(prefix="gaia_video_")
+            temp_dir = temp_dir_obj.name
+            gaia_logger.info(f"Created temporary directory for video: {temp_dir}")
+
             ydl_opts = {
-                'format': 'best[ext=mp4][height<=480]/best[ext=webm][height<=480]/bestvideo[height<=480]+bestaudio/best',
+                'format': 'bestvideo[height<=480][ext=mp4]+bestaudio[ext=m4a]/bestvideo[height<=480][ext=webm]+bestaudio[ext=webm]/best[height<=480][ext=mp4]/best[height<=480][ext=webm]/best[height<=480]',
                 'outtmpl': os.path.join(temp_dir, '%(id)s.%(ext)s'),
-                'quiet': True, # Quieter download
-                'max_filesize': 75 * 1024 * 1024, 
+                'quiet': True,
+                'max_filesize': 75 * 1024 * 1024,
                 'overwrites': True, 'noprogress': True, 'noplaylist': True, 'socket_timeout': 20,
-                'postprocessors': [{'key': 'FFmpegExtractAudio', 'preferredcodec': 'mp3', 'preferredquality': '192',}] # helps ensure one file sometimes
+                'merge_output_format': 'mp4', # Encourage mp4 output if merging
+                # Removed 'postprocessors': [{'key': 'FFmpegExtractAudio', ...}]
             }
             gaia_logger.info(f"Attempting to download video: {video_url}")
             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                info_dict = ydl.extract_info(video_url, download=True) 
-                video_file_path = ydl.prepare_filename(info_dict)
-                # yt-dlp might download separate video/audio and then merge.
-                # Ensure we have the video file, not just an audio file if download failed partway.
-                if not video_file_path.endswith(('.mp4', '.webm', '.mkv', '.flv', '.avi', '.mov')): # common video extensions
-                     possible_video_files = [f for f in os.listdir(temp_dir) if f.startswith(info_dict.get('id','')) and f.endswith(('.mp4', '.webm'))]
-                     if possible_video_files: video_file_path = os.path.join(temp_dir, possible_video_files[0])
-                     else:
-                        gaia_logger.error(f"Downloaded file '{video_file_path}' does not appear to be a video format.")
-                        # Attempt to find any video file in the temp_dir for this ID
-                        all_files = [os.path.join(temp_dir, f) for f in os.listdir(temp_dir) if info_dict.get('id','') in f]
-                        gaia_logger.debug(f"Files in temp_dir for video ID {info_dict.get('id','')}: {all_files}")
-                        # Clean up and report failure
-                        for f_cleanup in all_files:
-                            try: os.remove(f_cleanup)
-                            except Exception: pass
-                        try: os.rmdir(temp_dir)
-                        except Exception: pass
-                        return f"Video download resulted in a non-video file: {os.path.basename(video_file_path)}"
+                info_dict = ydl.extract_info(video_url, download=True)
+                video_file_path = ydl.prepare_filename(info_dict) # Get the final path
+
+                # Check if downloaded file is indeed a video format recognised by OpenCV
+                # Common video extensions that OpenCV usually handles well.
+                # This check is made more robust by also trying to open it.
+                if not video_file_path or not any(video_file_path.lower().endswith(ext) for ext in ['.mp4', '.webm', '.avi', '.mkv', '.mov', '.flv']):
+                    gaia_logger.warning(f"Downloaded file '{video_file_path}' might not be a standard video format or download failed to produce one. Will attempt to open.")
+                    # Try to find a plausible video file if the main one looks suspicious
+                    possible_video_files = [f for f in os.listdir(temp_dir) if f.startswith(info_dict.get('id','')) and any(f.lower().endswith(ext) for ext in ['.mp4', '.webm'])]
+                    if possible_video_files:
+                        video_file_path = os.path.join(temp_dir, possible_video_files[0])
+                        gaia_logger.info(f"Using alternative video file from temp_dir: {video_file_path}")
+                    # else: # The cap.isOpened() check below will handle if it's truly unusable
+                        # gaia_logger.error(f"No suitable video file found in temp_dir for {info_dict.get('id','')}")
+                        # return "Video download resulted in a non-video or unusable file."
 
 
             if not video_file_path or not os.path.exists(video_file_path):
@@ -908,43 +927,46 @@ class GaiaLevel1Agent:
             cap = cv2.VideoCapture(video_file_path)
             if not cap.isOpened():
                 gaia_logger.error(f"Cannot open video file: {video_file_path}")
-                return "Cannot open video file."
+                return f"Cannot open video file: {os.path.basename(video_file_path if video_file_path else 'N/A')}"
+
 
             max_simultaneous_species = 0
             species_details_for_max_frame = ""
-            
+
             total_frames_video = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
             fps = cap.get(cv2.CAP_PROP_FPS)
-            if not fps or fps == 0: fps = 25 # Default fps
-            
+            if not fps or fps <= 0: fps = 25 # Default fps if detection fails or is zero
+
             frame_interval = max(1, int(fps)) # Process ~1 frame per second
-            
+
             frames_analyzed_count = 0
             current_frame_num = 0
-            
-            gaia_logger.info(f"Video Info: ~{total_frames_video // fps:.0f}s, {fps:.2f} FPS. Analyzing ~1 frame/sec up to {VIDEO_MAX_FRAMES_TO_PROCESS} frames.")
+
+            gaia_logger.info(f"Video Info: ~{total_frames_video // fps if fps > 0 else total_frames_video:.0f}s, {fps:.2f} FPS. Analyzing ~1 frame/sec up to {VIDEO_MAX_FRAMES_TO_PROCESS} frames.")
 
             while cap.isOpened() and frames_analyzed_count < VIDEO_MAX_FRAMES_TO_PROCESS:
                 cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame_num) # Jump to frame
                 ret, frame_data = cap.read()
                 if not ret: break
 
-                timestamp_sec = current_frame_num / fps
+                timestamp_sec = current_frame_num / fps if fps > 0 else frames_analyzed_count # Fallback timestamp if fps is bad
                 gaia_logger.info(f"Processing frame {current_frame_num} (analyzed {frames_analyzed_count+1}/{VIDEO_MAX_FRAMES_TO_PROCESS}) at ~{timestamp_sec:.1f}s")
-                
+
                 try:
                     pil_image = Image.fromarray(cv2.cvtColor(frame_data, cv2.COLOR_BGR2RGB))
                 except Exception as e_conv:
                     gaia_logger.warning(f"Frame {current_frame_num} conversion to PIL failed: {e_conv}")
                     current_frame_num += frame_interval
                     continue
-                
+
                 detected_objects = detector(pil_image)
                 bird_crops_this_frame = []
                 for obj in detected_objects:
-                    if obj['label'].lower() == 'bird' and obj['score'] > VIDEO_CONFIDENCE_THRESHOLD_BIRD: # Check lowercase label too
+                    # Check label case-insensitively
+                    if obj['label'].lower() == 'bird' and obj['score'] > VIDEO_CONFIDENCE_THRESHOLD_BIRD:
                         box = obj['box']
                         xmin, ymin, xmax, ymax = box['xmin'], box['ymin'], box['xmax'], box['ymax']
+                        # Ensure box coordinates are valid
                         if not (0 <= xmin < xmax <= pil_image.width and 0 <= ymin < ymax <= pil_image.height):
                             gaia_logger.debug(f"Invalid box for bird: {box}, img size: {pil_image.size}")
                             continue
@@ -953,6 +975,7 @@ class GaiaLevel1Agent:
                         except Exception as e_crop:
                              gaia_logger.warning(f"Cropping bird failed for box {box}: {e_crop}")
 
+
                 if not bird_crops_this_frame:
                     current_frame_num += frame_interval
                     frames_analyzed_count += 1
@@ -963,45 +986,45 @@ class GaiaLevel1Agent:
                 vqa_question = "What is the specific species of this bird?"
 
                 for idx, bird_crop_img in enumerate(bird_crops_this_frame):
-                    if bird_crop_img.width < 20 or bird_crop_img.height < 20: continue 
+                    if bird_crop_img.width < 20 or bird_crop_img.height < 20: continue
                     try:
-                        vqa_answer_list = vqa_model(bird_crop_img, question=vqa_question, top_k=1) # Some models return list
-                        
+                        vqa_answer_list = vqa_model(bird_crop_img, question=vqa_question, top_k=1)
+
                         raw_vqa_answer_text = ""
-                        vqa_confidence = VIDEO_VQA_CONFIDENCE_THRESHOLD # Default if not provided
+                        vqa_confidence = VIDEO_VQA_CONFIDENCE_THRESHOLD # Default
 
                         if isinstance(vqa_answer_list, list) and vqa_answer_list:
                             raw_vqa_answer_text = vqa_answer_list[0].get('answer', "")
                             vqa_confidence = vqa_answer_list[0].get('score', vqa_confidence)
-                        elif isinstance(vqa_answer_list, dict): # Some pipelines might return dict directly
+                        elif isinstance(vqa_answer_list, dict):
                             raw_vqa_answer_text = vqa_answer_list.get('answer', "")
                             vqa_confidence = vqa_answer_list.get('score', vqa_confidence)
 
                         cleaned_species_name = self._clean_vqa_species_answer(raw_vqa_answer_text)
-                        
+
                         if cleaned_species_name and vqa_confidence >= VIDEO_VQA_CONFIDENCE_THRESHOLD :
                             frame_species_identified.add(cleaned_species_name)
                             current_frame_species_details.append(f"{cleaned_species_name} (VQA conf: {vqa_confidence:.2f})")
-                        elif cleaned_species_name: # Log if below confidence
+                        elif cleaned_species_name:
                              gaia_logger.debug(f"VQA species '{cleaned_species_name}' (raw: '{raw_vqa_answer_text}') for bird {idx} below confidence {VIDEO_VQA_CONFIDENCE_THRESHOLD} (score: {vqa_confidence:.2f})")
                         else:
                              gaia_logger.debug(f"VQA for bird {idx} resulted in unusable/generic species: '{raw_vqa_answer_text}'")
 
                     except Exception as e_vqa:
                         gaia_logger.warning(f"VQA inference error for bird crop {idx} (frame {current_frame_num}): {e_vqa}")
-                
+
                 if len(frame_species_identified) > max_simultaneous_species:
                     max_simultaneous_species = len(frame_species_identified)
                     species_details_for_max_frame = f"At ~{timestamp_sec:.1f}s, inferred species: {', '.join(current_frame_species_details) if current_frame_species_details else 'None specific'}"
-                
+
                 if frame_species_identified:
                     gaia_logger.info(f"Frame {current_frame_num} (~{timestamp_sec:.1f}s): Found {len(frame_species_identified)} distinct species types: {', '.join(list(frame_species_identified))}")
 
                 current_frame_num += frame_interval
                 frames_analyzed_count += 1
-            
-            cap.release()
-            
+
+            # cap.release() should be in finally
+
             context_str = (f"Video analysis result: The highest number of distinct bird species types inferred simultaneously "
                            f"in the analyzed portion of the video (up to {VIDEO_MAX_FRAMES_TO_PROCESS} frames) was {max_simultaneous_species}. "
                            f"{('Details from a frame with this count: ' + species_details_for_max_frame) if species_details_for_max_frame else 'No specific species details captured for the max count frame or no birds found.'}")
@@ -1010,72 +1033,70 @@ class GaiaLevel1Agent:
 
         except yt_dlp.utils.DownloadError as e:
             gaia_logger.error(f"yt-dlp download error for {video_url}: {str(e)}")
-            # Attempt to get a cleaner error message
-            msg_lines = str(e).splitlines()
-            clean_msg = msg_lines[-1] if msg_lines else str(e)
-            if "Unsupported URL" in str(e): clean_msg = "Unsupported video URL"
-            elif "video unavailable" in str(e).lower(): clean_msg = "Video is unavailable"
-            return f"Video download failed: {clean_msg}"
+            msg_str = str(e)
+            clean_msg = msg_str # Default to full message
+            if "Unsupported URL" in msg_str: clean_msg = "Unsupported video URL."
+            elif "video unavailable" in msg_str.lower(): clean_msg = "Video is unavailable."
+            elif "private video" in msg_str.lower(): clean_msg = "Video is private."
+            elif "age restricted" in msg_str.lower(): clean_msg = "Video is age-restricted and requires login."
+            elif "Sign in to confirm" in msg_str or "cookies" in msg_str.lower() or "authentication" in msg_str.lower():
+                 clean_msg = "Video download failed due to YouTube restrictions (e.g., sign-in, cookies, or authentication required)."
+            elif "HTTP Error 403" in msg_str or "Forbidden" in msg_str : clean_msg = "Access to video denied (Forbidden/403)."
+            elif "HTTP Error 404" in msg_str or "Not Found" in msg_str : clean_msg = "Video not found (404)."
+            # Keep the message relatively concise for the LLM
+            return f"Video download failed: {clean_msg[:250] + '...' if len(clean_msg) > 250 else clean_msg}" # Limit length of detailed message
+
         except Exception as e:
             gaia_logger.error(f"Error during video analysis for {video_url}: {e}", exc_info=True)
-            return f"An unexpected error occurred during video analysis: {type(e).__name__} - {str(e)}"
+            return f"An unexpected error occurred during video analysis: {type(e).__name__} - {str(e)[:100]}"
         finally:
-            if video_file_path and os.path.exists(video_file_path):
-                try: os.remove(video_file_path)
-                except Exception as e_remove: gaia_logger.warning(f"Could not remove temp video file {video_file_path}: {e_remove}")
-            
-            # Attempt to remove the temporary directory if it's empty
-            # This needs to be robust in case other files were created by yt-dlp or ffmpeg
-            try:
-                if os.path.exists(temp_dir):
-                    # List all files in temp_dir to attempt removal if needed.
-                    # For now, just try rmdir if it's truly empty, or log if not.
-                    if not os.listdir(temp_dir):
-                        os.rmdir(temp_dir)
-                        gaia_logger.info(f"Removed empty temp video directory: {temp_dir}")
-                    else:
-                        # If not empty, it might contain other yt-dlp artifacts (like .part files, audio)
-                        # For robustness in a contest, maybe leave it and rely on system temp cleaning,
-                        # or implement more aggressive cleanup of all files within this specific temp_dir.
-                        # For now, just log.
-                        gaia_logger.warning(f"Temp video directory {temp_dir} not empty after processing. Manual cleanup might be needed for: {os.listdir(temp_dir)}")
-            except OSError as e_rmdir: # Catch OSError for rmdir failures (e.g. dir not empty)
-                 gaia_logger.warning(f"Could not remove temp video directory {temp_dir} (possibly not empty or access issue): {e_rmdir}")
-            except Exception as e_final_clean:
-                 gaia_logger.error(f"Unexpected error during final cleanup of {temp_dir}: {e_final_clean}")
+            if cap and cap.isOpened():
+                cap.release()
+                gaia_logger.info("Video capture released.")
+            if temp_dir_obj:
+                temp_dir_path_for_log = temp_dir_obj.name # Store before cleanup for logging
+                try:
+                    temp_dir_obj.cleanup()
+                    gaia_logger.info(f"Successfully cleaned up temp video directory: {temp_dir_path_for_log}")
+                except Exception as e_cleanup:
+                    gaia_logger.error(f"Error cleaning up temp video directory {temp_dir_path_for_log}: {e_cleanup}", exc_info=True)
 
 
     def _parse_llm_output(self, llm_text: str) -> Dict[str, str]:
-        # ... (this method remains unchanged) ...
         reasoning_trace = ""
         model_answer = ""
         final_answer_sentinel = "FINAL ANSWER:"
-        
+
         parts = llm_text.split(final_answer_sentinel, 1)
-        
+
         if len(parts) == 2:
             reasoning_trace = parts[0].strip()
             model_answer = parts[1].strip()
         else:
-            reasoning_trace = llm_text 
+            reasoning_trace = llm_text # If sentinel not found, assume whole output is reasoning
             lines = llm_text.strip().split('\n')
-            model_answer = lines[-1].strip() if lines else "Could not parse answer" 
+            # Try to take the last non-empty line as answer, or a default if all reasoning
+            model_answer = "Could not parse answer" # Default if no clear answer found
+            for line in reversed(lines):
+                if line.strip():
+                    model_answer = line.strip()
+                    break
             gaia_logger.warning(f"LLM output did not contain '{final_answer_sentinel}'. Using fallback parsing. Full LLM text: '{llm_text[:200]}...'")
 
         return {"model_answer": model_answer, "reasoning_trace": reasoning_trace}
 
     def _formulate_answer_with_llm(self, question: str, file_context: Optional[str], web_context: Optional[str]) -> Dict[str, str]:
-        # ... (this method's prompt might need slight adjustment if video context phrasing changes, but core logic is fine) ...
         default_model_answer = "Information not available in provided context"
         default_reasoning = "LLM processing failed or context insufficient."
 
-        if not self.llm_model:
-            gaia_logger.warning("LLM model (Gemini) not available for answer formulation.")
-            reasoning = "LLM model (Gemini) not available for answer formulation."
+        if not self.llm_model or not genai or not GenerationConfig or not FinishReason or not HarmCategory or not HarmBlockThreshold: # Added more checks
+            gaia_logger.warning("LLM model (Gemini) or necessary enums/configs not available for answer formulation.")
+            reasoning = "LLM model (Gemini) or its configuration components not available for answer formulation."
             answer_val = default_model_answer
+            # Provide some context indication even if LLM is down
             if web_context and file_context:
                 reasoning += " Context from file and web was found but not processed by LLM."
-            elif web_context: # web_context may now include video_context
+            elif web_context:
                 reasoning += f" External context found: {web_context.splitlines()[0] if web_context.splitlines() else 'No specific snippet found.'}"
             elif file_context:
                 reasoning += f" File context found: {file_context[:100]}..."
@@ -1083,8 +1104,9 @@ class GaiaLevel1Agent:
                  reasoning += " No context found."
             return {"model_answer": answer_val, "reasoning_trace": reasoning}
 
+
         prompt_parts = [
-            "You are a general AI assistant. Your primary goal is to answer the user's question accurately and concisely based *only* on the provided context (from a document, web search results, or video analysis).", 
+            "You are a general AI assistant. Your primary goal is to answer the user's question accurately and concisely based *only* on the provided context (from a document, web search results, or video analysis).",
             "If the context comes from 'Video analysis result', understand that 'species types inferred' means the video was analyzed by an AI to identify birds and infer their species using visual question answering. The count refers to the maximum number of *distinct types* of birds identified in this way in any single analyzed video frame.",
             "First, think step-by-step and briefly explain your reasoning based on the context. This part is for clarity and should come before your final answer.",
             "After your reasoning, you MUST conclude your response with the exact phrase 'FINAL ANSWER:', followed by your answer on the same line or the next.",
@@ -1093,7 +1115,7 @@ class GaiaLevel1Agent:
             "  - If the answer is a string: use as few words as possible. Do not use articles (a, an, the) unless grammatically essential. Do not use abbreviations (e.g., write 'United States' not 'USA', 'Los Angeles' not 'LA') unless the question implies an abbreviation or it's a very common, universally understood one relevant to the context. Write digits in plain text (e.g., 'two' not '2') if they are part of a descriptive phrase, but use numerical digits if the question implies a code, identifier, version number, or a direct numerical value is more natural (e.g., 'Windows 10', 'part number 5').",
             "  - If the answer is a list of items: provide them as a comma-separated list (e.g., item1, item2, item3). Apply the number or string rules above to each element in the list.",
             "  - If the context is insufficient to answer the question: your reasoning should clearly state this, and your FINAL ANSWER should be 'Information not available in provided context'. Do not invent answers.",
-            "Prioritize information from 'Enriched Content' from web search results if available and relevant over shorter 'Snippets'. Information from 'Video Analysis Context' is highly specific to video-related questions.", 
+            "Prioritize information from 'Enriched Content' from web search results if available and relevant over shorter 'Snippets'. Information from 'Video Analysis Context' is highly specific to video-related questions.",
             "\nUser Question: ", question
         ]
 
@@ -1102,81 +1124,113 @@ class GaiaLevel1Agent:
         if file_context:
             file_header = "\n\nContext from Provided Document:\n---"
             file_footer = "\n---"
-            # Calculate available length more carefully
             len_web_ctx = len(web_context) if web_context else 0
-            max_len_for_file = MAX_CONTEXT_LENGTH_LLM - current_prompt_text_len - len_web_ctx - len(file_header) - len(file_footer) - 500 # Buffer for LLM answer template
-            
-            if max_len_for_file > 100 : 
+            max_len_for_file = MAX_CONTEXT_LENGTH_LLM - current_prompt_text_len - len_web_ctx - len(file_header) - len(file_footer) - 500 # Buffer
+
+            if max_len_for_file > 100 :
                 truncated_file_context = file_context[:max_len_for_file]
                 if len(file_context) > len(truncated_file_context):
                     truncated_file_context += " ... (file context truncated)"
                 prompt_parts.extend([file_header, truncated_file_context, file_footer])
                 current_prompt_text_len += len(file_header) + len(truncated_file_context) + len(file_footer)
                 context_added = True
-            else: gaia_logger.warning(f"Not enough space for file context in LLM prompt. Needed {max_len_for_file}, available after other parts: {MAX_CONTEXT_LENGTH_LLM - current_prompt_text_len - len_web_ctx - len(file_header) - len(file_footer)}")
+            else: gaia_logger.warning(f"Not enough space for file context in LLM prompt. Available after other parts: {MAX_CONTEXT_LENGTH_LLM - current_prompt_text_len - len_web_ctx - len(file_header) - len(file_footer)}")
 
 
-        if web_context: # This can include video analysis context
-            # Determine header based on content
+        if web_context:
             header_text = "\n\nContext from External Sources (Web/Video):\n---"
-            if "Video analysis result:" in web_context and "Source [" not in web_context:
+            if "Video analysis result:" in web_context and "Source [" not in web_context: # Only video
                 header_text = "\n\nContext from Video Analysis:\n---"
-            elif "Source [" in web_context and "Video analysis result:" not in web_context:
+            elif "Source [" in web_context and "Video analysis result:" not in web_context: # Only web
                 header_text = "\n\nContext from Web Search Results:\n---"
-            
+            # If both, the generic "External Sources" is fine.
+
             web_footer = "\n---"
-            # current_prompt_text_len already includes the base prompt_parts
-            # We need to calculate available length for web_context based on what's already added.
-            available_len_for_web = MAX_CONTEXT_LENGTH_LLM - current_prompt_text_len - len(header_text) - len(web_footer) - 300 # Buffer for LLM answer itself
+            available_len_for_web = MAX_CONTEXT_LENGTH_LLM - current_prompt_text_len - len(header_text) - len(web_footer) - 300
 
-            if available_len_for_web > 100: 
+            if available_len_for_web > 100:
                 truncated_web_context = web_context
                 if len(web_context) > available_len_for_web:
                     truncated_web_context = web_context[:available_len_for_web] + "\n... (external context truncated)"
                     gaia_logger.info(f"Truncated external (web/video) context from {len(web_context)} to {len(truncated_web_context)} chars for LLM.")
                 prompt_parts.extend([header_text, truncated_web_context, web_footer])
-                context_added = True # context_added flag might be set by file_context too
-            else: gaia_logger.warning(f"Not enough space for web/video context in LLM prompt. Needed {available_len_for_web}, available after other parts and file_ctx: {MAX_CONTEXT_LENGTH_LLM - current_prompt_text_len - len(header_text) - len(web_footer)}")
+                context_added = True
+            else: gaia_logger.warning(f"Not enough space for web/video context in LLM prompt. Available: {MAX_CONTEXT_LENGTH_LLM - current_prompt_text_len - len(header_text) - len(web_footer)}")
 
         if not context_added: prompt_parts.append("\n\nNo document, web, or video context could be provided due to length constraints or availability.")
-        prompt_parts.append("\n\nReasoning and Final Answer:") 
+        prompt_parts.append("\n\nReasoning and Final Answer:")
         final_prompt = "\n".join(prompt_parts)
-        
+
         gaia_logger.info(f"LLM Prompt (first 300 chars): {final_prompt[:300]}...")
         gaia_logger.info(f"LLM Total prompt length: {len(final_prompt)} chars.")
 
-        if not GenerationConfig: # Should be caught by class init
-            return {"model_answer": "LLM configuration error", "reasoning_trace": "GenerationConfig class not available."}
 
         try:
-            gen_config = GenerationConfig(temperature=0.1, top_p=0.95, max_output_tokens=1024) # Reduced max output tokens slightly
-            safety_set = [{"category": c, "threshold": "BLOCK_MEDIUM_AND_ABOVE"} for c in ["HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_SEXUALLY_EXPLICIT", "HARM_CATEGORY_DANGEROUS_CONTENT"]]
-            response = self.llm_model.generate_content(final_prompt, generation_config=gen_config, safety_settings=safety_set)
-            
-            if not response.candidates or (hasattr(response, 'prompt_feedback') and response.prompt_feedback.block_reason):
-                reason_text = "Unknown"
-                if hasattr(response, 'prompt_feedback') and response.prompt_feedback.block_reason: reason_text = response.prompt_feedback.block_reason.name
-                gaia_logger.warning(f"Gemini response blocked. Reason: {reason_text}.")
-                # Provide more specific message if possible
-                block_details = ""
-                if hasattr(response, 'prompt_feedback') and response.prompt_feedback.safety_ratings:
-                    block_details = "; ".join([f"{sr.category.name}: {sr.probability.name}" for sr in response.prompt_feedback.safety_ratings if sr.blocked])
-                return {"model_answer": "LLM Error: Response blocked", "reasoning_trace": f"My response was blocked by the LLM provider (Reason: {reason_text}). Details: {block_details}"}
-
-
-            llm_answer_text = response.text
+            gen_config = GenerationConfig(temperature=0.1, top_p=0.95, max_output_tokens=1024)
+            safety_settings = [
+                {"category": HarmCategory.HARM_CATEGORY_HARASSMENT, "threshold": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE},
+                {"category": HarmCategory.HARM_CATEGORY_HATE_SPEECH, "threshold": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE},
+                {"category": HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, "threshold": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE},
+                {"category": HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, "threshold": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE},
+            ]
+            response = self.llm_model.generate_content(final_prompt, generation_config=gen_config, safety_settings=safety_settings)
+
+            if hasattr(response, 'prompt_feedback') and response.prompt_feedback.block_reason:
+                reason_text = response.prompt_feedback.block_reason.name
+                block_details = "; ".join([f"{sr.category.name}: {sr.probability.name}" for sr in response.prompt_feedback.safety_ratings if hasattr(sr, 'blocked') and sr.blocked])
+                gaia_logger.warning(f"Gemini prompt blocked. Reason: {reason_text}. Details: {block_details}")
+                return {"model_answer": "LLM Error: Prompt blocked", "reasoning_trace": f"My input was blocked by the LLM provider (Reason: {reason_text}). Details: {block_details}"}
+
+            if not response.candidates:
+                gaia_logger.warning("Gemini response has no candidates.")
+                return {"model_answer": "LLM Error: No response", "reasoning_trace": "LLM did not provide any response candidates."}
+
+            candidate = response.candidates[0]
+            # Check candidate's finish_reason
+            if candidate.finish_reason != FinishReason.STOP:
+                reason_name = candidate.finish_reason.name if hasattr(candidate.finish_reason, 'name') else str(candidate.finish_reason)
+                safety_ratings_str = ""
+                if candidate.safety_ratings: # Check if safety_ratings exist
+                    relevant_ratings = [
+                        f"{sr.category.name.split('_')[-1] if hasattr(sr.category, 'name') else 'CAT?'}: {(sr.probability.name if hasattr(sr.probability, 'name') else 'PROB?')}"
+                        for sr in candidate.safety_ratings if (hasattr(sr,'blocked') and sr.blocked) or (hasattr(sr,'probability') and HarmProbability and sr.probability.value >= HarmProbability.MEDIUM.value)
+                    ]
+                    if relevant_ratings: safety_ratings_str = "; ".join(relevant_ratings)
+
+                gaia_logger.warning(f"Gemini candidate did not finish successfully. Reason: {reason_name}. Safety Ratings: {safety_ratings_str if safety_ratings_str else 'N/A'}")
+                
+                user_message = "LLM Error: Response incomplete"
+                if candidate.finish_reason == FinishReason.SAFETY: user_message = "LLM Error: Response blocked for safety"
+                elif candidate.finish_reason == FinishReason.MAX_TOKENS: user_message = "LLM Error: Response truncated (max tokens)"
+                elif candidate.finish_reason == FinishReason.RECITATION: user_message = "LLM Error: Response blocked (recitation)"
+
+                return {
+                    "model_answer": user_message,
+                    "reasoning_trace": f"LLM generation stopped. Reason: {reason_name}. " + (f"Details: {safety_ratings_str}" if safety_ratings_str else "")
+                }
+
+            llm_answer_text = response.text # Safe to access now
             gaia_logger.info(f"LLM Raw Full Answer (first 200 chars): {llm_answer_text[:200]}...")
             return self._parse_llm_output(llm_answer_text)
-            
+
+        except ValueError as ve:
+            if "finish_reason" in str(ve).lower() and ("part" in str(ve).lower() or "candidate" in str(ve).lower()):
+                gaia_logger.error(f"ValueError accessing Gemini response.text, likely due to non-STOP finish_reason not caught explicitly: {ve}", exc_info=False) # exc_info=False as it's handled
+                fr_from_ex = "Unknown (from ValueError)"
+                match_fr = re.search(r"finish_reason.*?is\s*(\w+)", str(ve), re.IGNORECASE) # Try to get name or number
+                if match_fr: fr_from_ex = match_fr.group(1)
+                return {"model_answer": "LLM Error: Invalid response state",
+                        "reasoning_trace": f"Could not parse LLM response. Finish reason possibly {fr_from_ex}. Details: {str(ve)[:150]}"}
+            else: # Other ValueErrors
+                gaia_logger.error(f"ValueError during Gemini call or processing: {ve}", exc_info=True)
+                return {"model_answer": "LLM Error: Value error", "reasoning_trace": f"A value error occurred: {str(ve)}"}
         except Exception as e:
             gaia_logger.error(f"Error calling Gemini API: {e}", exc_info=True)
             error_type_name = type(e).__name__
             error_message = str(e)
             reasoning = f"Error calling Gemini API: {error_type_name} - {error_message}"
             answer_val = "LLM API error"
-            
-            # Check for common API error types from google.generativeai.types.generation_types.BlockedPromptException or similar
-            # This requires inspecting the actual exception object 'e' or its attributes if it's a specific API exception type
+
             if "API key" in error_message.lower() and ("invalid" in error_message.lower() or "not valid" in error_message.lower()):
                 answer_val = "LLM Auth Error"
                 reasoning = "LLM API key is invalid or not authorized."
@@ -1186,27 +1240,30 @@ class GaiaLevel1Agent:
             elif "InternalServerError" in error_type_name or "500" in error_message :
                 answer_val = "LLM server error"
                 reasoning = "Error: LLM experienced an internal server error."
-            # Add more specific google.generativeai error handling if possible by inspecting 'e' type
-            # For example, if 'e' is an instance of google.generativeai.types.StopCandidateException for safety block
+            # Add specific handling for google.api_core.exceptions.ServiceUnavailable (503) if it occurs
+            elif "ServiceUnavailable" in error_type_name or "503" in error_message:
+                answer_val = "LLM service unavailable"
+                reasoning = "Error: LLM service is temporarily unavailable (503)."
+
 
             return {"model_answer": answer_val, "reasoning_trace": reasoning}
 
     def __call__(self, question: str, task_id: Optional[str] = None) -> Dict[str, str]:
         gaia_logger.info(f"Agent processing: '{question[:70]}...', TaskID: {task_id}")
         q_lower = question.lower().strip()
-        
+
         video_context_str: Optional[str] = None
-        # More specific regex to avoid matching general URLs in text that happen to have 'v='
-        video_url_match = re.search(r"(https?://(?:www\.)?(?:youtube\.com/watch\?v=|youtu\.be/)[\w\-=&%]+)", question)
+        # Regex for YouTube URLs (watch, short, and youtu.be forms)
+        video_url_match = re.search(r"(https?://(?:www\.)?(?:youtube\.com/(?:watch\?v=|shorts/)|youtu\.be/)[\w\-=&%]+)", question)
 
 
-        # Keywords to trigger video analysis for bird species counting
-        video_keywords = ["video", "youtube.com", "youtu.be"]
-        species_keywords = ["species", "bird", "birds", "type of bird", "kinds of bird"]
-        action_keywords = ["count", "how many", "number of", "simultaneously", "at the same time", "on camera"]
+        video_keywords = ["video", "youtube.com", "youtu.be", "clip", "recording"] # Broader keywords
+        species_keywords = ["species", "bird", "birds", "type of bird", "kinds of bird", "different birds"]
+        action_keywords = ["count", "how many", "number of", "simultaneously", "at the same time", "on camera", "identify", "list"]
 
+        # Trigger video analysis if a URL is found AND relevant keywords are present
         if video_url_match and \
-           any(vk in question for vk in video_keywords) and \
+           any(vk in q_lower for vk in video_keywords) and \
            any(sk in q_lower for sk in species_keywords) and \
            any(ak in q_lower for ak in action_keywords):
             video_url = video_url_match.group(0)
@@ -1220,80 +1277,79 @@ class GaiaLevel1Agent:
             return {"model_answer": "general AI assistant", "reasoning_trace": "User asked for my identity."}
 
         file_ctx_str: Optional[str] = None
-        # Check for file-related keywords more carefully
-        file_indicators = ["document", "file", "text provided", "attachment", "content of the file", "data in the file", "excel sheet", ".pdf", ".csv", ".txt", "audio file", "code snippet", "log file"]
-        # Question might imply a file without using the task_id directly if it refers to "the provided text" etc.
-        # For GAIA, task_id is usually present if a file is relevant.
-        if task_id and (any(fi in q_lower for fi in file_indicators) or "this task involves a file" in q_lower or "the provided" in q_lower):
+        file_indicators = ["document", "file", "text provided", "attachment", "content of the file", "data in the file", "excel sheet", ".pdf", ".csv", ".txt", "audio file", "code snippet", "log file", "spreadsheet"]
+        if task_id and (any(fi in q_lower for fi in file_indicators) or "this task involves a file" in q_lower or "the provided" in q_lower or "attached" in q_lower):
             file_ctx_str = self._fetch_and_process_file_content(task_id)
             if file_ctx_str: gaia_logger.info(f"Processed file context ({len(file_ctx_str)} chars) for task {task_id}")
             else: gaia_logger.warning(f"No file content or failed to process for task {task_id}")
-        
-        web_rag_ctx_str: Optional[str] = None # Separate for clarity
+
+        web_rag_ctx_str: Optional[str] = None
         needs_web_rag = True
-        
-        if video_context_str: 
-            # If video analysis provided a direct answer to a video-specific question, web RAG might be less critical or supplementary.
-            # Example: "Count birds in video X" -> video_context_str is primary.
-            # Example: "What is the habitat of birds shown in video X?" -> video context helps identify birds, web helps find habitat.
-            # For now, if video_context exists, we'll assume it might answer the question, but LLM can decide if web is still needed from prompt.
-            # Let's refine this: if the question *only* seems answerable by the video analysis itself, skip web.
-            if all(ak_q in q_lower for ak_q in ["count", "how many", "simultaneously"]) and any(sk_q in q_lower for sk_q in species_keywords):
-                 needs_web_rag = False
-                 gaia_logger.info("Video context seems primary for a counting question; RAG web search might be skipped or deprioritized by LLM.")
-
-
-        if file_ctx_str and len(file_ctx_str) > 300 and not video_context_str: 
-            # If a substantial file context exists, and no video context, evaluate if web is needed.
-            # This logic remains similar.
-            web_still_needed_kws = ["what is", "who is", "current", "latest", "news", "public opinion", "recent events", "search for", "find information on", "browse", "look up", "compare with", "external information"]
-            doc_can_answer_kws = ["summarize", "according to the document", "in the provided text", "based on the file content"]
+
+        # Logic to decide if RAG web search is needed
+        if video_context_str:
+            # If video analysis seems to directly answer a counting/identification question from video
+            if "Video analysis result:" in video_context_str and not "download failed" in video_context_str.lower() and not "skipped" in video_context_str.lower():
+                 if (("count" in q_lower or "how many" in q_lower or "number of" in q_lower) and ("simultaneously" in q_lower or "at the same time" in q_lower or "distinct" in q_lower)) and any(sk_q in q_lower for sk_q in species_keywords):
+                    needs_web_rag = False # Video analysis likely sufficient
+                    gaia_logger.info("Video context seems primary for a specific video counting question; web RAG may be skipped.")
+
+
+        if file_ctx_str and len(file_ctx_str) > 100 and not video_context_str: # Only consider file if no video context
+            # Keywords suggesting the answer is likely within the document
+            doc_can_answer_kws = ["summarize", "according to the document", "in the provided text", "based on the file content", "from this file", "in this data"]
+            # Keywords suggesting external info is needed despite file
+            web_still_needed_kws = ["what is the current", "latest news on", "public opinion of", "search for more about", "compare this to", "what happened after"]
+
             if any(kw in q_lower for kw in doc_can_answer_kws) and not any(kw in q_lower for kw in web_still_needed_kws):
                 needs_web_rag = False
-            elif not any(kw in q_lower for kw in web_still_needed_kws) and not question.endswith("?"): # Heuristic: statements might rely on file.
-                # More nuanced: if it's a question that clearly can't be answered by a generic file.
-                if not ("why" in q_lower or "how" in q_lower or "explain" in q_lower or "what if" in q_lower):
+                gaia_logger.info("File context seems primary; web RAG may be skipped.")
+            # Less strong heuristic: if it's a statement or simple file query not asking for external comparison/update
+            elif not any(kw in q_lower for kw in web_still_needed_kws) and not question.strip().endswith("?"):
+                 if not any(qk in q_lower for qk in ["why is", "how does", "explain the impact of", "what if"]): # Questions often needing broader context
                      needs_web_rag = False
+                     gaia_logger.info("File context seems sufficient for non-complex query; web RAG may be skipped.")
+
 
-        # Explicit negative constraint for web search
         if "don't search" in q_lower or "do not search" in q_lower or "without searching" in q_lower or "without using the internet" in q_lower:
             needs_web_rag = False
             gaia_logger.info("Web RAG explicitly disabled by user query.")
-        
+
         if needs_web_rag:
-            search_q = question.replace("?", "").strip() # Basic cleaning
-            # Potentially refine search_q if file_context or video_context gives hints
-            # For now, use original question for RAG query
-            rag_res = self.rag_pipeline.analyze(query=search_q, force_refresh=False) 
+            search_q = question.replace("?", "").strip()
+            # If video context failed, the question might still be about the video's topic, so RAG is useful.
+            # If file context is present but RAG is still needed, LLM will have to reconcile.
+            rag_res = self.rag_pipeline.analyze(query=search_q, force_refresh=False)
             if rag_res:
                 snippets = []
                 for i, res_item in enumerate(rag_res):
                     title = res_item.get('title','N/A')
                     body = res_item.get('body','')
                     href = res_item.get('href','#')
-                    provider = res_item.get('query_tag','WebSearch') # From RAG pipeline
-                    prefix = "EnrichedContent" if res_item.get('enriched') else "Snippet"
-                    body_preview = (body[:1500] + "...") if len(body) > 1500 else body # Max length for snippet
-                    snippets.append(f"Source [{i+1} - {provider}]: {title}\nURL: {href}\n{prefix}: {body_preview}\n---")
+                    provider_info = res_item.get('query_tag','WebSearch') # Can be refined if RAG provides more source details
+                    source_type = "EnrichedContent" if res_item.get('enriched') else "Snippet"
+                    body_preview = (body[:1500] + "...") if len(body) > 1500 else body
+                    snippets.append(f"Source [{i+1} - {provider_info}]: {title}\nURL: {href}\n{source_type}: {body_preview}\n---")
                 web_rag_ctx_str = "\n\n".join(snippets)
                 if web_rag_ctx_str: gaia_logger.info(f"RAG pipeline yielded web results ({len(web_rag_ctx_str)} chars).")
             else: gaia_logger.warning("RAG pipeline yielded no web results for the query.")
-        
-        # Consolidate external context for the LLM
+
         final_llm_external_context_parts = []
         if video_context_str:
-            final_llm_external_context_parts.append(f"Video Analysis Context:\n{video_context_str}")
+            final_llm_external_context_parts.append(f"{video_context_str}") # Header already in video_context_str
         if web_rag_ctx_str:
-            final_llm_external_context_parts.append(f"Web Search Context:\n{web_rag_ctx_str}")
-        
-        final_llm_external_context = "\n\n---\n\n".join(final_llm_external_context_parts) if final_llm_external_context_parts else None
-        
+            # No separate header needed if video_context_str already has "Video Analysis Context:"
+            # and web_rag_ctx_str is structured with "Source [n]:"
+            final_llm_external_context_parts.append(f"{web_rag_ctx_str}")
+
+        final_llm_external_context = "\n\n---\n\n".join(final_llm_external_context_parts).strip() if final_llm_external_context_parts else None
+
         agent_response_dict = self._formulate_answer_with_llm(question, file_ctx_str, final_llm_external_context)
         gaia_logger.info(f"LLM-based model_answer (first 70 chars): {agent_response_dict.get('model_answer', '')[:70]}...")
         return agent_response_dict
-    
 
-def run_and_submit_all(profile: gr.OAuthProfile | None): 
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
     space_id = os.getenv("SPACE_ID")
     if profile: username = f"{profile.username}"
     else: return "Please Login to Hugging Face.", None
@@ -1306,11 +1362,15 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         questions_data = response.json()
         if not questions_data or not isinstance(questions_data, list): return "Questions list empty/invalid.", None
     except Exception as e: return f"Error fetching questions: {e}", None
-    
+
     results_log_for_gradio, answers_for_api_submission = [], []
-    GEMINI_RPM_LIMIT = int(os.getenv("GEMINI_RPM_LIMIT", "60")) 
-    sleep_llm = (60.0 / GEMINI_RPM_LIMIT) + 0.5 if GEMINI_RPM_LIMIT > 0 else 0.2 
-    
+    # Use a more conservative default RPM if not set, matching free tier common limits.
+    GEMINI_RPM_LIMIT = int(os.getenv("GEMINI_RPM_LIMIT", "10")) # Default to 10 RPM if not set, as per common free tier
+    # Add a small buffer to sleep time
+    sleep_llm = (60.0 / GEMINI_RPM_LIMIT) + 0.5 if GEMINI_RPM_LIMIT > 0 else 0.2
+    gaia_logger.info(f"Using Gemini RPM limit: {GEMINI_RPM_LIMIT}, LLM call sleep: {sleep_llm:.2f}s")
+
+
     for i, item in enumerate(questions_data):
         task_id, q_text = item.get("task_id"), item.get("question")
         model_answer_val = "AGENT ERROR"
@@ -1322,7 +1382,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             results_log_for_gradio.append({"Task ID": task_id, "Question": q_text, "Submitted Answer": model_answer_val, "Reasoning Trace": reasoning_trace_val})
             answers_for_api_submission.append({"task_id": task_id, "submitted_answer": model_answer_val})
             continue
-        
+
         gaia_logger.info(f"Q {i+1}/{len(questions_data)} - Task: {task_id}")
         try:
             agent_response_dict = agent(question=q_text, task_id=task_id)
@@ -1332,24 +1392,24 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             gaia_logger.error(f"Error during agent call for task {task_id}: {e}", exc_info=True)
             model_answer_val = "AGENT EXECUTION ERROR"
             reasoning_trace_val = f"Agent call failed: {type(e).__name__} - {str(e)}"
-        
+
         answers_for_api_submission.append({"task_id": task_id, "submitted_answer": model_answer_val})
         results_log_for_gradio.append({"Task ID": task_id, "Question": q_text, "Submitted Answer": model_answer_val, "Reasoning Trace (first 500 chars)": reasoning_trace_val[:500] + ("..." if len(reasoning_trace_val) > 500 else "")})
-        
+
         if i < len(questions_data) - 1: time.sleep(sleep_llm)
-            
+
     if not answers_for_api_submission: return "Agent produced no answers for API submission.", pd.DataFrame(results_log_for_gradio or [{"Info": "No questions processed"}])
-    
+
     submission_payload_for_api = {
-        "username": username.strip(), 
-        "agent_code": agent_code, 
-        "answers": answers_for_api_submission 
+        "username": username.strip(),
+        "agent_code": agent_code,
+        "answers": answers_for_api_submission
     }
     gaia_logger.info(f"Submitting {len(answers_for_api_submission)} answers for '{username}' to API...")
     gaia_logger.debug(f"API Submission Payload Sample: {json.dumps(submission_payload_for_api)[:500]}")
 
     try:
-        response = requests.post(submit_url, json=submission_payload_for_api, timeout=60); 
+        response = requests.post(submit_url, json=submission_payload_for_api, timeout=60);
         response.raise_for_status()
         result_data = response.json()
         status = (f"Submission Successful!\nUser: {result_data.get('username')}\nScore: {result_data.get('score','N/A')}% "
@@ -1361,37 +1421,36 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         return f"Submission Failed: {err_detail}", pd.DataFrame(results_log_for_gradio)
     except Exception as e: return f"Submission Failed: {e}", pd.DataFrame(results_log_for_gradio)
 
-with gr.Blocks(title="GAIA RAG Agent - Advanced") as demo: 
-    gr.Markdown("# AGENT")
+with gr.Blocks(title="GAIA RAG Agent - Advanced") as demo:
+    gr.Markdown("# GAIA Level 1 Agent") # Updated Title
     gr.Markdown(
         """
         **Instructions:**
-        1.  Log in to Hugging Face.
-        2.  Click 'Run Evaluation & Submit All Answers'.
+        1.  Ensure you are logged in via the Hugging Face Login button below.
+        2.  Click 'Run Evaluation & Submit All Answers' to process all questions from the GAIA benchmark and submit them.
         ---
-        Agent uses RAG, advanced File Processing, and LLM.
+        This agent utilizes Retrieval-Augmented Generation (RAG) with multiple search providers, advanced file processing (CSV, JSON, Excel, PDF, Audio Transcription), and experimental video analysis capabilities (bird species identification/counting in YouTube videos) via Hugging Face Transformers. Answers are formulated by a Large Language Model (Google Gemini).
         """
     )
     gr.LoginButton()
     run_button = gr.Button("Run Evaluation & Submit All Answers", variant="primary")
     status_output = gr.Textbox(label="Status / Submission Result", lines=5, interactive=False)
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True, max_rows=20, height=500) # Added max_rows and height
     run_button.click(fn=run_and_submit_all, inputs=[], outputs=[status_output, results_table])
 
-if __name__ == "__main__": 
-    print("\n" + "-"*30 + " GAIA Level 1 Agent - RAG, FileProc, Video Analysis " + "-"*30) 
+if __name__ == "__main__":
+    print("\n" + "-"*30 + " GAIA Level 1 Agent - RAG, FileProc, Video Analysis " + "-"*30)
     required_env = {
-        "GOOGLE_GEMINI_API_KEY": GOOGLE_GEMINI_API_KEY, 
-        "GOOGLE_API_KEY": GOOGLE_CUSTOM_SEARCH_API_KEY, 
-        "GOOGLE_CSE_ID": GOOGLE_CUSTOM_SEARCH_CSE_ID, 
+        "GOOGLE_GEMINI_API_KEY": GOOGLE_GEMINI_API_KEY,
+        "GOOGLE_API_KEY": GOOGLE_CUSTOM_SEARCH_API_KEY,
+        "GOOGLE_CSE_ID": GOOGLE_CUSTOM_SEARCH_CSE_ID,
         "TAVILY_API_KEY": TAVILY_API_KEY,
     }
     missing_keys = [k for k, v in required_env.items() if not v]
     for k, v in required_env.items(): print(f"✅ {k} found." if v else f"⚠️ WARNING: {k} not set.")
-    
-    # Check for all critical libraries
+
     libraries_to_check = [
-        ("transformers", hf_transformers_pipeline), ("torch", torch), 
+        ("transformers", hf_transformers_pipeline), ("torch", torch),
         ("librosa", librosa), ("openpyxl", openpyxl), ("pdfplumber", pdfplumber),
         ("yt_dlp", yt_dlp), ("cv2 (opencv-python)", cv2), ("BeautifulSoup", BeautifulSoup),
         ("duckduckgo_search", DDGS), ("googleapiclient", build_google_search_service),
@@ -1402,6 +1461,11 @@ if __name__ == "__main__":
 
     if missing_keys: print(f"\n--- PLEASE SET MISSING ENV VARS FOR FULL FUNCTIONALITY: {', '.join(missing_keys)} ---\n")
     else: print("\n--- All major API Key Environment Variables found. ---")
-        
+    
+    # Log the Gemini RPM limit being used
+    gemini_rpm = os.getenv("GEMINI_RPM_LIMIT", "10 (defaulted)")
+    print(f"--- Using GEMINI_RPM_LIMIT: {gemini_rpm} (Ensure this matches your Gemini API plan limits) ---")
+
+
     print("-"*(60 + len(" GAIA Level 1 Agent - RAG, FileProc, Video Analysis ")) + "\n")
     demo.launch(server_name="0.0.0.0", server_port=7860, debug=False, share=False)