updated the prompt, refactored

app.py

@@ -10,7 +10,7 @@ from collections import deque
 import random
 from smolagents import CodeAgent, DuckDuckGoSearchTool, load_tool, tool
 from smolagents.models import Model, ChatMessage, MessageRole, Tool
-from tools import FinalAnswerTool, WikipediaSearchTool
+from tools import FinalAnswerTool, WikipediaSearchTool, VisitWebpageTool
 import google.generativeai as genai
 
 # (Keep Constants as is)
@@ -54,56 +54,79 @@ class GeminiModel(Model):
         self.model = genai.GenerativeModel('models/gemini-2.0-flash-lite')
         self.rate_limiter = RateLimiter(requests_per_minute=25)
 
-        self.system_prompt = """You are a high-performance reasoning agent. Your goal is to answer questions by breaking them down into a series of logical steps.
+        self.system_prompt = """You are a high-performance reasoning agent. Your goal is to answer questions by breaking them down into a series of logical steps using the tools provided.
 
-You are in a loop that has a limited number of turns. You must solve the problem efficiently.
+**YOUR TOOLS**
+- `web_search(query: str)`: Finds URLs and information.
+- `visit_webpage(url: str)`: Reads the content of a URL.
+- `wikipedia_search(query: str)`: Searches Wikipedia.
+- `final_answer(answer: str)`: Submits your final answer.
 
 **YOUR WORKFLOW**
-1.  **Think (`Thought:`):** Analyze the user's question. What is the first piece of information you need? Create a plan.
-2.  **Act (`Code:`):** Write a SINGLE line of Python code to execute the first step of your plan. Use one of your tools: `web_search(query)` or `wikipedia_search(query)`.
-3.  **Observe (`Observation:`):** You will receive the result of your action.
-4.  **Repeat:** Go back to step 1. Analyze the observation. Do you have the final answer, or do you need more information? Continue this process until you have everything you need.
-5.  **Final Answer:** Once you are certain you have the correct answer, your final action MUST be a call to `final_answer("your answer")`.
+1.  **Think (`Thought:`):** Analyze the question and create a plan.
+2.  **Act (`Code:`):** Execute ONE step of your plan.
+3.  **Observe (`Observation:`):** Use the result to inform your next step.
+4.  **Repeat** until you have the final answer.
+5.  **Submit** your answer using `final_answer()`.
 
 ---
-**GOLDEN PATH EXAMPLE: MULTI-STEP REASONING**
+**EXAMPLE 1: Using `web_search` and `visit_webpage`**
+*Question:* What is the surname of the equine veterinarian mentioned in 1.E Exercises from the chemistry materials licensed by Marisa Alviar-Agnew & Henry Agnew under the CK-12 license in LibreText's Introductory Chemistry materials as compiled 08/21/2023?
 
-*Question:* Who are the pitchers with the number before and after Taishō Tamai's number as of July 2023? Give them to me in the form Pitcher Before, Pitcher After, use their last names only, in Roman characters.
+**Your Turn 1:**
+Thought: I need to find the specific LibreText page. I'll use `web_search`.
+Code:
+```py
+web_search(query="LibreTexts Introductory Chemistry Agnew 1.E Exercises")
+```<end_code>
+*Observation:* A search result shows the URL `https://chem.libretexts.org/.../1.E%3A_Exercises`.
 
----
-**Your Turn 1**
-Thought: I need to find Taishō Tamai's jersey number and his team. I will use `web_search` to find this information.
+**Your Turn 2:**
+Thought: I have the URL. Now I need to read the content of the page to find the name.
 Code:
 ```py
-web_search(query="Taisho Tamai jersey number and team July 2023")
+visit_webpage(url="https://chem.libretexts.org/Courses/Some_College/Introductory_Chemistry_(Alviar-Agnew_and_Agnew)/01%3A_Introduction_to_Chemistry/1.E%3A_Exercises")
 ```<end_code>
+*Observation:* The webpage content includes the text "...an equine veterinarian, Dr. Smith...".
 
----
-*Observation from Turn 1:* `Taishō Tamai is a pitcher for the Orix Buffaloes, jersey number 61.`
+**Your Turn 3:**
+Thought: I've found the surname. It's Smith.
+Code:
+```py
+final_answer("Smith")
+```<end_code>
 
 ---
-**Your Turn 2**
-Thought: The observation tells me his number is 61 and he plays for the Orix Buffaloes. Now I need to find the 2023 pitcher roster for that team to identify the players with numbers 60 and 62.
+**EXAMPLE 2: Finding a specific count**
+*Question:* How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)?
+
+**Your Turn 1:**
+Thought: I need to find a reliable discography for Mercedes Sosa. `wikipedia_search` is a good starting point.
 Code:
 ```py
-web_search(query="Orix Buffaloes 2023 pitcher roster with jersey numbers")
+wikipedia_search(query="Mercedes Sosa discography")
 ```<end_code>
+*Observation:* The Wikipedia summary lists several albums.
 
----
-*Observation from Turn 2:* `The Orix Buffaloes 2023 roster includes... Pitcher: K. Mizuno, #60... Pitcher: T. Onaga, #62...`
+**Your Turn 2:**
+Thought: The summary is a good start, but I need a more detailed list with years to be sure. I will visit the Wikipedia page itself to get the full discography. The search result from the previous step implicitly gives me the URL.
+Code:
+```py
+visit_webpage(url="https://en.wikipedia.org/wiki/Mercedes_Sosa_discography")
+```<end_code>
+*Observation:* The page content contains a "Studio albums" section with dates. I can read it and count: *Acústico* (2002), *Corazón libre* (2005), *Cantora 1* (2009), *Cantora 2* (2009).
 
----
-**Your Turn 3**
-Thought: I have all the necessary information. The pitcher with the number before Taishō Tamai (#61) is K. Mizuno (#60). The pitcher after is T. Onaga (#62). The required format is "LastNameBefore, LastNameAfter".
+**Your Turn 3:**
+Thought: I have counted 4 studio albums in the specified period.
 Code:
 ```py
-final_answer("Mizuno, Onaga")
+final_answer("4")
 ```<end_code>
 """
 
     def generate(
         self,
-        messages: list[dict[str, str | list[dict]] | ChatMessage],
+        messages: list[ChatMessage],
         stop_sequences: list[str] | None = None,
         response_format: dict[str, str] | None = None,
         tools_to_call_from: list[Tool] | None = None,
@@ -112,70 +135,40 @@ final_answer("Mizuno, Onaga")
         retry_count = 0
         delay = INITIAL_RETRY_DELAY
 
+        # The smol-agent framework prepares the full conversation history.
+        # We concatenate the content of all messages to provide full context.
+        conversation_history = []
+        for message in messages:
+            content = ""
+            if isinstance(message, ChatMessage) and message.content:
+                content = message.content
+            elif isinstance(message, dict) and 'content' in message:
+                content = str(message['content'])
+            else:
+                content = str(message)
+            conversation_history.append(content)
+        
+        prompt = "\n".join(conversation_history)
+
+        # The system prompt comes first, followed by the full conversation.
+        full_prompt = f"{self.system_prompt}\n\n{prompt}"
+        
         while True:
             try:
-                # Wait if we need to due to rate limiting
                 self.rate_limiter.wait_if_needed()
 
-                # Handle different prompt types
-                if isinstance(messages, list) and len(messages) > 0:
-                    last_message = messages[-1]
-                    
-                    if isinstance(last_message, dict) and 'content' in last_message:
-                        content = last_message['content']
-                    elif isinstance(last_message, ChatMessage) and last_message.content:
-                        content = last_message.content
-                    else:
-                        content = ""
-                        for msg in messages:
-                            if isinstance(msg, dict) and 'content' in msg:
-                                content += str(msg['content']) + "\n"
-                            elif isinstance(msg, ChatMessage) and msg.content:
-                                content += str(msg.content) + "\n"
-                            else:
-                                content += str(msg) + "\n"
-                else:
-                    content = str(messages)
-
-                # Ensure content is a simple string for Gemini API
-                if isinstance(content, list):
-                    text_parts = []
-                    for part in content:
-                        if isinstance(part, dict):
-                            if 'text' in part:
-                                text_parts.append(part['text'])
-                            elif 'content' in part:
-                                text_parts.append(part['content'])
-                            else:
-                                text_parts.append(str(part))
-                        else:
-                            text_parts.append(str(part))
-                    content = "\n".join(text_parts)
-                elif isinstance(content, dict):
-                    if 'text' in content:
-                        content = content['text']
-                    elif 'content' in content:
-                        content = content['content']
-                    else:
-                        content = str(content)
-                
-                # Combine system prompt with user content
-                full_prompt = f"{self.system_prompt}\n\nTask: {content}"
-
-                # Generate response
                 response = self.model.generate_content(full_prompt)
                 
-                # Extract text from response
+                response_text = ""
                 if hasattr(response, 'text'):
                     response_text = response.text
+                elif hasattr(response, 'parts') and response.parts:
+                    response_text = "".join(part.text for part in response.parts if hasattr(part, 'text'))
                 elif isinstance(response, str):
                     response_text = response
-                elif hasattr(response, 'content'):
-                    response_text = response.content
                 else:
                     response_text = str(response)
                     
-                # Return ChatMessage object as expected by smolagents
                 return ChatMessage(
                     role=MessageRole.ASSISTANT,
                     content=response_text,
@@ -216,37 +209,33 @@ class MyAgent:
                 FinalAnswerTool(), 
                 DuckDuckGoSearchTool(),
                 WikipediaSearchTool(),
+                VisitWebpageTool(),
             ],
             model=self.model,
-            max_steps=7 # Increased to allow for multi-step reasoning
+            max_steps=7 # Keep high for multi-step reasoning
         )
 
-    def clean_and_format_answer(self, answer: str, question: str) -> str:
-        """Extracts the argument from the final_answer() call."""
-        match = re.search(r'final_answer\((?:"(.*?)"|\'(.*?)\'|(.*?))\)', answer, re.DOTALL)
-        if match:
-            # The result could be in group 1 (double quotes), group 2 (single quotes), or group 3 (no quotes)
-            result = match.group(1) or match.group(2) or match.group(3)
-            return result.strip() if result else ""
-        return ""
-
     def __call__(self, question: str) -> str:
         print(f"\n=== Processing Question: {question} ===")
-        
         try:
-            full_response = self.agent.run(question)
-            print(f"\n=== Raw Response from Agent ===\n{full_response}\n===")
-            answer = self.clean_and_format_answer(full_response, question)
-            
-            if answer:
+            # agent.run() executes the plan and returns the final answer.
+            answer = self.agent.run(question)
+            print(f"\n=== Final Answer from Agent ===\n{answer}\n===")
+
+            # If the agent returns a string, use it. Otherwise, indicate no answer was found.
+            if isinstance(answer, str) and answer:
                 return answer
             else:
-                print("Could not find a final_answer call in the agent's response.")
+                # This case might be hit if the agent finishes without a clear answer string.
                 return "I was unable to find a definitive answer."
 
         except Exception as e:
-            print(f"Error processing question: {e}")
-            return f"Error: {str(e)}"
+            error_message = str(e)
+            print(f"An error occurred while processing the question: {error_message}")
+            # Check for a timeout or max steps error from the agent.
+            if "Agent stopped after" in error_message and "final_answer" in error_message:
+                return "I was unable to find a definitive answer within the allowed steps."
+            return f"An error occurred: {error_message}"
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """

requirements.txt

@@ -6,4 +6,5 @@ smolagents
 google-generativeai
 python-dotenv
 wikipedia-api
-duckduckgo-search
+duckduckgo-search
+markdownify