Upload agent

agent.json

@@ -1,6 +1,11 @@
 {
     "class": "CodeAgent",
     "tools": [
+        "web_search",
+        "visit_webpage",
+        "suggest_menu",
+        "catering_service_tool",
+        "superhero_party_theme_generator",
         "final_answer"
     ],
     "model": {
@@ -26,12 +31,14 @@
             "post_messages": "Based on the above, please provide an answer to the following user task:\n{{task}}"
         }
     },
-    "max_steps": 20,
-    "verbosity_level": 1,
+    "max_steps": 10,
+    "verbosity_level": 2,
     "planning_interval": null,
     "name": null,
     "description": null,
     "requirements": [
+        "markdownify",
+        "requests",
         "smolagents"
     ],
     "authorized_imports": [

app.py

@@ -5,6 +5,11 @@ from smolagents import GradioUI, CodeAgent, InferenceClientModel
 # Get current directory path
 CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
 
+from tools.web_search import WebSearchTool as WebSearch
+from tools.visit_webpage import VisitWebpageTool as VisitWebpage
+from tools.suggest_menu import SimpleTool as SuggestMenu
+from tools.catering_service_tool import SimpleTool as CateringServiceTool
+from tools.superhero_party_theme_generator import SuperheroPartyThemeTool as SuperheroPartyThemeGenerator
 from tools.final_answer import FinalAnswerTool as FinalAnswer
 
 
@@ -13,6 +18,11 @@ model = InferenceClientModel(
 model_id='Qwen/Qwen3-Next-80B-A3B-Thinking',
 )
 
+web_search = WebSearch()
+visit_webpage = VisitWebpage()
+suggest_menu = SuggestMenu()
+catering_service_tool = CateringServiceTool()
+superhero_party_theme_generator = SuperheroPartyThemeGenerator()
 final_answer = FinalAnswer()
 
 
@@ -21,10 +31,10 @@ with open(os.path.join(CURRENT_DIR, "prompts.yaml"), 'r') as stream:
 
 agent = CodeAgent(
     model=model,
-    tools=[],
+    tools=[web_search, visit_webpage, suggest_menu, catering_service_tool, superhero_party_theme_generator],
     managed_agents=[],
-    max_steps=20,
-    verbosity_level=1,
+    max_steps=10,
+    verbosity_level=2,
     planning_interval=None,
     name=None,
     description=None,

requirements.txt

@@ -1 +1,3 @@
+markdownify
+requests
 smolagents

tools/catering_service_tool.py

@@ -0,0 +1,27 @@
+from smolagents import Tool
+from typing import Any, Optional
+
+class SimpleTool(Tool):
+    name = "catering_service_tool"
+    description = "This tool returns the highest-rated catering service in Gotham City."
+    inputs = {'query': {'type': 'string', 'description': 'A search term for finding catering services.'}}
+    output_type = "string"
+
+    def forward(self, query: str) -> str:
+        """
+        This tool returns the highest-rated catering service in Gotham City.
+
+        Args:
+            query: A search term for finding catering services.
+        """
+        # Example list of catering services and their ratings
+        services = {
+            "Gotham Catering Co.": 4.9,
+            "Wayne Manor Catering": 4.8,
+            "Gotham City Events": 4.7,
+        }
+
+        # Find the highest rated catering service (simulating search query filtering)
+        best_service = max(services, key=services.get)
+
+        return best_service

tools/suggest_menu.py

@@ -0,0 +1,23 @@
+from smolagents import Tool
+from typing import Any, Optional
+
+class SimpleTool(Tool):
+    name = "suggest_menu"
+    description = "Suggests a menu based on the occasion."
+    inputs = {'occasion': {'type': 'string', 'description': 'The type of occasion for the party.'}}
+    output_type = "string"
+
+    def forward(self, occasion: str) -> str:
+        """
+        Suggests a menu based on the occasion.
+        Args:
+            occasion: The type of occasion for the party.
+        """
+        if occasion == "casual":
+            return "Pizza, snacks, and drinks."
+        elif occasion == "formal":
+            return "3-course dinner with wine and dessert."
+        elif occasion == "superhero":
+            return "Buffet with high-energy and healthy food."
+        else:
+            return "Custom menu for the butler."

tools/superhero_party_theme_generator.py

@@ -0,0 +1,22 @@
+from typing import Any, Optional
+from smolagents.tools import Tool
+
+class SuperheroPartyThemeTool(Tool):
+    name = "superhero_party_theme_generator"
+    description = """
+    This tool suggests creative superhero-themed party ideas based on a category.
+    It returns a unique party theme idea."""
+    inputs = {'category': {'type': 'string', 'description': "The type of superhero party (e.g., 'classic heroes', 'villain masquerade', 'futuristic gotham')."}}
+    output_type = "string"
+
+    def forward(self, category: str):
+        themes = {
+            "classic heroes": "Justice League Gala: Guests come dressed as their favorite DC heroes with themed cocktails like 'The Kryptonite Punch'.",
+            "villain masquerade": "Gotham Rogues' Ball: A mysterious masquerade where guests dress as classic Batman villains.",
+            "futuristic gotham": "Neo-Gotham Night: A cyberpunk-style party inspired by Batman Beyond, with neon decorations and futuristic gadgets."
+        }
+
+        return themes.get(category.lower(), "Themed party idea not found. Try 'classic heroes', 'villain masquerade', or 'futuristic gotham'.")
+
+    def __init__(self, *args, **kwargs):
+        self.is_initialized = False

tools/visit_webpage.py

@@ -0,0 +1,53 @@
+from typing import Any, Optional
+from smolagents.tools import Tool
+import requests
+import re
+import markdownify
+
+class VisitWebpageTool(Tool):
+    name = "visit_webpage"
+    description = "Visits a webpage at the given url and reads its content as a markdown string. Use this to browse webpages."
+    inputs = {'url': {'type': 'string', 'description': 'The url of the webpage to visit.'}}
+    output_type = "string"
+
+    def __init__(self, max_output_length: int = 40000):
+        super().__init__()
+        self.max_output_length = max_output_length
+
+    def _truncate_content(self, content: str, max_length: int) -> str:
+        if len(content) <= max_length:
+            return content
+        return (
+            content[:max_length] + f"\n..._This content has been truncated to stay below {max_length} characters_...\n"
+        )
+
+    def forward(self, url: str) -> str:
+        try:
+            import re
+
+            import requests
+            from markdownify import markdownify
+            from requests.exceptions import RequestException
+        except ImportError as e:
+            raise ImportError(
+                "You must install packages `markdownify` and `requests` to run this tool: for instance run `pip install markdownify requests`."
+            ) from e
+        try:
+            # Send a GET request to the URL with a 20-second timeout
+            response = requests.get(url, timeout=20)
+            response.raise_for_status()  # Raise an exception for bad status codes
+
+            # Convert the HTML content to Markdown
+            markdown_content = markdownify(response.text).strip()
+
+            # Remove multiple line breaks
+            markdown_content = re.sub(r"\n{3,}", "\n\n", markdown_content)
+
+            return self._truncate_content(markdown_content, self.max_output_length)
+
+        except requests.exceptions.Timeout:
+            return "The request timed out. Please try again later or check the URL."
+        except RequestException as e:
+            return f"Error fetching the webpage: {str(e)}"
+        except Exception as e:
+            return f"An unexpected error occurred: {str(e)}"

tools/web_search.py

@@ -0,0 +1,116 @@
+from typing import Any, Optional
+from smolagents.tools import Tool
+import requests
+import xml
+import html
+
+class WebSearchTool(Tool):
+    name = "web_search"
+    description = "Performs a web search for a query and returns a string of the top search results formatted as markdown with titles, links, and descriptions."
+    inputs = {'query': {'type': 'string', 'description': 'The search query to perform.'}}
+    output_type = "string"
+
+    def __init__(self, max_results: int = 10, engine: str = "duckduckgo"):
+        super().__init__()
+        self.max_results = max_results
+        self.engine = engine
+
+    def forward(self, query: str) -> str:
+        results = self.search(query)
+        if len(results) == 0:
+            raise Exception("No results found! Try a less restrictive/shorter query.")
+        return self.parse_results(results)
+
+    def search(self, query: str) -> list:
+        if self.engine == "duckduckgo":
+            return self.search_duckduckgo(query)
+        elif self.engine == "bing":
+            return self.search_bing(query)
+        else:
+            raise ValueError(f"Unsupported engine: {self.engine}")
+
+    def parse_results(self, results: list) -> str:
+        return "## Search Results\n\n" + "\n\n".join(
+            [f"[{result['title']}]({result['link']})\n{result['description']}" for result in results]
+        )
+
+    def search_duckduckgo(self, query: str) -> list:
+        import requests
+
+        response = requests.get(
+            "https://lite.duckduckgo.com/lite/",
+            params={"q": query},
+            headers={"User-Agent": "Mozilla/5.0"},
+        )
+        response.raise_for_status()
+        parser = self._create_duckduckgo_parser()
+        parser.feed(response.text)
+        return parser.results
+
+    def _create_duckduckgo_parser(self):
+        from html.parser import HTMLParser
+
+        class SimpleResultParser(HTMLParser):
+            def __init__(self):
+                super().__init__()
+                self.results = []
+                self.current = {}
+                self.capture_title = False
+                self.capture_description = False
+                self.capture_link = False
+
+            def handle_starttag(self, tag, attrs):
+                attrs = dict(attrs)
+                if tag == "a" and attrs.get("class") == "result-link":
+                    self.capture_title = True
+                elif tag == "td" and attrs.get("class") == "result-snippet":
+                    self.capture_description = True
+                elif tag == "span" and attrs.get("class") == "link-text":
+                    self.capture_link = True
+
+            def handle_endtag(self, tag):
+                if tag == "a" and self.capture_title:
+                    self.capture_title = False
+                elif tag == "td" and self.capture_description:
+                    self.capture_description = False
+                elif tag == "span" and self.capture_link:
+                    self.capture_link = False
+                elif tag == "tr":
+                    # Store current result if all parts are present
+                    if {"title", "description", "link"} <= self.current.keys():
+                        self.current["description"] = " ".join(self.current["description"])
+                        self.results.append(self.current)
+                        self.current = {}
+
+            def handle_data(self, data):
+                if self.capture_title:
+                    self.current["title"] = data.strip()
+                elif self.capture_description:
+                    self.current.setdefault("description", [])
+                    self.current["description"].append(data.strip())
+                elif self.capture_link:
+                    self.current["link"] = "https://" + data.strip()
+
+        return SimpleResultParser()
+
+    def search_bing(self, query: str) -> list:
+        import xml.etree.ElementTree as ET
+
+        import requests
+
+        response = requests.get(
+            "https://www.bing.com/search",
+            params={"q": query, "format": "rss"},
+        )
+        response.raise_for_status()
+        root = ET.fromstring(response.text)
+        items = root.findall(".//item")
+        results = [
+            {
+                "title": item.findtext("title"),
+                "link": item.findtext("link"),
+                "description": item.findtext("description"),
+            }
+            for item in items[: self.max_results]
+        ]
+        return results