Update app.py

app.py

@@ -38,87 +38,74 @@ def file_reader(file_path: str) -> str:
     except Exception as e:
         return f"Error reading or processing file '{file_path}': {e}"
 
-# --- Agent Class (Now using a free Open-Source LLM) ---
+# --- Agent Class ---
 class GaiaSmolAgent:
     def __init__(self):
-        #print("Initializing GaiaSmolAgent with a free Open-Source LLM via Groq...")
+        """
+        Initializes the optimized agent.
+        Optimization 1: Use a faster LLM (Gemini 1.5 Flash) to reduce latency.
+        Optimization 2: Use a single, powerful agent with a detailed system prompt
+                        to eliminate the slow two-step (plan -> execute) process.
+        """
+        print("Initializing Optimized GaiaSmolAgent...")
         api_key = os.getenv("GEMINI_API_KEY")
         if not api_key:
             raise ValueError("API key 'GEMINI_API_KEY' not found in environment secrets.")
 
-        #model = InferenceClientModel(model_id="Qwen/Qwen2.5-Coder-32B-Instruct", provider="together")
-
-
-        self.planner_model = LiteLLMModel(
-            #model_id="groq/llama3-8b-8192",
-            model_id="gemini/gemini-1.5-pro-latest", 
+        # Use a faster, more cost-effective model optimized for speed.
+        model = LiteLLMModel(
+            model_id="gemini/gemini-1.5-flash-latest",
             api_key=api_key,
             temperature=0.0,
+            timeout=120.0, # Add a timeout to prevent hanging
         )
 
-        # Initialize the agent with the tools it can use.
-        self.executor_agent = CodeAgent(
-            model=self.planner_model,
-            tools=[file_reader, DuckDuckGoSearchTool()],
-            add_base_tools=True, # Provides a python interpreter
-        )
-        print("GaiaSmolAgent initialized successfully.")
-
-    def _generate_script(self, question: str) -> str:
-        """Generates a self-contained Python script to answer the question."""
-        print(f"Generating script for question: {question[:100]}...")
-        
-        prompt = f"""
-        You are an expert Python programmer. Your task is to write a single, self-contained Python script to answer the user's question.
+        # A more sophisticated system prompt to guide the agent's reasoning.
+        # This improves its ability to handle complex GAIA questions.
+        system_prompt = """
+        You are an expert-level research assistant AI. Your sole purpose is to answer the user's question by breaking it down into logical steps and using the provided tools.
 
-        You have access to the following functions which are pre-imported and ready to use:
-        - `duck_duck_go_search(query: str) -> str`: Searches the web and returns a string with the results.
-        - `file_reader(file_path: str) -> str`: Reads a file and returns its contents as a string.
+        **Available Tools:**
+        - `duck_duck_go_search(query: str) -> str`: Use this to find information, file URLs, or anything on the web.
+        - `file_reader(file_path: str) -> str`: Use this to read the contents of a file from a local path or a web URL.
 
-        CRITICAL INSTRUCTIONS:
-        1.  Your output must be ONLY the Python code for the script. Do not add any explanation or markdown formatting like ```python.
-        2.  The script MUST end with a call to a function `final_answer(answer: str)`.
-        3.  The `answer` passed to `final_answer` must be a single, concise string.
-        4.  All logic, including processing the string outputs from the tools, must be included in this single script. State is preserved within the script.
+        **Your Thought Process:**
+        1.  **Deconstruct the Goal:** Carefully analyze the question to understand what information is needed.
+        2.  **Formulate a Plan:** Think step-by-step about which tools to use in what order. For example, you might need to search for a URL first, then read the content of that URL.
+        3.  **Execute & Analyze:** Call the necessary tools. Carefully examine the output of each tool to extract the required facts. You can write Python code to process the data returned by the tools.
+        4.  **Synthesize the Answer:** Once you have gathered sufficient information, formulate a final, concise answer to the original question.
 
-        Question: "{question}"
-
-        Example for "What is the capital of France?":
-        search_result = duck_duck_go_search("capital of France")
-        # In a real scenario, you would parse this string to find the answer.
-        # For this example, we'll just summarize the string.
-        answer = "Based on the search, the capital is likely Paris." # Replace with actual logic
-        final_answer(answer)
-        
-        Now, write the Python script to answer the user's question.
+        **CRITICAL INSTRUCTIONS:**
+        - Your final action MUST be a single call to the `final_answer(answer: str)` function.
+        - The `answer` argument must be a string containing only the definitive answer.
+        - All code you write is executed in a restricted Python environment. You can define variables and write logic to process the tool outputs before calling `final_answer`.
+        - Do not ask for clarification. Directly proceed to solve the problem.
         """
-        messages = [{"role": "user", "content": [{"type": "text", "text": prompt}]}]
-        response_object = self.planner_model.generate(messages)
-        
-        # --- THIS IS THE FIX ---
-        # The response is an object, not a string. We need to access its .content attribute.
-        response_content = response_object.content
-        
-        if "```python" in response_content:
-            response_content = response_content.split("```python")[1].split("```")[0].strip()
-        
-        print(f"--- Generated Script ---\n{response_content}\n------------------------")
-        return response_content
+
+        # Initialize a single, powerful agent instead of a planner/executor pair.
+        self.agent = CodeAgent(
+            model=model,
+            tools=[file_reader, DuckDuckGoSearchTool()],
+            system_prompt=system_prompt,
+            add_base_tools=True,  # Provides the python interpreter and the final_answer function
+        )
+        print("Optimized GaiaSmolAgent initialized successfully.")
 
     def __call__(self, question: str) -> str:
-        """Generates and executes a single script to answer the question."""
-        print(f"Agent received question: {question[:100]}...")
-        
+        """
+        Directly runs the agent to generate and execute a plan to answer the question.
+        This simplified single-call approach is faster and more efficient.
+        """
+        print(f"Optimized Agent received question: {question[:100]}...")
         try:
-            script_to_execute = self._generate_script(question)
-            final_answer = self.executor_agent.run(script_to_execute)
-
+            # The agent now internally handles the reasoning, code generation, and execution in one step.
+            final_answer = self.agent.run(question)
         except Exception as e:
             print(f"FATAL AGENT ERROR: An exception occurred during agent execution: {e}")
-            print(traceback.format_exc()) # Print the full traceback for debugging
+            print(traceback.format_exc()) # Print full traceback for easier debugging
             return f"FATAL AGENT ERROR: {e}"
 
-        print(f"Agent returning final answer: {final_answer}")
+        print(f"Optimized Agent returning final answer: {final_answer}")
         return str(final_answer)
 
 # --- Main Application Logic (Unchanged) ---