Update app.py

app.py

@@ -3,6 +3,9 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+import json
+import re
+from typing import Dict, Any
 from dotenv import load_dotenv
 from openai import OpenAI
 from tenacity import retry, stop_after_attempt, wait_exponential
@@ -13,7 +16,9 @@ load_dotenv()
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-OPENAI_MODEL = "openai/gpt-4.1-nano"  # or "gpt-3.5-turbo" based on your preference
+OPENAI_MODEL = (
+    "gpt-4-turbo-preview"  # Using OpenAI's latest model for better performance
+)
 
 
 # --- Basic Agent Definition ---
@@ -22,32 +27,39 @@ class BasicAgent:
     def __init__(self):
         """Initialize the agent with OpenAI client and setup."""
         print("BasicAgent initializing...")
-        self.client = OpenAI(api_key="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",base_url="https://models.github.ai/inference")
+        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        self.question_history: Dict[str, Any] = {}  # Store question context
         print("BasicAgent initialized successfully.")
 
+    def _format_answer(self, raw_answer: str) -> str:
+        """Format the answer to improve exact matching success."""
+        # Remove any explanations or reasoning
+        if "Answer:" in raw_answer:
+            answer = raw_answer.split("Answer:")[-1].strip()
+        elif "Final answer:" in raw_answer:
+            answer = raw_answer.split("Final answer:")[-1].strip()
+        else:
+            answer = raw_answer.strip()
+
+        # Clean up formatting
+        answer = re.sub(
+            r"\s+", " ", answer
+        )  # Replace multiple spaces with single space
+        answer = answer.strip("\"'")  # Remove quotes
+        answer = answer.strip(".")  # Remove trailing periods
+
+        return answer.strip()
+
     @retry(
         stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10)
     )
-    def _get_completion(self, prompt: str) -> str:
+    def _get_completion(self, messages: list) -> str:
         """Get completion from OpenAI with retry logic."""
         try:
             response = self.client.chat.completions.create(
                 model=OPENAI_MODEL,
-                messages=[
-                    {
-                        "role": "system",
-                        "content": """You are a helpful AI assistant designed to answer questions from the GAIA benchmark. 
-                     Follow these guidelines:
-                     1. Provide clear, concise, and accurate answers
-                     2. If a question requires specific steps or calculations, show them clearly
-                     3. Format your response in a clean, readable way
-                     4. Be precise and avoid ambiguity
-                     5. If you're not completely sure about an answer, state your confidence level
-                     Remember: Your answers will be evaluated through exact matching.""",
-                    },
-                    {"role": "user", "content": prompt},
-                ],
-                temperature=0.2,  # Lower temperature for more consistent outputs
+                messages=messages,
+                temperature=0.1,  # Lower temperature for more consistent outputs
                 max_tokens=1000,
             )
             return response.choices[0].message.content.strip()
@@ -55,37 +67,70 @@ class BasicAgent:
             print(f"Error in OpenAI API call: {e}")
             raise
 
-    def _preprocess_question(self, question: str) -> str:
-        """Preprocess the question to enhance clarity and context."""
-        enhanced_prompt = f"""Please analyze and answer the following question from the GAIA benchmark.
-        Question: {question}
+    def _analyze_question(self, question: str) -> dict:
+        """Analyze the question to determine its type and required approach."""
+        system_msg = """You are an expert at analyzing questions. For the given question:
+1. Identify the question type (e.g., factual, calculation, reasoning)
+2. Identify key entities and concepts
+3. Determine if external knowledge is needed
+4. Suggest the best approach to answer it
+Provide your analysis in JSON format."""
 
-        Provide a clear, specific answer that can be evaluated through exact matching.
-        If the question requires multiple steps, please show your reasoning but ensure the final answer is clearly stated.
-        """
-        return enhanced_prompt
+        messages = [
+            {"role": "system", "content": system_msg},
+            {"role": "user", "content": f"Analyze this question: {question}"},
+        ]
+
+        try:
+            analysis = self._get_completion(messages)
+            return json.loads(analysis)
+        except:
+            return {"type": "unknown", "approach": "direct"}
+
+    def _get_answer(self, question: str, analysis: dict) -> str:
+        """Get the answer based on question analysis."""
+        system_prompt = f"""You are an AI assistant specialized in answering GAIA benchmark questions.
+Your task is to provide EXACT, PRECISE answers that can be matched against a ground truth.
+
+Guidelines:
+1. Provide ONLY the final answer, no explanations
+2. Be extremely precise and consistent in formatting
+3. For numerical answers, use digits (e.g., "42" not "forty-two")
+4. For lists, use comma-separated values without spaces after commas
+5. For yes/no questions, answer only with "Yes" or "No"
+6. Remove any punctuation from the end of your answer
+7. Keep your answer as concise as possible while being complete
+
+Question type: {analysis.get('type', 'unknown')}
+Approach: {analysis.get('approach', 'direct')}
+
+Remember: Your answer will be compared EXACTLY with the ground truth. Format matters!"""
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": question},
+        ]
+
+        raw_answer = self._get_completion(messages)
+        return self._format_answer(raw_answer)
 
     def __call__(self, question: str) -> str:
         """Process the question and return an answer."""
         print(f"Agent received question (first 50 chars): {question[:50]}...")
 
         try:
-            # Preprocess the question
-            enhanced_prompt = self._preprocess_question(question)
-
-            # Get completion from OpenAI
-            response = self._get_completion(enhanced_prompt)
+            # Analyze the question
+            analysis = self._analyze_question(question)
+            print(f"Question analysis: {json.dumps(analysis, indent=2)}")
 
-            # Extract the final answer
-            # If the response contains multiple lines or explanations,
-            # we'll try to extract just the final answer
-            answer_lines = response.strip().split("\n")
-            final_answer = answer_lines[-1].strip()
+            # Get and format the answer
+            answer = self._get_answer(question, analysis)
+            print(f"Generated answer: {answer}")
 
-            # Log the response for debugging
-            print(f"Agent generated answer: {final_answer[:100]}...")
+            # Store question context
+            self.question_history[question] = {"analysis": analysis, "answer": answer}
 
-            return final_answer
+            return answer
 
         except Exception as e:
             print(f"Error processing question: {e}")