Update app.py

app.py

@@ -7,12 +7,10 @@ from smolagents import (
     CodeAgent,
     DuckDuckGoSearchTool,
     VisitWebpageTool,
-    InferenceClientModel,
+    OpenAIModel,
     tool,
-    LiteLLMModel,
 )
 
-
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
@@ -23,241 +21,168 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 @tool
 def download_file_from_api(task_id: str) -> str:
-    """Downloads a file associated with a GAIA task and returns its text content.
-    Use this tool when a question mentions an attached file, spreadsheet, image,
-    audio, document, or any file that you need to read or analyze.
+    """Downloads a file for a GAIA task. Use when question mentions a file/attachment.
 
     Args:
-        task_id: The task_id string for the question that has an associated file.
+        task_id: The task_id string for the question.
     """
     import tempfile
-    api_url = "https://agents-course-unit4-scoring.hf.space"
-    url = f"{api_url}/files/{task_id}"
+    url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
     try:
-        response = requests.get(url, timeout=30)
-        response.raise_for_status()
-
-        content_type = response.headers.get("Content-Type", "")
-        print(f"  [download_file] Content-Type: {content_type}, Size: {len(response.content)} bytes")
-
-        # --- TEXT-BASED FILES ---
-        if any(t in content_type for t in ["text", "json", "csv", "xml", "html"]):
-            return response.text[:15000]
-
-        # --- EXCEL FILES ---
-        if any(t in content_type for t in ["spreadsheet", "excel", "openxmlformats-officedocument"]):
-            try:
-                import openpyxl
-                import io
-                wb = openpyxl.load_workbook(io.BytesIO(response.content))
-                result = []
-                for sheet_name in wb.sheetnames:
-                    ws = wb[sheet_name]
-                    result.append(f"--- Sheet: {sheet_name} ---")
-                    for row in ws.iter_rows(values_only=True):
-                        result.append("\t".join([str(c) if c is not None else "" for c in row]))
-                return "\n".join(result)[:15000]
-            except Exception as e:
-                return f"Excel file detected but error reading it: {str(e)}"
-
-        # --- PDF FILES ---
-        if "pdf" in content_type:
-            try:
-                import PyPDF2
-                import io
-                reader = PyPDF2.PdfReader(io.BytesIO(response.content))
-                text = ""
-                for page in reader.pages:
-                    text += page.extract_text() or ""
-                return text[:15000] if text.strip() else "PDF found but could not extract text."
-            except Exception as e:
-                return f"PDF file detected but error reading: {str(e)}"
-
-        # --- IMAGE FILES ---
-        if "image" in content_type:
+        resp = requests.get(url, timeout=30)
+        resp.raise_for_status()
+        ct = resp.headers.get("Content-Type", "")
+
+        if any(t in ct for t in ["text", "json", "csv", "xml", "html"]):
+            return resp.text[:12000]
+
+        if any(t in ct for t in ["spreadsheet", "excel", "openxmlformats"]):
+            import openpyxl, io
+            wb = openpyxl.load_workbook(io.BytesIO(resp.content))
+            lines = []
+            for sn in wb.sheetnames:
+                ws = wb[sn]
+                lines.append(f"--- Sheet: {sn} ---")
+                for row in ws.iter_rows(values_only=True):
+                    lines.append("\t".join(str(c) if c else "" for c in row))
+            return "\n".join(lines)[:12000]
+
+        if "pdf" in ct:
+            import PyPDF2, io
+            reader = PyPDF2.PdfReader(io.BytesIO(resp.content))
+            text = "".join(p.extract_text() or "" for p in reader.pages)
+            return text[:12000] if text.strip() else "PDF: no text extracted."
+
+        if "image" in ct:
             with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f:
-                f.write(response.content)
-                img_path = f.name
-            return f"IMAGE_FILE_SAVED:{img_path}"
+                f.write(resp.content)
+            return f"IMAGE_FILE_SAVED:{f.name}"
 
-        # --- AUDIO FILES ---
-        if any(t in content_type for t in ["audio", "mpeg", "wav", "mp3", "ogg"]):
+        if any(t in ct for t in ["audio", "mpeg", "wav", "mp3", "ogg"]):
             with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as f:
-                f.write(response.content)
-                audio_path = f.name
-            return f"AUDIO_FILE_SAVED:{audio_path}"
+                f.write(resp.content)
+            return f"AUDIO_FILE_SAVED:{f.name}"
 
-        # --- PYTHON FILES ---
-        if "python" in content_type or "x-python" in content_type:
-            return response.text[:15000]
+        if "python" in ct:
+            return resp.text[:12000]
 
-        # --- WORD DOCUMENTS ---
-        if "wordprocessingml" in content_type or "msword" in content_type:
-            try:
-                import docx
-                import io
-                doc = docx.Document(io.BytesIO(response.content))
-                text = "\n".join([p.text for p in doc.paragraphs])
-                return text[:15000] if text.strip() else "Word doc found but no text extracted."
-            except Exception as e:
-                return f"Word document detected but error reading: {str(e)}"
+        if "wordprocessingml" in ct or "msword" in ct:
+            import docx, io
+            doc = docx.Document(io.BytesIO(resp.content))
+            return "\n".join(p.text for p in doc.paragraphs)[:12000]
 
-        # --- FALLBACK ---
         with tempfile.NamedTemporaryFile(delete=False, suffix=".bin") as f:
-            f.write(response.content)
-            return f"File downloaded to {f.name} (type: {content_type}). Size: {len(response.content)} bytes."
+            f.write(resp.content)
+        return f"File saved: {f.name} (type: {ct}, {len(resp.content)} bytes)"
 
     except Exception as e:
-        return f"Error downloading file for task {task_id}: {str(e)}"
+        return f"Error downloading: {e}"
 
 
 @tool
 def describe_image(image_path: str) -> str:
-    """Describes the content of an image file using an AI vision model.
-    Use this when you have an image file path (from IMAGE_FILE_SAVED)
-    and need to understand what the image shows.
+    """Describes an image using a vision model. Use after getting IMAGE_FILE_SAVED.
 
     Args:
-        image_path: The local file path to the image to describe.
+        image_path: Path to the image file.
     """
     try:
         from huggingface_hub import InferenceClient
-
         client = InferenceClient(token=os.getenv("HF_TOKEN"))
-
         with open(image_path, "rb") as f:
-            image_bytes = f.read()
-
-        result = client.image_to_text(
-            image=image_bytes,
-            model="Salesforce/blip2-opt-2.7b",
-        )
-
-        if isinstance(result, str):
-            return f"Image description: {result}"
-        elif hasattr(result, "generated_text"):
-            return f"Image description: {result.generated_text}"
-        else:
-            return f"Image description: {str(result)}"
-
+            result = client.image_to_text(image=f.read(), model="Salesforce/blip2-opt-2.7b")
+        text = result if isinstance(result, str) else getattr(result, "generated_text", str(result))
+        return f"Image: {text}"
     except Exception as e:
-        return f"Could not describe image at {image_path}. Error: {str(e)}"
+        return f"Image error: {e}"
 
 
 @tool
 def transcribe_audio(audio_path: str) -> str:
-    """Transcribes an audio file to text using Whisper speech recognition.
-    Use this when you have an audio file path (from AUDIO_FILE_SAVED).
+    """Transcribes audio to text. Use after getting AUDIO_FILE_SAVED.
 
     Args:
-        audio_path: The local file path to the audio file to transcribe.
+        audio_path: Path to the audio file.
     """
     try:
         from huggingface_hub import InferenceClient
-
         client = InferenceClient(token=os.getenv("HF_TOKEN"))
-
         with open(audio_path, "rb") as f:
-            audio_bytes = f.read()
-
-        result = client.automatic_speech_recognition(
-            audio=audio_bytes,
-            model="openai/whisper-large-v3-turbo",
-        )
-
-        if isinstance(result, str):
-            return f"Audio transcription: {result}"
-        elif hasattr(result, "text"):
-            return f"Audio transcription: {result.text}"
-        elif isinstance(result, dict):
-            return f"Audio transcription: {result.get('text', str(result))}"
-        else:
-            return f"Audio transcription: {str(result)}"
-
+            result = client.automatic_speech_recognition(audio=f.read(), model="openai/whisper-large-v3-turbo")
+        text = result if isinstance(result, str) else getattr(result, "text", str(result))
+        return f"Transcription: {text}"
     except Exception as e:
-        return f"Error transcribing audio at {audio_path}: {str(e)}"
+        return f"Audio error: {e}"
 
 
 @tool
 def read_local_file(file_path: str) -> str:
-    """Reads the content of a local text file and returns it as a string.
+    """Reads a local text file.
 
     Args:
-        file_path: The path to the file to read.
+        file_path: Path to the file.
     """
     try:
         with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
-            return f.read()[:15000]
+            return f.read()[:12000]
     except Exception as e:
-        return f"Error reading file: {str(e)}"
+        return f"Read error: {e}"
 
 
 @tool
 def execute_python_file(file_path: str) -> str:
-    """Executes a Python script file and returns its stdout output.
+    """Runs a Python script and returns output.
 
     Args:
-        file_path: The path to the Python file to execute.
+        file_path: Path to the .py file.
     """
     import subprocess
     try:
-        result = subprocess.run(
-            ["python3", file_path],
-            capture_output=True,
-            text=True,
-            timeout=30,
-        )
-        output = ""
-        if result.stdout:
-            output += result.stdout
-        if result.stderr:
-            output += f"\nSTDERR: {result.stderr}"
-        return output.strip() if output.strip() else "Script executed but produced no output."
+        r = subprocess.run(["python3", file_path], capture_output=True, text=True, timeout=30)
+        out = r.stdout + (f"\nSTDERR: {r.stderr}" if r.stderr else "")
+        return out.strip() or "No output."
     except subprocess.TimeoutExpired:
-        return "Script execution timed out after 30 seconds."
+        return "Timeout after 30s."
     except Exception as e:
-        return f"Error executing Python file: {str(e)}"
+        return f"Exec error: {e}"
 
 
 # =============================================
-# AGENT CLASS
+# AGENT
 # =============================================
 
-CUSTOM_INSTRUCTIONS = """You are a precise AI assistant solving GAIA benchmark questions.
-
-CRITICAL RULES FOR ANSWERING:
-1. Your final answer must be ONLY the answer itself — no explanations, no "The answer is", no extra words.
-2. If the answer is a number, give just the number (e.g., "42").
-3. If the answer is a name, give just the name (e.g., "Paris").
-4. If asked for a comma-separated list, give just the list (e.g., "red, blue, green").
-5. Be precise and factual. Use tools to verify information when needed.
-
-TOOL USAGE RULES:
-6. If a question mentions an attached file, image, audio, spreadsheet, or document, FIRST use download_file_from_api with the task_id.
-7. If download returns "IMAGE_FILE_SAVED:/some/path", then call describe_image with that path.
-8. If download returns "AUDIO_FILE_SAVED:/some/path", then call transcribe_audio with that path.
-9. If the file is a Python script (.py), you can use read_local_file to view it or execute_python_file to run it.
-10. Use DuckDuckGoSearchTool when you need factual information from the internet.
-11. Use visit_webpage to read the full content of a specific URL.
-
-REASONING:
-12. Think step by step but keep your FINAL output as ONLY the answer.
-13. Double-check your answer before giving it.
+# Concise instructions to save tokens
+INSTRUCTIONS = """You solve GAIA benchmark questions precisely.
+
+ANSWER FORMAT:
+- Return ONLY the final answer. No "The answer is", no explanations.
+- Number → just the number (e.g. "42")
+- Name → just the name (e.g. "Paris")  
+- List → comma-separated (e.g. "red, blue, green")
+
+STRATEGY:
+- Keep reasoning SHORT. Think step by step but briefly.
+- Always verify facts with web_search. Don't rely on memory.
+- If the answer isn't found directly, break the problem into parts and reason through them.
+- For counting tasks: gather all items first, then count carefully.
+- If a question mentions a file/attachment, FIRST call download_file_from_api with the task_id.
+- If download returns IMAGE_FILE_SAVED → call describe_image with that path.
+- If download returns AUDIO_FILE_SAVED → call transcribe_audio with that path.
+- For reversed/encoded text, decode it before answering.
+- If a question references a URL, use visit_webpage to read it.
 """
 
 
 class BasicAgent:
-    """Agent using smolagents CodeAgent with HF Inference API."""
-
     def __init__(self):
-        print("Initializing SmolAgent for GAIA benchmark...")
+        print("Initializing agent with Gemini 2.0 Flash...")
 
-        # Use default model -> smolagents auto-select the provider
-        model = LiteLLMModel(
-            model_id="groq/llama-3.3-70b-versatile",
-            api_key=os.getenv("GROQ_API_KEY"),
+        model = OpenAIModel(
+            model_id="gemini-2.0-flash",
+            api_base="https://generativelanguage.googleapis.com/v1beta/openai/",
+            api_key=os.getenv("GEMINI_API_KEY"),
             temperature=0.1,
-            max_tokens=2096,
+            max_tokens=1500,
         )
 
         self.agent = CodeAgent(
@@ -271,223 +196,159 @@ class BasicAgent:
                 read_local_file,
                 execute_python_file,
             ],
-            max_steps=10,
+            max_steps=7,
             verbosity_level=2,
-            instructions=CUSTOM_INSTRUCTIONS,
+            instructions=INSTRUCTIONS,
             additional_authorized_imports=[
                 "json", "re", "math", "datetime", "collections",
                 "csv", "io", "os", "tempfile", "subprocess",
                 "base64", "hashlib", "unicodedata", "string",
             ],
         )
-
-        print("SmolAgent initialized successfully!")
+        print("Agent ready!")
 
     def __call__(self, question: str, task_id: str = None) -> str:
-        print(f"Agent processing: {question[:100]}...")
+        print(f"Processing: {question[:80]}...")
 
         if task_id:
-            prompt = f"""Answer this question. If you need to download an attached file, use download_file_from_api with task_id="{task_id}".
-
-Question: {question}
-
-Remember: respond with ONLY the final answer, nothing else."""
+            prompt = f'If needed, download file with: download_file_from_api("{task_id}")\n\nQuestion: {question}\n\nAnswer with ONLY the final answer.'
         else:
-            prompt = f"""Answer this question precisely.
-
-Question: {question}
-
-Remember: respond with ONLY the final answer, nothing else."""
+            prompt = f"Question: {question}\n\nAnswer with ONLY the final answer."
 
-        # Retry logic: try up to 2 times
         for attempt in range(2):
             try:
                 result = self.agent.run(prompt)
                 answer = str(result).strip()
 
-                # Clean up common LLM prefixes
-                prefixes_to_remove = [
-                    "The answer is ", "The answer is: ",
-                    "Answer: ", "FINAL ANSWER: ",
-                    "Final answer: ", "The final answer is ",
-                    "The final answer is: ", "Result: ",
-                ]
-                for prefix in prefixes_to_remove:
-                    if answer.lower().startswith(prefix.lower()):
-                        answer = answer[len(prefix):].strip()
-
-                # Remove wrapping quotes
-                if len(answer) > 2 and \
-                   ((answer.startswith('"') and answer.endswith('"')) or
-                    (answer.startswith("'") and answer.endswith("'"))):
-                    answer = answer[1:-1].strip()
-
-                # Remove trailing period for short answers
+                # Clean prefixes
+                for p in ["The answer is ", "The answer is: ", "Answer: ",
+                          "FINAL ANSWER: ", "Final answer: ", "The final answer is ",
+                          "The final answer is: ", "Result: "]:
+                    if answer.lower().startswith(p.lower()):
+                        answer = answer[len(p):].strip()
+
+                # Remove quotes
+                if len(answer) > 2 and answer[0] in '"\'':
+                    if answer[-1] == answer[0]:
+                        answer = answer[1:-1].strip()
+
+                # Remove trailing period
                 if answer.endswith(".") and len(answer.split()) <= 5:
                     answer = answer[:-1].strip()
 
-                print(f"Final answer: {answer}")
+                print(f"Answer: {answer}")
                 return answer
 
             except Exception as e:
-                print(f"Agent error (attempt {attempt + 1}): {e}")
+                print(f"Error (attempt {attempt+1}): {e}")
                 if attempt == 0:
-                    print("Retrying in 5 seconds...")
-                    time.sleep(5)
+                    time.sleep(3)
 
         return "Unable to determine the answer."
 
 
 # =============================================
-# SUBMISSION LOGIC
+# SUBMISSION
 # =============================================
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     space_id = os.getenv("SPACE_ID")
 
-    if profile:
-        username = f"{profile.username}"
-        print(f"User logged in: {username}")
-    else:
-        print("User not logged in.")
+    if not profile:
         return "Please Login to Hugging Face with the button.", None
 
+    username = profile.username
+    print(f"User: {username}")
+
     api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
 
     try:
         agent = BasicAgent()
     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(agent_code)
 
-    print(f"Fetching questions from: {questions_url}")
     try:
-        response = requests.get(questions_url, 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 requests.exceptions.RequestException as e:
-        return f"Error fetching questions: {e}", None
+        resp = requests.get(f"{api_url}/questions", timeout=15)
+        resp.raise_for_status()
+        questions = resp.json()
+        if not questions:
+            return "No questions fetched.", None
+        print(f"Fetched {len(questions)} questions.")
     except Exception as e:
-        return f"An unexpected error occurred fetching questions: {e}", None
+        return f"Error fetching questions: {e}", None
 
     results_log = []
-    answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
-    for i, item in enumerate(questions_data):
+    answers = []
+
+    for i, item in enumerate(questions):
         task_id = item.get("task_id")
-        question_text = item.get("question")
-        if not task_id or question_text is None:
+        question = item.get("question")
+        if not task_id or question is None:
             continue
+
         print(f"\n{'='*60}")
-        print(f"  Question {i+1}/{len(questions_data)} — Task: {task_id}")
-        print(f"  Q: {question_text[:120]}...")
+        print(f"  Q {i+1}/{len(questions)} — {task_id}")
+        print(f"  {question[:100]}...")
         print(f"{'='*60}")
+
         try:
-            submitted_answer = agent(question_text, task_id=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, task_id=task_id)
+            answers.append({"task_id": task_id, "submitted_answer": answer})
+            results_log.append({"Task ID": task_id, "Question": question, "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}"
-            })
-
-        # Small delay between questions to avoid rate limiting
-        time.sleep(2)
-
-    if not answers_payload:
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
-
-    submission_data = {
-        "username": username.strip(),
-        "agent_code": agent_code,
-        "answers": answers_payload
-    }
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+            print(f"Error on {task_id}: {e}")
+            results_log.append({"Task ID": task_id, "Question": question, "Submitted Answer": f"ERROR: {e}"})
+
+        time.sleep(1)
+
+    if not answers:
+        return "No answers produced.", pd.DataFrame(results_log)
+
+    submission = {"username": username.strip(), "agent_code": agent_code, "answers": answers}
+
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=120)
-        response.raise_for_status()
-        result_data = response.json()
-        final_status = (
+        resp = requests.post(f"{api_url}/submit", json=submission, timeout=120)
+        resp.raise_for_status()
+        data = resp.json()
+        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"User: {data.get('username')}\n"
+            f"Score: {data.get('score', 'N/A')}% "
+            f"({data.get('correct_count', '?')}/{data.get('total_attempted', '?')} correct)\n"
+            f"Message: {data.get('message', '')}"
         )
-        print("Submission successful.")
-        return final_status, pd.DataFrame(results_log)
+        return status, pd.DataFrame(results_log)
     except requests.exceptions.HTTPError as e:
-        error_detail = f"Server responded with status {e.response.status_code}."
-        try:
-            error_json = e.response.json()
-            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-        except requests.exceptions.JSONDecodeError:
-            error_detail += f" Response: {e.response.text[:500]}"
-        return f"Submission Failed: {error_detail}", pd.DataFrame(results_log)
-    except requests.exceptions.Timeout:
-        return "Submission Failed: The request timed out.", pd.DataFrame(results_log)
-    except requests.exceptions.RequestException as e:
-        return f"Submission Failed: Network error - {e}", pd.DataFrame(results_log)
+        detail = e.response.text[:500] if e.response else str(e)
+        return f"Submission Failed: {detail}", pd.DataFrame(results_log)
     except Exception as e:
-        return f"An unexpected error occurred during submission: {e}", pd.DataFrame(results_log)
+        return f"Submission error: {e}", pd.DataFrame(results_log)
 
 
-# --- Build Gradio Interface ---
+# --- Gradio UI ---
 with gr.Blocks() as demo:
     gr.Markdown("# 🤖 GAIA Agent — Final Assignment")
     gr.Markdown(
         """
-        **Agent**: SmolAgent (CodeAgent) with Qwen2.5-Coder-32B via Nebius (HF Inference)
-
+        **Agent**: CodeAgent with Gemini 2.0 Flash (free)
         **Tools**: Web Search · Webpage Visitor · File Downloader · Image Describer · Audio Transcriber · Python Executor
 
-        **Instructions:**
-        1. Log in to your Hugging Face account using the button below.
-        2. Click 'Run Evaluation & Submit All Answers' to start.
-        3. Wait for the agent to process all 20 questions (this may take several minutes).
+        1. Log in with your HF account
+        2. Click Run to start (takes ~15-20 min)
         """
     )
 
     gr.LoginButton()
     run_button = gr.Button("🚀 Run Evaluation & Submit All Answers")
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    status_output = gr.Textbox(label="Status", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Results", 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)
-    space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID")
-
-    if space_host_startup:
-        print(f"✅ SPACE_HOST found: {space_host_startup}")
-    else:
-        print("ℹ️  SPACE_HOST not found (running locally?).")
-
-    if space_id_startup:
-        print(f"✅ SPACE_ID found: {space_id_startup}")
-    else:
-        print("ℹ️  SPACE_ID not found (running locally?).")
-
-    print("-"*60 + "\n")
-    print("Launching Gradio Interface...")
+    print(f"SPACE_ID: {os.getenv('SPACE_ID', 'not set')}")
+    print("-"*60)
     demo.launch(debug=True, share=False)