Update app.py

app.py

@@ -3,217 +3,25 @@ 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
-)
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, FinalAnswerTool, LiteLLMModel
 
-# 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("===================================")
+
+model = LiteLLMModel(model_id="gemini/gemini-2.0-flash-lite", api_key=os.getenv('GEMINI_API_KEY'))
 
 # (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("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.")
-            
+        self.agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=model)
     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."
+        fixed_answer = self.agent.run(question)
+        print(f"Agent returning fixed answer: {fixed_answer}")
+        return fixed_answer
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -237,12 +45,6 @@ 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