From 239aa3aa0239b2ce1b13d08a170454b42db0c44d Mon Sep 17 00:00:00 2001
From: Taylor Beeston <beeston.taylor@gmail.com>
Date: Mon, 17 Apr 2023 12:38:46 -0700
Subject: [PATCH] :art: Bring in plugin_template

This would ideally be a shared package
---
 autogpt/plugin_template.py | 255 +++++++++++++++++++++++++++++++++++++
 requirements.txt           |   1 +
 2 files changed, 256 insertions(+)
 create mode 100644 autogpt/plugin_template.py

diff --git a/autogpt/plugin_template.py b/autogpt/plugin_template.py
new file mode 100644
index 00000000..90e9fa32
--- /dev/null
+++ b/autogpt/plugin_template.py
@@ -0,0 +1,255 @@
+"""This is a template for Auto-GPT plugins."""
+
+# TODO: Move to shared package
+
+import abc
+from typing import Any, Dict, List, Optional, Tuple, TypedDict
+from abstract_singleton import AbstractSingleton, Singleton
+
+from prompts.generator import PromptGenerator
+
+
+class Message(TypedDict):
+    role: str
+    content: str
+
+
+class AutoGPTPluginTemplate(AbstractSingleton, metaclass=Singleton):
+    """
+    This is a template for Auto-GPT plugins.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._name = "Auto-GPT-Plugin-Template"
+        self._version = "0.1.0"
+        self._description = "This is a template for Auto-GPT plugins."
+
+    @abc.abstractmethod
+    def can_handle_on_response(self) -> bool:
+        """This method is called to check that the plugin can
+        handle the on_response method.
+
+        Returns:
+            bool: True if the plugin can handle the on_response method."""
+        return False
+
+    @abc.abstractmethod
+    def on_response(self, response: str, *args, **kwargs) -> str:
+        """This method is called when a response is received from the model."""
+        pass
+
+    @abc.abstractmethod
+    def can_handle_post_prompt(self) -> bool:
+        """This method is called to check that the plugin can
+        handle the post_prompt method.
+
+        Returns:
+            bool: True if the plugin can handle the post_prompt method."""
+        return False
+
+    @abc.abstractmethod
+    def post_prompt(self, prompt: PromptGenerator) -> PromptGenerator:
+        """This method is called just after the generate_prompt is called,
+            but actually before the prompt is generated.
+
+        Args:
+            prompt (PromptGenerator): The prompt generator.
+
+        Returns:
+            PromptGenerator: The prompt generator.
+        """
+        pass
+
+    @abc.abstractmethod
+    def can_handle_on_planning(self) -> bool:
+        """This method is called to check that the plugin can
+        handle the on_planning method.
+
+        Returns:
+            bool: True if the plugin can handle the on_planning method."""
+        return False
+
+    @abc.abstractmethod
+    def on_planning(
+        self, prompt: PromptGenerator, messages: List[Message]
+    ) -> Optional[str]:
+        """This method is called before the planning chat completeion is done.
+
+        Args:
+            prompt (PromptGenerator): The prompt generator.
+            messages (List[str]): The list of messages.
+        """
+        pass
+
+    @abc.abstractmethod
+    def can_handle_post_planning(self) -> bool:
+        """This method is called to check that the plugin can
+        handle the post_planning method.
+
+        Returns:
+            bool: True if the plugin can handle the post_planning method."""
+        return False
+
+    @abc.abstractmethod
+    def post_planning(self, response: str) -> str:
+        """This method is called after the planning chat completeion is done.
+
+        Args:
+            response (str): The response.
+
+        Returns:
+            str: The resulting response.
+        """
+        pass
+
+    @abc.abstractmethod
+    def can_handle_pre_instruction(self) -> bool:
+        """This method is called to check that the plugin can
+        handle the pre_instruction method.
+
+        Returns:
+            bool: True if the plugin can handle the pre_instruction method."""
+        return False
+
+    @abc.abstractmethod
+    def pre_instruction(self, messages: List[Message]) -> List[Message]:
+        """This method is called before the instruction chat is done.
+
+        Args:
+            messages (List[Message]): The list of context messages.
+
+        Returns:
+            List[Message]: The resulting list of messages.
+        """
+        pass
+
+    @abc.abstractmethod
+    def can_handle_on_instruction(self) -> bool:
+        """This method is called to check that the plugin can
+        handle the on_instruction method.
+
+        Returns:
+            bool: True if the plugin can handle the on_instruction method."""
+        return False
+
+    @abc.abstractmethod
+    def on_instruction(self, messages: List[Message]) -> Optional[str]:
+        """This method is called when the instruction chat is done.
+
+        Args:
+            messages (List[Message]): The list of context messages.
+
+        Returns:
+            Optional[str]: The resulting message.
+        """
+        pass
+
+    @abc.abstractmethod
+    def can_handle_post_instruction(self) -> bool:
+        """This method is called to check that the plugin can
+        handle the post_instruction method.
+
+        Returns:
+            bool: True if the plugin can handle the post_instruction method."""
+        return False
+
+    @abc.abstractmethod
+    def post_instruction(self, response: str) -> str:
+        """This method is called after the instruction chat is done.
+
+        Args:
+            response (str): The response.
+
+        Returns:
+            str: The resulting response.
+        """
+        pass
+
+    @abc.abstractmethod
+    def can_handle_pre_command(self) -> bool:
+        """This method is called to check that the plugin can
+        handle the pre_command method.
+
+        Returns:
+            bool: True if the plugin can handle the pre_command method."""
+        return False
+
+    @abc.abstractmethod
+    def pre_command(
+        self, command_name: str, arguments: Dict[str, Any]
+    ) -> Tuple[str, Dict[str, Any]]:
+        """This method is called before the command is executed.
+
+        Args:
+            command_name (str): The command name.
+            arguments (Dict[str, Any]): The arguments.
+
+        Returns:
+            Tuple[str, Dict[str, Any]]: The command name and the arguments.
+        """
+        pass
+
+    @abc.abstractmethod
+    def can_handle_post_command(self) -> bool:
+        """This method is called to check that the plugin can
+        handle the post_command method.
+
+        Returns:
+            bool: True if the plugin can handle the post_command method."""
+        return False
+
+    @abc.abstractmethod
+    def post_command(self, command_name: str, response: str) -> str:
+        """This method is called after the command is executed.
+
+        Args:
+            command_name (str): The command name.
+            response (str): The response.
+
+        Returns:
+            str: The resulting response.
+        """
+        pass
+
+    @abc.abstractmethod
+    def can_handle_chat_completion(
+        self,
+        messages: List[Message],
+        model: Optional[str],
+        temperature: float,
+        max_tokens: Optional[int],
+    ) -> bool:
+        """This method is called to check that the plugin can
+          handle the chat_completion method.
+
+        Args:
+            messages (List[Message]): The messages.
+            model (str): The model name.
+            temperature (float): The temperature.
+            max_tokens (int): The max tokens.
+
+          Returns:
+              bool: True if the plugin can handle the chat_completion method."""
+        return False
+
+    @abc.abstractmethod
+    def handle_chat_completion(
+        self,
+        messages: List[Message],
+        model: Optional[str],
+        temperature: float,
+        max_tokens: Optional[int],
+    ) -> str:
+        """This method is called when the chat completion is done.
+
+        Args:
+            messages (List[Message]): The messages.
+            model (str): The model name.
+            temperature (float): The temperature.
+            max_tokens (int): The max tokens.
+
+        Returns:
+            str: The resulting response.
+        """
+        pass
diff --git a/requirements.txt b/requirements.txt
index 843b66bf..5e8f1000 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -29,6 +29,7 @@ black
 sourcery
 isort
 gitpython==3.1.31
+abstract-singleton
 
 # Testing dependencies
 pytest