Upload folder using huggingface_hub

.env

@@ -0,0 +1,11 @@
+OPENAI_API_KEY=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
+OPENAI_MODEL=gpt-4-1106-preview
+OPENAI_ORGANIZATION=your_openai_org_id_here
+GROQ_API_KEY=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
+DEEPGRAM_API_KEY=your_deepgram_api_key_here
+GROQ_API_KEY=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
+MAX_TOKENS=4000
+TEMPERATURE=0.3
+
+PORT=5002
+HOST=0.0.0.0

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - y
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

BrowsingAgent/BrowsingAgent.py

@@ -0,0 +1,166 @@
+import json
+import re
+
+from agency_swarm.agents import Agent
+from agency_swarm.tools.oai import FileSearch
+from typing_extensions import override
+import base64
+
+
+class BrowsingAgent(Agent):
+    SCREENSHOT_FILE_NAME = "screenshot.jpg"
+
+    def __init__(self, selenium_config=None, **kwargs):
+        from .tools.util.selenium import set_selenium_config
+        super().__init__(
+            name="BrowsingAgent",
+            description="This agent is designed to navigate and search web effectively.",
+            instructions="./instructions.md",
+            files_folder="./files",
+            schemas_folder="./schemas",
+            tools=[],
+            tools_folder="./tools",
+            temperature=0,
+            max_prompt_tokens=16000,
+            model="gpt-4o",
+            validation_attempts=25,
+            **kwargs
+        )
+        if selenium_config is not None:
+            set_selenium_config(selenium_config)
+
+        self.prev_message = ""
+
+    @override
+    def response_validator(self, message):
+        from .tools.util.selenium import get_web_driver, set_web_driver
+        from .tools.util import highlight_elements_with_labels, remove_highlight_and_labels
+        from selenium.webdriver.common.by import By
+        from selenium.webdriver.support.select import Select
+
+        # Filter out everything in square brackets
+        filtered_message = re.sub(r'\[.*?\]', '', message).strip()
+        
+        if filtered_message and self.prev_message == filtered_message:
+            raise ValueError("Do not repeat yourself. If you are stuck, try a different approach or search in google for the page you are looking for directly.")
+        
+        self.prev_message = filtered_message
+
+        if "[send screenshot]" in message.lower():
+            wd = get_web_driver()
+            remove_highlight_and_labels(wd)
+            self.take_screenshot()
+            response_text = "Here is the screenshot of the current web page:"
+
+        elif '[highlight clickable elements]' in message.lower():
+            wd = get_web_driver()
+            highlight_elements_with_labels(wd, 'a, button, div[onclick], div[role="button"], div[tabindex], '
+                                               'span[onclick], span[role="button"], span[tabindex]')
+            self._shared_state.set("elements_highlighted", 'a, button, div[onclick], div[role="button"], div[tabindex], '
+                                               'span[onclick], span[role="button"], span[tabindex]')
+
+            self.take_screenshot()
+
+            all_elements = wd.find_elements(By.CSS_SELECTOR, '.highlighted-element')
+
+            all_element_texts = [element.text for element in all_elements]
+
+            element_texts_json = {}
+            for i, element_text in enumerate(all_element_texts):
+                element_texts_json[str(i + 1)] = self.remove_unicode(element_text)
+            
+            element_texts_json = {k: v for k, v in element_texts_json.items() if v}
+
+            element_texts_formatted = ", ".join([f"{k}: {v}" for k, v in element_texts_json.items()])
+
+            response_text = ("Here is the screenshot of the current web page with highlighted clickable elements. \n\n"
+                             "Texts of the elements are: " + element_texts_formatted + ".\n\n"
+                             "Elements without text are not shown, but are available on screenshot. \n"
+                             "Please make sure to analyze the screenshot to find the clickable element you need to click on.")
+
+        elif '[highlight text fields]' in message.lower():
+            wd = get_web_driver()
+            highlight_elements_with_labels(wd, 'input, textarea')
+            self._shared_state.set("elements_highlighted", "input, textarea")
+
+            self.take_screenshot()
+
+            all_elements = wd.find_elements(By.CSS_SELECTOR, '.highlighted-element')
+
+            all_element_texts = [element.text for element in all_elements]
+
+            element_texts_json = {}
+            for i, element_text in enumerate(all_element_texts):
+                element_texts_json[str(i + 1)] = self.remove_unicode(element_text)
+
+            element_texts_formatted = ", ".join([f"{k}: {v}" for k, v in element_texts_json.items()])
+
+            response_text = ("Here is the screenshot of the current web page with highlighted text fields: \n"
+                             "Texts of the elements are: " + element_texts_formatted + ".\n"
+                             "Please make sure to analyze the screenshot to find the text field you need to fill.")
+
+        elif '[highlight dropdowns]' in message.lower():
+            wd = get_web_driver()
+            highlight_elements_with_labels(wd, 'select')
+            self._shared_state.set("elements_highlighted", "select")
+
+            self.take_screenshot()
+
+            all_elements = wd.find_elements(By.CSS_SELECTOR, '.highlighted-element')
+
+            all_selector_values = {}
+
+            i = 0
+            for element in all_elements:
+                select = Select(element)
+                options = select.options
+                selector_values = {}
+                for j, option in enumerate(options):
+                    selector_values[str(j)] = option.text
+                    if j > 10:
+                        break
+                all_selector_values[str(i + 1)] = selector_values
+
+            all_selector_values = {k: v for k, v in all_selector_values.items() if v}
+            all_selector_values_formatted = ", ".join([f"{k}: {v}" for k, v in all_selector_values.items()])
+
+            response_text = ("Here is the screenshot with highlighted dropdowns. \n"
+                             "Selector values are: " + all_selector_values_formatted + ".\n"
+                             "Please make sure to analyze the screenshot to find the dropdown you need to select.")
+
+        else:
+            return message
+
+        set_web_driver(wd)
+        content = self.create_response_content(response_text)
+        raise ValueError(content)
+
+    def take_screenshot(self):
+        from .tools.util.selenium import get_web_driver
+        from .tools.util import get_b64_screenshot
+        wd = get_web_driver()
+        screenshot = get_b64_screenshot(wd)
+        screenshot_data = base64.b64decode(screenshot)
+        with open(self.SCREENSHOT_FILE_NAME, "wb") as screenshot_file:
+            screenshot_file.write(screenshot_data)
+
+    def create_response_content(self, response_text):
+        with open(self.SCREENSHOT_FILE_NAME, "rb") as file:
+            file_id = self.client.files.create(
+                file=file,
+                purpose="vision",
+            ).id
+
+        content = [
+            {"type": "text", "text": response_text},
+            {
+                "type": "image_file",
+                "image_file": {"file_id": file_id}
+            }
+        ]
+        return content
+
+    # Function to check for Unicode escape sequences
+    def remove_unicode(self, data):
+        return re.sub(r'[^\x00-\x7F]+', '', data)
+

BrowsingAgent/__init__.py

@@ -0,0 +1 @@
+from .BrowsingAgent import BrowsingAgent

BrowsingAgent/instructions.md

@@ -0,0 +1,21 @@
+# Browsing Agent Instructions
+
+As an advanced browsing agent, you are equipped with specialized tools to navigate and search the web effectively. Your primary objective is to fulfill the user's requests by efficiently utilizing these tools.
+
+### Primary Instructions:
+
+1. **Avoid Guessing URLs**: Never attempt to guess the direct URL. Always perform a Google search if applicable, or return to your previous search results.
+2. **Navigating to New Pages**: Always use the `ClickElement` tool to open links when navigating to a new web page from the current source. Do not guess the direct URL.
+3. **Single Page Interaction**: You can only open and interact with one web page at a time. The previous web page will be closed when you open a new one. To navigate back, use the `GoBack` tool.
+4. **Requesting Screenshots**: Before using tools that interact with the web page, ask the user to send you the appropriate screenshot using one of the commands below.
+
+### Commands to Request Screenshots:
+
+- **'[send screenshot]'**: Sends the current browsing window as an image. Use this command if the user asks what is on the page.
+- **'[highlight clickable elements]'**: Highlights all clickable elements on the current web page. This must be done before using the `ClickElement` tool.
+- **'[highlight text fields]'**: Highlights all text fields on the current web page. This must be done before using the `SendKeys` tool.
+- **'[highlight dropdowns]'**: Highlights all dropdowns on the current web page. This must be done before using the `SelectDropdown` tool.
+
+### Important Reminders:
+
+- Only open and interact with one web page at a time. Do not attempt to read or click on multiple links simultaneously. Complete your interactions with the current web page before proceeding to a different source.

BrowsingAgent/requirements.txt

@@ -0,0 +1,3 @@
+selenium
+webdriver-manager
+selenium_stealth

BrowsingAgent/tools/ClickElement.py

@@ -0,0 +1,59 @@
+import time
+
+from pydantic import Field
+from selenium.webdriver.common.by import By
+
+from agency_swarm.tools import BaseTool
+from .util import get_web_driver, set_web_driver
+from .util.highlights import remove_highlight_and_labels
+
+
+class ClickElement(BaseTool):
+    """
+    This tool clicks on an element on the current web page based on its number.
+
+    Before using this tool make sure to highlight clickable elements on the page by outputting '[highlight clickable elements]' message.
+    """
+    element_number: int = Field(
+        ...,
+        description="The number of the element to click on. The element numbers are displayed on the page after highlighting elements.",
+    )
+
+    def run(self):
+        wd = get_web_driver()
+
+        if 'button' not in self._shared_state.get("elements_highlighted", ""):
+            raise ValueError("Please highlight clickable elements on the page first by outputting '[highlight clickable elements]' message. You must output just the message without calling the tool first, so the user can respond with the screenshot.")
+
+        all_elements = wd.find_elements(By.CSS_SELECTOR, '.highlighted-element')
+
+        # iterate through all elements with a number in the text
+        try:
+            element_text = all_elements[self.element_number - 1].text
+            element_text = element_text.strip() if element_text else ""
+            # Subtract 1 because sequence numbers start at 1, but list indices start at 0
+            try:
+                all_elements[self.element_number - 1].click()
+            except Exception as e:
+                if "element click intercepted" in str(e).lower():
+                    wd.execute_script("arguments[0].click();", all_elements[self.element_number - 1])
+                else:
+                    raise e
+
+            time.sleep(3)
+
+            result = f"Clicked on element {self.element_number}. Text on clicked element: '{element_text}'. Current URL is {wd.current_url} To further analyze the page, output '[send screenshot]' command."
+        except IndexError:
+            result = "Element number is invalid. Please try again with a valid element number."
+        except Exception as e:
+            result = str(e)
+
+        wd = remove_highlight_and_labels(wd)
+
+        wd.execute_script("document.body.style.zoom='1.5'")
+
+        set_web_driver(wd)
+
+        self._shared_state.set("elements_highlighted", "")
+
+        return result

BrowsingAgent/tools/ExportFile.py

@@ -0,0 +1,45 @@
+import base64
+import os
+
+from agency_swarm.tools import BaseTool
+from .util import get_web_driver
+
+
+class ExportFile(BaseTool):
+    """This tool converts the current full web page into a file and returns its file_id. You can then send this file id back to the user for further processing."""
+
+    def run(self):
+        wd = get_web_driver()
+        from agency_swarm import get_openai_client
+        client = get_openai_client()
+
+        # Define the parameters for the PDF
+        params = {
+            'landscape': False,
+            'displayHeaderFooter': False,
+            'printBackground': True,
+            'preferCSSPageSize': True,
+        }
+
+        # Execute the command to print to PDF
+        result = wd.execute_cdp_cmd('Page.printToPDF', params)
+        pdf = result['data']
+
+        pdf_bytes = base64.b64decode(pdf)
+
+        # Save the PDF to a file
+        with open("exported_file.pdf", "wb") as f:
+            f.write(pdf_bytes)
+
+        file_id = client.files.create(file=open("exported_file.pdf", "rb"), purpose="assistants",).id
+
+        self._shared_state.set("file_id", file_id)
+
+        return "Success. File exported with id: `" + file_id + "` You can now send this file id back to the user."
+
+
+if __name__ == "__main__":
+    wd = get_web_driver()
+    wd.get("https://www.google.com")
+    tool = ExportFile()
+    tool.run()

BrowsingAgent/tools/GoBack.py

@@ -0,0 +1,22 @@
+import time
+
+from agency_swarm.tools import BaseTool
+
+from .util.selenium import get_web_driver, set_web_driver
+
+
+class GoBack(BaseTool):
+    """W
+    This tool allows you to go back 1 page in the browser history. Use it in case of a mistake or if a page shows you unexpected content.
+    """
+
+    def run(self):
+        wd = get_web_driver()
+
+        wd.back()
+
+        time.sleep(3)
+
+        set_web_driver(wd)
+
+        return "Success. Went back 1 page. Current URL is: " + wd.current_url

BrowsingAgent/tools/ReadURL.py

@@ -0,0 +1,44 @@
+import time
+
+from pydantic import Field
+
+from agency_swarm.tools import BaseTool
+from .util.selenium import get_web_driver, set_web_driver
+
+
+class ReadURL(BaseTool):
+    """
+This tool reads a single URL and opens it in your current browser window. For each new source, either navigate directly to a URL that you believe contains the answer to the user's question or perform a Google search (e.g., 'https://google.com/search?q=search') if necessary. 
+
+If you are unsure of the direct URL, do not guess. Instead, use the ClickElement tool to click on links that might contain the desired information on the current web page.
+
+Note: This tool only supports opening one URL at a time. The previous URL will be closed when you open a new one.
+    """
+    chain_of_thought: str = Field(
+        ..., description="Think step-by-step about where you need to navigate next to find the necessary information.",
+        exclude=True
+    )
+    url: str = Field(
+        ..., description="URL of the webpage.", examples=["https://google.com/search?q=search"]
+    )
+
+    class ToolConfig:
+        one_call_at_a_time: bool = True
+
+    def run(self):
+        wd = get_web_driver()
+
+        wd.get(self.url)
+
+        time.sleep(2)
+
+        set_web_driver(wd)
+
+        self._shared_state.set("elements_highlighted", "")
+
+        return "Current URL is: " + wd.current_url + "\n" + "Please output '[send screenshot]' next to analyze the current web page or '[highlight clickable elements]' for further navigation."
+
+
+if __name__ == "__main__":
+    tool = ReadURL(url="https://google.com")
+    print(tool.run())

BrowsingAgent/tools/Scroll.py

@@ -0,0 +1,53 @@
+from typing import Literal
+
+from pydantic import Field
+
+from agency_swarm.tools import BaseTool
+from .util.selenium import get_web_driver, set_web_driver
+
+
+class Scroll(BaseTool):
+    """
+    This tool allows you to scroll the current web page up or down by 1 screen height.
+    """
+    direction: Literal["up", "down"] = Field(
+        ..., description="Direction to scroll."
+    )
+
+    def run(self):
+        wd = get_web_driver()
+
+        height = wd.get_window_size()['height']
+
+        # Get the zoom level
+        zoom_level = wd.execute_script("return document.body.style.zoom || '1';")
+        zoom_level = float(zoom_level.strip('%')) / 100 if '%' in zoom_level else float(zoom_level)
+
+        # Adjust height by zoom level
+        adjusted_height = height / zoom_level
+
+        current_scroll_position = wd.execute_script("return window.pageYOffset;")
+        total_scroll_height = wd.execute_script("return document.body.scrollHeight;")
+
+        result = ""
+
+        if self.direction == "up":
+            if current_scroll_position == 0:
+                # Reached the top of the page
+                result = "Reached the top of the page. Cannot scroll up any further.\n"
+            else:
+                wd.execute_script(f"window.scrollBy(0, -{adjusted_height});")
+                result = "Scrolled up by 1 screen height. Make sure to output '[send screenshot]' command to analyze the page after scrolling."
+
+        elif self.direction == "down":
+            if current_scroll_position + adjusted_height >= total_scroll_height:
+                # Reached the bottom of the page
+                result = "Reached the bottom of the page. Cannot scroll down any further.\n"
+            else:
+                wd.execute_script(f"window.scrollBy(0, {adjusted_height});")
+                result = "Scrolled down by 1 screen height. Make sure to output '[send screenshot]' command to analyze the page after scrolling."
+
+        set_web_driver(wd)
+
+        return result
+

BrowsingAgent/tools/SelectDropdown.py

@@ -0,0 +1,58 @@
+from typing import Dict
+from pydantic import Field, model_validator
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.select import Select
+
+from agency_swarm.tools import BaseTool
+from .util import get_web_driver, set_web_driver
+from .util.highlights import remove_highlight_and_labels
+
+
+class SelectDropdown(BaseTool):
+    """
+    This tool selects an option in a dropdown on the current web page based on the description of that element and which option to select.
+
+    Before using this tool make sure to highlight dropdown elements on the page by outputting '[highlight dropdowns]' message.
+    """
+
+    key_value_pairs: Dict[str, str] = Field(...,
+        description="A dictionary where the key is the sequence number of the dropdown element and the value is the index of the option to select.",
+        examples=[{"1": 0, "2": 1}, {"3": 2}]
+    )
+
+    @model_validator(mode='before')
+    @classmethod
+    def check_key_value_pairs(cls, data):
+        if not data.get('key_value_pairs'):
+            raise ValueError(
+                "key_value_pairs is required. Example format: "
+                "key_value_pairs={'1': 0, '2': 1}"
+            )
+        return data
+
+    def run(self):
+        wd = get_web_driver()
+
+        if 'select' not in self._shared_state.get("elements_highlighted", ""):
+            raise ValueError("Please highlight dropdown elements on the page first by outputting '[highlight dropdowns]' message. You must output just the message without calling the tool first, so the user can respond with the screenshot.")
+
+        all_elements = wd.find_elements(By.CSS_SELECTOR, '.highlighted-element')
+
+        try:
+            for key, value in self.key_value_pairs.items():
+                key = int(key)
+                element = all_elements[key - 1]
+
+                select = Select(element)
+
+                # Select the first option (index 0)
+                select.select_by_index(int(value))
+            result = f"Success. Option is selected in the dropdown. To further analyze the page, output '[send screenshot]' command."
+        except Exception as e:
+            result = str(e)
+
+        remove_highlight_and_labels(wd)
+
+        set_web_driver(wd)
+
+        return result

BrowsingAgent/tools/SendKeys.py

@@ -0,0 +1,73 @@
+import time
+from typing import Dict
+
+from pydantic import Field
+from selenium.webdriver import Keys
+from selenium.webdriver.common.by import By
+
+from agency_swarm.tools import BaseTool
+from .util import get_web_driver, set_web_driver
+from .util.highlights import remove_highlight_and_labels
+
+
+from pydantic import model_validator
+
+class SendKeys(BaseTool):
+    """
+    This tool sends keys into input fields on the current webpage based on the description of that element and what needs to be typed. It then clicks "Enter" on the last element to submit the form. You do not need to tell it to press "Enter"; it will do that automatically.
+
+    Before using this tool make sure to highlight the input elements on the page by outputting '[highlight text fields]' message.
+    """
+    elements_and_texts: Dict[int, str] = Field(...,
+        description="A dictionary where the key is the element number and the value is the text to be typed.",
+        examples=[
+            {52: "johndoe@gmail.com", 53: "password123"},
+            {3: "John Doe", 4: "123 Main St"},
+        ]
+    )
+
+    @model_validator(mode='before')  
+    @classmethod
+    def check_elements_and_texts(cls, data):
+        if not data.get('elements_and_texts'):
+            raise ValueError(
+                "elements_and_texts is required. Example format: "
+                "elements_and_texts={1: 'John Doe', 2: '123 Main St'}"
+            )
+        return data
+
+    def run(self):
+        wd = get_web_driver()
+        if 'input' not in self._shared_state.get("elements_highlighted", ""):
+            raise ValueError("Please highlight input elements on the page first by outputting '[highlight text fields]' message. You must output just the message without calling the tool first, so the user can respond with the screenshot.")
+
+        all_elements = wd.find_elements(By.CSS_SELECTOR, '.highlighted-element')
+
+        i = 0
+        try:
+            for key, value in self.elements_and_texts.items():
+                key = int(key)
+                element = all_elements[key - 1]
+
+                try:
+                    element.click()
+                    element.send_keys(Keys.CONTROL + "a")  # Select all text in input
+                    element.send_keys(Keys.DELETE)
+                    element.clear()
+                except Exception as e:
+                    pass
+                element.send_keys(value)
+                # send enter key to the last element
+                if i == len(self.elements_and_texts) - 1:
+                    element.send_keys(Keys.RETURN)
+                    time.sleep(3)
+                i += 1
+            result = f"Sent input to element and pressed Enter. Current URL is {wd.current_url} To further analyze the page, output '[send screenshot]' command."
+        except Exception as e:
+            result = str(e)
+
+        remove_highlight_and_labels(wd)
+
+        set_web_driver(wd)
+
+        return result

BrowsingAgent/tools/SolveCaptcha.py

@@ -0,0 +1,238 @@
+import base64
+import time
+
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.expected_conditions import presence_of_element_located, \
+    frame_to_be_available_and_switch_to_it
+from selenium.webdriver.support.wait import WebDriverWait
+
+from agency_swarm.tools import BaseTool
+from .util import get_b64_screenshot, remove_highlight_and_labels
+from .util.selenium import get_web_driver
+from agency_swarm.util import get_openai_client
+
+
+class SolveCaptcha(BaseTool):
+    """
+    This tool asks a human to solve captcha on the current webpage. Make sure that captcha is visible before running it.
+    """
+
+    def run(self):
+        wd = get_web_driver()
+
+        try:
+            WebDriverWait(wd, 10).until(
+                frame_to_be_available_and_switch_to_it((By.XPATH, "//iframe[@title='reCAPTCHA']"))
+            )
+
+            element = WebDriverWait(wd, 3).until(
+                presence_of_element_located((By.ID, "recaptcha-anchor"))
+            )
+        except Exception as e:
+            return "Could not find captcha checkbox"
+
+        try:
+            # Scroll the element into view
+            wd.execute_script("arguments[0].scrollIntoView(true);", element)
+            time.sleep(1)  # Give some time for the scrolling to complete
+
+            # Click the element using JavaScript
+            wd.execute_script("arguments[0].click();", element)
+        except Exception as e:
+            return f"Could not click captcha checkbox: {str(e)}"
+
+        try:
+            # Now check if the reCAPTCHA is checked
+            WebDriverWait(wd, 3).until(
+                lambda d: d.find_element(By.CLASS_NAME, "recaptcha-checkbox").get_attribute(
+                    "aria-checked") == "true"
+            )
+
+            return "Success"
+        except Exception as e:
+            pass
+
+        wd.switch_to.default_content()
+
+        client = get_openai_client()
+
+        WebDriverWait(wd, 10).until(
+            frame_to_be_available_and_switch_to_it(
+                (By.XPATH, "//iframe[@title='recaptcha challenge expires in two minutes']"))
+        )
+
+        time.sleep(2)
+
+        attempts = 0
+        while attempts < 5:
+            tiles = wd.find_elements(By.CLASS_NAME, "rc-imageselect-tile")
+
+            # filter out tiles with rc-imageselect-dynamic-selected class
+            tiles = [tile for tile in tiles if
+                     not tile.get_attribute("class").endswith("rc-imageselect-dynamic-selected")]
+
+            image_content = []
+            i = 0
+            for tile in tiles:
+                i += 1
+                screenshot = get_b64_screenshot(wd, tile)
+
+                image_content.append(
+                    {
+                        "type": "text",
+                        "text": f"Image {i}:",
+                    }
+                )
+                image_content.append(
+                    {
+                        "type": "image_url",
+                        "image_url":
+                            {
+                                "url": f"data:image/jpeg;base64,{screenshot}",
+                                "detail": "high",
+                            }
+                    },
+                )
+            # highlight all titles with rc-imageselect-tile class but not with rc-imageselect-dynamic-selected
+            # wd = highlight_elements_with_labels(wd, 'td.rc-imageselect-tile:not(.rc-imageselect-dynamic-selected)')
+
+            # screenshot = get_b64_screenshot(wd, wd.find_element(By.ID, "rc-imageselect"))
+
+            task_text = wd.find_element(By.CLASS_NAME, "rc-imageselect-instructions").text.strip().replace("\n",
+                                                                                                           " ")
+
+            continuous_task = 'once there are none left' in task_text.lower()
+
+            task_text = task_text.replace("Click verify", "Output 0")
+            task_text = task_text.replace("click skip", "Output 0")
+            task_text = task_text.replace("once", "if")
+            task_text = task_text.replace("none left", "none")
+            task_text = task_text.replace("all", "only")
+            task_text = task_text.replace("squares", "images")
+
+            additional_info = ""
+            if len(tiles) > 9:
+                additional_info = ("Keep in mind that all images are a part of a bigger image "
+                                   "from left to right, and top to bottom. The grid is 4x4. ")
+
+            messages = [
+                {
+                    "role": "system",
+                    "content": f"""You are an advanced AI designed to support users with visual impairments. 
+                    User will provide you with {i} images numbered from 1 to {i}. Your task is to output 
+                    the numbers of the images that contain the requested object, or at least some part of the requested 
+                    object. {additional_info}If there are no individual images that satisfy this condition, output 0.
+                    """.replace("\n", ""),
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        *image_content,
+                        {
+                            "type": "text",
+                            "text": f"{task_text}. Only output numbers separated by commas and nothing else. "
+                                    f"Output 0 if there are none."
+                        }
+                    ]
+                }]
+
+            response = client.chat.completions.create(
+                model="gpt-4o",
+                messages=messages,
+                max_tokens=1024,
+                temperature=0.0,
+            )
+
+            message = response.choices[0].message
+            message_text = message.content
+
+            # check if 0 is in the message
+            if "0" in message_text and "10" not in message_text:
+                # Find the button by its ID
+                verify_button = wd.find_element(By.ID, "recaptcha-verify-button")
+
+                verify_button_text = verify_button.text
+
+                # Click the button
+                wd.execute_script("arguments[0].click();", verify_button)
+
+                time.sleep(1)
+
+                try:
+                    if self.verify_checkbox(wd):
+                        return "Success. Captcha solved."
+                except Exception as e:
+                    print('Not checked')
+                    pass
+
+            else:
+                numbers = [int(s.strip()) for s in message_text.split(",") if s.strip().isdigit()]
+
+                # Click the tiles based on the provided numbers
+                for number in numbers:
+                    wd.execute_script("arguments[0].click();", tiles[number - 1])
+                    time.sleep(0.5)
+
+                time.sleep(3)
+
+                if not continuous_task:
+                    # Find the button by its ID
+                    verify_button = wd.find_element(By.ID, "recaptcha-verify-button")
+
+                    verify_button_text = verify_button.text
+
+                    # Click the button
+                    wd.execute_script("arguments[0].click();", verify_button)
+
+                    try:
+                        if self.verify_checkbox(wd):
+                            return "Success. Captcha solved."
+                    except Exception as e:
+                        pass
+                else:
+                    continue
+
+            if "verify" in verify_button_text.lower():
+                attempts += 1
+
+        wd = remove_highlight_and_labels(wd)
+
+        wd.switch_to.default_content()
+
+        # close captcha
+        try:
+            element = WebDriverWait(wd, 3).until(
+                presence_of_element_located((By.XPATH, "//iframe[@title='reCAPTCHA']"))
+            )
+
+            wd.execute_script(f"document.elementFromPoint({element.location['x']}, {element.location['y']-10}).click();")
+        except Exception as e:
+            print(e)
+            pass
+
+        return "Could not solve captcha."
+
+    def verify_checkbox(self, wd):
+        wd.switch_to.default_content()
+
+        try:
+            WebDriverWait(wd, 10).until(
+                frame_to_be_available_and_switch_to_it((By.XPATH, "//iframe[@title='reCAPTCHA']"))
+            )
+
+            WebDriverWait(wd, 5).until(
+                lambda d: d.find_element(By.CLASS_NAME, "recaptcha-checkbox").get_attribute(
+                    "aria-checked") == "true"
+            )
+
+            return True
+        except Exception as e:
+            wd.switch_to.default_content()
+
+            WebDriverWait(wd, 10).until(
+                frame_to_be_available_and_switch_to_it(
+                    (By.XPATH, "//iframe[@title='recaptcha challenge expires in two minutes']"))
+            )
+
+        return False
+

BrowsingAgent/tools/WebPageSummarizer.py

@@ -0,0 +1,39 @@
+from selenium.webdriver.common.by import By
+
+from agency_swarm.tools import BaseTool
+from .util import get_web_driver, set_web_driver
+
+
+class WebPageSummarizer(BaseTool):
+    """
+    This tool summarizes the content of the current web page, extracting the main points and providing a concise summary.
+    """
+
+    def run(self):
+        from agency_swarm import get_openai_client
+
+        wd = get_web_driver()
+        client = get_openai_client()
+
+        content = wd.find_element(By.TAG_NAME, "body").text
+
+        # only use the first 10000 characters
+        content = " ".join(content.split()[:10000])
+
+        completion = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "Your task is to summarize the content of the provided webpage. The summary should be concise and informative, capturing the main points and takeaways of the page."},
+                {"role": "user", "content": "Summarize the content of the following webpage:\n\n" + content},
+            ],
+            temperature=0.0,
+        )
+
+        return completion.choices[0].message.content
+
+if __name__ == "__main__":
+    wd = get_web_driver()
+    wd.get("https://en.wikipedia.org/wiki/Python_(programming_language)")
+    set_web_driver(wd)
+    tool = WebPageSummarizer()
+    print(tool.run())

BrowsingAgent/tools/__init__.py

@@ -0,0 +1,9 @@
+from .Scroll import Scroll
+from .ReadURL import ReadURL
+from .SendKeys import SendKeys
+from .ClickElement import ClickElement
+from .GoBack import GoBack
+from .SelectDropdown import SelectDropdown
+from .SolveCaptcha import SolveCaptcha
+from .ExportFile import ExportFile
+from .WebPageSummarizer import WebPageSummarizer

BrowsingAgent/tools/util/__init__.py

@@ -0,0 +1,3 @@
+from .get_b64_screenshot import get_b64_screenshot
+from .selenium import get_web_driver, set_web_driver
+from .highlights import remove_highlight_and_labels, highlight_elements_with_labels

BrowsingAgent/tools/util/get_b64_screenshot.py

@@ -0,0 +1,8 @@
+
+def get_b64_screenshot(wd, element=None):
+    if element:
+        screenshot_b64 = element.screenshot_as_base64
+    else:
+        screenshot_b64 = wd.get_screenshot_as_base64()
+
+    return screenshot_b64

BrowsingAgent/tools/util/highlights.py

@@ -0,0 +1,139 @@
+def highlight_elements_with_labels(driver, selector):
+    """
+    This function highlights clickable elements like buttons, links, and certain divs and spans
+    that match the given CSS selector on the webpage with a red border and ensures that labels are visible and positioned
+    correctly within the viewport.
+
+    :param driver: Instance of Selenium WebDriver.
+    :param selector: CSS selector for the elements to be highlighted.
+    """
+    script = f"""
+        // Helper function to check if an element is visible
+        function isElementVisible(element) {{
+            var rect = element.getBoundingClientRect();
+            if (rect.width <= 0 || rect.height <= 0 || 
+                rect.top >= (window.innerHeight || document.documentElement.clientHeight) || 
+                rect.bottom <= 0 || 
+                rect.left >= (window.innerWidth || document.documentElement.clientWidth) || 
+                rect.right <= 0) {{
+                return false;
+            }}
+            // Check if any parent element is hidden, which would hide this element as well
+            var parent = element;
+            while (parent) {{
+                var style = window.getComputedStyle(parent);
+                if (style.display === 'none' || style.visibility === 'hidden') {{
+                    return false;
+                }}
+                parent = parent.parentElement;
+            }}
+            return true;
+        }}
+
+        // Remove previous labels and styles if they exist
+        document.querySelectorAll('.highlight-label').forEach(function(label) {{
+            label.remove();
+        }});
+        document.querySelectorAll('.highlighted-element').forEach(function(element) {{
+            element.classList.remove('highlighted-element');
+            element.removeAttribute('data-highlighted');
+        }});
+
+        // Inject custom style for highlighting elements
+        var styleElement = document.getElementById('highlight-style');
+        if (!styleElement) {{
+            styleElement = document.createElement('style');
+            styleElement.id = 'highlight-style';
+            document.head.appendChild(styleElement);
+        }}
+        styleElement.textContent = `
+            .highlighted-element {{ 
+                border: 2px solid red !important; 
+                position: relative; 
+                box-sizing: border-box; 
+            }}
+            .highlight-label {{ 
+                position: absolute; 
+                z-index: 2147483647; 
+                background: yellow; 
+                color: black; 
+                font-size: 25px; 
+                padding: 3px 5px; 
+                border: 1px solid black; 
+                border-radius: 3px; 
+                white-space: nowrap; 
+                box-shadow: 0px 0px 2px #000; 
+                top: -25px; 
+                left: 0; 
+                display: none;
+            }}
+        `;
+
+        // Function to create and append a label to the body
+        function createAndAdjustLabel(element, index) {{
+            if (!isElementVisible(element)) return;
+
+            element.classList.add('highlighted-element');
+            var label = document.createElement('div');
+            label.className = 'highlight-label';
+            label.textContent = index.toString();
+            label.style.display = 'block'; // Make the label visible
+
+            // Calculate label position
+            var rect = element.getBoundingClientRect();
+            var top = rect.top + window.scrollY - 25; // Position label above the element
+            var left = rect.left + window.scrollX;
+
+            label.style.top = top + 'px';
+            label.style.left = left + 'px';
+
+            document.body.appendChild(label); // Append the label to the body
+        }}
+
+        // Select all clickable elements and apply the styles
+        var allElements = document.querySelectorAll('{selector}');
+        var index = 1;
+        allElements.forEach(function(element) {{
+            // Check if the element is not already highlighted and is visible
+            if (!element.dataset.highlighted && isElementVisible(element)) {{
+                element.dataset.highlighted = 'true';
+                createAndAdjustLabel(element, index++);
+            }}
+        }});
+        """
+
+    driver.execute_script(script)
+
+    return driver
+
+
+def remove_highlight_and_labels(driver):
+    """
+    This function removes all red borders and labels from the webpage elements,
+    reversing the changes made by the highlight functions using Selenium WebDriver.
+
+    :param driver: Instance of Selenium WebDriver.
+    """
+    selector = ('a, button, input, textarea, div[onclick], div[role="button"], div[tabindex], span[onclick], '
+                'span[role="button"], span[tabindex]')
+    script = f"""
+        // Remove all labels
+        document.querySelectorAll('.highlight-label').forEach(function(label) {{
+            label.remove();
+        }});
+
+        // Remove the added style for red borders
+        var highlightStyle = document.getElementById('highlight-style');
+        if (highlightStyle) {{
+            highlightStyle.remove();
+        }}
+
+        // Remove inline styles added by highlighting function
+        document.querySelectorAll('{selector}').forEach(function(element) {{
+            element.style.border = '';
+        }});
+        """
+
+    driver.execute_script(script)
+
+    return driver

BrowsingAgent/tools/util/selenium.py

@@ -0,0 +1,154 @@
+import os
+
+wd = None
+
+selenium_config = {
+    "chrome_profile_path": None,
+    "headless": True,
+    "full_page_screenshot": True,
+}
+
+
+def get_web_driver():
+    print("Initializing WebDriver...")
+    try:
+        from selenium import webdriver
+        from selenium.webdriver.chrome.service import Service as ChromeService
+        print("Selenium imported successfully.")
+    except ImportError:
+        print("Selenium not installed. Please install it with pip install selenium")
+        raise ImportError
+
+    try:
+        from webdriver_manager.chrome import ChromeDriverManager
+        print("webdriver_manager imported successfully.")
+    except ImportError:
+        print("webdriver_manager not installed. Please install it with pip install webdriver-manager")
+        raise ImportError
+
+    try:
+        from selenium_stealth import stealth
+        print("selenium_stealth imported successfully.")
+    except ImportError:
+        print("selenium_stealth not installed. Please install it with pip install selenium-stealth")
+        raise ImportError
+
+    global wd, selenium_config
+
+    if wd:
+        print("Returning existing WebDriver instance.")
+        return wd
+
+    chrome_profile_path = selenium_config.get("chrome_profile_path", None)
+    profile_directory = None
+    user_data_dir = None
+    if isinstance(chrome_profile_path, str) and os.path.exists(chrome_profile_path):
+        profile_directory = os.path.split(chrome_profile_path)[-1].strip("\\").rstrip("/")
+        user_data_dir = os.path.split(chrome_profile_path)[0].strip("\\").rstrip("/")
+        print(f"Using Chrome profile: {profile_directory}")
+        print(f"Using Chrome user data dir: {user_data_dir}")
+        print(f"Using Chrome profile path: {chrome_profile_path}")
+
+    chrome_options = webdriver.ChromeOptions()
+    print("ChromeOptions initialized.")
+
+    chrome_driver_path = "/usr/bin/chromedriver"
+    if not os.path.exists(chrome_driver_path):
+        print("ChromeDriver not found at /usr/bin/chromedriver. Installing using webdriver_manager.")
+        chrome_driver_path = ChromeDriverManager().install()
+    else:
+        print(f"ChromeDriver found at {chrome_driver_path}.")
+
+    if selenium_config.get("headless", False):
+        chrome_options.add_argument('--headless')
+        print("Headless mode enabled.")
+    if selenium_config.get("full_page_screenshot", False):
+        chrome_options.add_argument("--start-maximized")
+        print("Full page screenshot mode enabled.")
+    else:
+        chrome_options.add_argument("--window-size=1920,1080")
+        print("Window size set to 1920,1080.")
+
+    chrome_options.add_argument("--no-sandbox")
+    chrome_options.add_argument("--disable-gpu")
+    chrome_options.add_argument("--disable-dev-shm-usage")
+    chrome_options.add_argument("--remote-debugging-port=9222")
+    chrome_options.add_argument("--disable-extensions")
+    chrome_options.add_argument("--disable-popup-blocking")
+    chrome_options.add_argument("--ignore-certificate-errors")
+    chrome_options.add_argument("--disable-blink-features=AutomationControlled")
+    chrome_options.add_argument("--disable-web-security")
+    chrome_options.add_argument("--allow-running-insecure-content")
+    chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
+    chrome_options.add_experimental_option("useAutomationExtension", False)
+    print("Chrome options configured.")
+
+    if user_data_dir and profile_directory:
+        chrome_options.add_argument(f"user-data-dir={user_data_dir}")
+        chrome_options.add_argument(f"profile-directory={profile_directory}")
+        print(f"Using user data dir: {user_data_dir} and profile directory: {profile_directory}")
+
+    try:
+        wd = webdriver.Chrome(service=ChromeService(chrome_driver_path), options=chrome_options)
+        print("WebDriver initialized successfully.")
+        if wd.capabilities['chrome']['userDataDir']:
+            print(f"Profile path in use: {wd.capabilities['chrome']['userDataDir']}")
+    except Exception as e:
+        print(f"Error initializing WebDriver: {e}")
+        raise e
+
+    if not selenium_config.get("chrome_profile_path", None):
+        stealth(
+            wd,
+            languages=["en-US", "en"],
+            vendor="Google Inc.",
+            platform="Win32",
+            webgl_vendor="Intel Inc.",
+            renderer="Intel Iris OpenGL Engine",
+            fix_hairline=True,
+        )
+        print("Stealth mode configured.")
+
+    wd.implicitly_wait(3)
+    print("Implicit wait set to 3 seconds.")
+
+    return wd
+
+
+def set_web_driver(new_wd):
+    # remove all popups
+    js_script = """
+    var popUpSelectors = ['modal', 'popup', 'overlay', 'dialog']; // Add more selectors that are commonly used for pop-ups
+    popUpSelectors.forEach(function(selector) {
+        var elements = document.querySelectorAll(selector);
+        elements.forEach(function(element) {
+            // You can choose to hide or remove; here we're removing the element
+            element.parentNode.removeChild(element);
+        });
+    });
+    """
+
+    new_wd.execute_script(js_script)
+
+    # Close LinkedIn specific popups
+    if "linkedin.com" in new_wd.current_url:
+        linkedin_js_script = """
+        var linkedinSelectors = ['div.msg-overlay-list-bubble', 'div.ml4.msg-overlay-list-bubble__tablet-height'];
+        linkedinSelectors.forEach(function(selector) {
+            var elements = document.querySelectorAll(selector);
+            elements.forEach(function(element) {
+                element.parentNode.removeChild(element);
+            });
+        });
+        """
+        new_wd.execute_script(linkedin_js_script)
+
+    new_wd.execute_script("document.body.style.zoom='1.2'")
+
+    global wd
+    wd = new_wd
+
+
+def set_selenium_config(config):
+    global selenium_config
+    selenium_config = config

CompetitorTrackingAgent/CompetitorTrackingAgent.py

@@ -0,0 +1,19 @@
+from agency_swarm.agents import Agent
+
+
+class CompetitorTrackingAgent(Agent):
+    def __init__(self):
+        super().__init__(
+            name="CompetitorTrackingAgent",
+            description="This agent monitors competitors using web scraping tools like BeautifulSoup or Scrapy.",
+            instructions="./instructions.md",
+            files_folder="./files",
+            schemas_folder="./schemas",
+            tools=[],
+            tools_folder="./tools",
+            temperature=0.3,
+            max_prompt_tokens=25000,
+        )
+        
+    def response_validator(self, message):
+        return message

CompetitorTrackingAgent/__init__.py

@@ -0,0 +1 @@
+from .CompetitorTrackingAgent import CompetitorTrackingAgent

CompetitorTrackingAgent/instructions.md

@@ -0,0 +1,11 @@
+# CompetitorTrackingAgent Instructions
+
+You are an agent responsible for monitoring competitors by using web scraping tools like BeautifulSoup or Scrapy. You must ensure that the data collected is accurate and relevant to the agency's goals.
+
+### Primary Instructions:
+1. Identify competitor websites and online platforms that provide relevant information.
+2. Use web scraping tools like BeautifulSoup or Scrapy to extract data from these sources.
+3. Validate and clean the scraped data to ensure its accuracy and integrity.
+4. Store the collected data in a structured format that is accessible to other agents within the agency.
+5. Collaborate with other agents to provide them with the necessary data for their tasks.
+6. Monitor the competitor websites for any changes or updates and adjust the data collection process accordingly.

CompetitorTrackingAgent/tools/WebScrapingTool.py

@@ -0,0 +1,59 @@
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import requests
+from bs4 import BeautifulSoup
+
+class WebScrapingTool(BaseTool):
+    """
+    A tool for performing web scraping tasks using BeautifulSoup.
+    This tool fetches a web page, parses the HTML content, and extracts specific data based on given criteria or tags.
+    """
+
+    url: str = Field(
+        ..., description="The URL of the web page to scrape."
+    )
+    tag: str = Field(
+        ..., description="The HTML tag to search for in the web page."
+    )
+    attribute: str = Field(
+        None, description="The attribute of the HTML tag to filter by, if any."
+    )
+    attribute_value: str = Field(
+        None, description="The value of the attribute to filter by, if any."
+    )
+
+    def run(self):
+        """
+        Fetches the web page, parses the HTML content, and extracts data based on the specified tag and attribute.
+        """
+        try:
+            # Make an HTTP request to fetch the web page
+            response = requests.get(self.url)
+            response.raise_for_status()  # Raise an error for bad responses
+
+            # Parse the HTML content using BeautifulSoup
+            soup = BeautifulSoup(response.content, 'html.parser')
+
+            # Find all elements matching the specified tag and attribute
+            if self.attribute and self.attribute_value:
+                elements = soup.find_all(self.tag, {self.attribute: self.attribute_value})
+            else:
+                elements = soup.find_all(self.tag)
+
+            # Extract and return the text content of the found elements
+            extracted_data = [element.get_text(strip=True) for element in elements]
+            return extracted_data
+
+        except requests.RequestException as e:
+            return f"An error occurred while fetching the web page: {e}"
+        except Exception as e:
+            return f"An error occurred during parsing or extraction: {e}"
+
+if __name__ == "__main__":
+    tool = WebScrapingTool(
+        url="https://example.com",
+        tag="p",
+        attribute="class",
+        attribute_value="content"
+    )
+    print(tool.run())

DataAnalystAgent/DataAnalystAgent.py

@@ -0,0 +1,19 @@
+from agency_swarm.agents import Agent
+from agency_swarm.tools import CodeInterpreter
+
+class DataAnalystAgent(Agent):
+    def __init__(self):
+        super().__init__(
+            name="DataAnalystAgent",
+            description="This agent analyzes the collected data to identify trends, opportunities, and insights.",
+            instructions="./instructions.md",
+            files_folder="./files",
+            schemas_folder="./schemas",
+            tools=[CodeInterpreter],
+            tools_folder="./tools",
+            temperature=0.3,
+            max_prompt_tokens=25000,
+        )
+        
+    def response_validator(self, message):
+        return message

DataAnalystAgent/__init__.py

@@ -0,0 +1 @@
+from .DataAnalystAgent import DataAnalystAgent

DataAnalystAgent/instructions.md

@@ -0,0 +1,11 @@
+# DataAnalystAgent Instructions
+
+You are an agent responsible for analyzing the collected market data to identify trends, opportunities, and insights. You must use data analysis tools and libraries like Pandas and NumPy to perform your tasks effectively.
+
+### Primary Instructions:
+1. Access the structured data collected by the DataCollectorAgent.
+2. Use data analysis libraries such as Pandas and NumPy to process and analyze the data.
+3. Identify trends, patterns, and anomalies in the data that could provide valuable insights.
+4. Generate reports and visualizations to communicate your findings to other agents and clients.
+5. Collaborate with other agents to ensure your analysis aligns with the agency's goals and objectives.
+6. Continuously update your analysis based on new data and feedback from clients and stakeholders.

DataAnalystAgent/tools/DataAnalysisTool.py

@@ -0,0 +1,89 @@
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import io
+
+class DataAnalysisTool(BaseTool):
+    """
+    This tool utilizes data analysis libraries such as Pandas and NumPy to process and analyze structured data.
+    It is capable of identifying trends, patterns, and anomalies in the data.
+    The tool also generates reports and visualizations to communicate findings.
+    """
+
+    data: str = Field(
+        ..., description="The structured data in CSV format to be analyzed."
+    )
+
+    def run(self):
+        """
+        Processes and analyzes the provided structured data.
+        Identifies trends, patterns, and anomalies, and generates reports and visualizations.
+        """
+        # Load data into a Pandas DataFrame
+        data_io = io.StringIO(self.data)
+        df = pd.read_csv(data_io)
+
+        # Perform basic data analysis
+        summary = self._generate_summary(df)
+        trends = self._identify_trends(df)
+        anomalies = self._detect_anomalies(df)
+
+        # Generate visualizations
+        visualizations = self._generate_visualizations(df)
+
+        # Compile the report
+        report = {
+            "summary": summary,
+            "trends": trends,
+            "anomalies": anomalies,
+            "visualizations": visualizations
+        }
+
+        return report
+
+    def _generate_summary(self, df):
+        """
+        Generates a summary of the data including basic statistics.
+        """
+        summary = df.describe().to_dict()
+        return summary
+
+    def _identify_trends(self, df):
+        """
+        Identifies trends in the data using rolling averages.
+        """
+        trends = {}
+        for column in df.select_dtypes(include=[np.number]).columns:
+            trends[column] = df[column].rolling(window=5).mean().dropna().tolist()
+        return trends
+
+    def _detect_anomalies(self, df):
+        """
+        Detects anomalies in the data using z-score method.
+        """
+        anomalies = {}
+        for column in df.select_dtypes(include=[np.number]).columns:
+            z_scores = np.abs((df[column] - df[column].mean()) / df[column].std())
+            anomalies[column] = df[column][z_scores > 3].tolist()
+        return anomalies
+
+    def _generate_visualizations(self, df):
+        """
+        Generates visualizations for the data.
+        """
+        visualizations = {}
+        for column in df.select_dtypes(include=[np.number]).columns:
+            plt.figure(figsize=(10, 6))
+            sns.lineplot(data=df, x=df.index, y=column)
+            plt.title(f'Trend for {column}')
+            plt.xlabel('Index')
+            plt.ylabel(column)
+            buf = io.BytesIO()
+            plt.savefig(buf, format='png')
+            buf.seek(0)
+            visualizations[column] = buf.getvalue()
+            plt.close()
+        return visualizations