Add new agents and tools for Devid and BrowsingAgent; remove obsolete ResearchAndReportAgent

app/agents/BrowsingAgent/BrowsingAgent.py

@@ -0,0 +1,188 @@
+import base64
+import re
+
+from typing_extensions import override
+
+from agency_swarm.agents import Agent
+from agency_swarm.tools.oai import FileSearch
+
+
+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 selenium.webdriver.common.by import By
+        from selenium.webdriver.support.select import Select
+
+        from .tools.util import (
+            highlight_elements_with_labels,
+            remove_highlight_and_labels,
+        )
+        from .tools.util.selenium import get_web_driver, set_web_driver
+
+        # 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 import get_b64_screenshot
+        from .tools.util.selenium import get_web_driver
+
+        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)

app/agents/BrowsingAgent/__init__.py

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

app/agents/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.

app/agents/BrowsingAgent/requirements.txt

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

app/agents/BrowsingAgent/tools/ClickElement.py

@@ -0,0 +1,65 @@
+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

app/agents/BrowsingAgent/tools/ExportFile.py

@@ -0,0 +1,53 @@
+import base64
+
+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()

app/agents/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

app/agents/BrowsingAgent/tools/ReadURL.py

@@ -0,0 +1,54 @@
+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())

app/agents/BrowsingAgent/tools/Scroll.py

@@ -0,0 +1,58 @@
+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

app/agents/BrowsingAgent/tools/SelectDropdown.py

@@ -0,0 +1,63 @@
+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

app/agents/BrowsingAgent/tools/SendKeys.py

@@ -0,0 +1,76 @@
+import time
+from typing import Dict
+
+from pydantic import Field, model_validator
+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
+
+
+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: "[email protected]", 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

app/agents/BrowsingAgent/tools/SolveCaptcha.py

@@ -0,0 +1,272 @@
+import base64
+import time
+
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.expected_conditions import (
+    frame_to_be_available_and_switch_to_it,
+    presence_of_element_located,
+)
+from selenium.webdriver.support.wait import WebDriverWait
+
+from agency_swarm.tools import BaseTool
+from agency_swarm.util import get_openai_client
+
+from .util import get_b64_screenshot, remove_highlight_and_labels
+from .util.selenium import get_web_driver
+
+
+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

app/agents/BrowsingAgent/tools/WebPageSummarizer.py

@@ -0,0 +1,48 @@
+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())

app/agents/BrowsingAgent/tools/__init__.py

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

app/agents/BrowsingAgent/tools/util/__init__.py

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

app/agents/BrowsingAgent/tools/util/get_b64_screenshot.py

@@ -0,0 +1,7 @@
+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

app/agents/BrowsingAgent/tools/util/highlights.py

@@ -0,0 +1,141 @@
+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

app/agents/BrowsingAgent/tools/util/selenium.py

@@ -0,0 +1,169 @@
+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

app/agents/Devid/Devid.py

@@ -0,0 +1,47 @@
+import re
+
+from typing_extensions import override
+
+from agency_swarm.agents import Agent
+from agency_swarm.tools import FileSearch
+from agency_swarm.util.validators import llm_validator
+
+
+class Devid(Agent):
+    def __init__(self):
+        super().__init__(
+            name="Devid",
+            description="Devid is an AI software engineer capable of performing advanced coding tasks.",
+            instructions="./instructions.md",
+            files_folder="./files",
+            schemas_folder="./schemas",
+            tools=[FileSearch],
+            tools_folder="./tools",
+            validation_attempts=1,
+            temperature=0,
+            max_prompt_tokens=25000,
+        )
+
+    @override
+    def response_validator(self, message):
+        pattern = r"(```)((.*\n){5,})(```)"
+
+        if re.search(pattern, message):
+            # take only first 100 characters
+            raise ValueError(
+                "You returned code snippet. Please never return code snippets to me. "
+                "Use the FileWriter tool to write the code locally. Then, test it if possible. Continue."
+            )
+
+        llm_validator(
+            statement="Verify whether the update from the AI Developer Agent confirms the task's "
+            "successful completion. If the task remains unfinished, provide guidance "
+            "within the 'reason' argument on the next steps the agent should take. For "
+            "instance, if the agent encountered an error, advise the inclusion of debug "
+            "statements for another attempt. Should the agent outline potential "
+            "solutions or further actions, direct the agent to execute those plans. "
+            "Message does not have to contain code snippets. Just confirmation.",
+            client=self.client,
+        )(message)
+
+        return message

app/agents/Devid/__init__.py

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

app/agents/Devid/instructions.md

@@ -0,0 +1,21 @@
+# Devid Operational Guide
+
+As an AI software developer known as Devid, your role involves reading, writing, and modifying files to fulfill tasks derived from user requests.
+
+**Operational Environment**:
+- You have direct access to the internet, system executions, or environment variables.
+- Interaction with the local file system to read, write, and modify files is permitted.
+- Python is installed in your environment, enabling the execution of Python scripts and code snippets.
+- Node.js and npm are also installed, allowing for the execution of Node.js scripts and code snippets.
+- Installation of additional third-party libraries is within your capabilities.
+- Execution of commands in the terminal to compile and run code is possible.
+
+## Primary Instructions:
+
+1. Begin by fully understanding the task at hand. Use the `myfiles_browser` tool to access and review any files uploaded by the user. If initial access to files fails, retry the operation until successful. Continue browsing the files until you have gathered sufficient information to proceed. Skip this step if no files were provided.
+2. Verify your current directory's path and contents with `ListDir` and `CheckCurrentDir`. If necessary, navigate to the correct directory using the `DirectoryNavigator` tool or create a new directory for the task.
+3. Utilize the `FileWriter` for creating or modifying files. To read a file, employ the `FileReader` tool. Always modify local files when executing tasks and avoid sending code snippets to the user. Work on one file at a time and refrain from creating or modifying multiple files simultaneously. Complete each file with `FileWriter` before proceeding to the next, integrating these files into the dependencies of the main file.
+4. Execute your written code with the `CommandExecutor` by running the appropriate terminal commands. Iteratively debug and test to achieve the desired outcome. Seek clarification from the user only after all internal resolution efforts have been exhausted. To install additional libraries, execute the necessary terminal commands.
+5. Repeat the above steps for each task.
+
+**Important Note**: Your capabilities include accessing and interacting with local files, online resources, and the terminal. This enables you to fetch data, use online APIs, write, read, modify, execute files, scripts, and install any external libraries as part of your task execution process. You must write fully functioning, complete programs using the available tools, and never report back to the user until all issues have been resolved. Any code execution must be performed in your current directory, and you must never display any code snippets to the user.

app/agents/Devid/tools/ChangeFile.py

@@ -0,0 +1,107 @@
+import os
+from enum import Enum
+from typing import List, Literal, Optional
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+from agency_swarm import BaseTool
+
+
+class LineChange(BaseModel):
+    """
+    Line changes to be made.
+    """
+
+    line_number: int = Field(
+        ..., description="Line number to change.", examples=[1, 2, 3]
+    )
+    new_line: Optional[str] = Field(
+        None,
+        description="New line to replace the old line. Not required only for delete mode.",
+        examples=["This is a new line"],
+    )
+    mode: Literal["replace", "insert", "delete"] = Field(
+        "replace",
+        description='Mode to use for the line change. "replace" replaces the line with the new line. '
+        '"insert" inserts the new line at the specified line number, moving the previous line down.'
+        ' "delete" deletes the specified line number.',
+    )
+
+    @model_validator(mode="after")
+    def validate_new_line(self):
+        mode, new_line = self.mode, self.new_line
+        if mode == "delete" and new_line is not None:
+            raise ValueError("new_line should not be specified for delete mode.")
+        elif mode in ["replace", "insert"] and new_line is None:
+            raise ValueError(
+                "new_line should be specified for replace and insert modes."
+            )
+        return self
+
+
+class ChangeFile(BaseTool):
+    """
+    This tool changes specified lines in a file. Returns the new file contents with line numbers at the start of each line.
+    """
+
+    chain_of_thought: str = Field(
+        ...,
+        description="Please think step-by-step about the required changes to the file in order to construct a fully functioning and correct program according to the requirements.",
+        exclude=True,
+    )
+    file_path: str = Field(
+        ...,
+        description="Path to the file with extension.",
+        examples=["./file.txt", "./file.json", "../../file.py"],
+    )
+    changes: List[LineChange] = Field(
+        ...,
+        description="Line changes to be made to the file.",
+        examples=[
+            {"line_number": 1, "new_line": "This is a new line", "mode": "replace"}
+        ],
+    )
+
+    def run(self):
+        # read file
+        with open(self.file_path, "r") as f:
+            file_contents = f.readlines()
+
+            # Process changes in a way that accounts for modifications affecting line numbers
+            for change in sorted(
+                self.changes, key=lambda x: x.line_number, reverse=True
+            ):
+                try:
+                    if change.mode == "replace" and 0 < change.line_number <= len(
+                        file_contents
+                    ):
+                        file_contents[change.line_number - 1] = change.new_line + "\n"
+                    elif change.mode == "insert":
+                        file_contents.insert(
+                            change.line_number - 1, change.new_line + "\n"
+                        )
+                    elif change.mode == "delete" and 0 < change.line_number <= len(
+                        file_contents
+                    ):
+                        file_contents.pop(change.line_number - 1)
+                except IndexError:
+                    return f"Error: Line number {change.line_number} is out of the file's range."
+
+        # write file
+        with open(self.file_path, "w") as f:
+            f.writelines(file_contents)
+
+        with open(self.file_path, "r") as f:
+            file_contents = f.readlines()
+
+        # return file contents with line numbers
+        return "\n".join([f"{i + 1}. {line}" for i, line in enumerate(file_contents)])
+
+    # use field validation to ensure that the file path is valid
+    @field_validator("file_path", mode="after")
+    @classmethod
+    def validate_file_path(cls, v: str):
+        if not os.path.exists(v):
+            raise ValueError("File path does not exist.")
+
+        return v

app/agents/Devid/tools/CheckCurrentDir.py

@@ -0,0 +1,23 @@
+from pydantic import Field
+
+from agency_swarm import BaseTool
+
+
+class CheckCurrentDir(BaseTool):
+    """
+    This tool checks the current directory path.
+    """
+
+    chain_of_thought: str = Field(
+        ...,
+        description="Please think step-by-step about what you need to do next, after checking current directory to solve the task.",
+        exclude=True,
+    )
+
+    class ToolConfig:
+        one_call_at_a_time: bool = True
+
+    def run(self):
+        import os
+
+        return os.getcwd()

app/agents/Devid/tools/CommandExecutor.py

@@ -0,0 +1,46 @@
+import shlex
+import subprocess
+
+from dotenv import find_dotenv, load_dotenv
+from pydantic import Field
+
+from agency_swarm.tools import BaseTool
+
+
+class CommandExecutor(BaseTool):
+    """
+    Executes a specified command in the terminal and captures the output.
+
+    This tool runs a given command in the system's default shell and returns the stdout and stderr.
+    """
+
+    command: str = Field(..., description="The command to execute in the terminal.")
+
+    def run(self):
+        """
+        Executes the command and captures its output.
+
+        Returns:
+            A dictionary containing the standard output (stdout), standard error (stderr),
+            and the exit code of the command.
+        """
+        load_dotenv(find_dotenv() or None)
+        # Ensure the command is safely split for subprocess
+        command_parts = shlex.split(self.command)
+
+        # Execute the command and capture the output
+        result = subprocess.run(command_parts, capture_output=True, text=True)
+
+        # check if the command failed
+        if result.returncode != 0 or result.stderr:
+            return (
+                f"stdout: {result.stdout}\nstderr: {result.stderr}\nexit code: {result.returncode}\n\n"
+                f"Please add error handling and continue debugging until the command runs successfully."
+            )
+
+        return f"stdout: {result.stdout}\nstderr: {result.stderr}\nexit code: {result.returncode}"
+
+
+if __name__ == "__main__":
+    tool = CommandExecutor(command="ls -l")
+    print(tool.run())

app/agents/Devid/tools/DirectoryNavigator.py

@@ -0,0 +1,56 @@
+import os
+
+from pydantic import Field, field_validator, model_validator
+
+from agency_swarm.tools import BaseTool
+
+
+class DirectoryNavigator(BaseTool):
+    """Allows you to navigate directories. Do not use this tool more than once at a time.
+    You must finish all tasks in the current directory before navigating into new directory."""
+
+    path: str = Field(..., description="The path of the directory to navigate to.")
+    create: bool = Field(
+        False,
+        description="If True, the directory will be created if it does not exist.",
+    )
+
+    class ToolConfig:
+        one_call_at_a_time: bool = True
+
+    def run(self):
+        try:
+            os.chdir(self.path)
+            return f"Successfully changed directory to: {self.path}"
+        except Exception as e:
+            return f"Error changing directory: {e}"
+
+    @field_validator("create", mode="before")
+    @classmethod
+    def validate_create(cls, v):
+        if not isinstance(v, bool):
+            if v.lower() == "true":
+                return True
+            elif v.lower() == "false":
+                return False
+        return v
+
+    @model_validator(mode="after")
+    def validate_path(self):
+        if not os.path.isdir(self.path):
+            if "/mnt/data" in self.path:
+                raise ValueError(
+                    "You tried to access an openai file directory with a local directory reader tool. "
+                    + "Please use the `myfiles_browser` tool to access openai files instead. "
+                    + "Your local files are most likely located in your current directory."
+                )
+
+            if self.create:
+                os.makedirs(self.path)
+            else:
+                raise ValueError(
+                    f"The path {self.path} does not exist. Please provide a valid directory path. "
+                    + "If you want to create the directory, set the `create` parameter to True."
+                )
+
+        return self

app/agents/Devid/tools/FileMover.py

@@ -0,0 +1,39 @@
+import os
+import shutil
+
+from pydantic import Field
+
+from agency_swarm.tools import BaseTool
+
+
+class FileMover(BaseTool):
+    """
+    FileMover is a tool designed to move files from a source path to a destination path. If the destination directory does not exist, it will be created.
+    """
+
+    source_path: str = Field(
+        ...,
+        description="The full path of the file to move, including the file name and extension.",
+    )
+    destination_path: str = Field(
+        ...,
+        description="The destination path where the file should be moved, including the new file name and extension if changing.",
+    )
+
+    def run(self):
+        """
+        Executes the file moving operation from the source path to the destination path.
+        It checks if the destination directory exists and creates it if necessary, then moves the file.
+        """
+        if not os.path.exists(self.source_path):
+            return f"Source file does not exist at {self.source_path}"
+
+        # Ensure the destination directory exists
+        destination_dir = os.path.dirname(self.destination_path)
+        if not os.path.exists(destination_dir):
+            os.makedirs(destination_dir)
+
+        # Move the file
+        shutil.move(self.source_path, self.destination_path)
+
+        return f"File moved successfully from {self.source_path} to {self.destination_path}"

app/agents/Devid/tools/FileReader.py

@@ -0,0 +1,32 @@
+from pydantic import Field, field_validator
+
+from agency_swarm.tools import BaseTool
+
+
+class FileReader(BaseTool):
+    """This tool reads a file and returns the contents along with line numbers on the left."""
+
+    file_path: str = Field(
+        ...,
+        description="Path to the file to read with extension.",
+        examples=["./file.txt", "./file.json", "../../file.py"],
+    )
+
+    def run(self):
+        # read file
+        with open(self.file_path, "r") as f:
+            file_contents = f.readlines()
+
+        # return file contents
+        return "\n".join([f"{i + 1}. {line}" for i, line in enumerate(file_contents)])
+
+    @field_validator("file_path", mode="after")
+    @classmethod
+    def validate_file_path(cls, v):
+        if "file-" in v:
+            raise ValueError(
+                "You tried to access an openai file with a wrong file reader tool. "
+                "Please use the `myfiles_browser` tool to access openai files instead."
+                "This tool is only for reading local files."
+            )
+        return v

app/agents/Devid/tools/FileWriter.py

@@ -0,0 +1,246 @@
+import os
+import re
+from typing import List, Literal, Optional
+
+from pydantic import Field, field_validator
+
+from agency_swarm import get_openai_client
+from agency_swarm.tools import BaseTool
+from agency_swarm.util.validators import llm_validator
+
+from .util import format_file_deps
+
+history = [
+    {
+        "role": "system",
+        "content": "As a top-tier software engineer focused on developing programs incrementally, you are entrusted with the creation or modification of files based on user requirements. It's imperative to operate under the assumption that all necessary dependencies are pre-installed and accessible, and the file in question will be deployed in an appropriate environment. Furthermore, it is presumed that all other modules or files upon which this file relies are accurate and error-free. Your output should be encapsulated within a code block, without specifying the programming language. Prior to embarking on the coding process, you must outline a methodical, step-by-step plan to precisely fulfill the requirements — no more, no less. It is crucial to ensure that the final code block is a complete file, without any truncation. This file should embody a flawless, fully operational program, inclusive of all requisite imports and functions, devoid of any placeholders, unless specified otherwise by the user.",
+    },
+]
+
+
+class FileWriter(BaseTool):
+    """This tools allows you to write new files or modify existing files according to specified requirements. In 'write' mode, it creates a new file or overwrites an existing one. In 'modify' mode, it modifies an existing file according to the provided requirements.
+    Note: This tool does not have access to other files within the project. You must provide all necessary details to ensure that the generated file can be used in conjunction with other files in this project."""
+
+    file_path: str = Field(
+        ...,
+        description="The path of the file to write or modify. Will create directories if they don't exist.",
+    )
+    requirements: str = Field(
+        ...,
+        description="The comprehensive requirements explaining how the file should be written or modified. This should be a detailed description of what the file should contain, including example inputs, desired behaviour and ideal outputs. It must not contain any code or implementation details.",
+    )
+    details: str = Field(
+        None,
+        description="Additional details like error messages, or class, function, and variable names from other files that this file depends on.",
+    )
+    documentation: Optional[str] = Field(
+        None,
+        description="Relevant documentation extracted with the myfiles_browser tool. You must pass all the relevant code from the documentation, as this tool does not have access to those files.",
+    )
+    mode: Literal["write", "modify"] = Field(
+        ...,
+        description="The mode of operation for the tool. 'write' is used to create a new file or overwrite an existing one. 'modify' is used to modify an existing file.",
+    )
+    file_dependencies: List[str] = Field(
+        [],
+        description="Paths to other files that the file being written depends on.",
+        examples=[
+            "/path/to/dependency1.py",
+            "/path/to/dependency2.css",
+            "/path/to/dependency3.js",
+        ],
+    )
+    library_dependencies: List[str] = Field(
+        [],
+        description="Any library dependencies required for the file to be written.",
+        examples=["numpy", "pandas"],
+    )
+
+    class ToolConfig:
+        one_call_at_a_time = True
+
+    def run(self):
+        client = get_openai_client()
+
+        file_dependencies = format_file_deps(self.file_dependencies)
+
+        library_dependencies = ", ".join(self.library_dependencies)
+
+        filename = os.path.basename(self.file_path)
+
+        if self.mode == "write":
+            message = f"Please write {filename} file that meets the following requirements: '{self.requirements}'.\n"
+        else:
+            message = f"Please rewrite the {filename} file according to the following requirements: '{self.requirements}'.\n Only output the file content, without any other text."
+
+        if file_dependencies:
+            message += f"\nHere are the dependencies from other project files: {file_dependencies}."
+        if library_dependencies:
+            message += f"\nUse the following libraries: {library_dependencies}"
+        if self.details:
+            message += f"\nAdditional Details: {self.details}"
+        if self.documentation:
+            message += f"\nDocumentation: {self.documentation}"
+
+        if self.mode == "modify":
+            message += f"\nThe existing file content is as follows:"
+
+            try:
+                with open(self.file_path, "r") as file:
+                    file_content = file.read()
+                    message += f"\n\n```{file_content}```"
+            except Exception as e:
+                return f"Error reading {self.file_path}: {e}"
+
+        history.append({"role": "user", "content": message})
+
+        messages = history.copy()
+
+        # use the last 5 messages
+        messages = messages[-5:]
+
+        # add system message upfront
+        messages.insert(0, history[0])
+
+        n = 0
+        error_message = ""
+        while n < 3:
+            if self.mode == "modify":
+                resp = client.chat.completions.create(
+                    messages=messages,
+                    model="gpt-4o",
+                    temperature=0,
+                    prediction={"type": "content", "content": file_content},
+                )
+            else:
+                resp = client.chat.completions.create(
+                    messages=messages,
+                    model="gpt-4o",
+                    temperature=0,
+                )
+
+            content = resp.choices[0].message.content
+
+            messages.append({"role": "assistant", "content": content})
+
+            pattern = r"```(?:[a-zA-Z]+\n)?(.*?)```"
+            match = re.findall(pattern, content, re.DOTALL)
+            if match:
+                code = match[-1].strip()
+                try:
+                    self.validate_content(code)
+
+                    history.append({"role": "assistant", "content": content})
+
+                    break
+                except Exception as e:
+                    print(f"Error: {e}. Trying again.")
+                    error_message = str(e)
+                    messages.append(
+                        {"role": "user", "content": f"Error: {e}. Please try again."}
+                    )
+            else:
+                messages.append(
+                    {
+                        "role": "user",
+                        "content": f"Error: Could not find the code block in the response. Please try again.",
+                    }
+                )
+
+            n += 1
+
+        if n == 3 or not code:
+            history.append({"role": "assistant", "content": content})
+            history.append({"role": "user", "content": error_message})
+            return "Error: Could not generate a valid file: " + error_message
+
+        try:
+            # create directories if they don't exist
+            dir_path = os.path.dirname(self.file_path)
+            if dir_path != "" and not os.path.exists(dir_path):
+                os.makedirs(dir_path, exist_ok=True)
+
+            with open(self.file_path, "w") as file:
+                file.write(code)
+            return f"Successfully wrote to file: {self.file_path}. Please make sure to now test the program. Below is the content of the file:\n\n```{content}```\n\nPlease now verify the integrity of the file and test it."
+        except Exception as e:
+            return f"Error writing to file: {e}"
+
+    @field_validator("file_dependencies", mode="after")
+    @classmethod
+    def validate_file_dependencies(cls, v):
+        for file in v:
+            if not os.path.exists(file):
+                raise ValueError(f"File dependency '{file}' does not exist.")
+        return v
+
+    def validate_content(self, v):
+        client = get_openai_client()
+
+        llm_validator(
+            statement="Check if the code is bug-free. Code should be considered in isolation, with the understanding that it is part of a larger, fully developed program that strictly adheres to these standards of completeness and correctness. All files, elements, components, functions, or modules referenced within this snippet are assumed to exist in other parts of the project and are also devoid of any errors, ensuring a cohesive and error-free integration across the entire software solution. Certain placeholders may be present.",
+            client=client,
+            model="gpt-4o",
+            temperature=0,
+            allow_override=False,
+        )(v)
+
+        return v
+
+    @field_validator("requirements", mode="after")
+    @classmethod
+    def validate_requirements(cls, v):
+        if "placeholder" in v:
+            raise ValueError(
+                "Requirements contain placeholders. "
+                "Please never user placeholders. Instead, implement only the code that you are confident about."
+            )
+
+        # check if code is included in requirements
+        pattern = r"(```)((.*\n){5,})(```)"
+        if re.search(pattern, v):
+            raise ValueError(
+                "Requirements contain a code snippet. Please never include code snippets in requirements. "
+                "Requirements must be a description of the complete file to be written. You can include specific class, function, and variable names, but not the actual code."
+            )
+
+        return v
+
+    @field_validator("details", mode="after")
+    @classmethod
+    def validate_details(cls, v):
+        if len(v) == 0:
+            raise ValueError(
+                "Details are required. Remember: this tool does not have access to other files. Please provide additional details like relevant documentation, error messages, or class, function, and variable names from other files that this file depends on."
+            )
+        return v
+
+    @field_validator("documentation", mode="after")
+    @classmethod
+    def validate_documentation(cls, v):
+        # check if documentation contains code
+        pattern = r"(```)((.*\n){5,})(```)"
+        pattern2 = r"(`)(.*)(`)"
+        if not (re.search(pattern, v) or re.search(pattern2, v)):
+            raise ValueError(
+                "Documentation does not contain a code snippet. Please provide relevant documentation extracted with the myfiles_browser tool. You must pass all the relevant code snippets information, as this tool does not have access to those files."
+            )
+
+
+if __name__ == "__main__":
+    # Test case for 'write' mode
+    tool_write = FileWriter(
+        requirements="Write a program that takes a list of integers as input and returns the sum of all the integers in the list.",
+        mode="write",
+        file_path="test_write.py",
+    )
+    print(tool_write.run())
+
+    # Test case for 'modify' mode
+    tool_modify = FileWriter(
+        requirements="Modify the program to also return the product of all the integers in the list.",
+        mode="modify",
+        file_path="test_write.py",
+    )
+    print(tool_modify.run())

app/agents/Devid/tools/ListDir.py

@@ -0,0 +1,84 @@
+import os
+
+from pydantic import Field, field_validator
+
+from agency_swarm import BaseTool
+
+
+class ListDir(BaseTool):
+    """
+    This tool returns the tree structure of the directory.
+    """
+
+    dir_path: str = Field(
+        ...,
+        description="Path of the directory to read.",
+        examples=["./", "./test", "../../"],
+    )
+
+    def run(self):
+        tree = []
+
+        def list_directory_tree(path, indent=""):
+            """Recursively list the contents of a directory in a tree-like format."""
+            if not os.path.isdir(path):
+                raise ValueError(f"The path {path} is not a valid directory")
+
+            items = os.listdir(path)
+            # exclude common hidden files and directories
+            exclude = [
+                ".git",
+                ".idea",
+                "__pycache__",
+                "node_modules",
+                ".venv",
+                ".gitignore",
+                ".gitkeep",
+                ".DS_Store",
+                ".vscode",
+                ".next",
+                "dist",
+                "build",
+                "out",
+                "venv",
+                "env",
+                "logs",
+                "data",
+            ]
+
+            items = [item for item in items if item not in exclude]
+
+            for i, item in enumerate(items):
+                item_path = os.path.join(path, item)
+                if i < len(items) - 1:
+                    tree.append(indent + "├── " + item)
+                    if os.path.isdir(item_path):
+                        list_directory_tree(item_path, indent + "│   ")
+                else:
+                    tree.append(indent + "└── " + item)
+                    if os.path.isdir(item_path):
+                        list_directory_tree(item_path, indent + "    ")
+
+        list_directory_tree(self.dir_path)
+
+        return "\n".join(tree)
+
+    @field_validator("dir_path", mode="after")
+    @classmethod
+    def validate_dir_path(cls, v):
+        if "file-" in v:
+            raise ValueError(
+                "You tried to access an openai file with a local directory reader tool. "
+                "Please use the `myfiles_browser` tool to access openai directories instead."
+            )
+
+        if not os.path.isdir(v):
+            if "/mnt/data" in v:
+                raise ValueError(
+                    "You tried to access an openai file directory with a local directory reader tool. "
+                    "Please use the `myfiles_browser` tool to access openai files instead. "
+                    "You can work in your local directory by using the `FileReader` tool."
+                )
+
+            raise ValueError(f"The path {v} is not a valid directory")
+        return v

app/agents/Devid/tools/util/__init__.py

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

app/agents/Devid/tools/util/format_file_deps.py

@@ -0,0 +1,68 @@
+from typing import List, Literal
+
+from pydantic import BaseModel, Field
+
+from agency_swarm import get_openai_client
+
+
+def format_file_deps(v):
+    client = get_openai_client()
+    result = ""
+    for file in v:
+        # extract dependencies from the file using openai
+        with open(file, "r") as f:
+            content = f.read()
+
+        class Dependency(BaseModel):
+            type: Literal["class", "function", "import"] = Field(
+                ..., description="The type of the dependency."
+            )
+            name: str = Field(
+                ...,
+                description="The name of the dependency, matching the import or definition.",
+            )
+
+        class Dependencies(BaseModel):
+            dependencies: List[Dependency] = Field(
+                [], description="The dependencies extracted from the file."
+            )
+
+            def append_dependencies(self):
+                functions = [
+                    dep.name for dep in self.dependencies if dep.type == "function"
+                ]
+                classes = [dep.name for dep in self.dependencies if dep.type == "class"]
+                imports = [
+                    dep.name for dep in self.dependencies if dep.type == "import"
+                ]
+                variables = [
+                    dep.name for dep in self.dependencies if dep.type == "variable"
+                ]
+                nonlocal result
+                result += f"File path: {file}\n"
+                result += f"Functions: {functions}\nClasses: {classes}\nImports: {imports}\nVariables: {variables}\n\n"
+
+        completion = client.beta.chat.completions.parse(
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are a world class dependency resolved. You must extract the dependencies from the file provided.",
+                },
+                {
+                    "role": "user",
+                    "content": f"Extract the dependencies from the file '{file}'.",
+                },
+            ],
+            model="gpt-4o-mini",
+            temperature=0,
+            response_format=Dependencies,
+        )
+
+        if completion.choices[0].message.refusal:
+            raise ValueError(completion.choices[0].message.refusal)
+
+        model = completion.choices[0].message.parsed
+
+        model.append_dependencies()
+
+    return result

app/agents/NotionProjectAgent/NotionProjectAgent.py

@@ -1,48 +0,0 @@
-import os
-
-from agency_swarm.agents import Agent
-from .tools.GetTasks import GetTasksTool
-from .tools.GetTask import GetTaskTool
-from .tools.CreateTask import CreateTaskTool
-from .tools.UpdateTask import UpdateTaskTool
-from .tools.DeleteTask import DeleteTaskTool
-
-
-class NotionProjectAgent(Agent):
-    def __init__(self):
-        # Retrieve the Notion integration secret from the environment
-        try:
-            integration_secret = os.environ["NOTION_INTEGRATION_SECRET"]
-        except KeyError:
-            raise EnvironmentError(
-                "NOTION_INTEGRATION_SECRET environment variable is not set."
-            )
-
-        # Initialize the parent Agent class with updated parameters
-        super().__init__(
-            name="NotionProjectAgent",
-            description="Project Management Assistant who tracks and updates project progress on Notion",
-            instructions="./instructions.md",
-            files_folder="./files",
-            schemas_folder="./schemas",
-            tools=[
-                GetTasksTool,
-                GetTaskTool,
-                CreateTaskTool,
-                UpdateTaskTool,
-                DeleteTaskTool,
-            ],
-            tools_folder="./tools",
-            model="gpt-4o",
-            temperature=0.3,
-            max_prompt_tokens=25000,
-            # api_headers={
-            #     "notion_tasks.json": {
-            #         "Authorization": f"Bearer {integration_secret}",
-            #         "Notion-Version": "2022-06-28",
-            #     }
-            # },
-        )
-
-    def response_validator(self, message):
-        return message

app/agents/NotionProjectAgent/__init__.py

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

app/agents/NotionProjectAgent/instructions.md

@@ -1,39 +0,0 @@
-# NotionProjectAgent Instructions
-
-Your team uses Notion to manage projects and tasks.
-Users often refer to tasks by name, and sometimes there may not be an exact match, so you should look for the closest ones. If in doubt, provide the user with valid options to choose from or ask for more information if necessary.
-
-## NOTION_STRUCTURE
-
--> Database: The highest level of organization in Notion. Contains all your tasks.
---> Page: A task in a Notion database, assignable with due dates.
---> Subpage: A child page of a parent Page, assignable to different people.
-
-## DEFAULT_NOTION_IDS
-
-Use these IDs unless specified otherwise
-
-- Database ID: 1a88235ee2ff801e8f93d8ab2e14de1d
-
-## DATABASE PROPERTIES
-
-- Task Name
-- Status
-- Priority
-- Due Date
-
-## WORKFLOWS
-
-### Create a high level WBS
-
-When required to create a WBS, you may be prompted with information about the project scope and requirements and/or you may provided with information in a task (page) in the Notion database. Understand the project and create a high level WBS containing 5 to 10 tasks, which cover the project scope for start to end. Each high level task should be a page in the Notion database.
-
-You may ask the ResearchAndReportAgent to help you with the creation of the WBS or to provide you with supporting information for one or more tasks, in a way that helps whoever started the task to better understand how to complete it.
-
-### Task Status Reporting
-
-When asked for a project status report, retrieve all tasks from the Notion database using the GetTasksTool. Group tasks by status (Backlog, In Progress, Testing, Completed) and provide a summary of each group. For tasks that are overdue (due date is in the past and status is not Completed), highlight them and suggest using UpdateTaskTool to adjust either the due date or status. If there are high priority tasks that haven't been started, emphasize these in your report.
-
-### Project Timeline Management
-
-When managing project timelines, first retrieve all tasks using GetTasksTool with sorting by due date. Analyze the distribution of tasks over time and identify potential bottlenecks (multiple high-priority tasks due on the same day). For each bottleneck period, retrieve detailed information about each task using GetTaskTool to understand their scope and requirements. Suggest timeline adjustments by using UpdateTaskTool to redistribute workload more evenly. When new tasks are added with CreateTaskTool, automatically check if they affect the existing timeline and provide recommendations for due date assignments that maintain a balanced workload.

app/agents/ResearchAndReportAgent/ResearchAndReportAgent.py

@@ -1,20 +0,0 @@
-from agency_swarm.agents import Agent
-
-
-class ResearchAndReportAgent(Agent):
-    def __init__(self):
-        super().__init__(
-            name="ResearchAndReportAgent",
-            description="Project Management Assistant who supports project planning and execution by performing researching, writing reports and sending them via e-mail or text",
-            instructions="./instructions.md",
-            files_folder="./files",
-            schemas_folder="./schemas",
-            tools=[],
-            tools_folder="./tools",
-            model="gpt-4o",
-            temperature=0.3,
-            max_prompt_tokens=25000,
-        )
-
-    def response_validator(self, message):
-        return message

app/agents/ResearchAndReportAgent/__init__.py

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

app/agents/ResearchAndReportAgent/instructions.md

@@ -1,2 +0,0 @@
-# ResearchAndReportAgent Instructions
-

app/agents/ResearchAndReportAgent/tools/ExampleTool.py

@@ -1,30 +0,0 @@
-from agency_swarm.tools import BaseTool
-from pydantic import Field
-import os
-
-account_id = "MY_ACCOUNT_ID"
-api_key = os.getenv("MY_API_KEY") # or access_token = os.getenv("MY_ACCESS_TOKEN")
-
-class ExampleTool(BaseTool):
-    """
-    A brief description of what the custom tool does.
-    The docstring should clearly explain the tool's purpose and functionality.
-    It will be used by the agent to determine when to use this tool.
-    """
-
-    # Define the fields with descriptions using Pydantic Field
-    example_field: str = Field(
-        ..., description="Description of the example field, explaining its purpose and usage for the Agent."
-    )
-
-    def run(self):
-        """
-        The implementation of the run method, where the tool's main functionality is executed.
-        This method should utilize the fields defined above to perform the task.
-        Docstring is not required for this method and will not be used by the agent.
-        """
-        # Your custom tool logic goes here
-        # do_something(self.example_field, api_key, account_id)
-
-        # Return the result of the tool's operation as a string
-        return "Result of ExampleTool operation"

app/agents/TechnicalProjectManager/TechnicalProjectManager.py

@@ -1,16 +1,28 @@
 from agency_swarm.agents import Agent
 from .tools.SendWhatsAppText import SendWhatsAppText
+from .tools.CreateTask import CreateTask
+from .tools.UpdateTask import UpdateTask
+from .tools.DeleteTask import DeleteTask
+from .tools.GetTask import GetTask
+from .tools.GetTasks import GetTasks
 
 
 class TechnicalProjectManager(Agent):
     def __init__(self):
         super().__init__(
             name="TechnicalProjectManager",
-            description="João Morossini's AI proxy, working as a Technical Project Manager at Agency AI",
+            description="João Morossini's AI proxy, working as a Technical Project Manager at VRSEN AI",
             instructions="./instructions.md",
             files_folder="./files",
             schemas_folder="./schemas",
-            tools=[SendWhatsAppText],
+            tools=[
+                SendWhatsAppText,
+                CreateTask,
+                UpdateTask,
+                DeleteTask,
+                GetTask,
+                GetTasks,
+            ],
             tools_folder="./tools",
             model="gpt-4o",
             temperature=0.3,

app/agents/TechnicalProjectManager/instructions.md

@@ -2,7 +2,48 @@
 
 You are a Technical Project Manager working at VRSEN AI.
 
-In your team, you have a few agents:
+Your Team consists of:
 
-- NotionProjectAgent: This agent is responsible for managing the project in Notion. This agent is capable of creating, updating and deleting tasks in a pre defined Notion database. Whenever the user mentions tasks or project, assume that the request is related to this specific database and that the NotionProjectAgent is the right agent to use.
-- ResearchAndReportAgent: This agent is responsible for perfoming research to support project planning, execution and reporting. Although the company has knowledge and experience in AI, it is very important to keep up to date with the latest developments in the field. Use this agent to find relevant products, services, technologies, trends, best practices, etc.
+- Devid (Code writing and execution)
+- BrowsingAgent (Online research and broswer actions)
+
+## NOTION INSTRUCTIONS
+
+Your team uses Notion to manage projects and tasks.
+Users often refer to tasks by name, and sometimes there may not be an exact match, so you should look for the closest ones. If in doubt, provide the user with valid options to choose from or ask for more information if necessary.
+
+Remember to track your team's tasks in Notion.
+
+Always use this database ID unless specified otherwise
+
+- Database ID: 1a88235ee2ff801e8f93d8ab2e14de1d
+
+### NOTION_STRUCTURE
+
+-> Database: The highest level of organization in Notion. Contains all your tasks.
+--> Page: A task in a Notion database, assignable with due dates.
+--> Subpage: A child page of a parent Page, assignable to different people.
+
+## DATABASE PROPERTIES
+
+- Task Name
+- Task Description
+- Status
+- Priority
+- Due Date
+
+## WORKFLOWS
+
+### Create a high level WBS
+
+When required to create a WBS, you may be prompted with information about the project scope and requirements and/or you may provided with information in a task (page) in the Notion database. Understand the project and create a high level WBS containing 5 to 10 tasks, which cover the project scope for start to end. Each high level task should be a page in the Notion database.
+
+You may ask the ResearchAndReportAgent to help you with the creation of the WBS or to provide you with supporting information for one or more tasks, in a way that helps whoever started the task to better understand how to complete it.
+
+### Task Status Reporting
+
+When asked for a project status report, retrieve all tasks from the Notion database using the GetTasksTool. Group tasks by status (Backlog, In Progress, Testing, Completed) and provide a summary of each group. For tasks that are overdue (due date is in the past and status is not Completed), highlight them and suggest using UpdateTaskTool to adjust either the due date or status. If there are high priority tasks that haven't been started, emphasize these in your report.
+
+### Project Timeline Management
+
+When managing project timelines, first retrieve all tasks using GetTasksTool with sorting by due date. Analyze the distribution of tasks over time and identify potential bottlenecks (multiple high-priority tasks due on the same day). For each bottleneck period, retrieve detailed information about each task using GetTaskTool to understand their scope and requirements. Suggest timeline adjustments by using UpdateTaskTool to redistribute workload more evenly. When new tasks are added with CreateTaskTool, automatically check if they affect the existing timeline and provide recommendations for due date assignments that maintain a balanced workload.

app/agents/TechnicalProjectManager/tools/ExampleTool.py

@@ -1,30 +0,0 @@
-from agency_swarm.tools import BaseTool
-from pydantic import Field
-import os
-
-account_id = "MY_ACCOUNT_ID"
-api_key = os.getenv("MY_API_KEY") # or access_token = os.getenv("MY_ACCESS_TOKEN")
-
-class ExampleTool(BaseTool):
-    """
-    A brief description of what the custom tool does.
-    The docstring should clearly explain the tool's purpose and functionality.
-    It will be used by the agent to determine when to use this tool.
-    """
-
-    # Define the fields with descriptions using Pydantic Field
-    example_field: str = Field(
-        ..., description="Description of the example field, explaining its purpose and usage for the Agent."
-    )
-
-    def run(self):
-        """
-        The implementation of the run method, where the tool's main functionality is executed.
-        This method should utilize the fields defined above to perform the task.
-        Docstring is not required for this method and will not be used by the agent.
-        """
-        # Your custom tool logic goes here
-        # do_something(self.example_field, api_key, account_id)
-
-        # Return the result of the tool's operation as a string
-        return "Result of ExampleTool operation"