Update app.py

app.py

@@ -19,31 +19,30 @@ except ImportError:
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+CURRENT_PROMPT = """You are a helpful assistant that can search the web and execute Python code to answer questions.
+
+Question: {question}
+
+To answer this question:
+1. If you need current information or facts you're unsure about, use the search tool first
+2. Write Python code to solve the problem
+3. Make sure your final answer is clear and direct
+
+Available tools:
+- web_search(query): Search the web for information
+- All standard Python libraries
+
+Please provide a complete solution that ends with the final answer."""
+
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     """
-    Simple agent using smolagents CodeAgent with DuckDuckGoSearchTool.
-    
-    Based on Unit 2 course content:
-    - Uses CodeAgent from smolagents (writes Python code to solve problems)
-    - Has access to DuckDuckGoSearchTool for web search
-    - Follows ReAct pattern automatically within CodeAgent
-    
-    How ReAct works in smolagents:
-    1. CodeAgent receives a question
-    2. INTERNAL LOOP (hidden from us):
-       - Think: LLM reasons about what to do next
-       - Act: LLM writes Python code (may call tools like DuckDuckGoSearchTool)
-       - Observe: LLM sees the code execution results
-       - Repeat: If not satisfied, continues the loop (up to max_steps)
-    3. Returns final answer when LLM decides it's complete
-    
-    The while loop is built into CodeAgent - we just call agent.run(question)!
+    Basic agent using smolagents CodeAgent with DuckDuckGoSearchTool.
     """
     
     def __init__(self):
-        print("SimpleCodeAgent initialized.")
+        print("BasicAgent initialized.")
 
         # Check GPU availability
         print(f"🔍 GPU Check:")
@@ -54,80 +53,95 @@ class BasicAgent:
             print(f"   - Device name: {torch.cuda.get_device_name()}")
             print(f"   - Device memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
         else:
-            print("   - No CUDA devices found -- must research this more !!")
-        
+            print("   - No CUDA devices found, will use CPU")
+
         if SMOLAGENTS_AVAILABLE:
             try:
-                # Initialize the model (from Unit 2)
+                # Initialize the model
+                print("🤖 Initializing TransformersModel...")
                 self.model = TransformersModel(
                     model_id="google/gemma-3-4b-it",
-                    torch_dtype=torch.float16,
-                    device_map="auto",
-                    trust_remote_code=True,
+                    torch_dtype=torch.bfloat16,
+                    device_map="auto"
                 )
+
+                # Verify where model actually loaded
+                if hasattr(self.model, 'device'):
+                    print(f"✅ Model loaded on device: {self.model.device}")
+                elif hasattr(self.model, 'model') and hasattr(self.model.model, 'device'):
+                    print(f"✅ Model loaded on device: {self.model.model.device}")
+                else:
+                    print("✅ Model loaded (device info not directly accessible)")
+
+                # Initialize the search tool
+                self.search_tool = DuckDuckGoSearchTool()
                 
-                # Create CodeAgent with DuckDuckGoSearchTool (core Unit 2 concept)
+                # Create CodeAgent with DuckDuckGoSearchTool and additional imports
                 self.agent = CodeAgent(
-                    tools=[DuckDuckGoSearchTool()],
+                    tools=[self.search_tool],
                     model=self.model,
                     additional_authorized_imports=[
                         'math', 'statistics', 're',  # Basic computation
                         'requests', 'json',           # Web requests and JSON
-                        'pandas', 'numpy',            # Data analysis  
+                        'pandas', 'numpy',            # Data analysis
                         'zipfile', 'os',              # File processing
                         'datetime', 'time'            # Date/time operations
                     ]
                 )
-                
-                self.available = True
-                print("✅ Smolagents CodeAgent initialized successfully")
-                
+
+                self.tools_available = True
+                print("✅ Smolagents CodeAgent initialized with DuckDuckGoSearchTool")
+
             except Exception as e:
                 print(f"⚠️ Error initializing smolagents: {e}")
-                self.available = False
+                import traceback
+                traceback.print_exc()
+                self.tools_available = False
         else:
-            self.available = False
-    
-    def __call__(self, question: str) -> str:
-        """
-        Main agent execution - just pass the question to CodeAgent.
-        The CodeAgent will Think-Act-Observe automatically and format the answer properly.
-        """
-        print(f"Agent processing: {question[:80]}...")
-        
-        if not self.available:
-            return self._fallback_response(question)
-        
-        try:
-            # Let the CodeAgent handle everything with ReAct pattern
-            # We'll include formatting instructions in our prompt
-            formatted_question = f"""Please answer this question with just the direct answer needed (no prefixes like "The answer is"):
+            self.tools_available = False
 
-{question}
+        if not self.tools_available:
+            print("⚠️ Using fallback implementation without smolagents")
 
-Important: 
-- For numbers, provide just the number
-- For names/words, provide just the name/word  
-- For yes/no questions, answer just "Yes" or "No"
-- Use web search when you need current information
-- Write Python code for calculations or data processing"""
+    def _run_smolagents(self, question):
+        """Run question through smolagents CodeAgent with enhanced prompting."""
+        try:
+            # Use the global CURRENT_PROMPT variable
+            formatted_question = CURRENT_PROMPT.format(question=question)
 
-            result = self.agent.run(formatted_question)
+            print(f"🔄 Processing question: {question}")
+            print(f"🔧 Available tools: {[tool.__class__.__name__ for tool in self.agent.tools]}")
             
-            final_answer = str(result).strip()
-            print(f"Agent answer: {final_answer}")
-            return final_answer
+            # Run the agent
+            result = self.agent.run(formatted_question)
             
+            print(f"Raw result: {result}")
+
+            # Clean up the result (remove any remaining prefixes)
+            if isinstance(result, str):
+                result = result.strip()
+                # Remove common prefixes
+                prefixes_to_remove = ["The answer is ", "Answer: ", "Final answer: "]
+                for prefix in prefixes_to_remove:
+                    if result.startswith(prefix):
+                        result = result[len(prefix):].strip()
+
+            return result
+
         except Exception as e:
-            print(f"Agent error: {e}")
-            return "Unable to process question"
-    
-    def _fallback_response(self, question: str) -> str:
-        """
-        Fallback if smolagents is not available.
-        """
-        print("Smolagents not available - using basic fallback")
-        return "Smolagents required but not available"
+            import traceback
+            return f"Agent error: {e}\n{traceback.format_exc()}"
+
+    def _fallback_implementation(self, question):
+        """Fallback when smolagents is not available."""
+        return f"Smolagents not available. Question received: {question}"
+
+    def __call__(self, question):
+        """Process a question using the smolagents CodeAgent or fallback."""
+        if self.tools_available:
+            return self._run_smolagents(question)
+        else:
+            return self._fallback_implementation(question)
 
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):