updated

app.py

@@ -3,35 +3,146 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from core_agent import GAIAAgent
 
-from typing import Optional, Dict
-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 ---
 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("Initializing the BasicAgent")
-              
-        # Get Gemini API key
-        api_key = os.getenv('GOOGLE_API_KEY')
-        if not api_key:
-            raise ValueError("GOOGLE_API_KEY environment variable not set.")
+        print("BasicAgent initialized.")
+        
+        # Call debug function to show available environment variables
+        debug_environment()
+        
+        # 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",
+                                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",
+                            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.")
             
-        # 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]}...")
-        final_answer = self.agent.run(question)
-        print(f"Agent returning fixed answer: {final_answer}")
-        return final_answer
+        
+        # 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."
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -55,6 +166,12 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
         agent = BasicAgent()
+        
+        # Check if agent is properly initialized
+        if not agent.gaia_agent:
+            print("ERROR: Agent was not properly initialized")
+            return "ERROR: Agent was not properly initialized. Check the logs for details on missing API keys or configuration.", None
+        
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None