import json import signal import sys from datetime import datetime from colorama import Fore, Style from autogpt.config import Config from autogpt.config.ai_config import AIConfig from autogpt.json_utils.utilities import extract_json_from_response, validate_json from autogpt.llm.chat import chat_with_ai from autogpt.llm.providers.openai import OPEN_AI_CHAT_MODELS from autogpt.llm.utils import count_string_tokens from autogpt.log_cycle.log_cycle import ( FULL_MESSAGE_HISTORY_FILE_NAME, NEXT_ACTION_FILE_NAME, USER_INPUT_FILE_NAME, LogCycleHandler, ) from autogpt.logs import logger, print_assistant_thoughts from autogpt.memory.message_history import MessageHistory from autogpt.memory.vector import VectorMemory from autogpt.models.command_registry import CommandRegistry from autogpt.speech import say_text from autogpt.spinner import Spinner from autogpt.utils import clean_input from autogpt.workspace import Workspace class Agent: """Agent class for interacting with Auto-GPT. Attributes: ai_name: The name of the agent. memory: The memory object to use. 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 exactly one 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) """ def __init__( self, ai_name: str, memory: VectorMemory, next_action_count: int, command_registry: CommandRegistry, ai_config: AIConfig, system_prompt: str, triggering_prompt: str, workspace_directory: str, config: Config, ): self.ai_name = ai_name self.memory = memory self.history = MessageHistory(self) self.next_action_count = next_action_count self.command_registry = command_registry self.config = config self.ai_config = ai_config self.system_prompt = system_prompt self.triggering_prompt = triggering_prompt self.workspace = Workspace(workspace_directory, config.restrict_to_workspace) self.created_at = datetime.now().strftime("%Y%m%d_%H%M%S") self.cycle_count = 0 self.log_cycle_handler = LogCycleHandler() self.fast_token_limit = OPEN_AI_CHAT_MODELS.get( config.fast_llm_model ).max_tokens def start_interaction_loop(self): # Avoid circular imports from autogpt.app import execute_command, get_command # Interaction Loop self.cycle_count = 0 command_name = None arguments = None user_input = "" # Signal handler for interrupting y -N def signal_handler(signum, frame): if self.next_action_count == 0: sys.exit() else: print( Fore.RED + "Interrupt signal received. Stopping continuous command execution." + Style.RESET_ALL ) self.next_action_count = 0 signal.signal(signal.SIGINT, signal_handler) while True: # Discontinue if continuous limit is reached self.cycle_count += 1 self.log_cycle_handler.log_count_within_cycle = 0 self.log_cycle_handler.log_cycle( self.ai_config.ai_name, self.created_at, self.cycle_count, [m.raw() for m in self.history], FULL_MESSAGE_HISTORY_FILE_NAME, ) if ( self.config.continuous_mode and self.config.continuous_limit > 0 and self.cycle_count > self.config.continuous_limit ): logger.typewriter_log( "Continuous Limit Reached: ", Fore.YELLOW, f"{self.config.continuous_limit}", ) break # Send message to AI, get response with Spinner("Thinking... ", plain_output=self.config.plain_output): assistant_reply = chat_with_ai( self.config, self, self.system_prompt, self.triggering_prompt, self.fast_token_limit, self.config.fast_llm_model, ) try: assistant_reply_json = extract_json_from_response( assistant_reply.content ) validate_json(assistant_reply_json, self.config) except json.JSONDecodeError as e: logger.error(f"Exception while validating assistant reply JSON: {e}") assistant_reply_json = {} for plugin in self.config.plugins: if not plugin.can_handle_post_planning(): continue assistant_reply_json = plugin.post_planning(assistant_reply_json) # Print Assistant thoughts if assistant_reply_json != {}: # Get command name and arguments try: print_assistant_thoughts( self.ai_name, assistant_reply_json, self.config ) command_name, arguments = get_command( assistant_reply_json, assistant_reply, self.config ) if self.config.speak_mode: say_text(f"I want to execute {command_name}") arguments = self._resolve_pathlike_command_args(arguments) except Exception as e: logger.error("Error: \n", str(e)) self.log_cycle_handler.log_cycle( self.ai_config.ai_name, self.created_at, self.cycle_count, assistant_reply_json, NEXT_ACTION_FILE_NAME, ) # First log new-line so user can differentiate sections better in console logger.typewriter_log("\n") logger.typewriter_log( "NEXT ACTION: ", Fore.CYAN, f"COMMAND = {Fore.CYAN}{command_name}{Style.RESET_ALL} " f"ARGUMENTS = {Fore.CYAN}{arguments}{Style.RESET_ALL}", ) if not self.config.continuous_mode and self.next_action_count == 0: # ### GET USER AUTHORIZATION TO EXECUTE COMMAND ### # Get key press: Prompt the user to press enter to continue or escape # to exit self.user_input = "" logger.info( "Enter 'y' to authorise command, 'y -N' to run N continuous commands, 's' to run self-feedback commands, " "'n' to exit program, or enter feedback for " f"{self.ai_name}..." ) while True: if self.config.chat_messages_enabled: console_input = clean_input( self.config, "Waiting for your response..." ) else: console_input = clean_input( self.config, Fore.MAGENTA + "Input:" + Style.RESET_ALL ) if console_input.lower().strip() == self.config.authorise_key: user_input = "GENERATE NEXT COMMAND JSON" break elif console_input.lower().strip() == "": logger.warn("Invalid input format.") continue elif console_input.lower().startswith( f"{self.config.authorise_key} -" ): try: self.next_action_count = abs( int(console_input.split(" ")[1]) ) user_input = "GENERATE NEXT COMMAND JSON" except ValueError: logger.warn( "Invalid input format. Please enter 'y -n' where n is" " the number of continuous tasks." ) continue break elif console_input.lower() == self.config.exit_key: user_input = "EXIT" break else: user_input = console_input command_name = "human_feedback" self.log_cycle_handler.log_cycle( self.ai_config.ai_name, self.created_at, self.cycle_count, user_input, USER_INPUT_FILE_NAME, ) break if user_input == "GENERATE NEXT COMMAND JSON": logger.typewriter_log( "-=-=-=-=-=-=-= COMMAND AUTHORISED BY USER -=-=-=-=-=-=-=", Fore.MAGENTA, "", ) elif user_input == "EXIT": logger.info("Exiting...") break else: # First log new-line so user can differentiate sections better in console logger.typewriter_log("\n") # Print authorized commands left value logger.typewriter_log( f"{Fore.CYAN}AUTHORISED COMMANDS LEFT: {Style.RESET_ALL}{self.next_action_count}" ) # Execute command if command_name is not None and command_name.lower().startswith("error"): result = f"Could not execute command: {arguments}" elif command_name == "human_feedback": result = f"Human feedback: {user_input}" else: for plugin in self.config.plugins: if not plugin.can_handle_pre_command(): continue command_name, arguments = plugin.pre_command( command_name, arguments ) command_result = execute_command( command_name=command_name, arguments=arguments, agent=self, ) result = f"Command {command_name} returned: " f"{command_result}" result_tlength = count_string_tokens( str(command_result), self.config.fast_llm_model ) memory_tlength = count_string_tokens( str(self.history.summary_message()), self.config.fast_llm_model ) if result_tlength + memory_tlength + 600 > self.fast_token_limit: result = f"Failure: command {command_name} returned too much output. \ Do not execute this command again with the same arguments." for plugin in self.config.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 # Check if there's a result from the command append it to the message # history if result is not None: self.history.add("system", result, "action_result") logger.typewriter_log("SYSTEM: ", Fore.YELLOW, result) else: self.history.add("system", "Unable to execute command", "action_result") logger.typewriter_log( "SYSTEM: ", Fore.YELLOW, "Unable to execute command" ) def _resolve_pathlike_command_args(self, command_args): if "directory" in command_args and command_args["directory"] in {"", "/"}: command_args["directory"] = str(self.workspace.root) else: for pathlike in ["filename", "directory", "clone_path"]: if pathlike in command_args: command_args[pathlike] = str( self.workspace.get_path(command_args[pathlike]) ) return command_args