Create app.py

app.py

@@ -5,20 +5,63 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-# Removed bs4 and BeautifulSoup as we'll use SerpAPI
-# from bs4 import BeautifulSoup
-# import requests
+import cv2 # Import opencv-python for video processing
+import speech_recognition as sr # Import SpeechRecognition for audio processing
+from pydub import AudioSegment # Import pydub for audio manipulation
+import tempfile # Import tempfile for temporary file handling
+import numpy as np # Import numpy for image processing
 
-# Import SerpAPI
+
+# Import libraries for SerpAPI
 from serpapi import GoogleSearch
-from google.colab import userdata # To access the API key from secrets
+import google.generativeai as genai # Keep the import as the user might add LLM functionality back later
+
+# Removed the import of google.colab.userdata as it's not available outside Colab
+# from google.colab import userdata # To access the API key from secrets
+
+
+# --- Get API Keys from Environment Variables ---
+# SERPAPI_API_KEY and GOOGLE_API_KEY should be set as secrets in your Hugging Face Space
+SERPAPI_API_KEY = os.getenv('SERPAPI_API_KEY')
+print(f"SERPAPI_API_KEY (first 5 chars): {SERPAPI_API_KEY[:5] if SERPAPI_API_KEY else 'None'}...") # Debugging API key
+
+# Access GOOGLE_API_KEY directly from environment variables using os.getenv()
+GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')
+print(f"GOOGLE_API_KEY (first 5 chars): {GOOGLE_API_KEY[:5] if GOOGLE_API_KEY else 'None'}...") # Debugging API key
+
+# --- Define the default API URL ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space" # Updated API URL
+
+
+# --- Google Generative AI LLM Initialization ---
+# Keep LLM initialization but handle potential errors and None state
+print("Attempting to initialize Google Generative AI model...") # Debugging print before loading
+
+gemini_model = None # Initialize to None
+
+# The check for GOOGLE_API_KEY and LLM configuration already uses os.getenv()
+if not GOOGLE_API_KEY:
+    print("Warning: GOOGLE_API_KEY environment variable not set. LLM will not be available.")
+else:
+    try:
+        # Configure the generative AI library
+        genai.configure(api_key=GOOGLE_API_KEY)
+        print("Google Generative AI configured.")
+
+        # Initialize the Generative Model
+        # Using a fast and efficient model like gemini-1.5-flash
+        # You can explore other models like 'gemini-1.5-pro' for potentially better results
+        gemini_model = genai.GenerativeModel('gemini-1.5-flash')
+        print("Gemini model initialized successfully.") # Debugging print after successful init
+
+    except Exception as e:
+        print(f"An error occurred during Google Generative AI initialization: {e}")
+        gemini_model = None # Ensure model is None if initialization fails
 
-# --- Constants ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-SERPAPI_API_KEY = userdata.get('SERPAPI_API_KEY') # Get SerpAPI key from Colab secrets
 
 # --- Web Search Function (using SerpAPI) ---
 def web_search(query: str) -> list[dict]:
+    # Removed global gemini_model declaration as it's not used here
     """
     Performs a web search using SerpAPI and returns relevant information.
 
@@ -26,12 +69,13 @@ def web_search(query: str) -> list[dict]:
         query: The search query string.
 
     Returns:
-        A list of dictionaries, where each dictionary represents a search result
-        with keys 'title', 'snippet', and 'url'. Returns an empty list if no
-        results are found or an error occurs.
-    """
+            A list of dictionaries, where each dictionary represents a search result
+            with keys 'title', 'snippet', and 'url'. Returns an empty list if no
+            results are found or an error occurs.
+        """
+    print(f"web_search called with query: {query[:50]}...") # Debugging web_search call
     if not SERPAPI_API_KEY:
-        print("SerpAPI key not found in Colab secrets.")
+        print("SerpAPI key not found in environment variables.")
         return []
 
     params = {
@@ -44,11 +88,23 @@ def web_search(query: str) -> list[dict]:
 
     try:
         search = GoogleSearch(params)
-        search_results = search.get_dict() # Get results as a dictionary
+        search_results_dict = search.get_dict() # Get results as a dictionary
+        print(f"SerpAPI raw response keys: {search_results_dict.keys() if isinstance(search_results_dict, dict) else 'Response is not a dictionary'}") # Debugging response keys
+
+        # Log the full SerpAPI response for debugging if organic_results is missing or empty
+        if not isinstance(search_results_dict, dict) or "organic_results" not in search_results_dict or not isinstance(search_results_dict["organic_results"], list) or not search_results_dict["organic_results"]:
+             print(f"SerpAPI response did not contain organic results or had invalid format. Response: {search_results_dict}")
+
 
         # Extract organic results
-        if "organic_results" in search_results:
-            for result in search_results["organic_results"]:
+        # Add check that search_results_dict and organic_results are valid
+        if isinstance(search_results_dict, dict) and "organic_results" in search_results_dict and isinstance(search_results_dict["organic_results"], list):
+            print(f"Found {len(search_results_dict['organic_results'])} organic results.") # Debugging result count
+            for result in search_results_dict["organic_results"]:
+                # Add check for None or non-dict result item
+                if result is None or not isinstance(result, dict):
+                    print(f"Skipping invalid search result item: {result}")
+                    continue
                 item = {
                     'title': result.get('title'),
                     'url': result.get('link'),
@@ -56,59 +112,334 @@ def web_search(query: str) -> list[dict]:
                 }
                 results.append(item)
         else:
-            print("No organic results found in SerpAPI response.")
+            print(f"No 'organic_results' key found or invalid format in SerpAPI response. Response type: {type(search_results_dict)}")
 
 
     except Exception as e:
         print(f"An error occurred during SerpAPI web search: {e}")
+        # Ensure an empty list is returned on error
+        return []
 
-    return results
-
+    print(f"web_search returning {len(results)} results.") # Debugging return count
+    return results # Always return a list (empty or with results)
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 
+# --- Basic Agent Definition (Modified to remove LLM dependency for now) ---
 class BasicAgent:
 
     def __init__(self):
-        print("BasicAgent initialized.")
+        print("BasicAgent initialized.") # Debugging print before init
+        # Removed global gemini_model declaration as it's not used here
+        # global gemini_model # Access global variable
+        # if gemini_model is None:
+        #      print("Warning: Google Generative AI model not successfully loaded before agent initialization.")
+        # else:
+        #     print("Google Generative AI model found and ready.") # Debugging print after successful init
+
+
+    def process_video(self, video_source: str) -> str:
+        """
+        Processes a video source (file path or URL), extracts frames, and
+        performs placeholder visual analysis.
+
+        Args:
+            video_source: Path to the video file or a video URL.
+
+        Returns:
+            A string summarizing the video processing result or an error message.
+        """
+        print(f"Processing video source: {video_source}")
+        cap = None
+        try:
+            # Attempt to open the video source
+            # Using cv2.CAP_FFMPEG might help with URLs, but requires FFmpeg
+            # cap = cv2.VideoCapture(video_source, cv2.CAP_FFMPEG)
+            cap = cv2.VideoCapture(video_source)
 
-    def __call__(self, question: str) -> str:
+
+            # Check if the video was opened successfully
+            if not cap.isOpened():
+                print(f"Error: Could not open video source {video_source}")
+                return f"Error: Could not open video source {video_source}"
+
+            frame_count = 0
+            while True:
+                # Read a frame from the video
+                ret, frame = cap.read()
+
+                # If frame was not read successfully, we've reached the end of the video
+                if not ret:
+                    print("End of video stream.")
+                    break
+
+                frame_count += 1
+                # --- Placeholder for visual analysis ---
+                # In a real application, you would perform analysis on the 'frame' object here.
+                # This could involve object detection, scene recognition, etc.
+                # Example placeholder:
+                # gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                # Perform analysis on gray_frame
+
+                if frame_count % 100 == 0: # Print progress every 100 frames
+                    print(f"Processed {frame_count} frames.")
+
+            print(f"Finished processing video. Total frames extracted: {frame_count}")
+            return f"Successfully processed video. Extracted {frame_count} frames."
+
+        except Exception as e:
+            print(f"An error occurred during video processing: {e}")
+            return f"An error occurred during video processing: {e}"
+        finally:
+            # Release the video capture object
+            if cap:
+                cap.release()
+                print("Video capture released.")
+
+    def process_audio(self, audio_source: str) -> str:
+        """
+        Processes an audio source (file path), extracts speech, and performs
+        placeholder audio analysis.
+
+        Args:
+            audio_source: Path to the audio file.
+
+        Returns:
+            A string summarizing the audio processing result or an error message.
+        """
+        print(f"Processing audio source: {audio_source}")
+        recognizer = sr.Recognizer()
+        try:
+            # Load the audio file
+            audio = AudioSegment.from_file(audio_source)
+            print(f"Audio loaded. Duration: {len(audio)} ms")
+
+            # Export to a format SpeechRecognition can handle (e.g., WAV)
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as fp:
+                audio.export(fp.name, format="wav")
+                temp_wav_file = fp.name
+            print(f"Audio exported to temporary WAV: {temp_wav_file}")
+
+            # Use SpeechRecognition to transcribe the audio
+            with sr.AudioFile(temp_wav_file) as source:
+                print("Reading audio file for transcription...")
+                audio_data = recognizer.record(source) # read the entire audio file
+                print("Audio data recorded.")
+
+            # Attempt to recognize speech
+            try:
+                print("Attempting speech recognition...")
+                text = recognizer.recognize_google(audio_data) # Using Google Web Speech API
+                print(f"Transcription result: {text}")
+                return f"Audio processed. Transcription: '{text}'"
+            except sr.UnknownValueError:
+                print("Speech Recognition could not understand audio")
+                return "Audio processed, but could not understand speech."
+            except sr.RequestError as e:
+                print(f"Could not request results from Google Speech Recognition service; {e}")
+                return f"Audio processed, but speech recognition service failed: {e}"
+            except Exception as e:
+                print(f"An unexpected error occurred during speech recognition: {e}")
+                return f"An unexpected error occurred during speech recognition: {e}"
+
+        except Exception as e:
+            print(f"An error occurred during audio processing: {e}")
+            return f"An error occurred during audio processing: {e}"
+        finally:
+            # Clean up the temporary WAV file
+            if 'temp_wav_file' in locals() and os.path.exists(temp_wav_file):
+                os.remove(temp_wav_file)
+                print(f"Temporary WAV file removed: {temp_wav_file}")
+
+
+    def __call__(self, question: str, video_source: str | None = None, audio_source: str | None = None) -> str:
+        # Removed global gemini_model declaration as it's not used here
         print(f"Agent received question (first 50 chars): {question[:50]}...")
+        print(f"Video source provided: {video_source}")
+        print(f"Audio source provided: {audio_source}")
 
-        # Simple logic to determine if a web search is needed
+        # --- Check for media processing tasks ---
+        media_processing_results = []
+        if video_source:
+            print("Video source provided. Attempting video processing.")
+            video_processing_result = self.process_video(video_source)
+            media_processing_results.append(f"Video processing result: {video_processing_result}")
+
+        if audio_source:
+            print("Audio source provided. Attempting audio processing.")
+            audio_processing_result = self.process_audio(audio_source)
+            media_processing_results.append(f"Audio processing result: {audio_processing_result}")
+
+        # If media was processed, return the results for now
+        if media_processing_results:
+            return "\n".join(media_processing_results)
+
+
+        # Simple logic to determine if a web search is needed (only if no media source)
         question_lower = question.lower()
         search_keywords = ["what is", "how to", "where is", "who is", "when did", "define", "explain", "tell me about"]
         needs_search = any(keyword in question_lower for keyword in search_keywords) or "?" in question
+        print(f"Needs search: {needs_search}") # Debugging search decision
 
+        # --- Analyze question and refine search query ---
+        # Simplified search query generation - removed LLM query generation
+        search_query = question # Default search query is the original question
         if needs_search:
-            print(f"Question likely requires search. Searching for: {question}")
-            search_results = web_search(question) # Call the web_search function
-
-            if search_results:
-                # Process search results to formulate an answer
-                answer_parts = []
-                for i, result in enumerate(search_results[:3]): # Use top 3 results
-                    if result.get('snippet'):
-                        answer_parts.append(f"Snippet {i+1}: {result['snippet']}")
-                    elif result.get('title'):
-                         answer_parts.append(f"Result {i+1} Title: {result['title']}")
-                    # Optional: add URL
-                    # if result.get('url'):
-                    #      answer_parts.append(f"URL {i+1}: {result['url']}")
-
-
-                if answer_parts:
-                    formulated_answer = "Based on web search:\n" + "\n".join(answer_parts)
-                    print(f"Agent returning search-based answer: {formulated_answer[:100]}...")
-                    return formulated_answer
+            print("Analyzing question for keywords and refining search query...")
+            # Basic keyword extraction: split by common question words and take the rest
+            parts = question_lower.split("what is", 1)
+            if len(parts) > 1:
+                search_query = parts[1].strip()
+            else:
+                parts = question_lower.split("how to", 1)
+                if len(parts) > 1:
+                    search_query = parts[1].strip()
                 else:
-                    print("Web search returned results but no useful snippets/titles found.")
-                    return "I couldn't find a specific answer from the web search results."
+                     parts = question_lower.split("where is", 1)
+                     if len(parts) > 1:
+                         search_query = parts[1].strip()
+                     else:
+                         parts = question_lower.split("who is", 1)
+                         if len(parts) > 1:
+                             search_query = parts[1].strip()
+                         else:
+                              parts = question_lower.split("when did", 1)
+                              if len(parts) > 1:
+                                  search_query = parts[1].strip()
+                              else:
+                                   parts = question_lower.split("define", 1)
+                                   if len(parts) > 1:
+                                       search_query = parts[1].strip()
+                                   else:
+                                        parts = question_lower.split("explain", 1)
+                                        if len(parts) > 1:
+                                            search_query = parts[1].strip()
+                                        else:
+                                             parts = question_lower.split("tell me about", 1)
+                                             if len(parts) > 1:
+                                                 search_query = parts[1].strip()
+                                             else:
+                                                 # If no specific question keyword found, use the whole question
+                                                 search_query = question_lower.strip()
+
+
+            # Optional: Add quotation marks for multi-word phrases if identified
+            # This simple approach just uses the extracted part as is.
+            # A more complex approach would identify multi-word entities (e.g., "New York City")
+            # and wrap them in quotes.
+
+            # Optional: Add contextual terms
+            # Example: If "musician" or "band" is in the question, add "discography"
+            if any(word in question_lower for word in ["musician", "band", "artist", "singer"]):
+                 search_query += " discography"
+            elif any(word in question_lower for word in ["movie", "film", "actor", "actress"]):
+                 search_query += " plot summary"
+            elif any(word in question_lower for word in ["book", "author", "novel"]):
+                 search_query += " plot summary"
+
+
+            print(f"Final search query used: {search_query}") # Debugging final query
+
+            search_results = [] # Initialize search_results to an empty list before the try block
+            if needs_search:
+                print(f"Question likely requires search. Searching for: {search_query}")
+                try:
+                    search_results = web_search(search_query) # Call the web_search function with the generated query
+                    print(f"Received {len(search_results)} search results from web_search.") # Debugging results received
+                    print(f"Type of search_results: {type(search_results)}") # Debugging type of search_results
+                except Exception as e:
+                    print(f"An error occurred during web search: {e}")
+                    return f"An error occurred during web search: {e}"
+
+                # --- Use LLM to process search results if available (Removed LLM Synthesis) ---
+                # Check that search_results is a list and is not empty
+                if isinstance(search_results, list) and search_results and gemini_model is not None:
+                    print("Using Google LLM to process search results.") # Debugging print before LLM call
+
+                    # Format search results for the LLM
+                    context = ""
+                    for i, result in enumerate(search_results[:5]): # Use top 5 results for context
+                        # Add check for None or non-dict result item before accessing keys
+                        if result is None or not isinstance(result, dict):
+                            print(f"Skipping invalid result at index {i} in LLM context formatting: {result}")
+                            continue
+                        context += f"Source {i+1}:\n"
+                        if result.get('title'):
+                             context += f"Title: {result['title']}\n"
+                        if result.get('snippet'):
+                             context += f"Snippet: {result['snippet']}\n"
+                        if result.get('url'):
+                             context += f"URL: {result['url']}\n"
+                        context += "---\n" # Separator
+
+                    # Refined prompt for the LLM
+                    prompt = f"""Carefully read the following search results and answer the user's question based *only* on the information provided in these results.
+If the search results do not contain sufficient information to fully answer the question, explicitly state that you could not find enough information in the provided results.
+Do not use any outside knowledge. Structure your answer clearly and concisely.
+
+Question: {question}
+
+Search Results:
+{context}
+
+Answer:"""
+
+                    print(f"LLM Prompt (first 500 chars):\n{prompt[:500]}...") # Debugging prompt
+
+                    try:
+                        # Generate content using the Gemini model
+                        response = gemini_model.generate_content(prompt)
+                        generated_text = response.text # Get the generated text
+
+                        # Add check for empty or whitespace generated text
+                        if generated_text and generated_text.strip():
+                             llm_answer = generated_text.strip()
+                             print(f"LLM generated text (first 100 chars): {generated_text[:100]}...") # Debugging raw output
+                             print(f"Agent returning LLM-based answer (first 100 chars): {llm_answer[:100]}...") # Debugging final answer
+                             return llm_answer
+                        else:
+                             print("LLM generated empty or whitespace answer.")
+                             return "I couldn't generate a specific answer based on the search results."
+
+
+                    except Exception as llm_e:
+                         print(f"An error occurred during LLM generation: {llm_e}")
+                         return f"An error occurred while processing search results with the LLM: {llm_e}"
+
+                # Fallback if search results are empty or not a list, or LLM is None
+                elif isinstance(search_results, list) and search_results: # Search results exist and is a list, but LLM is not available or failed
+                     print("Google Generative AI model not loaded or search results empty or LLM failed. Cannot use LLM for synthesis.")
+                     # Return the old style answer if LLM is not available, but only if search results exist
+                     print("Returning basic answer based on search results (LLM not available).")
+                     answer_parts = []
+                     for i, result in enumerate(search_results[:3]):
+                        # Add check for None or non-dict result item before accessing keys
+                        if result is None or not isinstance(result, dict):
+                            print(f"Skipping invalid result at index {i} in basic answer formatting: {result}")
+                            continue
+                        if result.get('snippet'):
+                           # Limit snippet length to avoid overly long responses
+                           snippet = result['snippet']
+                           if len(snippet) > 200:
+                               snippet = snippet[:200] + "..."
+                           answer_parts.append(f"Snippet {i+1}: {snippet}")
+                        elif result.get('title'):
+                             answer_parts.append(f"Result {i+1} Title: {result['title']}")
+                     if answer_parts:
+                         return "Based on web search (LLM not available):\n" + "\n".join(answer_parts)
+                     else:
+                         # Fallback if no useful snippets/titles found in search results
+                         print("No useful snippets/titles found in search results.")
+                         return "I couldn't find useful information in the search results (LLM not available)."
+                else: # search_results is None or not a list, or empty
+                    print(f"Web search returned no results or results in invalid format. Type: {type(search_results)}")
+                    return "I couldn't find any relevant information on the web for your question."
+
+            else: # needs_search is True but no search results were returned (this case is now covered by the try-except around web_search)
+                 # This else block should ideally not be reached if needs_search is True and web_search is called
+                 print("Question required search, but no search was performed or it failed.")
+                 return "I couldn't perform a web search for your question."
+
 
-            else:
-                print("Web search returned no results.")
-                return "I couldn't find any relevant information on the web for your question."
         else:
             # If no search is needed, return a default or simple response
             print("Question does not appear to require search. Returning fixed answer.")
@@ -121,6 +452,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None, other_arg=None): # Modi
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
+    print("run_and_submit_all function started.") # Debugging print at function start
     # --- Determine HF Space Runtime URL and Repo URL ---
     space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
@@ -132,12 +464,14 @@ def run_and_submit_all( profile: gr.OAuthProfile | None, other_arg=None): # Modi
         return "Please Login to Hugging Face with the button.", None
 
     api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
+    questions_url = f"{api_url}/agent_challenge/questions" # Corrected endpoint
+    submit_url = f"{api_url}/agent_challenge/submit" # Corrected endpoint
 
     # 1. Instantiate Agent ( modify this part to create your agent)
+    print("Attempting to instantiate BasicAgent...") # Debugging print before instantiation
     try:
         agent = BasicAgent()
+        print("BasicAgent instantiated successfully.") # Debugging print after instantiation
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -147,12 +481,14 @@ def run_and_submit_all( profile: gr.OAuthProfile | None, other_arg=None): # Modi
 
     # 2. Fetch Questions
     print(f"Fetching questions from: {questions_url}")
+    questions_data = None # Initialize to None
     try:
         response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
-        if not questions_data:
-             print("Fetched questions list is empty.")
+        # Add check for empty or non-list questions_data immediately after fetching
+        if not isinstance(questions_data, list) or not questions_data:
+             print(f"Fetched questions_data is empty or not a list. Type: {type(questions_data)}")
              return "Fetched questions list is empty or invalid format.", None
         print(f"Fetched {len(questions_data)} questions.")
     except requests.exceptions.RequestException as e:
@@ -160,7 +496,8 @@ def run_and_submit_all( profile: gr.OAuthProfile | None, other_arg=None): # Modi
         return f"Error fetching questions: {e}", None
     except requests.exceptions.JSONDecodeError as e:
          print(f"Error decoding JSON response from questions endpoint: {e}")
-         print(f"Response text: {response.text[:500]}")
+         # Print the response text for debugging if JSON decoding fails
+         print(f"Response text: {response.text[:500] if 'response' in locals() else 'No response object'}")
          return f"Error decoding server response for questions: {e}", None
     except Exception as e:
         print(f"An unexpected error occurred fetching questions: {e}")
@@ -171,14 +508,23 @@ def run_and_submit_all( profile: gr.OAuthProfile | None, other_arg=None): # Modi
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
+    # The check that questions_data is a list is now done immediately after fetching
     for item in questions_data:
+        # Add check for None or non-dict item before accessing keys
+        if item is None or not isinstance(item, dict):
+            print(f"Skipping invalid item in questions_data: {item}")
+            continue
         task_id = item.get("task_id")
         question_text = item.get("question")
-        if not task_id or question_text is None:
-            print(f"Skipping item with missing task_id or question: {item}")
+        if not task_id or not isinstance(task_id, (str, int)) or not question_text or not isinstance(question_text, str):
+            print(f"Skipping item with missing or invalid task_id or question: {item}")
             continue
+        print(f"Processing Task ID: {task_id}") # Debugging task ID
         try:
+            # Here, we only pass the question text for now, as the API doesn't support video input
+            # The video processing logic is added but not triggered by this function
             submitted_answer = agent(question_text)
+            print(f"Agent returned answer for {task_id}: {submitted_answer[:50]}...") # Debugging returned answer
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
         except Exception as e:
@@ -215,8 +561,17 @@ def run_and_submit_all( profile: gr.OAuthProfile | None, other_arg=None): # Modi
         try:
             error_json = e.response.json()
             error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+            status_message = f"Submission Failed: {error_detail}"
+            print(status_message)
+            # If submission fails, also return the results log so the user can see what was attempted
+            results_df = pd.DataFrame(results_log)
+            return status_message, results_df
         except requests.exceptions.JSONDecodeError:
             error_detail += f" Response: {e.response.text[:500]}"
+            status_message = f"Submission Failed: {error_detail}"
+            print(status_message)
+            results_df = pd.DataFrame(results_log)
+            return status_message, results_df
         status_message = f"Submission Failed: {error_detail}"
         print(status_message)
         results_df = pd.DataFrame(results_log)
@@ -238,6 +593,25 @@ def run_and_submit_all( profile: gr.OAuthProfile | None, other_arg=None): # Modi
         return status_message, results_df
 
 
+# Function to call process_video directly for testing
+def test_video_processing(video_source: str) -> str:
+    print(f"Testing video processing with source: {video_source}")
+    try:
+        agent = BasicAgent()
+        return agent.process_video(video_source)
+    except Exception as e:
+        return f"Error during video processing test: {e}"
+
+# Function to call process_audio directly for testing
+def test_audio_processing(audio_source: str) -> str:
+    print(f"Testing audio processing with source: {audio_source}")
+    try:
+        agent = BasicAgent()
+        return agent.process_audio(audio_source)
+    except Exception as e:
+        return f"Error during audio processing test: {e}"
+
+
 # Move Gradio interface definition and launch outside the function
 with gr.Blocks(theme=gr.themes.Soft(), title="Basic Agent Evaluation Runner") as demo:
     gr.Markdown(
@@ -248,15 +622,16 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Basic Agent Evaluation Runner") as
 
         **Instructions:**
         1. Ensure your agent logic is defined in the `BasicAgent` class above.
-        2. **Get a SerpAPI key and add it to Colab Secrets (name it `SERPAPI_API_KEY`).**
+        2. **Get a SerpAPI key and a Google AI API key and add them as environment variables in your runtime environment (e.g., as secrets in your Hugging Face Space settings).**
         3. Log in to Hugging Face using the button below.
-        4. Click the "Run Evaluation & Submit All Answers" button.
-        5. The application will fetch questions, run your agent, submit answers, and display the results below.
+        4. Click the "Run Evaluation & Submit All Answers" button to run on predefined questions.
+        5. Use the "Test Video Processing" and "Test Audio Processing" sections to test media analysis.
         """
     )
     login_btn = gr.LoginButton()
 
     run_button = gr.Button("Run Evaluation & Submit All Answers")
+    run_button.interactive = True # Re-enable the button
 
     status_output = gr.Textbox(label="Run Status", interactive=False, lines=5)
     results_output = gr.DataFrame(label="Evaluation Results")
@@ -267,6 +642,30 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Basic Agent Evaluation Runner") as
         outputs=[status_output, results_output]
     )
 
+    gr.Markdown("---") # Separator
+    gr.Markdown("## Test Media Processing")
+
+    video_test_input = gr.Video(label="Upload Video or Paste URL")
+    video_test_button = gr.Button("Test Video Processing")
+    video_test_output = gr.Textbox(label="Video Processing Result", interactive=False)
+
+    video_test_button.click(
+        test_video_processing,
+        inputs=[video_test_input],
+        outputs=[video_test_output]
+    )
+
+    audio_test_input = gr.Audio(label="Upload Audio or Paste URL")
+    audio_test_button = gr.Button("Test Audio Processing")
+    audio_test_output = gr.Textbox(label="Audio Processing Result", interactive=False)
+
+    audio_test_button.click(
+        test_audio_processing,
+        inputs=[audio_test_input],
+        outputs=[audio_test_output]
+    )
+
+
 # Ensure the app launches when the script is run
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0") # Ensure binding to all interfaces