Create app.py

app.py

@@ -3,6 +3,34 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from core_agent import GAIAAgent
+from smolagents import (
+    CodeAgent, 
+    DuckDuckGoSearchTool,
+    TransformersModel,
+    OpenAIServerModel,
+    PythonInterpreterTool,
+    tool
+)
+
+# 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 ---
@@ -13,11 +41,179 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 class BasicAgent:
     def __init__(self):
         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 or openai_key or xai_key:
+                # 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 == "GeminiModel":
+                        gemini_api_key = os.environ.get("GEMINI_API_KEY")
+                        if not gemini_api_key:
+                            raise ValueError("No Gemini API key provided. Please set GEMINI_API_KEY environment variable.")
+                        self.gaia_agent = GAIAAgent(
+                            model_type="GeminiModel",
+                            model_id=model_id,
+                            api_key=gemini_api_key,
+                            temperature=temperature,
+                            executor_type="local",
+                            verbose=verbose
+                        )
+                        print("Using Google Gemini model")
+                    elif xai_key:
+                        # Use X.AI API with OpenAIServerModel
+                        api_base = os.environ.get("XAI_API_BASE", "https://api.x.ai/v1")
+                        self.gaia_agent = GAIAAgent(
+                            model_type="OpenAIServerModel",
+                            model_id="grok-3-latest",  # X.AI's model
+                            api_key=xai_key,
+                            api_base=api_base,
+                            temperature=temperature,
+                            executor_type="local",
+                            verbose=verbose
+                        )
+                        print(f"Using OpenAIServerModel with X.AI API at {api_base}")
+                    elif model_type == "TransformersModel":
+                        # Use local transformers model
+                        print(f"Loading local model: {model_id}")
+                        self.gaia_agent = GAIAAgent(
+                            model_type="TransformersModel",
+                            model_id=model_id,
+                            temperature=temperature,
+                            executor_type="local",
+                            verbose=verbose
+                        )
+                        print(f"Using TransformersModel with model_id: {model_id}")
+                    elif 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}")
+                    elif openai_key:
+                        # Default to OpenAI API
+                        api_base = os.environ.get("AGENT_API_BASE")
+                        kwargs = {
+                            "model_type": "OpenAIServerModel",
+                            "model_id": model_id,
+                            "api_key": openai_key,
+                            "temperature": temperature,
+                            "executor_type": "local",
+                            "verbose": verbose
+                        }
+                        if api_base:
+                            kwargs["api_base"] = api_base
+                            print(f"Using custom API base: {api_base}")
+                        
+                        self.gaia_agent = GAIAAgent(**kwargs)
+                        print(f"Using OpenAIServerModel 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
+                            )
+                        elif openai_key:
+                            self.gaia_agent = GAIAAgent(
+                                model_type="OpenAIServerModel",
+                                model_id="gpt-3.5-turbo",
+                                api_key=openai_key,
+                                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.")
+            
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_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):
     """
@@ -41,6 +237,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
@@ -146,11 +348,9 @@ with gr.Blocks() as demo:
     gr.Markdown(
         """
         **Instructions:**
-
         1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
         2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
         3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-
         ---
         **Disclaimers:**
         Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).