changed model

app.py

@@ -5,19 +5,19 @@ import pandas as pd
 import re
 import io
 import contextlib
+import json
 from huggingface_hub import InferenceClient
 from langchain_community.tools import DuckDuckGoSearchRun
 from PyPDF2 import PdfReader
 from docx import Document
-import json
+from youtube_transcript_api import YouTubeTranscriptApi
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-# A powerful, open-source model with function-calling capabilities
-MODEL_ID = "NousResearch/Hermes-2-Pro-Mistral-7B"
-# This prompt template is inspired by the ReAct framework and is tailored for tool use.
-PROMPT_TEMPLATE = """<|im_start|>system
-You are a helpful assistant designed to answer questions accurately. You have access to the following tools:
+# Switched to a more reliable and fast model available on the free Inference API
+MODEL_ID = "mistralai/Mistral-7B-Instruct-v0.2"
+# Updated prompt template to match the Mistral format
+PROMPT_TEMPLATE = """<s>[INST]You are a helpful assistant designed to answer questions accurately. You have access to the following tools:
 
 {tools_description}
 
@@ -32,10 +32,10 @@ When you have the final answer, respond with:
 Thought: I have now found the final answer.
 Final Answer: The final answer.
 
-Do not use a tool if you are not sure about the parameters. Do not make up file names.
-Question: {question}<|im_end|>
-<|im_start|>assistant
-{scratchpad}"""
+Do not use a tool if you are not sure about the parameters. Do not make up file names. If a tool is not available for a task (e.g., image analysis), state that you cannot answer.
+
+Question: {question}
+[/INST]{scratchpad}"""
 
 
 # --- Tool Definitions ---
@@ -46,13 +46,6 @@ class WebSearchTool:
         self.search = DuckDuckGoSearchRun()
 
     def __call__(self, query: str):
-        """
-        Searches the web for the given query.
-        Args:
-            query (str): The search query.
-        Returns:
-            str: The search results.
-        """
         print(f"--- Calling WebSearchTool with query: {query} ---")
         try:
             return self.search.run(query)
@@ -66,16 +59,9 @@ class WebSearchTool:
 class PythonREPLTool:
     """A tool to execute Python code."""
     def __call__(self, code: str):
-        """
-        Executes Python code and returns the output.
-        Args:
-            code (str): The Python code to execute.
-        Returns:
-            str: The output of the executed code.
-        """
         print(f"--- Calling PythonREPLTool with code: {code} ---")
-        if "os" in code or "sys" in code or "subprocess" in code:
-            return "Error: Use of os, sys, or subprocess is not allowed."
+        if any(keyword in code for keyword in ["os", "sys", "subprocess", "eval", "exec"]):
+            return "Error: Use of os, sys, subprocess, eval, or exec is not allowed for security reasons."
             
         local_vars = {}
         string_io = io.StringIO()
@@ -84,7 +70,6 @@ class PythonREPLTool:
                 exec(code, {}, local_vars)
             output = string_io.getvalue()
             if not output and local_vars:
-                 # If there was no print statement, return the value of the last variable
                 output = str(list(local_vars.values())[-1])
             return output if output else "Code executed with no output."
         except Exception as e:
@@ -100,32 +85,24 @@ class FileReaderTool:
         self.api_url = api_url
 
     def __call__(self, task_id: str, file_name: str):
-        """
-        Reads the content of a file.
-        Args:
-            task_id (str): The ID of the task the file is associated with.
-            file_name (str): The name of the file to read. The LLM must infer this from the question.
-        Returns:
-            str: The content of the file.
-        """
         print(f"--- Calling FileReaderTool for task_id: {task_id}, file_name: {file_name} ---")
+        if file_name.endswith(('.mp3', '.wav', '.flac')):
+            return "Error: This tool cannot read audio files. Use the `audio_transcriber` tool instead."
+            
         file_url = f"{self.api_url}/files/{task_id}"
         
         try:
             response = requests.get(file_url, timeout=20)
             response.raise_for_status()
-            
-            content = ""
             file_content = io.BytesIO(response.content)
             
+            content = ""
             if file_name.endswith('.pdf'):
                 pdf = PdfReader(file_content)
-                for page in pdf.pages:
-                    content += page.extract_text() if page.extract_text() else ""
+                content = "".join(page.extract_text() for page in pdf.pages if page.extract_text())
             elif file_name.endswith('.docx'):
                 doc = Document(file_content)
-                for para in doc.paragraphs:
-                    content += para.text + '\n'
+                content = "\n".join(para.text for para in doc.paragraphs)
             elif file_name.endswith('.csv'):
                 df = pd.read_csv(file_content)
                 content = df.to_string()
@@ -136,91 +113,114 @@ class FileReaderTool:
                 content = file_content.read().decode('utf-8')
             else:
                 return f"Error: Unsupported file type for '{file_name}'. Supported types: .pdf, .docx, .csv, .json, .txt."
-
             return content if content else "File is empty."
-        
-        except requests.exceptions.RequestException as e:
-            return f"Error downloading file: {e}"
         except Exception as e:
             return f"Error reading file '{file_name}': {e}"
 
     @property
     def description(self):
-        return 'file_reader(task_id: str, file_name: str) -> str - Reads the content of a file associated with the current task. Use the file name mentioned in the question.'
+        return 'file_reader(task_id: str, file_name: str) -> str - Reads content of text-based files (.pdf, .docx, .csv, .json, .txt). For audio, use audio_transcriber.'
+
+class AudioTranscriptionTool:
+    """A tool to transcribe audio files using the Hugging Face Inference API."""
+    def __init__(self, api_url: str, client: InferenceClient):
+        self.api_url = api_url
+        self.client = client
+
+    def __call__(self, task_id: str, file_name: str):
+        print(f"--- Calling AudioTranscriptionTool for task: {task_id}, file: {file_name} ---")
+        file_url = f"{self.api_url}/files/{task_id}"
+        try:
+            response = requests.get(file_url, timeout=30)
+            response.raise_for_status()
+            audio_data = response.content
+            transcription = self.client.automatic_speech_recognition(audio_data)
+            return transcription['text'] if transcription and 'text' in transcription else "Could not transcribe audio."
+        except Exception as e:
+            return f"Error during audio transcription: {e}"
+
+    @property
+    def description(self):
+        return 'audio_transcriber(task_id: str, file_name: str) -> str - Transcribes an audio file (.mp3, .wav) associated with the current task.'
+
+class YouTubeTranscriptTool:
+    """A tool to fetch the transcript of a YouTube video."""
+    def __call__(self, video_url: str):
+        print(f"--- Calling YouTubeTranscriptTool for URL: {video_url} ---")
+        match = re.search(r"v=([a-zA-Z0-9_-]+)", video_url)
+        if not match:
+            return "Error: Invalid YouTube URL. Could not extract video ID."
+        video_id = match.group(1)
+        try:
+            transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+            return " ".join([d['text'] for d in transcript_list])
+        except Exception as e:
+            return f"Error fetching transcript for video {video_id}: {e}. The video might not have a transcript."
+
+    @property
+    def description(self):
+        return 'youtube_transcript_fetcher(video_url: str) -> str - Fetches the transcript of a YouTube video. Use for questions about video content.'
 
 
 # --- GAIA Agent Definition ---
 class GaiaAgent:
     def __init__(self, hf_token: str, api_url: str, max_turns: int = 8):
-        print("GaiaAgent initializing...")
         if not hf_token:
             raise ValueError("Hugging Face token is required for the Inference API.")
-        
         self.llm_client = InferenceClient(model=MODEL_ID, token=hf_token)
         self.max_turns = max_turns
         
-        # Initialize tools
         self.tools = {
             "web_search": WebSearchTool(),
             "python_repl": PythonREPLTool(),
             "file_reader": FileReaderTool(api_url=api_url),
+            "youtube_transcript_fetcher": YouTubeTranscriptTool(),
+            "audio_transcriber": AudioTranscriptionTool(api_url=api_url, client=self.llm_client),
         }
         self.tools_description = "\n".join([f"- `{tool.description}`" for tool in self.tools.values()])
         self.tool_names = ", ".join(self.tools.keys())
-        print("GaiaAgent initialized successfully.")
+        print("GaiaAgent initialized successfully with tools:", self.tool_names)
 
     def __call__(self, question: str, task_id: str) -> str:
         print(f"\n--- Running agent on task {task_id} ---")
         print(f"Question: {question[:100]}...")
-        
         scratchpad = ""
         
         for turn in range(self.max_turns):
             print(f"Turn {turn + 1}/{self.max_turns}")
-
-            # 1. Construct the prompt
             prompt = PROMPT_TEMPLATE.format(
                 tools_description=self.tools_description,
                 tool_names=self.tool_names,
                 question=question,
                 scratchpad=scratchpad,
             )
-
-            # 2. Call the LLM
             try:
                 llm_output = self.llm_client.text_generation(
-                    prompt, max_new_tokens=1024, stop_sequences=["<|im_end|>", "Observation:"], temperature=0.1
+                    prompt, max_new_tokens=1024, stop_sequences=["Observation:", "[/INST]"], temperature=0.1
                 ).strip()
             except Exception as e:
-                print(f"LLM API call failed: {e}")
                 return f"Error: LLM call failed. {e}"
 
             print(f"LLM Output:\n{llm_output}")
             scratchpad += llm_output
-
-            # 3. Parse the output for Final Answer or Action
+            
             final_answer_match = re.search(r"Final Answer:\s*(.*)", scratchpad, re.DOTALL)
-            action_match = re.search(r"Action:\s*([a-zA-Z0-9_]+)\((.*)\)", llm_output)
+            action_match = re.search(r"Action:\s*([a-zA-Z0-9_]+)\((.*)\)", llm_output, re.DOTALL)
 
             if final_answer_match:
-                answer = final_answer_match.group(1).strip()
-                print(f"Final Answer Found: {answer}")
-                return answer
+                return final_answer_match.group(1).strip()
             
             elif action_match:
                 tool_name = action_match.group(1).strip()
                 tool_args_str = action_match.group(2).strip()
                 
                 if tool_name not in self.tools:
-                    observation = f"Error: Unknown tool '{tool_name}'. Available tools: {self.tool_names}"
+                    observation = f"Error: Unknown tool '{tool_name}'."
                 else:
                     try:
-                        # Safely parse arguments
                         args_dict = eval(f"dict({tool_args_str})", {"__builtins__": None}, {})
-                        
-                        if tool_name == 'file_reader':
+                        if tool_name in ['file_reader', 'audio_transcriber']:
                             args_dict['task_id'] = task_id
-                            
                         tool = self.tools[tool_name]
                         observation = tool(**args_dict)
                     except Exception as e:
@@ -229,102 +229,67 @@ class GaiaAgent:
                 print(f"Observation: {str(observation)[:200]}...")
                 scratchpad += f"\nObservation: {str(observation)}\n"
             else:
-                print("No valid action or final answer found in LLM output. Continuing thought process.")
-                scratchpad += "\nObservation: No valid action taken. Please either use a tool with the correct format `Action: tool_name(arg_name=\"value\")` or provide the final answer in the format `Final Answer: your_answer`."
+                scratchpad += "\nObservation: No valid action or final answer found. Please format your response as either 'Action: tool_name(args)' or 'Final Answer: your_answer'."
 
-        print("Agent reached max turns.")
         return "Agent stopped after reaching maximum turns."
 
 # --- Main Submission Logic ---
-
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     hf_token = os.getenv("HF_TOKEN")
     if not hf_token:
-        return "Error: `HF_TOKEN` environment variable not set. Please add it to your Space secrets.", None
+        return "Error: `HF_TOKEN` secret not set. Please add it to your Space secrets.", None
 
     space_id = os.getenv("SPACE_ID")
     if not space_id:
-        return "Error: `SPACE_ID` environment variable not found. Are you running in a Hugging Face Space?", None
+        return "Error: `SPACE_ID` not found. Are you in a Hugging Face Space?", None
 
     if not profile:
         return "Please Login to Hugging Face with the button to submit.", None
     
     username = profile.username
-    print(f"User logged in: {username}")
-
     api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
 
-    # 1. Instantiate Agent
     try:
         agent = GaiaAgent(hf_token=hf_token, api_url=api_url)
     except Exception as e:
-        print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
 
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(f"Code link: {agent_code}")
-
-    # 2. Fetch Questions
     try:
-        response = requests.get(questions_url, timeout=15)
+        response = requests.get(f"{api_url}/questions", timeout=15)
         response.raise_for_status()
         questions_data = response.json()
-        if not questions_data:
-             return "Fetched questions list is empty or invalid format.", None
-        print(f"Fetched {len(questions_data)} questions.")
     except Exception as e:
         return f"Error fetching questions: {e}", None
 
-    # 3. Run Agent and Collect Answers
-    results_log = []
-    answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
+    results_log, answers_payload = [], []
     for item in questions_data:
-        task_id = item.get("task_id")
-        question_text = item.get("question")
-        if not task_id or question_text is None:
-            continue
+        task_id, question_text = item.get("task_id"), item.get("question")
+        if not all([task_id, question_text]): continue
         try:
-            submitted_answer = agent(question_text, task_id)
-            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})
+            answer = agent(question_text, task_id)
+            answers_payload.append({"task_id": task_id, "submitted_answer": answer})
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": answer})
         except Exception as e:
-             print(f"Error running agent on task {task_id}: {e}")
              results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     if not answers_payload:
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+        return "Agent did not produce any answers.", pd.DataFrame(results_log)
 
-    # 4. Prepare and 5. Submit
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    print(f"Submitting {len(answers_payload)} answers for user '{username}'...")
     
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=120)
+        response = requests.post(f"{api_url}/submit", json=submission_data, timeout=120)
         response.raise_for_status()
         result_data = response.json()
         final_status = (
-            f"Submission Successful!\n"
-            f"User: {result_data.get('username')}\n"
-            f"Overall Score: {result_data.get('score', 'N/A')}% "
-            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
-            f"Message: {result_data.get('message', 'No message received.')}"
+            f"Submission Successful! Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')})"
         )
-        results_df = pd.DataFrame(results_log)
-        return final_status, results_df
+        return final_status, pd.DataFrame(results_log)
     except requests.exceptions.RequestException as e:
-        error_detail = "Network error or server responded with an error."
-        if e.response is not None:
-             error_detail = f"Server responded with status {e.response.status_code}. Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except Exception as e:
-        status_message = f"An unexpected error occurred during submission: {e}"
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        error_detail = f"Server responded with status {e.response.status_code}. Response: {e.response.text[:500]}" if e.response else str(e)
+        return f"Submission Failed: {error_detail}", pd.DataFrame(results_log)
 
 
 # --- Gradio Interface ---
@@ -333,41 +298,19 @@ with gr.Blocks() as demo:
     gr.Markdown(
         """
         **Instructions:**
-
-        1.  **Add your HF Token**: Go to the 'Settings' tab of this Space and add a secret named `HF_TOKEN` with your Hugging Face read token.
-        2.  **Login**: Log in to your Hugging Face account using the button below. This is required for submission.
-        3.  **Run**: Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-        ---
-        **Disclaimer:**
-        This process can take several minutes as the agent processes each question. Please be patient.
+        1.  **Add your HF Token**: Go to your Space's **Settings** and add a secret named `HF_TOKEN` with your Hugging Face `read` token.
+        2.  **Login**: Use the button below to login with your Hugging Face account.
+        3.  **Run**: Click 'Run Evaluation & Submit' to start the agent. This may take several minutes.
         """
     )
-
     with gr.Row():
         gr.LoginButton()
         run_button = gr.Button("Run Evaluation & Submit All Answers", variant="primary")
-
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=4, interactive=False)
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
-
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
-    )
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
     if not os.getenv("HF_TOKEN"):
-        print("⚠️  WARNING: `HF_TOKEN` secret not found. The agent will not be able to run.")
-    else:
-        print("✅ `HF_TOKEN` secret found.")
-
-    space_id_startup = os.getenv("SPACE_ID")
-    if space_id_startup:
-        print(f"✅ SPACE_ID found: {space_id_startup}")
-    else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?).")
-    
-    print("-"*(60 + len(" App Starting ")) + "\n")
-    print("Launching Gradio Interface for GAIA Agent Evaluation...")
+        print("⚠️ WARNING: `HF_TOKEN` secret not found. The agent will not run.")
     demo.launch()

requirements.txt

@@ -6,4 +6,5 @@ duckduckgo-search
 pypdf2
 python-docx
 pandas
-openpyxl
+openpyxl
+youtube-transcript-api