initial commit of agent with score of 60

README.md

@@ -102,6 +102,27 @@ AGENT_TIMEOUT=120  # Timeout in seconds for API calls
 AGENT_API_BASE=https://api.groq.com/openai/v1  # For X.AI when using OpenAIServerModel
 ```
 
+### Hugging Face Spaces Setup
+
+When deploying to Hugging Face Spaces, you need to add your API keys as secrets:
+
+1. Go to your Space's Settings → Repository Secrets
+2. Add the following secrets (add at least one of these API keys):
+   - `HUGGINGFACEHUB_API_TOKEN` - Your Hugging Face API token
+   - `OPENAI_API_KEY` - Your OpenAI API key
+   - `XAI_API_KEY` - Your X.AI/Grok API key
+
+3. Add additional configuration secrets as needed:
+   - `AGENT_MODEL_TYPE` - Model type (e.g., "OpenAIServerModel")
+   - `AGENT_MODEL_ID` - Model ID to use (e.g., "gpt-4o")
+   - `AGENT_TEMPERATURE` - Temperature setting (e.g., "0.2")
+   - `AGENT_VERBOSE` - Set to "true" for detailed logging
+
+4. For X.AI's API, also set:
+   - `XAI_API_BASE` - The API base URL
+
+![Hugging Face Secrets Setup](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/spaces/secrets.png)
+
 ## Usage
 
 ### Running the Agent

app.py

@@ -5,6 +5,25 @@ import inspect
 import pandas as pd
 from core_agent import GAIAAgent
 
+# 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"
@@ -15,6 +34,9 @@ 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
@@ -26,58 +48,101 @@ class BasicAgent:
                 print("python-dotenv not installed, continuing with environment as is")
             
             # Try to load API keys from environment
-            api_key = os.getenv("XAI_API_KEY") or os.getenv("OPENAI_API_KEY") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+            # 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 api_key:
-                # Default model parameters
-                model_type = os.getenv("AGENT_MODEL_TYPE", "OpenAIServerModel")
-                model_id = os.getenv("AGENT_MODEL_ID", "gpt-4o")
+            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}")
                 
-                if os.getenv("XAI_API_KEY"):
+                if 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=os.getenv("XAI_API_KEY"),
-                        api_base="https://api.x.ai/v1",  # X.AI's endpoint, not Groq
-                        temperature=0.2,
+                        api_key=xai_key,
+                        api_base=api_base,
+                        temperature=temperature,
                         executor_type="local",
-                        verbose=False
+                        verbose=verbose
                     )
-                    print("Using OpenAIServerModel with X.AI API")
-                elif model_type == "HfApiModel" and os.getenv("HUGGINGFACEHUB_API_TOKEN"):
+                    print(f"Using OpenAIServerModel with X.AI API at {api_base}")
+                elif model_type == "HfApiModel" and hf_token:
                     # Use Hugging Face API
                     self.gaia_agent = GAIAAgent(
                         model_type="HfApiModel",
                         model_id=model_id,
-                        api_key=os.getenv("HUGGINGFACEHUB_API_TOKEN"),
-                        temperature=0.2,
+                        api_key=hf_token,
+                        temperature=temperature,
                         executor_type="local",
-                        verbose=False
+                        verbose=verbose
                     )
                     print(f"Using HfApiModel with model_id: {model_id}")
-                else:
+                elif openai_key:
                     # Default to OpenAI API
-                    self.gaia_agent = GAIAAgent(
-                        model_type="OpenAIServerModel",
-                        model_id=model_id,
-                        api_key=os.getenv("OPENAI_API_KEY"),
-                        temperature=0.2,
-                        executor_type="local",
-                        verbose=False
-                    )
+                    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
+                        )
             else:
-                # No API keys available, use a local model setup with minimal dependencies
-                self.gaia_agent = GAIAAgent(
-                    model_type="HfApiModel",
-                    model_id="gpt2",  # Simple model for basic testing
-                    temperature=0.2,
-                    executor_type="local",
-                    verbose=False
-                )
-                print("Warning: No API keys found. Using a basic local execution setup.")
+                # 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}")
@@ -124,6 +189,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