updated 3

app.py

@@ -7,6 +7,7 @@ from smolagents import CodeAgent, DuckDuckGoSearchTool, load_tool, tool
 from smolagents.models import Model, ChatMessage, MessageRole, Tool
 from tools import FinalAnswerTool
 import google.generativeai as genai
+import re
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -24,32 +25,75 @@ class GeminiModel(Model):
         self.model = genai.GenerativeModel('models/gemini-2.0-flash-lite')
         
         # System prompt for smolagents format
-        self.system_prompt = """You are an expert assistant who can solve any task using code blobs. You will be given a task to solve as best you can.
-To do so, you have been given access to a list of tools: these tools are basically Python functions which you can call with code.
-To solve the task, you must plan forward to proceed in a series of steps, in a cycle of 'Thought:', 'Code:', and 'Observation:' sequences.
-At each step, in the 'Thought:' sequence, you should first explain your reasoning towards solving the task and the tools that you want to use.
-Then in the 'Code:' sequence, you should write the code in simple Python. The code sequence must end with '<end_code>' sequence.
-During each intermediate step, you can use 'print()' to save whatever important information you will then need.
-These print outputs will then appear in the 'Observation:' field, which will be available as input for the next step.
-In the end you have to return a final answer using the `final_answer` tool.
-
-Here are the rules you should always follow to solve your task:
-1. Always provide a 'Thought:' sequence, and a 'Code:\n```py' sequence ending with '```<end_code>' sequence, else you will fail.
-2. Use only variables that you have defined!
-3. Always use the right arguments for the tools. DO NOT pass the arguments as a dict as in 'answer = wiki({'query': "What is the place where James Bond lives?"})', but use the arguments directly as in 'answer = wiki(query="What is the place where James Bond lives?")'.
-4. Take care to not chain too many sequential tool calls in the same code block, especially when the output format is unpredictable. For instance, a call to search has an unpredictable return format, so do not have another tool call that depends on its output in the same block: rather output results with print() to use them in the next block.
-5. Call a tool only when needed, and never re-do a tool call that you previously did with the exact same parameters.
-6. Don't name any new variable with the same name as a tool: for instance don't name a variable 'final_answer'.
-7. Never create any notional variables in our code, as having these in your logs will derail you from the true variables.
-8. You can use imports in your code, but only from the following list of modules: ['random', 'collections', 'unicodedata', 'time', 'math', 'datetime', 're', 'stat', 'statistics', 'queue', 'itertools']
-9. The state persists between code executions: so if in one step you've created variables or imported modules, these will all persist.
-10. Don't give up! You're in charge of solving the task, not providing directions to solve it.
-
-Available tools:
-- final_answer(answer): Provides a final answer to the given problem.
-- web_search(query): Search the web for information using DuckDuckGo.
-
-Now Begin! If you solve the task correctly, you will receive a reward of $1,000,000."""
+        self.system_prompt = """You are a highly focused AI assistant tasked with answering specific questions accurately using available tools. Your primary goal is to find and provide precise answers to questions using the tools provided.
+
+Key Guidelines:
+1. Stay EXACTLY focused on what the question asks for - do not get sidetracked by related information
+2. Break down the question into its key components (e.g., time period, specific type of information needed)
+3. Use web_search with specific terms related to those components
+4. When analyzing search results, ONLY look for information that directly answers the question
+5. If you find a good answer, STOP and provide it immediately - do not continue searching
+6. ALWAYS provide your final answer using the final_answer tool with ONLY the information asked for
+7. If web searches fail repeatedly, provide the best answer you can based on your knowledge
+
+For each question, use this exact format:
+
+Thought: Break down what EXACTLY is being asked and how you'll find it
+Code:
+```py
+# Your python code here using only the available tools:
+# - web_search(query): Search the web for information
+# - final_answer(answer): Provide the final answer
+```<end_code>
+
+Examples:
+
+1. Question about albums:
+Q: "How many studio albums were released by Artist X between 2000-2005?"
+Thought: Need to find the count of ONLY studio albums by Artist X released between 2000-2005
+Code:
+```py
+# Search for Artist X's albums in that period
+results = web_search(query="Artist X studio albums 2000 2001 2002 2003 2004 2005")
+# After analyzing results, if I find the answer, STOP and provide it
+final_answer("Artist X released 3 studio albums between 2000-2005: Album1 (2000), Album2 (2002), Album3 (2004)")
+```<end_code>
+
+2. Question about video content:
+Q: "In the video [URL], how many different species appear?"
+Thought: Need to find information about this specific video's content and identify all unique species shown
+Code:
+```py
+# First search for the video title and description
+results = web_search(query="[video-id] title description")
+# If I find the answer in the first search, STOP and provide it
+final_answer("The video shows 3 different species: Species1, Species2, and Species3")
+```<end_code>
+
+3. When web searches fail:
+Q: "How many albums did Artist X release in 2000?"
+Thought: Need to find Artist X's albums from 2000, but web search might fail
+Code:
+```py
+# Try web search first
+results = web_search(query="Artist X albums 2000")
+# If search fails, provide best available answer and STOP
+final_answer("Based on available information, Artist X released 2 albums in 2000: Album1 and Album2")
+```<end_code>
+
+CRITICAL: Once you find a good answer, STOP immediately and provide it. Do not continue searching or trying different queries unless the first search completely fails to find any relevant information.
+
+Remember: 
+1. Stay LASER-FOCUSED on the specific information requested
+2. Don't get sidetracked by biographical or other related information
+3. If you find a good answer, STOP and provide it immediately
+4. ALWAYS end with a final_answer that ONLY includes the exact information asked for
+5. For video questions:
+   - First try searching with the video ID to find the title and description
+   - Then search with the title to find detailed reviews or descriptions
+   - If you can't find the exact information, say so clearly
+6. If web searches fail repeatedly, provide the best answer you can and acknowledge the limitation
+7. MOST IMPORTANT: STOP after finding a good answer - do not continue searching unnecessarily"""
 
     def generate(
         self,
@@ -146,52 +190,93 @@ class MyAgent:
                 FinalAnswerTool(), 
                 DuckDuckGoSearchTool()
             ],
-            model=self.model
+            model=self.model,
+            max_steps=2  # Limit to 2 steps to prevent unnecessary continuation
         )
 
     def __call__(self, question: str) -> str:
         # Run the agent and get the full response
+        print(f"\n=== Processing Question: {question} ===")
         full_response = self.agent.run(question)
         
-        # Extract only the final answer from the response
-        # The final answer is typically returned by the final_answer tool
-        # Look for patterns like "Out - Final answer:" or similar
-        if "Out - Final answer:" in full_response:
-            # Extract everything after "Out - Final answer:"
-            final_answer = full_response.split("Out - Final answer:")[-1].strip()
-            return final_answer
-        elif "Final answer:" in full_response:
-            # Alternative pattern
-            final_answer = full_response.split("Final answer:")[-1].strip()
-            return final_answer
-        elif "final_answer(answer=" in full_response:
-            # Extract from final_answer tool call
-            import re
-            match = re.search(r'final_answer\(answer="([^"]+)"\)', full_response)
-            if match:
-                return match.group(1)
-        else:
-            # If no clear final answer pattern is found, return the last meaningful line
-            lines = full_response.strip().split('\n')
-            for line in reversed(lines):
-                line = line.strip()
-                if (line and 
-                    not line.startswith('[') and 
-                    not line.startswith('─') and 
-                    not line.startswith('╭') and 
-                    not line.startswith('╰') and
-                    not line.startswith('Out:') and
-                    not line.startswith('Execution logs:') and
-                    not line.startswith('Code parsing') and
-                    not line.startswith('Error:') and
-                    not line.startswith('```') and
-                    not line.startswith('Thought:') and
-                    not line.startswith('Code:') and
-                    not line.startswith('<end_code>') and
-                    len(line) > 3):  # Avoid very short lines
-                    return line
-            # Fallback to the full response if no clean answer is found
-            return full_response
+        print(f"\n=== Raw Response from Agent ===\n{full_response}\n===")
+        
+        # First try to find a final_answer tool call
+        if "final_answer(" in full_response:
+            # Look for both quoted and unquoted versions
+            patterns = [
+                r'final_answer\(answer="([^"]+)"\)',  # Double quoted
+                r"final_answer\(answer='([^']+)'\)",  # Single quoted
+                r'final_answer\(answer=([^,\)]+)\)',  # Unquoted
+                r'final_answer\("([^"]+)"\)',  # Simple double quoted
+                r"final_answer\('([^']+)'\)",  # Simple single quoted
+                r'final_answer\(([^,\)]+)\)',  # Simple unquoted
+            ]
+            
+            for pattern in patterns:
+                match = re.search(pattern, full_response)
+                if match:
+                    answer = match.group(1).strip()
+                    print(f"Found answer via final_answer tool: {answer}")
+                    return answer
+        
+        # Look for explicit final answer markers
+        markers = [
+            "Out - Final answer:", 
+            "Final answer:",
+            "Answer:",
+            "The answer is:"
+        ]
+        
+        for marker in markers:
+            if marker in full_response:
+                parts = full_response.split(marker)
+                answer = parts[-1].strip()
+                # Clean up the answer - remove any following sections
+                answer = answer.split("\n")[0].strip()
+                print(f"Found answer via marker '{marker}': {answer}")
+                return answer
+        
+        # If the raw response is just a simple answer (like a number or short text)
+        # and doesn't contain execution logs or other markers, use it directly
+        clean_response = full_response.strip()
+        if (len(clean_response) < 100 and 
+            not any(marker in clean_response for marker in [
+                '[', '─', '╭', '╰', 'Out:', 'Execution logs:', 
+                'Code parsing', 'Error:', '```', 'Thought:', 
+                'Code:', '<end_code>', 'Observation:', 'Step', 'Duration',
+                'New run', 'Executing parsed code'
+            ])):
+            print(f"Using raw response as answer: {clean_response}")
+            return clean_response
+        
+        # If we get here, we need to try to extract a meaningful answer from the response
+        print("No explicit answer format found, analyzing response content...")
+        
+        # Split into lines and look for meaningful content
+        lines = full_response.strip().split('\n')
+        
+        # First look for lines that look like direct answers (not prefixed with common markers)
+        for line in lines:
+            line = line.strip()
+            if (line and 
+                not any(line.startswith(x) for x in [
+                    '[', '─', '╭', '╰', 'Out:', 'Execution logs:', 
+                    'Code parsing', 'Error:', '```', 'Thought:', 
+                    'Code:', '<end_code>', 'Observation:', 'Step', 'Duration'
+                ]) and
+                not any(line.endswith(x) for x in ['seconds', 'seconds)']) and
+                len(line) > 1 and
+                not line.startswith('─') and
+                not line.startswith('╭') and
+                not line.startswith('╰')):
+                print(f"Found potential answer from content: {line}")
+                return line
+                
+        # If we still haven't found anything, return a clear error
+        error_msg = "Could not extract a clear answer from the agent's response"
+        print(error_msg)
+        return error_msg
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """