Update app.py

app.py

@@ -23,65 +23,65 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 #         print(f"Agent returning fixed answer: {fixed_answer}")
 #         return fixed_answer
 
-class GeminiModel:
-    def __init__(self, model_name="gemini-2.0-flash-exp"):
-        api_key = os.getenv("GEMINI_API_KEY")
-        if not api_key:
-            raise ValueError("GEMINI_API_KEY is missing.")
-
-        os.environ["GOOGLE_API_KEY"] = api_key
-        self.client = genai.Client()
-        self.model_id = model_name
-
-        self.generation_config = types.GenerateContentConfig(
-            temperature=0.4,
-            top_p=0.9,
-            top_k=40,
-            candidate_count=1,
-            seed=42,
-            presence_penalty=0.0,
-            frequency_penalty=0.0,
-        )
+# class GeminiModel:
+#     def __init__(self, model_name="gemini-2.0-flash-exp"):
+#         api_key = os.getenv("GEMINI_API_KEY")
+#         if not api_key:
+#             raise ValueError("GEMINI_API_KEY is missing.")
+
+#         os.environ["GOOGLE_API_KEY"] = api_key
+#         self.client = genai.Client()
+#         self.model_id = model_name
+
+#         self.generation_config = types.GenerateContentConfig(
+#             temperature=0.4,
+#             top_p=0.9,
+#             top_k=40,
+#             candidate_count=1,
+#             seed=42,
+#             presence_penalty=0.0,
+#             frequency_penalty=0.0,
+#         )
 
-    def __call__(self, prompt: str, **kwargs) -> str:
-        """Send prompt to Gemini."""
-        try:
-            response = self.client.generate_content(
-                model=self.model_id,
-                contents=[{"role": "user", "parts": [{"text": prompt}]}],
-                generation_config=self.generation_config
-            )
-            # Return a dictionary that CodeAgent expects
-            return {"content": response.candidates[0].content.parts[0].text.strip()}
-        except Exception as e:
-            return {"content": f"Error during Gemini call: {str(e)}"}
+#     def __call__(self, prompt: str, **kwargs) -> str:
+#         """Send prompt to Gemini."""
+#         try:
+#             response = self.client.generate_content(
+#                 model=self.model_id,
+#                 contents=[{"role": "user", "parts": [{"text": prompt}]}],
+#                 generation_config=self.generation_config
+#             )
+#             # Return a dictionary that CodeAgent expects
+#             return {"content": response.candidates[0].content.parts[0].text.strip()}
+#         except Exception as e:
+#             return {"content": f"Error during Gemini call: {str(e)}"}
 
-# Define BasicAgent properly
-class BasicAgent:
-    def __init__(self):
-        print("Initializing CodeAgent with Gemini + tools.")
+# # Define BasicAgent properly
+# class BasicAgent:
+#     def __init__(self):
+#         print("Initializing CodeAgent with Gemini + tools.")
 
-        # Load tools
-        self.search_tool = DuckDuckGoSearchTool()
+#         # Load tools
+#         self.search_tool = DuckDuckGoSearchTool()
 
-        # Build the agent
-        self.agent = CodeAgent(
-            tools=[self.search_tool],
-            model=GeminiModel(),  # Our simple Gemini wrapper
-            planning_interval=3  # Activate planning
-        )
-
-    def __call__(self, question: str) -> str:
-        """Call the CodeAgent."""
-        print(f"Running agent for task: {question[:50]}...")
-        try:
-            result = self.agent.run(question)
+#         # Build the agent
+#         self.agent = CodeAgent(
+#             tools=[self.search_tool],
+#             model=GeminiModel(),  # Our simple Gemini wrapper
+#             planning_interval=3  # Activate planning
+#         )
 
-            # Sleep to respect rate limits
-            time.sleep(7)
-            return result
-        except Exception as e:
-            return f"Error running agent: {str(e)}"
+#     def __call__(self, question: str) -> str:
+#         """Call the CodeAgent."""
+#         print(f"Running agent for task: {question[:50]}...")
+#         try:
+#             result = self.agent.run(question)
+
+#             # Sleep to respect rate limits
+#             time.sleep(7)
+#             return result
+#         except Exception as e:
+#             return f"Error running agent: {str(e)}"
             
 # class BasicAgent(ReActAgent):
 #     def __init__(self):
@@ -151,6 +151,70 @@ class BasicAgent:
 #             return decoded.split("Answer:")[-1].strip()
 #         return decoded.strip()
 
+
+
+# Setup Gemini Client
+api_key = os.getenv("GEMINI_API_KEY")
+if not api_key:
+    raise ValueError("GEMINI_API_KEY is missing.")
+os.environ["GOOGLE_API_KEY"] = api_key
+client = genai.Client()
+model_id = "gemini-2.0-flash-exp"
+
+generation_config = types.GenerateContentConfig(
+    temperature=0.4,
+    top_p=0.9,
+    top_k=40,
+    candidate_count=1,
+    seed=42,
+    presence_penalty=0.0,
+    frequency_penalty=0.0,
+)
+
+# Define the real agent
+class BasicAgent:
+    def __init__(self):
+        print("Initializing BasicAgent with direct Gemini calls + DuckDuckGo tool.")
+
+        self.search_tool = DuckDuckGoSearchTool()
+
+        # Dummy model placeholder, not used
+        self.agent = CodeAgent(
+            tools=[self.search_tool],
+            model=self,  # Pass self as the model
+            planning_interval=3
+        )
+
+    def __call__(self, prompt: str, **kwargs) -> object:
+        """Directly call Gemini API for each prompt."""
+        try:
+            response = client.generate_content(
+                model=model_id,
+                contents=[{"role": "user", "parts": [{"text": prompt}]}],
+                generation_config=generation_config
+            )
+            answer = response.candidates[0].content.parts[0].text.strip()
+            # Wrap in a simple object with .content attribute
+            class Output:
+                def __init__(self, content):
+                    self.content = content
+            return Output(content=answer)
+        except Exception as e:
+            class Output:
+                def __init__(self, content):
+                    self.content = content
+            return Output(content=f"Error: {str(e)}")
+
+    def run_agent(self, question: str) -> str:
+        """Run the agent on a question."""
+        print(f"Running agent for task: {question[:50]}...")
+        try:
+            result = self.agent.run(question)
+            time.sleep(7)  # Respect rate limits
+            return result
+        except Exception as e:
+            return f"Error running agent: {str(e)}"
+
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,