Updated

app.py

@@ -3,148 +3,32 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-from main_agent import GAIAAgent
+from gemini_agent import GeminiAgent
 
-# Debug function to show available environment variables
-def debug_environment():
-    """Print available environment variables related to API keys (with values hidden)"""
-    debug_vars = [
-        "HF_API_TOKEN", "HUGGINGFACEHUB_API_TOKEN", 
-        "OPENAI_API_KEY", "XAI_API_KEY",
-        "AGENT_MODEL_TYPE", "AGENT_MODEL_ID", 
-        "AGENT_TEMPERATURE", "AGENT_VERBOSE"
-    ]
-    
-    print("=== DEBUG: Environment Variables ===")
-    for var in debug_vars:
-        if os.environ.get(var):
-            # Hide actual values for security
-            print(f"{var}: [SET]")
-        else:
-            print(f"{var}: [NOT SET]")
-    print("===================================")
-
-# (Keep Constants as is)
-# --- Constants ---
+# Constants
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     def __init__(self):
-        print("BasicAgent initialized.")
+        print("Initializing the BasicAgent")
         
-        # Call debug function to show available environment variables
-        debug_environment()
+        # Load environment variables
+        load_dotenv()
         
-        # Initialize the GAIAAgent with local execution
-        try:
-            # Load environment variables if dotenv is available
-            try:
-                import dotenv
-                dotenv.load_dotenv()
-                print("Loaded environment variables from .env file")
-            except ImportError:
-                print("python-dotenv not installed, continuing with environment as is")
-            
-            # Try to load API keys from environment
-            # Check both HF_API_TOKEN and HUGGINGFACEHUB_API_TOKEN (HF Spaces uses HF_API_TOKEN)
-            hf_token = os.environ.get("HF_API_TOKEN") or os.environ.get("HUGGINGFACEHUB_API_TOKEN")
-            openai_key = os.environ.get("OPENAI_API_KEY")
-            xai_key = os.environ.get("XAI_API_KEY")
-            
-            # If we have at least one API key, use a model-based approach
-            if hf_token:
-                # Default model parameters - read directly from environment
-                model_type = os.environ.get("AGENT_MODEL_TYPE", "OpenAIServerModel")
-                model_id = os.environ.get("AGENT_MODEL_ID", "gpt-4o")
-                temperature = float(os.environ.get("AGENT_TEMPERATURE", "0.2"))
-                verbose = os.environ.get("AGENT_VERBOSE", "false").lower() == "true"
-                
-                print(f"Agent config - Model Type: {model_type}, Model ID: {model_id}")
-                
-                try:
-                    if model_type == "HfApiModel" and hf_token:
-                        # Use Hugging Face API
-                        self.gaia_agent = GAIAAgent(
-                            model_type="HfApiModel",
-                            model_id=model_id,
-                            api_key=hf_token,
-                            temperature=temperature,
-                            executor_type="local",
-                            verbose=verbose
-                        )
-                        print(f"Using HfApiModel with model_id: {model_id}")
-                    else:
-                        # Fallback to using whatever token we have
-                        print("WARNING: Using fallback initialization with available token")
-                        if hf_token:
-                            self.gaia_agent = GAIAAgent(
-                                model_type="HfApiModel",
-                                # model_id="mistralai/Mistral-7B-Instruct-v0.2",
-                                model_id="mistralai/Mistral-7B-Instruct-v0.1",
-                                api_key=hf_token,
-                                temperature=temperature,
-                                executor_type="local",
-                                verbose=verbose
-                            )
-                        else:
-                            self.gaia_agent = GAIAAgent(
-                                model_type="OpenAIServerModel",
-                                model_id="grok-3-latest",
-                                api_key=xai_key,
-                                api_base=os.environ.get("XAI_API_BASE", "https://api.x.ai/v1"),
-                                temperature=temperature,
-                                executor_type="local",
-                                verbose=verbose
-                            )
-                except ImportError as ie:
-                    # Handle OpenAI module errors specifically
-                    if "openai" in str(ie).lower() and hf_token:
-                        print(f"OpenAI module error: {ie}. Falling back to HfApiModel.")
-                        self.gaia_agent = GAIAAgent(
-                            model_type="HfApiModel",
-                            # model_id="mistralai/Mistral-7B-Instruct-v0.2",
-                            model_id="mistralai/Mistral-7B-Instruct-v0.1",
-                            api_key=hf_token,
-                            temperature=temperature,
-                            executor_type="local",
-                            verbose=verbose
-                        )
-                        print(f"Using HfApiModel with model_id: mistralai/Mistral-7B-Instruct-v0.2 (fallback)")
-                    else:
-                        raise
-            else:
-                # No API keys available, log the error
-                print("ERROR: No API keys found. Please set at least one of these environment variables:")
-                print("- HUGGINGFACEHUB_API_TOKEN or HF_API_TOKEN")
-                print("- OPENAI_API_KEY")
-                print("- XAI_API_KEY")
-                self.gaia_agent = None
-                print("WARNING: No API keys found. Agent will not be able to answer questions.")
-                
-        except Exception as e:
-            print(f"Error initializing GAIAAgent: {e}")
-            self.gaia_agent = None
-            print("WARNING: Failed to initialize agent. Falling back to basic responses.")
+        # Get Gemini API key
+        api_key = os.getenv('GOOGLE_API_KEY')
+        if not api_key:
+            raise ValueError("GOOGLE_API_KEY environment variable not set.")
             
+        # Initialize GeminiAgent
+        self.agent = GeminiAgent(api_key=api_key)
+        print("GeminiAgent initialized successfully")
+
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        
-        # Check if we have a functioning GAIA agent
-        if self.gaia_agent:
-            try:
-                # Process the question using the GAIA agent
-                answer = self.gaia_agent.answer_question(question)
-                print(f"Agent generated answer: {answer[:50]}..." if len(answer) > 50 else f"Agent generated answer: {answer}")
-                return answer
-            except Exception as e:
-                print(f"Error processing question: {e}")
-                # Fall back to a simple response on error
-                return "An error occurred while processing your question. Please check the agent logs for details."
-        else:
-            # We don't have a valid agent, provide a basic response
-            return "The agent is not properly initialized. Please check your API keys and configuration."
+        final_answer = self.agent.run(question)
+        print(f"Agent returning fixed answer: {final_answer}")
+        return final_answer
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """