Plugin Support

.env.template

@@ -188,3 +188,10 @@ OPENAI_API_KEY=your-openai-api-key
 # TW_CONSUMER_SECRET=
 # TW_ACCESS_TOKEN=
 # TW_ACCESS_TOKEN_SECRET=
+
+################################################################################
+### ALLOWLISTED PLUGINS
+################################################################################
+
+#ALLOWLISTED_PLUGINS - Sets the listed plugins that are allowed (Example: plugin1,plugin2,plugin3)
+ALLOWLISTED_PLUGINS=

.gitignore

@@ -157,5 +157,7 @@ vicuna-*
 # mac
 .DS_Store
 
+openai/
+
 # news
 CURRENT_BULLETIN.md

.isort.cfg

@@ -0,0 +1,10 @@
+[settings]
+profile = black
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+use_parentheses = true
+ensure_newline_before_comments = true
+line_length = 88
+sections = FUTURE,STDLIB,THIRDPARTY,FIRSTPARTY,LOCALFOLDER
+skip = .tox,__pycache__,*.pyc,venv*/*,reports,venv,env,node_modules,.env,.venv,dist

README.md

@@ -254,6 +254,22 @@ export GOOGLE_API_KEY="YOUR_GOOGLE_API_KEY"
 export CUSTOM_SEARCH_ENGINE_ID="YOUR_CUSTOM_SEARCH_ENGINE_ID"
 ```
 
+## Plugins
+
+See https://github.com/Significant-Gravitas/Auto-GPT-Plugin-Template for the template of the plugins.
+
+⚠️💀 WARNING 💀⚠️: Review the code of any plugin you use, this allows for any Python to be executed and do malicious things. Like stealing your API keys.
+
+Drop the repo's zipfile in the plugins folder.
+
+![Download Zip](https://raw.githubusercontent.com/BillSchumacher/Auto-GPT/master/plugin.png)
+
+If you add the plugins class name to the `ALLOWLISTED_PLUGINS` in the `.env` you will not be prompted otherwise you'll be warned before loading the plugin:
+
+```
+ALLOWLISTED_PLUGINS=example-plugin1,example-plugin2,example-plugin3
+```
+
 ## Setting Your Cache Type
 
 By default, Auto-GPT is going to use LocalCache instead of redis or Pinecone.

autogpt/agent/agent.py

@@ -19,18 +19,25 @@ class Agent:
         memory: The memory object to use.
         full_message_history: The full message history.
         next_action_count: The number of actions to execute.
-        system_prompt: The system prompt is the initial prompt that defines everything the AI needs to know to achieve its task successfully.
-        Currently, the dynamic and customizable information in the system prompt are ai_name, description and goals.
-
-        triggering_prompt: The last sentence the AI will see before answering. For Auto-GPT, this prompt is:
-            Determine which next command to use, and respond using the format specified above:
-            The triggering prompt is not part of the system prompt because between the system prompt and the triggering
-            prompt we have contextual information that can distract the AI and make it forget that its goal is to find the next task to achieve.
+        system_prompt: The system prompt is the initial prompt that defines everything
+          the AI needs to know to achieve its task successfully.
+        Currently, the dynamic and customizable information in the system prompt are
+          ai_name, description and goals.
+
+        triggering_prompt: The last sentence the AI will see before answering.
+            For Auto-GPT, this prompt is:
+            Determine which next command to use, and respond using the format specified
+              above:
+            The triggering prompt is not part of the system prompt because between the
+              system prompt and the triggering
+            prompt we have contextual information that can distract the AI and make it
+              forget that its goal is to find the next task to achieve.
             SYSTEM PROMPT
             CONTEXTUAL INFORMATION (memory, previous conversations, anything relevant)
             TRIGGERING PROMPT
 
-        The triggering prompt reminds the AI about its short term meta task (defining the next task)
+        The triggering prompt reminds the AI about its short term meta task
+        (defining the next task)
     """
 
     def __init__(
@@ -39,13 +46,17 @@ def __init__(
         memory,
         full_message_history,
         next_action_count,
+        command_registry,
+        config,
         system_prompt,
         triggering_prompt,
     ):
         self.ai_name = ai_name
         self.memory = memory
         self.full_message_history = full_message_history
         self.next_action_count = next_action_count
+        self.command_registry = command_registry
+        self.config = config
         self.system_prompt = system_prompt
         self.triggering_prompt = triggering_prompt
 
@@ -73,6 +84,7 @@ def start_interaction_loop(self):
             # Send message to AI, get response
             with Spinner("Thinking... "):
                 assistant_reply = chat_with_ai(
+                    self,
                     self.system_prompt,
                     self.triggering_prompt,
                     self.full_message_history,
@@ -81,6 +93,10 @@ def start_interaction_loop(self):
                 )  # TODO: This hardcodes the model to use GPT3.5. Make this an argument
 
             assistant_reply_json = fix_json_using_multiple_techniques(assistant_reply)
+            for plugin in cfg.plugins:
+                if not plugin.can_handle_post_planning():
+                    continue
+                assistant_reply_json = plugin.post_planning(self, assistant_reply_json)
 
             # Print Assistant thoughts
             if assistant_reply_json != {}:
@@ -89,14 +105,13 @@ def start_interaction_loop(self):
                 try:
                     print_assistant_thoughts(self.ai_name, assistant_reply_json)
                     command_name, arguments = get_command(assistant_reply_json)
-                    # command_name, arguments = assistant_reply_json_valid["command"]["name"], assistant_reply_json_valid["command"]["args"]
                     if cfg.speak_mode:
                         say_text(f"I want to execute {command_name}")
                 except Exception as e:
                     logger.error("Error: \n", str(e))
 
             if not cfg.continuous_mode and self.next_action_count == 0:
-                ### GET USER AUTHORIZATION TO EXECUTE COMMAND ###
+                # ### GET USER AUTHORIZATION TO EXECUTE COMMAND ###
                 # Get key press: Prompt the user to press enter to continue or escape
                 # to exit
                 logger.typewriter_log(
@@ -168,30 +183,46 @@ def start_interaction_loop(self):
             elif command_name == "human_feedback":
                 result = f"Human feedback: {user_input}"
             else:
-                result = (
-                    f"Command {command_name} returned: "
-                    f"{execute_command(command_name, arguments)}"
+                for plugin in cfg.plugins:
+                    if not plugin.can_handle_pre_command():
+                        continue
+                    command_name, arguments = plugin.pre_command(
+                        command_name, arguments
+                    )
+                command_result = execute_command(
+                    self.command_registry,
+                    command_name,
+                    arguments,
+                    self.config.prompt_generator,
                 )
+                result = f"Command {command_name} returned: " f"{command_result}"
+
+                for plugin in cfg.plugins:
+                    if not plugin.can_handle_post_command():
+                        continue
+                    result = plugin.post_command(command_name, result)
                 if self.next_action_count > 0:
                     self.next_action_count -= 1
+            if command_name != "do_nothing":
+                memory_to_add = (
+                    f"Assistant Reply: {assistant_reply} "
+                    f"\nResult: {result} "
+                    f"\nHuman Feedback: {user_input} "
+                )
 
-            memory_to_add = (
-                f"Assistant Reply: {assistant_reply} "
-                f"\nResult: {result} "
-                f"\nHuman Feedback: {user_input} "
-            )
-
-            self.memory.add(memory_to_add)
+                self.memory.add(memory_to_add)
 
-            # Check if there's a result from the command append it to the message
-            # history
-            if result is not None:
-                self.full_message_history.append(create_chat_message("system", result))
-                logger.typewriter_log("SYSTEM: ", Fore.YELLOW, result)
-            else:
-                self.full_message_history.append(
-                    create_chat_message("system", "Unable to execute command")
-                )
-                logger.typewriter_log(
-                    "SYSTEM: ", Fore.YELLOW, "Unable to execute command"
-                )
+                # Check if there's a result from the command append it to the message
+                # history
+                if result is not None:
+                    self.full_message_history.append(
+                        create_chat_message("system", result)
+                    )
+                    logger.typewriter_log("SYSTEM: ", Fore.YELLOW, result)
+                else:
+                    self.full_message_history.append(
+                        create_chat_message("system", "Unable to execute command")
+                    )
+                    logger.typewriter_log(
+                        "SYSTEM: ", Fore.YELLOW, "Unable to execute command"
+                    )

autogpt/agent/agent_manager.py

@@ -1,10 +1,11 @@
 """Agent manager for managing GPT agents"""
 from __future__ import annotations
 
-from typing import Union
+from typing import List, Union
 
-from autogpt.config.config import Singleton
+from autogpt.config.config import Config, Singleton
 from autogpt.llm_utils import create_chat_completion
+from autogpt.types.openai import Message
 
 
 class AgentManager(metaclass=Singleton):
@@ -13,6 +14,7 @@ class AgentManager(metaclass=Singleton):
     def __init__(self):
         self.next_key = 0
         self.agents = {}  # key, (task, full_message_history, model)
+        self.cfg = Config()
 
     # Create new GPT agent
     # TODO: Centralise use of create_chat_completion() to globally enforce token limit
@@ -28,26 +30,44 @@ def create_agent(self, task: str, prompt: str, model: str) -> tuple[int, str]:
         Returns:
             The key of the new agent
         """
-        messages = [
+        messages: List[Message] = [
             {"role": "user", "content": prompt},
         ]
-
+        for plugin in self.cfg.plugins:
+            if not plugin.can_handle_pre_instruction():
+                continue
+            if plugin_messages := plugin.pre_instruction(messages):
+                messages.extend(iter(plugin_messages))
         # Start GPT instance
         agent_reply = create_chat_completion(
             model=model,
             messages=messages,
         )
 
-        # Update full message history
         messages.append({"role": "assistant", "content": agent_reply})
 
+        plugins_reply = ""
+        for i, plugin in enumerate(self.cfg.plugins):
+            if not plugin.can_handle_on_instruction():
+                continue
+            if plugin_result := plugin.on_instruction(messages):
+                sep = "\n" if i else ""
+                plugins_reply = f"{plugins_reply}{sep}{plugin_result}"
+
+        if plugins_reply and plugins_reply != "":
+            messages.append({"role": "assistant", "content": plugins_reply})
         key = self.next_key
         # This is done instead of len(agents) to make keys unique even if agents
         # are deleted
         self.next_key += 1
 
         self.agents[key] = (task, messages, model)
 
+        for plugin in self.cfg.plugins:
+            if not plugin.can_handle_post_instruction():
+                continue
+            agent_reply = plugin.post_instruction(agent_reply)
+
         return key, agent_reply
 
     def message_agent(self, key: str | int, message: str) -> str:
@@ -65,15 +85,37 @@ def message_agent(self, key: str | int, message: str) -> str:
         # Add user message to message history before sending to agent
         messages.append({"role": "user", "content": message})
 
+        for plugin in self.cfg.plugins:
+            if not plugin.can_handle_pre_instruction():
+                continue
+            if plugin_messages := plugin.pre_instruction(messages):
+                for plugin_message in plugin_messages:
+                    messages.append(plugin_message)
+
         # Start GPT instance
         agent_reply = create_chat_completion(
             model=model,
             messages=messages,
         )
 
-        # Update full message history
         messages.append({"role": "assistant", "content": agent_reply})
 
+        plugins_reply = agent_reply
+        for i, plugin in enumerate(self.cfg.plugins):
+            if not plugin.can_handle_on_instruction():
+                continue
+            if plugin_result := plugin.on_instruction(messages):
+                sep = "\n" if i else ""
+                plugins_reply = f"{plugins_reply}{sep}{plugin_result}"
+        # Update full message history
+        if plugins_reply and plugins_reply != "":
+            messages.append({"role": "assistant", "content": plugins_reply})
+
+        for plugin in self.cfg.plugins:
+            if not plugin.can_handle_post_instruction():
+                continue
+            agent_reply = plugin.post_instruction(agent_reply)
+
         return agent_reply
 
     def list_agents(self) -> list[tuple[str | int, str]]:
@@ -86,7 +128,7 @@ def list_agents(self) -> list[tuple[str | int, str]]:
         # Return a list of agent keys and their tasks
         return [(key, task) for key, (task, _, _) in self.agents.items()]
 
-    def delete_agent(self, key: Union[str, int]) -> bool:
+    def delete_agent(self, key: str | int) -> bool:
         """Delete an agent from the agent manager
 
         Args: