Release v0.4.6 (#5039)

.coveragerc

@@ -1,2 +1,2 @@
-[run]
+[run]
 relative_files = true

.devcontainer/Dockerfile

@@ -10,4 +10,4 @@ RUN apt-get update && apt-get install -y \
 RUN apt-get install -y curl jq wget git
 
 # Declare working directory
-WORKDIR /workspace/AutoGPT
+WORKDIR /workspace/Auto-GPT

.devcontainer/devcontainer.json

@@ -1,7 +1,7 @@
 {
   "dockerComposeFile": "./docker-compose.yml",
   "service": "auto-gpt",
-  "workspaceFolder": "/workspace/AutoGPT",
+  "workspaceFolder": "/workspace/Auto-GPT",
   "shutdownAction": "stopCompose",
   "features": {
     "ghcr.io/devcontainers/features/common-utils:2": {
@@ -46,11 +46,11 @@
   // "forwardPorts": [],
 
   // Use 'postCreateCommand' to run commands after the container is created.
-  // "postCreateCommand": "poetry install",
+  // "postCreateCommand": "pip3 install --user -r requirements.txt",
 
   // Set `remoteUser` to `root` to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
   "remoteUser": "vscode",
 
   // Add the freshly containerized repo to the list of safe repositories
-  "postCreateCommand": "git config --global --add safe.directory /workspace/AutoGPT && poetry install"
-}
+  "postCreateCommand": "git config --global --add safe.directory /workspace/Auto-GPT && pip3 install --user -r requirements.txt"
+}

.devcontainer/docker-compose.yml

@@ -9,4 +9,4 @@ services:
       context: ../
     tty: true
     volumes:
-      - ../:/workspace/AutoGPT
+      - ../:/workspace/Auto-GPT

.dockerignore

@@ -0,0 +1,9 @@
+.*
+*.template
+*.yaml
+*.yml
+!prompt_settings.yaml
+
+*.md
+*.png
+!BULLETIN.md

.env.template

@@ -0,0 +1,212 @@
+# For further descriptions of these settings see docs/configuration/options.md or go to docs.agpt.co
+
+################################################################################
+### AUTO-GPT - GENERAL SETTINGS
+################################################################################
+
+## OPENAI_API_KEY - OpenAI API Key (Example: my-openai-api-key)
+OPENAI_API_KEY=your-openai-api-key
+
+## EXECUTE_LOCAL_COMMANDS - Allow local command execution (Default: False)
+# EXECUTE_LOCAL_COMMANDS=False
+
+## RESTRICT_TO_WORKSPACE - Restrict file operations to workspace ./auto_gpt_workspace (Default: True)
+# RESTRICT_TO_WORKSPACE=True
+
+## USER_AGENT - Define the user-agent used by the requests library to browse website (string)
+# USER_AGENT="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36"
+
+## AI_SETTINGS_FILE - Specifies which AI Settings file to use, relative to the Auto-GPT root directory. (defaults to ai_settings.yaml)
+# AI_SETTINGS_FILE=ai_settings.yaml
+
+## PLUGINS_CONFIG_FILE - The path to the plugins_config.yaml file, relative to the Auto-GPT root directory. (Default plugins_config.yaml)
+# PLUGINS_CONFIG_FILE=plugins_config.yaml
+
+## PROMPT_SETTINGS_FILE - Specifies which Prompt Settings file to use, relative to the Auto-GPT root directory. (defaults to prompt_settings.yaml)
+# PROMPT_SETTINGS_FILE=prompt_settings.yaml
+
+## OPENAI_API_BASE_URL - Custom url for the OpenAI API, useful for connecting to custom backends. No effect if USE_AZURE is true, leave blank to keep the default url
+# the following is an example:
+# OPENAI_API_BASE_URL=http://localhost:443/v1
+
+## OPENAI_FUNCTIONS - Enables OpenAI functions: https://platform.openai.com/docs/guides/gpt/function-calling
+## WARNING: this feature is only supported by OpenAI's newest models. Until these models become the default on 27 June, add a '-0613' suffix to the model of your choosing.
+# OPENAI_FUNCTIONS=False
+
+## AUTHORISE COMMAND KEY - Key to authorise commands
+# AUTHORISE_COMMAND_KEY=y
+
+## EXIT_KEY - Key to exit AUTO-GPT
+# EXIT_KEY=n
+
+## PLAIN_OUTPUT - Plain output, which disables the spinner (Default: False)
+# PLAIN_OUTPUT=False
+
+## DISABLED_COMMAND_CATEGORIES - The list of categories of commands that are disabled (Default: None)
+# DISABLED_COMMAND_CATEGORIES=
+
+################################################################################
+### LLM PROVIDER
+################################################################################
+
+## TEMPERATURE - Sets temperature in OpenAI (Default: 0)
+# TEMPERATURE=0
+
+## OPENAI_ORGANIZATION - Your OpenAI Organization key (Default: None)
+# OPENAI_ORGANIZATION=
+
+## USE_AZURE - Use Azure OpenAI or not (Default: False)
+# USE_AZURE=False
+
+## AZURE_CONFIG_FILE - The path to the azure.yaml file, relative to the Auto-GPT root directory. (Default: azure.yaml)
+# AZURE_CONFIG_FILE=azure.yaml
+
+
+################################################################################
+### LLM MODELS
+################################################################################
+
+## SMART_LLM - Smart language model (Default: gpt-4)
+# SMART_LLM=gpt-4
+
+## FAST_LLM - Fast language model (Default: gpt-3.5-turbo)
+# FAST_LLM=gpt-3.5-turbo
+
+## EMBEDDING_MODEL - Model to use for creating embeddings
+# EMBEDDING_MODEL=text-embedding-ada-002
+
+################################################################################
+### SHELL EXECUTION
+################################################################################
+
+## SHELL_COMMAND_CONTROL - Whether to use "allowlist" or "denylist" to determine what shell commands can be executed (Default: denylist)
+# SHELL_COMMAND_CONTROL=denylist
+
+## ONLY if SHELL_COMMAND_CONTROL is set to denylist:
+## SHELL_DENYLIST - List of shell commands that ARE NOT allowed to be executed by Auto-GPT (Default: sudo,su)
+# SHELL_DENYLIST=sudo,su
+
+## ONLY if SHELL_COMMAND_CONTROL is set to allowlist:
+## SHELL_ALLOWLIST - List of shell commands that ARE allowed to be executed by Auto-GPT (Default: None)
+# SHELL_ALLOWLIST=
+
+################################################################################
+### MEMORY
+################################################################################
+
+### General
+
+## MEMORY_BACKEND - Memory backend type
+# MEMORY_BACKEND=json_file
+
+## MEMORY_INDEX - Value used in the Memory backend for scoping, naming, or indexing (Default: auto-gpt)
+# MEMORY_INDEX=auto-gpt
+
+### Redis
+
+## REDIS_HOST - Redis host (Default: localhost, use "redis" for docker-compose)
+# REDIS_HOST=localhost
+
+## REDIS_PORT - Redis port (Default: 6379)
+# REDIS_PORT=6379
+
+## REDIS_PASSWORD - Redis password (Default: "")
+# REDIS_PASSWORD=
+
+## WIPE_REDIS_ON_START - Wipes data / index on start (Default: True)
+# WIPE_REDIS_ON_START=True
+
+################################################################################
+### IMAGE GENERATION PROVIDER
+################################################################################
+
+### Common
+
+## IMAGE_PROVIDER - Image provider (Default: dalle)
+# IMAGE_PROVIDER=dalle
+
+## IMAGE_SIZE - Image size (Default: 256)
+# IMAGE_SIZE=256
+
+### Huggingface (IMAGE_PROVIDER=huggingface)
+
+## HUGGINGFACE_IMAGE_MODEL - Text-to-image model from Huggingface (Default: CompVis/stable-diffusion-v1-4)
+# HUGGINGFACE_IMAGE_MODEL=CompVis/stable-diffusion-v1-4
+
+## HUGGINGFACE_API_TOKEN - HuggingFace API token (Default: None)
+# HUGGINGFACE_API_TOKEN=
+
+### Stable Diffusion (IMAGE_PROVIDER=sdwebui)
+
+## SD_WEBUI_AUTH - Stable Diffusion Web UI username:password pair (Default: None)
+# SD_WEBUI_AUTH=
+
+## SD_WEBUI_URL - Stable Diffusion Web UI API URL (Default: http://localhost:7860)
+# SD_WEBUI_URL=http://localhost:7860
+
+################################################################################
+### AUDIO TO TEXT PROVIDER
+################################################################################
+
+## AUDIO_TO_TEXT_PROVIDER - Audio-to-text provider (Default: huggingface)
+# AUDIO_TO_TEXT_PROVIDER=huggingface
+
+## HUGGINGFACE_AUDIO_TO_TEXT_MODEL - The model for HuggingFace to use (Default: CompVis/stable-diffusion-v1-4)
+# HUGGINGFACE_AUDIO_TO_TEXT_MODEL=CompVis/stable-diffusion-v1-4
+
+################################################################################
+### GITHUB
+################################################################################
+
+## GITHUB_API_KEY - Github API key / PAT (Default: None)
+# GITHUB_API_KEY=
+
+## GITHUB_USERNAME - Github username (Default: None)
+# GITHUB_USERNAME=
+
+################################################################################
+### WEB BROWSING
+################################################################################
+
+## HEADLESS_BROWSER - Whether to run the browser in headless mode (default: True)
+# HEADLESS_BROWSER=True
+
+## USE_WEB_BROWSER - Sets the web-browser driver to use with selenium (default: chrome)
+# USE_WEB_BROWSER=chrome
+
+## BROWSE_CHUNK_MAX_LENGTH - When browsing website, define the length of chunks to summarize (Default: 3000)
+# BROWSE_CHUNK_MAX_LENGTH=3000
+
+## BROWSE_SPACY_LANGUAGE_MODEL - spaCy language model](https://spacy.io/usage/models) to use when creating chunks. (Default: en_core_web_sm)
+# BROWSE_SPACY_LANGUAGE_MODEL=en_core_web_sm
+
+## GOOGLE_API_KEY - Google API key (Default: None)
+# GOOGLE_API_KEY=
+
+## GOOGLE_CUSTOM_SEARCH_ENGINE_ID - Google custom search engine ID (Default: None)
+# GOOGLE_CUSTOM_SEARCH_ENGINE_ID=
+
+################################################################################
+### TEXT TO SPEECH PROVIDER
+################################################################################
+
+## TEXT_TO_SPEECH_PROVIDER - Which Text to Speech provider to use (Default: gtts)
+# TEXT_TO_SPEECH_PROVIDER=gtts
+
+### Only if TEXT_TO_SPEECH_PROVIDER=streamelements
+## STREAMELEMENTS_VOICE - Voice to use for StreamElements (Default: Brian)
+# STREAMELEMENTS_VOICE=Brian
+
+### Only if TEXT_TO_SPEECH_PROVIDER=elevenlabs
+## ELEVENLABS_API_KEY - Eleven Labs API key (Default: None)
+# ELEVENLABS_API_KEY=
+
+## ELEVENLABS_VOICE_ID - Eleven Labs voice ID (Example: None)
+# ELEVENLABS_VOICE_ID=
+
+################################################################################
+### CHAT MESSAGES
+################################################################################
+
+## CHAT_MESSAGES_ENABLED - Enable chat messages (Default: False)
+# CHAT_MESSAGES_ENABLED=False

.envrc

@@ -1,4 +1,4 @@
 # Upon entering directory, direnv requests user permission once to automatically load project dependencies onwards.
-# Eliminating the need of running "nix develop github:superherointj/nix-auto-gpt" for Nix users to develop/use AutoGPT.
+# Eliminating the need of running "nix develop github:superherointj/nix-auto-gpt" for Nix users to develop/use Auto-GPT.
 
 [[ -z $IN_NIX_SHELL ]] && use flake github:superherointj/nix-auto-gpt

.flake8

@@ -1,5 +1,6 @@
 [flake8]
 max-line-length = 88
+select = "E303, W293, W291, W292, E305, E231, E302"
 exclude =
     .tox,
     __pycache__,
@@ -9,4 +10,3 @@ exclude =
     .venv/*,
     reports/*,
     dist/*,
-    data/*,

.gitattributes

@@ -1,10 +1,5 @@
-classic/frontend/build/** linguist-generated
-
-**/poetry.lock linguist-generated
-
-docs/_javascript/** linguist-vendored
-
 # Exclude VCR cassettes from stats
-classic/forge/tests/vcr_cassettes/**/**.y*ml linguist-generated
+tests/Auto-GPT-test-cassettes/**/**.y*ml linguist-generated
 
-* text=auto
+# Mark documentation as such
+docs/**.md linguist-documentation

.github/CODEOWNERS

@@ -1,7 +1,2 @@
-* @Significant-Gravitas/maintainers
-.github/workflows/ @Significant-Gravitas/devops
-classic/forge/ @Significant-Gravitas/forge-maintainers
-classic/benchmark/ @Significant-Gravitas/benchmark-maintainers
-classic/frontend/ @Significant-Gravitas/frontend-maintainers
-autogpt_platform/infra @Significant-Gravitas/devops
-.github/CODEOWNERS @Significant-Gravitas/admins
+.github/workflows/ @Significant-Gravitas/maintainers
+autogpt/core @collijk

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: Torantulino

.github/ISSUE_TEMPLATE/1.bug.yml

@@ -1,5 +1,5 @@
 name: Bug report 🐛
-description: Create a bug report for AutoGPT.
+description: Create a bug report for Auto-GPT.
 labels: ['status: needs triage']
 body:
   - type: markdown
@@ -13,16 +13,16 @@ body:
         [backlog]: https://github.com/orgs/Significant-Gravitas/projects/1
         [roadmap]: https://github.com/orgs/Significant-Gravitas/projects/2  
         [discord]: https://discord.gg/autogpt
-        [discussions]: https://github.com/Significant-Gravitas/AutoGPT/discussions
+        [discussions]: https://github.com/Significant-Gravitas/Auto-GPT/discussions
         [#tech-support]: https://discord.com/channels/1092243196446249134/1092275629602394184
-        [existing issues]: https://github.com/Significant-Gravitas/AutoGPT/issues?q=is%3Aissue
-        [wiki page on Contributing]: https://github.com/Significant-Gravitas/AutoGPT/wiki/Contributing
+        [existing issues]: https://github.com/Significant-Gravitas/Auto-GPT/issues?q=is%3Aissue
+        [wiki page on Contributing]: https://github.com/Significant-Gravitas/Nexus/wiki/Contributing
 
   - type: checkboxes
     attributes:
       label: ⚠️ Search for existing issues first ⚠️
       description: >
-        Please [search the history](https://github.com/Significant-Gravitas/AutoGPT/issues)
+        Please [search the history](https://github.com/Torantulino/Auto-GPT/issues)
         to see if an issue already exists for the same problem.
       options:
         - label: I have searched the existing issues, and there is no existing issue for my problem
@@ -35,8 +35,8 @@ body:
         A good rule of thumb: What would you type if you were searching for the issue?
         
         For example:
-        BAD - my AutoGPT keeps looping
-        GOOD - After performing execute_python_file, AutoGPT goes into a loop where it keeps trying to execute the file.
+        BAD - my auto-gpt keeps looping
+        GOOD - After performing execute_python_file, auto-gpt goes into a loop where it keeps trying to execute the file.
         
         ⚠️ SUPER-busy repo, please help the volunteer maintainers.
         The less time we spend here, the more time we can spend building AutoGPT.
@@ -54,7 +54,7 @@ body:
     attributes:
       label: Which Operating System are you using?
       description: >
-        Please select the operating system you were using to run AutoGPT when this problem occurred.
+        Please select the operating system you were using to run Auto-GPT when this problem occurred.
       options:
         - Windows
         - Linux
@@ -73,12 +73,12 @@ body:
 
   - type: dropdown
     attributes:
-      label: Which version of AutoGPT are you using?
+      label: Which version of Auto-GPT are you using?
       description: |
-        Please select which version of AutoGPT you were using when this issue occurred.
-        If you downloaded the code from the [releases page](https://github.com/Significant-Gravitas/AutoGPT/releases/) make sure you were using the latest code. 
-        **If you weren't please try with the [latest code](https://github.com/Significant-Gravitas/AutoGPT/releases/)**.
-        If installed with git you can run `git branch` to see which version of AutoGPT you are running.
+        Please select which version of Auto-GPT you were using when this issue occurred.
+        If you downloaded the code from the [releases page](https://github.com/Significant-Gravitas/Auto-GPT/releases/) make sure you were using the latest code. 
+        **If you weren't please try with the [latest code](https://github.com/Significant-Gravitas/Auto-GPT/releases/)**.
+        If installed with git you can run `git branch` to see which version of Auto-GPT you are running.
       options:
         - Latest Release
         - Stable (branch)
@@ -88,16 +88,14 @@ body:
 
   - type: dropdown
     attributes:
-      label: What LLM Provider do you use?
+      label: Do you use OpenAI GPT-3 or GPT-4?
       description: >
-        If you are using AutoGPT with `SMART_LLM=gpt-3.5-turbo`, your problems may be caused by
-        the [limitations](https://github.com/Significant-Gravitas/AutoGPT/issues?q=is%3Aissue+label%3A%22AI+model+limitation%22) of GPT-3.5.
+        If you are using Auto-GPT with `--gpt3only`, your problems may be caused by
+        the [limitations](https://github.com/Significant-Gravitas/Auto-GPT/issues?q=is%3Aissue+label%3A%22AI+model+limitation%22) of GPT-3.5.
       options:
-        - Azure
-        - Groq
-        - Anthropic
-        - Llamafile
-        - Other (detail in issue)
+        - GPT-3.5
+        - GPT-4
+        - GPT-4(32k)
     validations:
       required: true
 
@@ -128,17 +126,10 @@ body:
             label: Specify the area
             description: Please specify the area you think is best related to the issue.
 
-  - type: input
-    attributes:
-      label: What commit or version are you using?
-      description: It is helpful for us to reproduce to know what version of the software you were using when this happened. Please run `git log -n 1 --pretty=format:"%H"` to output the full commit hash.
-    validations:
-      required: true
-
   - type: textarea
     attributes:
       label: Describe your issue.
-      description: Describe the problem you are experiencing. Try to describe only the issue and phrase it short but clear. ⚠️ Provide NO other data in this field
+      description: Describe the problem you are experiencing. Try to describe only the issue and phrase it short but clear. ⚠️ Provide NO other data in this field  
     validations:
       required: true
 
@@ -148,16 +139,16 @@ body:
       value: |
         ⚠️The following is OPTIONAL, please keep in mind that the log files may contain personal information such as credentials.⚠️
         
-        "The log files are located in the folder 'logs' inside the main AutoGPT folder."
+        "The log files are located in the folder 'logs' inside the main auto-gpt folder."
 
   - type: textarea
     attributes:
       label: Upload Activity Log Content
       description: |
         Upload the activity log content, this can help us understand the issue better. 
-        To do this, go to the folder logs in your main AutoGPT folder, open activity.log and copy/paste the contents to this field. 
-        ⚠️ The activity log may contain personal data given to AutoGPT by you in prompt or input as well as 
-        any personal information that AutoGPT collected out of files during last run. Do not add the activity log if you are not comfortable with sharing it. ⚠️
+        To do this, go to the folder logs in your main auto-gpt folder, open activity.log and copy/paste the contents to this field. 
+        ⚠️ The activity log may contain personal data given to auto-gpt by you in prompt or input as well as 
+        any personal information that auto-gpt collected out of files during last run. Do not add the activity log if you are not comfortable with sharing it. ⚠️
     validations:
       required: false
 
@@ -166,8 +157,8 @@ body:
       label: Upload Error Log Content
       description: |
         Upload the error log content, this will help us understand the issue better. 
-        To do this, go to the folder logs in your main AutoGPT folder, open error.log and copy/paste the contents to this field. 
-        ⚠️ The error log may contain personal data given to AutoGPT by you in prompt or input as well as 
-        any personal information that AutoGPT collected out of files during last run. Do not add the activity log if you are not comfortable with sharing it. ⚠️
+        To do this, go to the folder logs in your main auto-gpt folder, open error.log and copy/paste the contents to this field. 
+        ⚠️ The error log may contain personal data given to auto-gpt by you in prompt or input as well as 
+        any personal information that auto-gpt collected out of files during last run. Do not add the activity log if you are not comfortable with sharing it. ⚠️
     validations:
       required: false

.github/ISSUE_TEMPLATE/2.feature.yml

@@ -1,16 +1,16 @@
 name: Feature request 🚀
-description: Suggest a new idea for AutoGPT!
+description: Suggest a new idea for Auto-GPT!
 labels: ['status: needs triage']
 body:
   - type: markdown
     attributes:
       value: |
-        First, check out our [wiki page on Contributing](https://github.com/Significant-Gravitas/AutoGPT/wiki/Contributing)
+        First, check out our [wiki page on Contributing](https://github.com/Significant-Gravitas/Nexus/wiki/Contributing)
         Please provide a searchable summary of the issue in the title above ⬆️.
   - type: checkboxes
     attributes:
       label: Duplicates
-      description: Please [search the history](https://github.com/Significant-Gravitas/AutoGPT/issues) to see if an issue already exists for the same problem.
+      description: Please [search the history](https://github.com/Torantulino/Auto-GPT/issues) to see if an issue already exists for the same problem.
       options:
         - label: I have searched the existing issues
           required: true

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,23 +1,49 @@
-### Background
-
-<!-- Clearly explain the need for these changes: -->
-
-### Changes 🏗️
-
-<!-- Concisely describe all of the changes made in this pull request: -->
-
-
-### Testing 🔍
-> [!NOTE] 
-Only for the new autogpt platform, currently in autogpt_platform/
-
-<!--
-Please make sure your changes have been tested and are in good working condition. 
-Here is a list of our critical paths, if you need some inspiration on what and how to test:
+<!-- ⚠️ At the moment any non-essential commands are not being merged.
+If you want to add non-essential commands to Auto-GPT, please create a plugin instead.
+We are expecting to ship plugin support within the week (PR #757).
+Resources:
+* https://github.com/Significant-Gravitas/Auto-GPT-Plugin-Template
 -->
 
-- Create from scratch and execute an agent with at least 3 blocks
-- Import an agent from file upload, and confirm it executes correctly
-- Upload agent to marketplace
-- Import an agent from marketplace and confirm it executes correctly
-- Edit an agent from monitor, and confirm it executes correctly
+<!-- 📢 Announcement
+We've recently noticed an increase in pull requests focusing on combining multiple changes. While the intentions behind these PRs are appreciated, it's essential to maintain a clean and manageable git history. To ensure the quality of our repository, we kindly ask you to adhere to the following guidelines when submitting PRs:
+
+Focus on a single, specific change.
+Do not include any unrelated or "extra" modifications.
+Provide clear documentation and explanations of the changes made.
+Ensure diffs are limited to the intended lines — no applying preferred formatting styles or line endings (unless that's what the PR is about).
+For guidance on committing only the specific lines you have changed, refer to this helpful video: https://youtu.be/8-hSNHHbiZg
+
+Check out our [wiki page on Contributing](https://github.com/Significant-Gravitas/Nexus/wiki/Contributing)
+
+By following these guidelines, your PRs are more likely to be merged quickly after testing, as long as they align with the project's overall direction. -->
+
+### Background
+<!-- Provide a concise overview of the rationale behind this change. Include relevant context, prior discussions, or links to related issues. Ensure that the change aligns with the project's overall direction. -->
+
+### Changes
+<!-- Describe the specific, focused change made in this pull request. Detail the modifications clearly and avoid any unrelated or "extra" changes. -->
+
+### Documentation
+<!-- Explain how your changes are documented, such as in-code comments or external documentation. Ensure that the documentation is clear, concise, and easy to understand. -->
+
+### Test Plan
+<!-- Describe how you tested this functionality. Include steps to reproduce, relevant test cases, and any other pertinent information. -->
+
+### PR Quality Checklist
+- [ ] My pull request is atomic and focuses on a single change.
+- [ ] I have thoroughly tested my changes with multiple different prompts.
+- [ ] I have considered potential risks and mitigations for my changes.
+- [ ] I have documented my changes clearly and comprehensively.
+- [ ] I have not snuck in any "extra" small tweaks changes. <!-- Submit these as separate Pull Requests, they are the easiest to merge! -->
+- [ ] I have run the following commands against my code to ensure it passes our linters:
+    ```shell
+    black .
+    isort .
+    mypy
+    autoflake --remove-all-unused-imports --recursive --ignore-init-module-imports --ignore-pass-after-docstring autogpt tests --in-place
+    ```
+
+<!-- If you haven't added tests, please explain why. If you have, check the appropriate box. If you've ensured your PR is atomic and well-documented, check the corresponding boxes. -->
+
+<!-- By submitting this, I agree that my pull request should be closed if I do not fill this out or follow the guidelines. -->

.github/labeler.yml

@@ -1,27 +0,0 @@
-AutoGPT Agent:
-- changed-files:
-  - any-glob-to-any-file: classic/original_autogpt/**
-
-Forge:
-- changed-files:
-  - any-glob-to-any-file: classic/forge/**
-
-Benchmark:
-- changed-files:
-  - any-glob-to-any-file: classic/benchmark/**
-
-Frontend:
-- changed-files:
-  - any-glob-to-any-file: classic/frontend/**
-
-documentation:
-- changed-files:
-  - any-glob-to-any-file: docs/**
-
-Builder:
-- changed-files:
-  - any-glob-to-any-file: autogpt_platform/autogpt_builder/**
-
-Server:
-- changed-files:
-  - any-glob-to-any-file: autogpt_platform/autogpt_server/**

.github/workflows/benchmarks.yml

@@ -0,0 +1,73 @@
+name: Benchmarks
+
+on:
+  schedule:
+    - cron: '0 8 * * *'
+  workflow_dispatch:
+
+jobs:
+  Benchmark:
+    name: ${{ matrix.config.task-name }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        config:
+          - python-version: "3.10"
+            task: "tests/challenges"
+            task-name: "Mandatory Tasks"
+          - python-version: "3.10"
+            task: "--beat-challenges -ra tests/challenges"
+            task-name: "Challenging Tasks"
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+        with:
+          ref: master
+
+      - name: Set up Python ${{ matrix.config.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.config.python-version }}
+
+      - id: get_date
+        name: Get date
+        run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
+
+      - name: Set up Python dependency cache
+        uses: actions/cache@v3
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}-${{ steps.get_date.outputs.date }}
+
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+
+      - name: Run pytest with coverage
+        run: |
+          rm -rf tests/Auto-GPT-test-cassettes
+          pytest -n auto --record-mode=all ${{ matrix.config.task }}
+        env:
+          CI: true
+          PROXY: ${{ secrets.PROXY }}
+          AGENT_MODE: ${{ secrets.AGENT_MODE }}
+          AGENT_TYPE: ${{ secrets.AGENT_TYPE }}
+          PLAIN_OUTPUT: True
+
+      - name: Upload logs as artifact
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: test-logs-${{ matrix.config.task-name }}
+          path: logs/
+
+      - name: Upload cassettes as artifact
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: cassettes-${{ matrix.config.task-name }}
+          path: tests/Auto-GPT-test-cassettes/

.github/workflows/ci.yml

@@ -0,0 +1,261 @@
+name: Python CI
+
+on:
+  push:
+    branches: [ master, ci-test* ]
+    paths-ignore:
+      - 'tests/Auto-GPT-test-cassettes'
+      - 'tests/challenges/current_score.json'
+  pull_request:
+    branches: [ stable, master, release-* ]
+  pull_request_target:
+    branches: [ master, release-*, ci-test* ]
+
+concurrency:
+  group: ${{ format('ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
+  cancel-in-progress: ${{ startsWith(github.event_name, 'pull_request') }}
+
+jobs:
+  lint:
+    # eliminate duplicate runs
+    if: github.event_name == 'push' || (github.event.pull_request.head.repo.fork == (github.event_name == 'pull_request_target'))
+
+    runs-on: ubuntu-latest
+    env:
+      min-python-version: "3.10"
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          ref: ${{ github.event.pull_request.head.ref }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+
+      - name: Set up Python ${{ env.min-python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.min-python-version }}
+
+      - id: get_date
+        name: Get date
+        run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
+
+      - name: Set up Python dependency cache
+        uses: actions/cache@v3
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}-${{ steps.get_date.outputs.date }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+
+      - name: Lint with flake8
+        run: flake8
+
+      - name: Check black formatting
+        run: black . --check
+        if: success() || failure()
+
+      - name: Check isort formatting
+        run: isort . --check
+        if: success() || failure()
+
+      - name: Check mypy formatting
+        run: mypy
+        if: success() || failure()
+
+      - name: Check for unused imports and pass statements
+        run: |
+          cmd="autoflake --remove-all-unused-imports --recursive --ignore-init-module-imports --ignore-pass-after-docstring autogpt tests"
+          $cmd --check || (echo "You have unused imports or pass statements, please run '${cmd} --in-place'" && exit 1)
+
+  test:
+    # eliminate duplicate runs
+    if: github.event_name == 'push' || (github.event.pull_request.head.repo.fork == (github.event_name == 'pull_request_target'))
+
+    permissions:
+      # Gives the action the necessary permissions for publishing new
+      # comments in pull requests.
+      pull-requests: write
+      # Gives the action the necessary permissions for pushing data to the
+      # python-coverage-comment-action branch, and for editing existing
+      # comments (to avoid publishing multiple comments in the same PR)
+      contents: write
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    strategy:
+      matrix:
+        python-version: ["3.10"]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          ref: ${{ github.event.pull_request.head.ref }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+          submodules: true
+
+      - name: Configure git user Auto-GPT-Bot
+        run: |
+          git config --global user.name "Auto-GPT-Bot"
+          git config --global user.email "github-bot@agpt.co"
+
+      - name: Checkout cassettes
+        if: ${{ startsWith(github.event_name, 'pull_request') }}
+        run: |
+          cassette_branch="${{ github.event.pull_request.user.login }}-${{ github.event.pull_request.head.ref }}"
+          cassette_base_branch="${{ github.event.pull_request.base.ref }}"
+          cd tests/Auto-GPT-test-cassettes
+
+          if ! git ls-remote --exit-code --heads origin $cassette_base_branch ; then
+            cassette_base_branch="master"
+          fi
+
+          if git ls-remote --exit-code --heads origin $cassette_branch ; then
+            git fetch origin $cassette_branch
+            git fetch origin $cassette_base_branch
+
+            git checkout $cassette_branch
+
+            # Pick non-conflicting cassette updates from the base branch
+            git merge --no-commit --strategy-option=ours origin/$cassette_base_branch
+            echo "Using cassettes from mirror branch '$cassette_branch'," \
+              "synced to upstream branch '$cassette_base_branch'."
+          else
+            git checkout -b $cassette_branch
+            echo "Branch '$cassette_branch' does not exist in cassette submodule." \
+              "Using cassettes from '$cassette_base_branch'."
+          fi
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - id: get_date
+        name: Get date
+        run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
+
+      - name: Set up Python dependency cache
+        uses: actions/cache@v3
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}-${{ steps.get_date.outputs.date }}
+
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+
+      - name: Run pytest with coverage
+        run: |
+          pytest -vv --cov=autogpt --cov-branch --cov-report term-missing --cov-report xml \
+            --numprocesses=logical --durations=10 \
+            tests/unit tests/integration tests/challenges
+          python tests/challenges/utils/build_current_score.py
+        env:
+          CI: true
+          PROXY: ${{ github.event_name == 'pull_request_target' && secrets.PROXY || '' }}
+          AGENT_MODE: ${{ github.event_name == 'pull_request_target' && secrets.AGENT_MODE || '' }}
+          AGENT_TYPE: ${{ github.event_name == 'pull_request_target' && secrets.AGENT_TYPE || '' }}
+          OPENAI_API_KEY: ${{ github.event_name != 'pull_request_target' && secrets.OPENAI_API_KEY || '' }}
+          PLAIN_OUTPUT: True
+
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v3
+
+      - id: setup_git_auth
+        name: Set up git token authentication
+        # Cassettes may be pushed even when tests fail
+        if: success() || failure()
+        run: |
+          config_key="http.${{ github.server_url }}/.extraheader"
+          base64_pat=$(echo -n "pat:${{ secrets.PAT_REVIEW }}" | base64 -w0)
+
+          git config "$config_key" \
+            "Authorization: Basic $base64_pat"
+
+          cd tests/Auto-GPT-test-cassettes
+          git config "$config_key" \
+            "Authorization: Basic $base64_pat"
+
+          echo "config_key=$config_key" >> $GITHUB_OUTPUT
+
+      - name: Push updated challenge scores
+        if: github.event_name == 'push'
+        run: |
+          score_file="tests/challenges/current_score.json"
+
+          if ! git diff --quiet $score_file; then
+            git add $score_file
+            git commit -m "Update challenge scores"
+            git push origin HEAD:${{ github.ref_name }}
+          else
+            echo "The challenge scores didn't change."
+          fi
+
+      - id: push_cassettes
+        name: Push updated cassettes
+        # For pull requests, push updated cassettes even when tests fail
+        if: github.event_name == 'push' || success() || failure()
+        run: |
+          if [ "${{ startsWith(github.event_name, 'pull_request') }}" = "true" ]; then
+            is_pull_request=true
+            cassette_branch="${{ github.event.pull_request.user.login }}-${{ github.event.pull_request.head.ref }}"
+          else
+            cassette_branch="${{ github.ref_name }}"
+          fi
+
+          cd tests/Auto-GPT-test-cassettes
+          # Commit & push changes to cassettes if any
+          if ! git diff --quiet; then
+            git add .
+            git commit -m "Auto-update cassettes"
+            git push origin HEAD:$cassette_branch
+            if [ ! $is_pull_request ]; then
+              cd ../..
+              git add tests/Auto-GPT-test-cassettes
+              git commit -m "Update cassette submodule"
+              git push origin HEAD:$cassette_branch
+            fi
+            echo "updated=true" >> $GITHUB_OUTPUT
+          else
+            echo "updated=false" >> $GITHUB_OUTPUT
+            echo "No cassette changes to commit"
+          fi
+
+      - name: Post Set up git token auth
+        if: steps.setup_git_auth.outcome == 'success'
+        run: |
+          git config --unset-all '${{ steps.setup_git_auth.outputs.config_key }}'
+          git submodule foreach git config --unset-all '${{ steps.setup_git_auth.outputs.config_key }}'
+
+      - name: Apply "behaviour change" label and comment on PR
+        if: ${{ startsWith(github.event_name, 'pull_request') }}
+        run: |
+          PR_NUMBER=${{ github.event.pull_request.number }}
+          TOKEN=${{ secrets.PAT_REVIEW }}
+          REPO=${{ github.repository }}
+
+          if [[ "${{ steps.push_cassettes.outputs.updated }}" == "true" ]]; then
+            echo "Adding label and comment..."
+            curl -X POST \
+            -H "Authorization: Bearer $TOKEN" \
+            -H "Accept: application/vnd.github.v3+json" \
+            https://api.github.com/repos/$REPO/issues/$PR_NUMBER/labels \
+            -d '{"labels":["behaviour change"]}'
+
+            echo $TOKEN | gh auth login --with-token
+            gh api repos/$REPO/issues/$PR_NUMBER/comments -X POST -F body="You changed AutoGPT's behaviour. The cassettes have been updated and will be merged to the submodule when this Pull Request gets merged."
+          fi
+
+      - name: Upload logs to artifact
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: test-logs
+          path: logs/

.github/workflows/classic-autogpt-ci.yml

@@ -1,138 +0,0 @@
-name: Classic - AutoGPT CI
-
-on:
-  push:
-    branches: [ master, development, ci-test* ]
-    paths:
-      - '.github/workflows/classic-autogpt-ci.yml'
-      - 'classic/original_autogpt/**'
-  pull_request:
-    branches: [ master, development, release-* ]
-    paths:
-      - '.github/workflows/classic-autogpt-ci.yml'
-      - 'classic/original_autogpt/**'
-
-concurrency:
-  group: ${{ format('classic-autogpt-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
-  cancel-in-progress: ${{ startsWith(github.event_name, 'pull_request') }}
-
-defaults:
-  run:
-    shell: bash
-    working-directory: classic/original_autogpt
-
-jobs:
-  test:
-    permissions:
-      contents: read
-    timeout-minutes: 30
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.10"]
-        platform-os: [ubuntu, macos, macos-arm64, windows]
-    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
-
-    steps:
-      # Quite slow on macOS (2~4 minutes to set up Docker)
-      # - name: Set up Docker (macOS)
-      #   if: runner.os == 'macOS'
-      #   uses: crazy-max/ghaction-setup-docker@v3
-
-      - name: Start MinIO service (Linux)
-        if: runner.os == 'Linux'
-        working-directory: '.'
-        run: |
-          docker pull minio/minio:edge-cicd
-          docker run -d -p 9000:9000 minio/minio:edge-cicd
-
-      - name: Start MinIO service (macOS)
-        if: runner.os == 'macOS'
-        working-directory: ${{ runner.temp }}
-        run: |
-          brew install minio/stable/minio
-          mkdir data
-          minio server ./data &
-
-      # No MinIO on Windows:
-      # - Windows doesn't support running Linux Docker containers
-      # - It doesn't seem possible to start background processes on Windows. They are
-      #   killed after the step returns.
-      #   See: https://github.com/actions/runner/issues/598#issuecomment-2011890429
-
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Configure git user Auto-GPT-Bot
-        run: |
-          git config --global user.name "Auto-GPT-Bot"
-          git config --global user.email "github-bot@agpt.co"
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - id: get_date
-        name: Get date
-        run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
-
-      - name: Set up Python dependency cache
-        # On Windows, unpacking cached dependencies takes longer than just installing them
-        if: runner.os != 'Windows'
-        uses: actions/cache@v4
-        with:
-          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/original_autogpt/poetry.lock') }}
-
-      - name: Install Poetry (Unix)
-        if: runner.os != 'Windows'
-        run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-
-          if [ "${{ runner.os }}" = "macOS" ]; then
-            PATH="$HOME/.local/bin:$PATH"
-            echo "$HOME/.local/bin" >> $GITHUB_PATH
-          fi
-
-      - name: Install Poetry (Windows)
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
-
-          $env:PATH += ";$env:APPDATA\Python\Scripts"
-          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
-
-      - name: Install Python dependencies
-        run: poetry install
-
-      - name: Run pytest with coverage
-        run: |
-          poetry run pytest -vv \
-            --cov=autogpt --cov-branch --cov-report term-missing --cov-report xml \
-            --numprocesses=logical --durations=10 \
-            tests/unit tests/integration
-        env:
-          CI: true
-          PLAIN_OUTPUT: True
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          S3_ENDPOINT_URL: ${{ runner.os != 'Windows' && 'http://127.0.0.1:9000' || '' }}
-          AWS_ACCESS_KEY_ID: minioadmin
-          AWS_SECRET_ACCESS_KEY: minioadmin
-
-      - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v4
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          flags: autogpt-agent,${{ runner.os }}
-
-      - name: Upload logs to artifact
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: test-logs
-          path: classic/original_autogpt/logs/

.github/workflows/classic-autogpt-docker-ci.yml

@@ -1,166 +0,0 @@
-name: Classic - AutoGPT Docker CI
-
-on:
-  push:
-    branches: [ master, development ]
-    paths:
-      - '.github/workflows/classic-autogpt-docker-ci.yml'
-      - 'classic/original_autogpt/**'
-      - 'classic/forge/**'
-  pull_request:
-    branches: [ master, development, release-* ]
-    paths:
-      - '.github/workflows/classic-autogpt-docker-ci.yml'
-      - 'classic/original_autogpt/**'
-      - 'classic/forge/**'
-
-concurrency:
-  group: ${{ format('classic-autogpt-docker-ci-{0}', github.head_ref && format('pr-{0}', github.event.pull_request.number) || github.sha) }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
-defaults:
-  run:
-    working-directory: classic/original_autogpt
-
-env:
-  IMAGE_NAME: auto-gpt
-  DEPLOY_IMAGE_NAME: ${{ secrets.DOCKER_USER && format('{0}/', secrets.DOCKER_USER) || '' }}auto-gpt
-  DEV_IMAGE_TAG: latest-dev
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        build-type: [release, dev]
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
-
-    - if: runner.debug
-      run: |
-        ls -al
-        du -hs *
-
-    - id: build
-      name: Build image
-      uses: docker/build-push-action@v5
-      with:
-        context: classic/
-        file: classic/Dockerfile.autogpt
-        build-args: BUILD_TYPE=${{ matrix.build-type }}
-        tags: ${{ env.IMAGE_NAME }}
-        labels: GIT_REVISION=${{ github.sha }}
-        load: true    # save to docker images
-        # cache layers in GitHub Actions cache to speed up builds
-        cache-from: type=gha,scope=autogpt-docker-${{ matrix.build-type }}
-        cache-to: type=gha,scope=autogpt-docker-${{ matrix.build-type }},mode=max
-
-    - name: Generate build report
-      env:
-        event_name: ${{ github.event_name }}
-        event_ref: ${{ github.event.ref }}
-        event_ref_type: ${{ github.event.ref}}
-
-        build_type: ${{ matrix.build-type }}
-
-        prod_branch: master
-        dev_branch: development
-        repository: ${{ github.repository }}
-        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'development' && 'development' || 'master' }}
-
-        current_ref: ${{ github.ref_name }}
-        commit_hash: ${{ github.event.after }}
-        source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.event.release && github.event.release.tag_name || github.sha) }}
-        push_forced_label: ${{ github.event.forced && '☢️ forced' || '' }}
-
-        new_commits_json: ${{ toJSON(github.event.commits) }}
-        compare_url_template: ${{ format('/{0}/compare/{{base}}...{{head}}', github.repository) }}
-
-        github_context_json: ${{ toJSON(github) }}
-        job_env_json: ${{ toJSON(env) }}
-        vars_json: ${{ toJSON(vars) }}
-
-      run: .github/workflows/scripts/docker-ci-summary.sh >> $GITHUB_STEP_SUMMARY
-      continue-on-error: true
-
-  test:
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-
-    services:
-      minio:
-        image: minio/minio:edge-cicd
-        options: >
-          --name=minio
-          --health-interval=10s --health-timeout=5s --health-retries=3
-          --health-cmd="curl -f http://localhost:9000/minio/health/live"
-
-    steps:
-      - name: Check out repository
-        uses: actions/checkout@v4
-        with:
-          submodules: true
-
-      - if: github.event_name == 'push'
-        name: Log in to Docker hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKER_USER }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - id: build
-        name: Build image
-        uses: docker/build-push-action@v5
-        with:
-          context: classic/
-          file: classic/Dockerfile.autogpt
-          build-args: BUILD_TYPE=dev  # include pytest
-          tags: >
-            ${{ env.IMAGE_NAME }},
-            ${{ env.DEPLOY_IMAGE_NAME }}:${{ env.DEV_IMAGE_TAG }}
-          labels: GIT_REVISION=${{ github.sha }}
-          load: true                  # save to docker images
-          # cache layers in GitHub Actions cache to speed up builds
-          cache-from: type=gha,scope=autogpt-docker-dev
-          cache-to: type=gha,scope=autogpt-docker-dev,mode=max
-
-      - id: test
-        name: Run tests
-        env:
-          CI: true
-          PLAIN_OUTPUT: True
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          S3_ENDPOINT_URL: http://minio:9000
-          AWS_ACCESS_KEY_ID: minioadmin
-          AWS_SECRET_ACCESS_KEY: minioadmin
-        run: |
-          set +e
-          docker run --env CI --env OPENAI_API_KEY \
-            --network container:minio \
-            --env S3_ENDPOINT_URL --env AWS_ACCESS_KEY_ID --env AWS_SECRET_ACCESS_KEY \
-            --entrypoint poetry ${{ env.IMAGE_NAME }} run \
-            pytest -v --cov=autogpt --cov-branch --cov-report term-missing \
-            --numprocesses=4 --durations=10 \
-            tests/unit tests/integration 2>&1 | tee test_output.txt
-
-          test_failure=${PIPESTATUS[0]}
-
-          cat << $EOF >> $GITHUB_STEP_SUMMARY
-          # Tests $([ $test_failure = 0 ] && echo '✅' || echo '❌')
-          \`\`\`
-          $(cat test_output.txt)
-          \`\`\`
-          $EOF
-
-          exit $test_failure
-
-      - if: github.event_name == 'push' && github.ref_name == 'master'
-        name: Push image to Docker Hub
-        run: docker push ${{ env.DEPLOY_IMAGE_NAME }}:${{ env.DEV_IMAGE_TAG }}

.github/workflows/classic-autogpts-ci.yml

@@ -1,76 +0,0 @@
-name: Classic - Agent smoke tests
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '0 8 * * *'
-  push:
-    branches: [ master, development, ci-test* ]
-    paths:
-      - '.github/workflows/classic-autogpts-ci.yml'
-      - 'classic/original_autogpt/**'
-      - 'classic/forge/**'
-      - 'classic/benchmark/**'
-      - 'classic/run'
-      - 'classic/cli.py'
-      - 'classic/setup.py'
-      - '!**/*.md'
-  pull_request:
-    branches: [ master, development, release-* ]
-    paths:
-      - '.github/workflows/classic-autogpts-ci.yml'
-      - 'classic/original_autogpt/**'
-      - 'classic/forge/**'
-      - 'classic/benchmark/**'
-      - 'classic/run'
-      - 'classic/cli.py'
-      - 'classic/setup.py'
-      - '!**/*.md'
-
-defaults:
-  run:
-    shell: bash
-    working-directory: classic
-
-jobs:
-  serve-agent-protocol:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        agent-name: [ original_autogpt ]
-      fail-fast: false
-    timeout-minutes: 20
-    env:
-      min-python-version: '3.10'
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Set up Python ${{ env.min-python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.min-python-version }}
-
-      - name: Install Poetry
-        working-directory: ./classic/${{ matrix.agent-name }}/
-        run: |
-          curl -sSL https://install.python-poetry.org | python -
-
-      - name: Run regression tests
-        run: |
-          ./run agent start ${{ matrix.agent-name }}
-          cd ${{ matrix.agent-name }}
-          poetry run agbenchmark --mock --test=BasicRetrieval --test=Battleship --test=WebArenaTask_0
-          poetry run agbenchmark --test=WriteFile
-        env:
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          AGENT_NAME: ${{ matrix.agent-name }}
-          REQUESTS_CA_BUNDLE: /etc/ssl/certs/ca-certificates.crt
-          HELICONE_CACHE_ENABLED: false
-          HELICONE_PROPERTY_AGENT: ${{ matrix.agent-name }}
-          REPORTS_FOLDER: ${{ format('../../reports/{0}', matrix.agent-name) }}
-          TELEMETRY_ENVIRONMENT: autogpt-ci
-          TELEMETRY_OPT_IN: ${{ github.ref_name == 'master' }}

.github/workflows/classic-benchmark-ci.yml

@@ -1,169 +0,0 @@
-name: Classic - AGBenchmark CI
-
-on:
-  push:
-    branches: [ master, development, ci-test* ]
-    paths:
-      - 'classic/benchmark/**'
-      - '!classic/benchmark/reports/**'
-      - .github/workflows/classic-benchmark-ci.yml
-  pull_request:
-    branches: [ master, development, release-* ]
-    paths:
-      - 'classic/benchmark/**'
-      - '!classic/benchmark/reports/**'
-      - .github/workflows/classic-benchmark-ci.yml
-
-concurrency:
-  group: ${{ format('benchmark-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
-  cancel-in-progress: ${{ startsWith(github.event_name, 'pull_request') }}
-
-defaults:
-  run:
-    shell: bash
-
-env:
-  min-python-version: '3.10'
-
-jobs:
-  test:
-    permissions:
-      contents: read
-    timeout-minutes: 30
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.10"]
-        platform-os: [ubuntu, macos, macos-arm64, windows]
-    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
-    defaults:
-      run:
-        shell: bash
-        working-directory: classic/benchmark
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Set up Python dependency cache
-        # On Windows, unpacking cached dependencies takes longer than just installing them
-        if: runner.os != 'Windows'
-        uses: actions/cache@v4
-        with:
-          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/benchmark/poetry.lock') }}
-
-      - name: Install Poetry (Unix)
-        if: runner.os != 'Windows'
-        run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-
-          if [ "${{ runner.os }}" = "macOS" ]; then
-            PATH="$HOME/.local/bin:$PATH"
-            echo "$HOME/.local/bin" >> $GITHUB_PATH
-          fi
-
-      - name: Install Poetry (Windows)
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
-
-          $env:PATH += ";$env:APPDATA\Python\Scripts"
-          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
-
-      - name: Install Python dependencies
-        run: poetry install
-
-      - name: Run pytest with coverage
-        run: |
-          poetry run pytest -vv \
-            --cov=agbenchmark --cov-branch --cov-report term-missing --cov-report xml \
-            --durations=10 \
-            tests
-        env:
-          CI: true
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-
-      - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v4
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          flags: agbenchmark,${{ runner.os }}
-
-  self-test-with-agent:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        agent-name: [ forge ]
-      fail-fast: false
-    timeout-minutes: 20
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Set up Python ${{ env.min-python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.min-python-version }}
-
-      - name: Install Poetry
-        run: |
-          curl -sSL https://install.python-poetry.org | python -
-
-      - name: Run regression tests
-        working-directory: classic
-        run: |
-          ./run agent start ${{ matrix.agent-name }}
-          cd ${{ matrix.agent-name }}
-
-          set +e # Ignore non-zero exit codes and continue execution
-          echo "Running the following command: poetry run agbenchmark --maintain --mock"
-          poetry run agbenchmark --maintain --mock
-          EXIT_CODE=$?
-          set -e  # Stop ignoring non-zero exit codes
-          # Check if the exit code was 5, and if so, exit with 0 instead
-          if [ $EXIT_CODE -eq 5 ]; then
-            echo "regression_tests.json is empty."
-          fi
-
-          echo "Running the following command: poetry run agbenchmark --mock"
-          poetry run agbenchmark --mock
-
-          echo "Running the following command: poetry run agbenchmark --mock --category=data"
-          poetry run agbenchmark --mock --category=data
-
-          echo "Running the following command: poetry run agbenchmark --mock --category=coding"
-          poetry run agbenchmark --mock --category=coding
-
-          echo "Running the following command: poetry run agbenchmark --test=WriteFile"
-          poetry run agbenchmark --test=WriteFile
-          cd ../benchmark
-          poetry install
-          echo "Adding the BUILD_SKILL_TREE environment variable. This will attempt to add new elements in the skill tree. If new elements are added, the CI fails because they should have been pushed"
-          export BUILD_SKILL_TREE=true
-
-          poetry run agbenchmark --mock
-
-          CHANGED=$(git diff --name-only | grep -E '(agclassic/benchmark/challenges)|(../classic/frontend/assets)') || echo "No diffs"
-          if [ ! -z "$CHANGED" ]; then
-            echo "There are unstaged changes please run agbenchmark and commit those changes since they are needed."
-            echo "$CHANGED"
-            exit 1
-          else
-            echo "No unstaged changes."
-          fi
-        env:
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          TELEMETRY_ENVIRONMENT: autogpt-benchmark-ci
-          TELEMETRY_OPT_IN: ${{ github.ref_name == 'master' }}

.github/workflows/classic-benchmark_publish_package.yml

@@ -1,55 +0,0 @@
-name: Classic - Publish to PyPI
-
-on:
-  workflow_dispatch:
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-      with:
-        submodules: true
-        fetch-depth: 0
-
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: 3.8
-
-    - name: Install Poetry
-      working-directory: ./classic/benchmark/
-      run: |
-        curl -sSL https://install.python-poetry.org | python3 -
-        echo "$HOME/.poetry/bin" >> $GITHUB_PATH
-
-    - name: Build project for distribution
-      working-directory: ./classic/benchmark/
-      run: poetry build
-
-    - name: Install dependencies
-      working-directory: ./classic/benchmark/
-      run: poetry install
-
-    - name: Check Version
-      working-directory: ./classic/benchmark/
-      id: check-version
-      run: |
-        echo version=$(poetry version --short) >> $GITHUB_OUTPUT
-
-    - name: Create Release
-      uses: ncipollo/release-action@v1
-      with:
-        artifacts: "classic/benchmark/dist/*"
-        token: ${{ secrets.GITHUB_TOKEN }}
-        draft: false
-        generateReleaseNotes: false
-        tag: agbenchmark-v${{ steps.check-version.outputs.version }}
-        commit: master
-
-    - name: Build and publish
-      working-directory: ./classic/benchmark/
-      run: poetry publish -u __token__ -p ${{ secrets.PYPI_API_TOKEN }}

.github/workflows/classic-forge-ci.yml

@@ -1,236 +0,0 @@
-name: Classic - Forge CI
-
-on:
-  push:
-    branches: [ master, development, ci-test* ]
-    paths:
-      - '.github/workflows/classic-forge-ci.yml'
-      - 'classic/forge/**'
-      - '!classic/forge/tests/vcr_cassettes'
-  pull_request:
-    branches: [ master, development, release-* ]
-    paths:
-      - '.github/workflows/classic-forge-ci.yml'
-      - 'classic/forge/**'
-      - '!classic/forge/tests/vcr_cassettes'
-
-concurrency:
-  group: ${{ format('forge-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
-  cancel-in-progress: ${{ startsWith(github.event_name, 'pull_request') }}
-
-defaults:
-  run:
-    shell: bash
-    working-directory: classic/forge
-
-jobs:
-  test:
-    permissions:
-      contents: read
-    timeout-minutes: 30
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.10"]
-        platform-os: [ubuntu, macos, macos-arm64, windows]
-    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
-
-    steps:
-      # Quite slow on macOS (2~4 minutes to set up Docker)
-      # - name: Set up Docker (macOS)
-      #   if: runner.os == 'macOS'
-      #   uses: crazy-max/ghaction-setup-docker@v3
-
-      - name: Start MinIO service (Linux)
-        if: runner.os == 'Linux'
-        working-directory: '.'
-        run: |
-          docker pull minio/minio:edge-cicd
-          docker run -d -p 9000:9000 minio/minio:edge-cicd
-
-      - name: Start MinIO service (macOS)
-        if: runner.os == 'macOS'
-        working-directory: ${{ runner.temp }}
-        run: |
-          brew install minio/stable/minio
-          mkdir data
-          minio server ./data &
-
-      # No MinIO on Windows:
-      # - Windows doesn't support running Linux Docker containers
-      # - It doesn't seem possible to start background processes on Windows. They are
-      #   killed after the step returns.
-      #   See: https://github.com/actions/runner/issues/598#issuecomment-2011890429
-
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Checkout cassettes
-        if: ${{ startsWith(github.event_name, 'pull_request') }}
-        env:
-          PR_BASE: ${{ github.event.pull_request.base.ref }}
-          PR_BRANCH: ${{ github.event.pull_request.head.ref }}
-          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
-        run: |
-          cassette_branch="${PR_AUTHOR}-${PR_BRANCH}"
-          cassette_base_branch="${PR_BASE}"
-          cd tests/vcr_cassettes
-
-          if ! git ls-remote --exit-code --heads origin $cassette_base_branch ; then
-            cassette_base_branch="master"
-          fi
-
-          if git ls-remote --exit-code --heads origin $cassette_branch ; then
-            git fetch origin $cassette_branch
-            git fetch origin $cassette_base_branch
-
-            git checkout $cassette_branch
-
-            # Pick non-conflicting cassette updates from the base branch
-            git merge --no-commit --strategy-option=ours origin/$cassette_base_branch
-            echo "Using cassettes from mirror branch '$cassette_branch'," \
-              "synced to upstream branch '$cassette_base_branch'."
-          else
-            git checkout -b $cassette_branch
-            echo "Branch '$cassette_branch' does not exist in cassette submodule." \
-              "Using cassettes from '$cassette_base_branch'."
-          fi
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Set up Python dependency cache
-        # On Windows, unpacking cached dependencies takes longer than just installing them
-        if: runner.os != 'Windows'
-        uses: actions/cache@v4
-        with:
-          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/forge/poetry.lock') }}
-
-      - name: Install Poetry (Unix)
-        if: runner.os != 'Windows'
-        run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-
-          if [ "${{ runner.os }}" = "macOS" ]; then
-            PATH="$HOME/.local/bin:$PATH"
-            echo "$HOME/.local/bin" >> $GITHUB_PATH
-          fi
-
-      - name: Install Poetry (Windows)
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
-
-          $env:PATH += ";$env:APPDATA\Python\Scripts"
-          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
-
-      - name: Install Python dependencies
-        run: poetry install
-
-      - name: Run pytest with coverage
-        run: |
-          poetry run pytest -vv \
-            --cov=forge --cov-branch --cov-report term-missing --cov-report xml \
-            --durations=10 \
-            forge
-        env:
-          CI: true
-          PLAIN_OUTPUT: True
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          S3_ENDPOINT_URL: ${{ runner.os != 'Windows' && 'http://127.0.0.1:9000' || '' }}
-          AWS_ACCESS_KEY_ID: minioadmin
-          AWS_SECRET_ACCESS_KEY: minioadmin
-
-      - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v4
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          flags: forge,${{ runner.os }}
-
-      - id: setup_git_auth
-        name: Set up git token authentication
-        # Cassettes may be pushed even when tests fail
-        if: success() || failure()
-        run: |
-          config_key="http.${{ github.server_url }}/.extraheader"
-          if [ "${{ runner.os }}" = 'macOS' ]; then
-            base64_pat=$(echo -n "pat:${{ secrets.PAT_REVIEW }}" | base64)
-          else
-            base64_pat=$(echo -n "pat:${{ secrets.PAT_REVIEW }}" | base64 -w0)
-          fi
-
-          git config "$config_key" \
-            "Authorization: Basic $base64_pat"
-
-          cd tests/vcr_cassettes
-          git config "$config_key" \
-            "Authorization: Basic $base64_pat"
-
-          echo "config_key=$config_key" >> $GITHUB_OUTPUT
-
-      - id: push_cassettes
-        name: Push updated cassettes
-        # For pull requests, push updated cassettes even when tests fail
-        if: github.event_name == 'push' || (! github.event.pull_request.head.repo.fork && (success() || failure()))
-        env:
-          PR_BRANCH: ${{ github.event.pull_request.head.ref }}
-          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
-        run: |
-          if [ "${{ startsWith(github.event_name, 'pull_request') }}" = "true" ]; then
-            is_pull_request=true
-            cassette_branch="${PR_AUTHOR}-${PR_BRANCH}"
-          else
-            cassette_branch="${{ github.ref_name }}"
-          fi
-
-          cd tests/vcr_cassettes
-          # Commit & push changes to cassettes if any
-          if ! git diff --quiet; then
-            git add .
-            git commit -m "Auto-update cassettes"
-            git push origin HEAD:$cassette_branch
-            if [ ! $is_pull_request ]; then
-              cd ../..
-              git add tests/vcr_cassettes
-              git commit -m "Update cassette submodule"
-              git push origin HEAD:$cassette_branch
-            fi
-            echo "updated=true" >> $GITHUB_OUTPUT
-          else
-            echo "updated=false" >> $GITHUB_OUTPUT
-            echo "No cassette changes to commit"
-          fi
-
-      - name: Post Set up git token auth
-        if: steps.setup_git_auth.outcome == 'success'
-        run: |
-          git config --unset-all '${{ steps.setup_git_auth.outputs.config_key }}'
-          git submodule foreach git config --unset-all '${{ steps.setup_git_auth.outputs.config_key }}'
-
-      - name: Apply "behaviour change" label and comment on PR
-        if: ${{ startsWith(github.event_name, 'pull_request') }}
-        run: |
-          PR_NUMBER="${{ github.event.pull_request.number }}"
-          TOKEN="${{ secrets.PAT_REVIEW }}"
-          REPO="${{ github.repository }}"
-
-          if [[ "${{ steps.push_cassettes.outputs.updated }}" == "true" ]]; then
-            echo "Adding label and comment..."
-            echo $TOKEN | gh auth login --with-token
-            gh issue edit $PR_NUMBER --add-label "behaviour change"
-            gh issue comment $PR_NUMBER --body "You changed AutoGPT's behaviour on ${{ runner.os }}. The cassettes have been updated and will be merged to the submodule when this Pull Request gets merged."
-          fi
-
-      - name: Upload logs to artifact
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: test-logs
-          path: classic/forge/logs/

.github/workflows/classic-frontend-ci.yml

@@ -1,60 +0,0 @@
-name: Classic - Frontend CI/CD
-
-on:
-  push:
-    branches:
-      - master
-      - development
-      - 'ci-test*' # This will match any branch that starts with "ci-test"
-    paths:
-      - 'classic/frontend/**'
-      - '.github/workflows/frontend-ci.yml'
-  pull_request:
-    paths:
-      - 'classic/frontend/**'
-      - '.github/workflows/frontend-ci.yml'
-
-jobs:
-  build:
-    permissions:
-      contents: write
-      pull-requests: write
-    runs-on: ubuntu-latest
-    env:
-      BUILD_BRANCH: ${{ format('frontend-build/{0}', github.ref_name) }}
-
-    steps:
-    - name: Checkout Repo
-      uses: actions/checkout@v4
-
-    - name: Setup Flutter
-      uses: subosito/flutter-action@v2
-      with:
-        flutter-version: '3.13.2'
-
-    - name: Build Flutter to Web
-      run: |
-        cd classic/frontend
-        flutter build web --base-href /app/
-
-    # - name: Commit and Push to ${{ env.BUILD_BRANCH }}
-    #   if: github.event_name == 'push'
-    #   run: |
-    #     git config --local user.email "action@github.com"
-    #     git config --local user.name "GitHub Action"
-    #     git add classic/frontend/build/web
-    #     git checkout -B ${{ env.BUILD_BRANCH }}
-    #     git commit -m "Update frontend build to ${GITHUB_SHA:0:7}" -a
-    #     git push -f origin ${{ env.BUILD_BRANCH }}
-
-    - name: Create PR ${{ env.BUILD_BRANCH }} -> ${{ github.ref_name }}
-      if: github.event_name == 'push'
-      uses: peter-evans/create-pull-request@v6
-      with:
-        add-paths: classic/frontend/build/web
-        base: ${{ github.ref_name }}
-        branch: ${{ env.BUILD_BRANCH }}
-        delete-branch: true
-        title: "Update frontend build in `${{ github.ref_name }}`"
-        body: "This PR updates the frontend build based on commit ${{ github.sha }}."
-        commit-message: "Update frontend build based on commit ${{ github.sha }}"

.github/workflows/classic-python-checks.yml

@@ -1,151 +0,0 @@
-name: Classic - Python checks
-
-on:
-  push:
-    branches: [ master, development, ci-test* ]
-    paths:
-      - '.github/workflows/lint-ci.yml'
-      - 'classic/original_autogpt/**'
-      - 'classic/forge/**'
-      - 'classic/benchmark/**'
-      - '**.py'
-      - '!classic/forge/tests/vcr_cassettes'
-  pull_request:
-    branches: [ master, development, release-* ]
-    paths:
-      - '.github/workflows/lint-ci.yml'
-      - 'classic/original_autogpt/**'
-      - 'classic/forge/**'
-      - 'classic/benchmark/**'
-      - '**.py'
-      - '!classic/forge/tests/vcr_cassettes'
-
-concurrency:
-  group: ${{ format('lint-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
-  cancel-in-progress: ${{ startsWith(github.event_name, 'pull_request') }}
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  get-changed-parts:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - id: changes-in
-        name: Determine affected subprojects
-        uses: dorny/paths-filter@v3
-        with:
-          filters: |
-            original_autogpt:
-              - classic/original_autogpt/autogpt/**
-              - classic/original_autogpt/tests/**
-              - classic/original_autogpt/poetry.lock
-            forge:
-              - classic/forge/forge/**
-              - classic/forge/tests/**
-              - classic/forge/poetry.lock
-            benchmark:
-              - classic/benchmark/agbenchmark/**
-              - classic/benchmark/tests/**
-              - classic/benchmark/poetry.lock
-    outputs:
-      changed-parts: ${{ steps.changes-in.outputs.changes }}
-
-  lint:
-    needs: get-changed-parts
-    runs-on: ubuntu-latest
-    env:
-      min-python-version: "3.10"
-
-    strategy:
-      matrix:
-        sub-package: ${{ fromJson(needs.get-changed-parts.outputs.changed-parts) }}
-      fail-fast: false
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Set up Python ${{ env.min-python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.min-python-version }}
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pypoetry
-          key: ${{ runner.os }}-poetry-${{ hashFiles(format('{0}/poetry.lock', matrix.sub-package)) }}
-
-      - name: Install Poetry
-        run: curl -sSL https://install.python-poetry.org | python3 -
-
-      # Install dependencies
-
-      - name: Install Python dependencies
-        run: poetry -C classic/${{ matrix.sub-package }} install
-
-      # Lint
-
-      - name: Lint (isort)
-        run: poetry run isort --check .
-        working-directory: classic/${{ matrix.sub-package }}
-
-      - name: Lint (Black)
-        if: success() || failure()
-        run: poetry run black --check .
-        working-directory: classic/${{ matrix.sub-package }}
-
-      - name: Lint (Flake8)
-        if: success() || failure()
-        run: poetry run flake8 .
-        working-directory: classic/${{ matrix.sub-package }}
-
-  types:
-    needs: get-changed-parts
-    runs-on: ubuntu-latest
-    env:
-      min-python-version: "3.10"
-
-    strategy:
-      matrix:
-        sub-package: ${{ fromJson(needs.get-changed-parts.outputs.changed-parts) }}
-      fail-fast: false
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Set up Python ${{ env.min-python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.min-python-version }}
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pypoetry
-          key: ${{ runner.os }}-poetry-${{ hashFiles(format('{0}/poetry.lock', matrix.sub-package)) }}
-
-      - name: Install Poetry
-        run: curl -sSL https://install.python-poetry.org | python3 -
-
-      # Install dependencies
-
-      - name: Install Python dependencies
-        run: poetry -C classic/${{ matrix.sub-package }} install
-
-      # Typecheck
-
-      - name: Typecheck
-        if: success() || failure()
-        run: poetry run pyright
-        working-directory: classic/${{ matrix.sub-package }}

.github/workflows/docker-cache-clean.yml

@@ -1,11 +1,11 @@
-name: Classic - Purge Auto-GPT Docker CI cache
+name: Purge Docker CI cache
 
 on:
   schedule:
     - cron: 20 4 * * 1,4
 
 env:
-  BASE_BRANCH: development
+  BASE_BRANCH: master
   IMAGE_NAME: auto-gpt
 
 jobs:
@@ -16,21 +16,19 @@ jobs:
         build-type: [release, dev]
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v3
 
     - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
+      uses: docker/setup-buildx-action@v2
 
     - id: build
       name: Build image
-      uses: docker/build-push-action@v5
+      uses: docker/build-push-action@v3
       with:
-        context: classic/
-        file: classic/Dockerfile.autogpt
         build-args: BUILD_TYPE=${{ matrix.build-type }}
         load: true    # save to docker images
         # use GHA cache as read-only
-        cache-to: type=gha,scope=autogpt-docker-${{ matrix.build-type }},mode=max
+        cache-to: type=gha,scope=docker-${{ matrix.build-type }},mode=max
 
     - name: Generate build report
       env:
@@ -39,10 +37,10 @@ jobs:
 
         build_type: ${{ matrix.build-type }}
 
-        prod_branch: master
-        dev_branch: development
+        prod_branch: stable
+        dev_branch: master
         repository: ${{ github.repository }}
-        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'development' && 'development' || 'master' }}
+        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'stable' && 'master' || 'stable' }}
 
         current_ref: ${{ github.ref_name }}
         commit_hash: ${{ github.sha }}

.github/workflows/docker-ci.yml

@@ -0,0 +1,124 @@
+name: Docker CI
+
+on:
+  push:
+    branches: [ master ]
+    paths-ignore:
+      - 'tests/Auto-GPT-test-cassettes'
+      - 'tests/challenges/current_score.json'
+  pull_request:
+    branches: [ master, release-*, stable ]
+
+concurrency:
+  group: ${{ format('docker-ci-{0}', github.head_ref && format('pr-{0}', github.event.pull_request.number) || github.sha) }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+env:
+  IMAGE_NAME: auto-gpt
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        build-type: [release, dev]
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v2
+
+    - if: runner.debug
+      run: |
+        ls -al
+        du -hs *
+
+    - id: build
+      name: Build image
+      uses: docker/build-push-action@v3
+      with:
+        build-args: BUILD_TYPE=${{ matrix.build-type }}
+        tags: ${{ env.IMAGE_NAME }}
+        load: true    # save to docker images
+        # cache layers in GitHub Actions cache to speed up builds
+        cache-from: type=gha,scope=docker-${{ matrix.build-type }}
+        cache-to: type=gha,scope=docker-${{ matrix.build-type }},mode=max
+
+    - name: Generate build report
+      env:
+        event_name: ${{ github.event_name }}
+        event_ref: ${{ github.event.ref }}
+        event_ref_type: ${{ github.event.ref}}
+
+        build_type: ${{ matrix.build-type }}
+
+        prod_branch: stable
+        dev_branch: master
+        repository: ${{ github.repository }}
+        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'stable' && 'master' || 'stable' }}
+
+        current_ref: ${{ github.ref_name }}
+        commit_hash: ${{ github.event.after }}
+        source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.event.release && github.event.release.tag_name || github.sha) }}
+        push_forced_label: ${{ github.event.forced && '☢️ forced' || '' }}
+
+        new_commits_json: ${{ toJSON(github.event.commits) }}
+        compare_url_template: ${{ format('/{0}/compare/{{base}}...{{head}}', github.repository) }}
+
+        github_context_json: ${{ toJSON(github) }}
+        job_env_json: ${{ toJSON(env) }}
+        vars_json: ${{ toJSON(vars) }}
+
+      run: .github/workflows/scripts/docker-ci-summary.sh >> $GITHUB_STEP_SUMMARY
+      continue-on-error: true
+
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v3
+        with:
+          submodules: true
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - id: build
+        name: Build image
+        uses: docker/build-push-action@v3
+        with:
+          build-args: BUILD_TYPE=dev  # include pytest
+          tags: ${{ env.IMAGE_NAME }}
+          load: true                  # save to docker images
+          # cache layers in GitHub Actions cache to speed up builds
+          cache-from: type=gha,scope=docker-dev
+          cache-to: type=gha,scope=docker-dev,mode=max
+
+      - id: test
+        name: Run tests
+        env:
+          CI: true
+          PLAIN_OUTPUT: True
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+        run: |
+          set +e
+          test_output=$(
+            docker run --env CI --env OPENAI_API_KEY --entrypoint python ${{ env.IMAGE_NAME }} -m \
+            pytest -v --cov=autogpt --cov-branch --cov-report term-missing \
+              --numprocesses=4 --durations=10 \
+              tests/unit tests/integration 2>&1
+          )
+          test_failure=$?
+
+          echo "$test_output"
+
+          cat << $EOF >> $GITHUB_STEP_SUMMARY
+          # Tests $([ $test_failure = 0 ] && echo '✅' || echo '❌')
+          \`\`\`
+          $test_output
+          \`\`\`
+          $EOF
+
+          exit $test_failure

.github/workflows/docker-release.yml

@@ -1,4 +1,4 @@
-name: Classic - AutoGPT Docker Release
+name: Docker Release
 
 on:
   release:
@@ -16,36 +16,31 @@ env:
 
 jobs:
   build:
-    if: startsWith(github.ref, 'refs/tags/autogpt-')
     runs-on: ubuntu-latest
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v3
 
     - name: Log in to Docker hub
-      uses: docker/login-action@v3
+      uses: docker/login-action@v2
       with:
         username: ${{ secrets.DOCKER_USER }}
         password: ${{ secrets.DOCKER_PASSWORD }}
 
     - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
+      uses: docker/setup-buildx-action@v2
 
       # slashes are not allowed in image tags, but can appear in git branch or tag names
     - id: sanitize_tag
       name: Sanitize image tag
-      run: |
-        tag=${raw_tag//\//-}
-        echo tag=${tag#autogpt-} >> $GITHUB_OUTPUT
+      run: echo tag=${raw_tag//\//-} >> $GITHUB_OUTPUT
       env:
         raw_tag: ${{ github.ref_name }}
 
     - id: build
       name: Build image
-      uses: docker/build-push-action@v5
+      uses: docker/build-push-action@v3
       with:
-        context: classic/
-        file: Dockerfile.autogpt
         build-args: BUILD_TYPE=release
         load: true    # save to docker images
         # push: true  # TODO: uncomment when this issue is fixed: https://github.com/moby/buildkit/issues/1555
@@ -53,11 +48,10 @@ jobs:
           ${{ env.IMAGE_NAME }},
           ${{ env.DEPLOY_IMAGE_NAME }}:latest,
           ${{ env.DEPLOY_IMAGE_NAME }}:${{ steps.sanitize_tag.outputs.tag }}
-        labels: GIT_REVISION=${{ github.sha }}
 
         # cache layers in GitHub Actions cache to speed up builds
-        cache-from: ${{ !inputs.no_cache && 'type=gha' || '' }},scope=autogpt-docker-release
-        cache-to: type=gha,scope=autogpt-docker-release,mode=max
+        cache-from: ${{ !inputs.no_cache && 'type=gha' || '' }},scope=docker-release
+        cache-to: type=gha,scope=docker-release,mode=max
 
     - name: Push image to Docker Hub
       run: docker push --all-tags ${{ env.DEPLOY_IMAGE_NAME }}
@@ -69,10 +63,10 @@ jobs:
         event_ref_type: ${{ github.event.ref}}
         inputs_no_cache: ${{ inputs.no_cache }}
 
-        prod_branch: master
-        dev_branch: development
+        prod_branch: stable
+        dev_branch: master
         repository: ${{ github.repository }}
-        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'development' && 'development' || 'master' }}
+        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'stable' && 'master' || 'stable' }}
 
         ref_type: ${{ github.ref_type }}
         current_ref: ${{ github.ref_name }}

.github/workflows/documentation-release.yml

@@ -0,0 +1,37 @@
+name: Docs
+
+on:
+  push:
+    branches: [ stable ]
+    paths:
+      - 'docs/**'
+      - 'mkdocs.yml'
+      - '.github/workflows/documentation.yml'
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Set up Python 3
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.x
+
+      - name: Set up workflow cache
+        uses: actions/cache@v3
+        with:
+          key: ${{ github.ref }}
+          path: .cache
+
+      - run: pip install mkdocs-material
+
+      - run: mkdocs gh-deploy --force

.github/workflows/platform-autogpt-builder-ci.yml

@@ -1,41 +0,0 @@
-name: Platform - AutoGPT Builder CI
-
-on:
-  push:
-    branches: [ master ]
-    paths:
-      - '.github/workflows/autogpt-builder-ci.yml'
-      - 'autogpt_platform/autogpt_builder/**'
-  pull_request:
-    paths:
-      - '.github/workflows/autogpt-builder-ci.yml'
-      - 'autogpt_platform/autogpt_builder/**'
-
-defaults:
-  run:
-    shell: bash
-    working-directory: autogpt_platform/autogpt_builder
-
-jobs:
-
-  lint:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Set up Node.js
-      uses: actions/setup-node@v4
-      with:
-        node-version: '21'
-
-    - name: Install dependencies
-      run: |
-        npm install
-
-    - name: Check formatting with Prettier
-      run: |
-        npx prettier --check .
-
-    - name: Run lint
-      run: |
-        npm run lint

.github/workflows/platform-autogpt-infra-ci.yml

@@ -1,56 +0,0 @@
-name: Platform - AutoGPT Builder Infra
-
-on:
-  push:
-    branches: [ master ]
-    paths:
-      - '.github/workflows/autogpt-infra-ci.yml'
-      - 'autogpt_platform/infra/**'
-  pull_request:
-    paths:
-      - '.github/workflows/autogpt-infra-ci.yml'
-      - 'autogpt_platform/infra/**'
-
-defaults:
-  run:
-    shell: bash
-    working-directory: autogpt_platform/infra
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-
-      - name: TFLint
-        uses: pauloconnor/tflint-action@v0.0.2
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-            tflint_path: terraform/
-            tflint_recurse: true
-            tflint_changed_only: false
-
-      - name: Set up Helm
-        uses: azure/setup-helm@v4.2.0
-        with:
-          version: v3.14.4
-
-      - name: Set up chart-testing
-        uses: helm/chart-testing-action@v2.6.0
-
-      - name: Run chart-testing (list-changed)
-        id: list-changed
-        run: |
-          changed=$(ct list-changed --target-branch ${{ github.event.repository.default_branch }})
-          if [[ -n "$changed" ]]; then
-            echo "changed=true" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Run chart-testing (lint)
-        if: steps.list-changed.outputs.changed == 'true'
-        run: ct lint --target-branch ${{ github.event.repository.default_branch }}

.github/workflows/platform-autogpt-server-ci.yml

@@ -1,155 +0,0 @@
-name: Platform - AutoGPT Server CI
-
-on:
-  push:
-    branches: [master, development, ci-test*]
-    paths:
-      - ".github/workflows/autogpt-server-ci.yml"
-      - "autogpt_platform/autogpt_server/**"
-  pull_request:
-    branches: [master, development, release-*]
-    paths:
-      - ".github/workflows/autogpt-server-ci.yml"
-      - "autogpt_platform/autogpt_server/**"
-
-concurrency:
-  group: ${{ format('autogpt-server-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
-  cancel-in-progress: ${{ startsWith(github.event_name, 'pull_request') }}
-
-defaults:
-  run:
-    shell: bash
-    working-directory: autogpt_platform/autogpt_server
-
-jobs:
-  test:
-    permissions:
-      contents: read
-    timeout-minutes: 30
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.10"]
-        platform-os: [ubuntu, macos, macos-arm64, windows]
-    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
-
-    steps:
-      - name: Setup PostgreSQL
-        uses: ikalnytskyi/action-setup-postgres@v6
-        with:
-          username: ${{ secrets.DB_USER || 'postgres' }}
-          password: ${{ secrets.DB_PASS || 'postgres' }}
-          database: postgres
-          port: 5432
-        id: postgres
-
-      # Quite slow on macOS (2~4 minutes to set up Docker)
-      # - name: Set up Docker (macOS)
-      #   if: runner.os == 'macOS'
-      #   uses: crazy-max/ghaction-setup-docker@v3
-
-      - name: Start MinIO service (Linux)
-        if: runner.os == 'Linux'
-        working-directory: "."
-        run: |
-          docker pull minio/minio:edge-cicd
-          docker run -d -p 9000:9000 minio/minio:edge-cicd
-
-      - name: Start MinIO service (macOS)
-        if: runner.os == 'macOS'
-        working-directory: ${{ runner.temp }}
-        run: |
-          brew install minio/stable/minio
-          mkdir data
-          minio server ./data &
-
-      # No MinIO on Windows:
-      # - Windows doesn't support running Linux Docker containers
-      # - It doesn't seem possible to start background processes on Windows. They are
-      #   killed after the step returns.
-      #   See: https://github.com/actions/runner/issues/598#issuecomment-2011890429
-
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - id: get_date
-        name: Get date
-        run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
-
-      - name: Set up Python dependency cache
-        # On Windows, unpacking cached dependencies takes longer than just installing them
-        if: runner.os != 'Windows'
-        uses: actions/cache@v4
-        with:
-          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
-          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/autogpt_server/poetry.lock') }}
-
-      - name: Install Poetry (Unix)
-        if: runner.os != 'Windows'
-        run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-
-          if [ "${{ runner.os }}" = "macOS" ]; then
-            PATH="$HOME/.local/bin:$PATH"
-            echo "$HOME/.local/bin" >> $GITHUB_PATH
-          fi
-
-      - name: Install Poetry (Windows)
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
-
-          $env:PATH += ";$env:APPDATA\Python\Scripts"
-          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
-
-      - name: Install Python dependencies
-        run: poetry install
-
-      - name: Generate Prisma Client
-        run: poetry run prisma generate
-
-      - name: Run Database Migrations
-        run: poetry run prisma migrate dev --name updates
-        env:
-          CONNECTION_STR: ${{ steps.postgres.outputs.connection-uri }}
-
-      - id: lint
-        name: Run Linter
-        run: poetry run lint
-
-      - name: Run pytest with coverage
-        run: |
-          if [[ "${{ runner.debug }}" == "1" ]]; then
-            poetry run pytest -vv -o log_cli=true -o log_cli_level=DEBUG test
-          else
-            poetry run pytest -vv test
-          fi
-        if: success() || (failure() && steps.lint.outcome == 'failure')
-        env:
-          LOG_LEVEL: ${{ runner.debug && 'DEBUG' || 'INFO' }}
-    env:
-      CI: true
-      PLAIN_OUTPUT: True
-      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-      DB_USER: ${{ secrets.DB_USER || 'postgres' }}
-      DB_PASS: ${{ secrets.DB_PASS || 'postgres' }}
-      DB_NAME: postgres
-      DB_PORT: 5432
-      RUN_ENV: local
-      PORT: 8080
-      DATABASE_URL: postgresql://${{ secrets.DB_USER || 'postgres' }}:${{ secrets.DB_PASS || 'postgres' }}@localhost:5432/${{ secrets.DB_NAME || 'postgres'}}
-
-      # - name: Upload coverage reports to Codecov
-      #   uses: codecov/codecov-action@v4
-      #   with:
-      #     token: ${{ secrets.CODECOV_TOKEN }}
-      #     flags: autogpt-server,${{ runner.os }}

.github/workflows/pr-label.yml

@@ -1,12 +1,12 @@
-name: Repo - Pull Request auto-label
+name: "Pull Request auto-label"
 
 on:
   # So that PRs touching the same files as the push are updated
   push:
-    branches: [ master, development, release-* ]
+    branches: [ master, release-* ]
     paths-ignore:
-      - 'classic/forge/tests/vcr_cassettes'
-      - 'classic/benchmark/reports/**'
+      - 'tests/Auto-GPT-test-cassettes'
+      - 'tests/challenges/current_score.json'
   # So that the `dirtyLabel` is removed if conflicts are resolve
   # We recommend `pull_request_target` so that github secrets are available.
   # In `pull_request` we wouldn't be able to change labels of fork PRs
@@ -52,15 +52,6 @@ jobs:
           l_label: 'size/l'
           l_max_size: 500
           xl_label: 'size/xl'
-          message_if_xl:
-
-  scope:
-    if: ${{ github.event_name == 'pull_request_target' }}
-    permissions:
-      contents: read
-      pull-requests: write
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/labeler@v5
-        with:
-          sync-labels: true
+          message_if_xl: >
+            This PR exceeds the recommended size of 500 lines.
+            Please make sure you are NOT addressing multiple issues with one PR.

.github/workflows/repo-close-stale-issues.yml

@@ -1,34 +0,0 @@
-name: Repo - Close stale issues
-on:
-  schedule:
-    - cron: '30 1 * * *'
-  workflow_dispatch:
-
-permissions:
-  issues: write
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/stale@v9
-        with:
-          # operations-per-run: 5000
-          stale-issue-message: >
-            This issue has automatically been marked as _stale_ because it has not had
-            any activity in the last 50 days. You can _unstale_ it by commenting or
-            removing the label. Otherwise, this issue will be closed in 10 days.
-          stale-pr-message: >
-            This pull request has automatically been marked as _stale_ because it has
-            not had any activity in the last 50 days. You can _unstale_ it by commenting
-            or removing the label.
-          close-issue-message: >
-            This issue was closed automatically because it has been stale for 10 days
-            with no activity.
-          days-before-stale: 50
-          days-before-close: 10
-          # Do not touch meta issues:
-          exempt-issue-labels: meta,fridge,project management
-          # Do not affect pull requests:
-          days-before-pr-stale: -1
-          days-before-pr-close: -1

.github/workflows/repo-stats.yml

@@ -1,20 +0,0 @@
-name: Repo - Github Stats
-
-on:
-  schedule:
-    # Run this once per day, towards the end of the day for keeping the most
-    # recent data point most meaningful (hours are interpreted in UTC).
-    - cron: "0 23 * * *"
-  workflow_dispatch: # Allow for running this manually.
-
-jobs:
-  j1:
-    name: github-repo-stats
-    runs-on: ubuntu-latest
-    steps:
-      - name: run-ghrs
-        # Use latest release.
-        uses: jgehrcke/github-repo-stats@HEAD
-        with:
-          ghtoken: ${{ secrets.ghrs_github_api_token }}
-

.github/workflows/repo-workflow-checker.yml

@@ -1,31 +0,0 @@
-name: Repo - PR Status Checker
-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-
-jobs:
-  status-check:
-    name: Check PR Status
-    runs-on: ubuntu-latest
-    steps:
-      # - name: Wait some time for all actions to start
-      #   run: sleep 30
-      - uses: actions/checkout@v4
-        # with:
-          # fetch-depth: 0
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.10"
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install requests
-      - name: Check PR Status
-        run: |
-          echo "Current directory before running Python script:"
-          pwd
-          echo "Attempting to run Python script:"
-          python .github/workflows/scripts/check_actions_status.py
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/scripts/check_actions_status.py

@@ -1,109 +0,0 @@
-import json
-import os
-import requests
-import sys
-import time
-from typing import Dict, List, Tuple
-
-
-def get_environment_variables() -> Tuple[str, str, str, str, str]:
-    """Retrieve and return necessary environment variables."""
-    try:
-        with open(os.environ["GITHUB_EVENT_PATH"]) as f:
-            event = json.load(f)
-
-        sha = event["pull_request"]["head"]["sha"]
-
-        return (
-            os.environ["GITHUB_API_URL"],
-            os.environ["GITHUB_REPOSITORY"],
-            sha,
-            os.environ["GITHUB_TOKEN"],
-            os.environ["GITHUB_RUN_ID"],
-        )
-    except KeyError as e:
-        print(f"Error: Missing required environment variable or event data: {e}")
-        sys.exit(1)
-
-
-def make_api_request(url: str, headers: Dict[str, str]) -> Dict:
-    """Make an API request and return the JSON response."""
-    try:
-        print("Making API request to:", url)
-        response = requests.get(url, headers=headers, timeout=10)
-        response.raise_for_status()
-        return response.json()
-    except requests.RequestException as e:
-        print(f"Error: API request failed. {e}")
-        sys.exit(1)
-
-
-def process_check_runs(check_runs: List[Dict]) -> Tuple[bool, bool]:
-    """Process check runs and return their status."""
-    runs_in_progress = False
-    all_others_passed = True
-
-    for run in check_runs:
-        if str(run["name"]) != "Check PR Status":
-            status = run["status"]
-            conclusion = run["conclusion"]
-
-            if status == "completed":
-                if conclusion not in ["success", "skipped", "neutral"]:
-                    all_others_passed = False
-                    print(
-                        f"Check run {run['name']} (ID: {run['id']}) has conclusion: {conclusion}"
-                    )
-            else:
-                runs_in_progress = True
-                print(f"Check run {run['name']} (ID: {run['id']}) is still {status}.")
-                all_others_passed = False
-        else:
-            print(
-                f"Skipping check run {run['name']} (ID: {run['id']}) as it is the current run."
-            )
-
-    return runs_in_progress, all_others_passed
-
-
-def main():
-    api_url, repo, sha, github_token, current_run_id = get_environment_variables()
-
-    endpoint = f"{api_url}/repos/{repo}/commits/{sha}/check-runs"
-    headers = {
-        "Accept": "application/vnd.github.v3+json",
-    }
-    if github_token:
-        headers["Authorization"] = f"token {github_token}"
-
-    print(f"Current run ID: {current_run_id}")
-
-    while True:
-        data = make_api_request(endpoint, headers)
-
-        check_runs = data["check_runs"]
-
-        print("Processing check runs...")
-
-        print(check_runs)
-
-        runs_in_progress, all_others_passed = process_check_runs(check_runs)
-
-        if not runs_in_progress:
-            break
-
-        print(
-            "Some check runs are still in progress. Waiting 3 minutes before checking again..."
-        )
-        time.sleep(180)
-
-    if all_others_passed:
-        print("All other completed check runs have passed. This check passes.")
-        sys.exit(0)
-    else:
-        print("Some check runs have failed or have not completed. This check fails.")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

.gitignore

@@ -1,11 +1,12 @@
 ## Original ignores
-.github_access_token
-classic/original_autogpt/keys.py
-classic/original_autogpt/*.json
+autogpt/keys.py
+autogpt/*.json
 auto_gpt_workspace/*
 *.mpeg
 .env
 azure.yaml
+ai_settings.yaml
+last_run_ai_settings.yaml
 .vscode
 .idea/*
 auto-gpt.json
@@ -27,11 +28,15 @@ __pycache__/
 
 # Distribution / packaging
 .Python
+build/
 develop-eggs/
 dist/
+/plugins/
+plugins_config.yaml
 downloads/
 eggs/
 .eggs/
+lib/
 lib64/
 parts/
 sdist/
@@ -155,19 +160,3 @@ openai/
 
 # news
 CURRENT_BULLETIN.md
-
-# AgBenchmark
-agclassic/benchmark/reports/
-
-# Nodejs
-package-lock.json
-
-
-# Allow for locally private items
-# private
-pri* 
-# ignore
-ig*
-.github_access_token
-LICENSE.rtf
-autogpt_platform/autogpt_server/settings.py

.gitmodules

@@ -1,6 +1,4 @@
-[submodule "classic/forge/tests/vcr_cassettes"]
-	path = classic/forge/tests/vcr_cassettes
-	url = https://github.com/Significant-Gravitas/Auto-GPT-test-cassettes
-[submodule "autogpt_platform/supabase"]
-	path = autogpt_platform/supabase
-	url = https://github.com/supabase/supabase.git
+[submodule "tests/Auto-GPT-test-cassettes"]
+    path = tests/Auto-GPT-test-cassettes
+    url = https://github.com/Significant-Gravitas/Auto-GPT-test-cassettes
+    branch = master

.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

.pr_agent.toml

@@ -1,6 +0,0 @@
-[pr_reviewer]
-num_code_suggestions=0
-
-[pr_code_suggestions]
-commitable_code_suggestions=false
-num_code_suggestions=0

.pre-commit-config.yaml

@@ -3,125 +3,40 @@ repos:
     rev: v4.4.0
     hooks:
       - id: check-added-large-files
-        args: ["--maxkb=500"]
-      - id: fix-byte-order-marker
+        args: ['--maxkb=500']
+      - id: check-byte-order-marker
       - id: check-case-conflict
       - id: check-merge-conflict
       - id: check-symlinks
       - id: debug-statements
 
-  - repo: local
-    # isort needs the context of which packages are installed to function, so we
-    # can't use a vendored isort pre-commit hook (which runs in its own isolated venv).
+  - repo: https://github.com/pycqa/isort
+    rev: 5.12.0
     hooks:
-      - id: isort-autogpt
-        name: Lint (isort) - AutoGPT
-        entry: poetry -C classic/original_autogpt run isort
-        files: ^classic/original_autogpt/
-        types: [file, python]
-        language: system
-
-      - id: isort-forge
-        name: Lint (isort) - Forge
-        entry: poetry -C classic/forge run isort
-        files: ^classic/forge/
-        types: [file, python]
-        language: system
-
-      - id: isort-benchmark
-        name: Lint (isort) - Benchmark
-        entry: poetry -C classic/benchmark run isort
-        files: ^classic/benchmark/
-        types: [file, python]
-        language: system
-
-  - repo: https://github.com/psf/black
-    rev: 23.12.1
-    # Black has sensible defaults, doesn't need package context, and ignores
-    # everything in .gitignore, so it works fine without any config or arguments.
-    hooks:
-      - id: black
-        name: Lint (Black)
+      - id: isort
         language_version: python3.10
 
-  - repo: https://github.com/PyCQA/flake8
-    rev: 7.0.0
-    # To have flake8 load the config of the individual subprojects, we have to call
-    # them separately.
+  - repo: https://github.com/psf/black
+    rev: 23.3.0
     hooks:
-      - id: flake8
-        name: Lint (Flake8) - AutoGPT
-        alias: flake8-autogpt
-        files: ^classic/original_autogpt/(autogpt|scripts|tests)/
-        args: [--config=classic/original_autogpt/.flake8]
+      - id: black
+        language_version: python3.10
 
-      - id: flake8
-        name: Lint (Flake8) - Forge
-        alias: flake8-forge
-        files: ^classic/forge/(forge|tests)/
-        args: [--config=classic/forge/.flake8]
-
-      - id: flake8
-        name: Lint (Flake8) - Benchmark
-        alias: flake8-benchmark
-        files: ^classic/benchmark/(agbenchmark|tests)/((?!reports).)*[/.]
-        args: [--config=classic/benchmark/.flake8]
-
-  - repo: local
-    # To have watertight type checking, we check *all* the files in an affected
-    # project. To trigger on poetry.lock we also reset the file `types` filter.
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: 'v1.3.0'
     hooks:
-      - id: pyright
-        name: Typecheck - AutoGPT
-        alias: pyright-autogpt
-        entry: poetry -C classic/original_autogpt run pyright
-        args: [-p, autogpt, autogpt]
-        # include forge source (since it's a path dependency) but exclude *_test.py files:
-        files: ^(classic/original_autogpt/((autogpt|scripts|tests)/|poetry\.lock$)|classic/forge/(classic/forge/.*(?<!_test)\.py|poetry\.lock)$)
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: pyright
-        name: Typecheck - Forge
-        alias: pyright-forge
-        entry: poetry -C classic/forge run pyright
-        args: [-p, forge, forge]
-        files: ^classic/forge/(classic/forge/|poetry\.lock$)
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: pyright
-        name: Typecheck - Benchmark
-        alias: pyright-benchmark
-        entry: poetry -C classic/benchmark run pyright
-        args: [-p, benchmark, benchmark]
-        files: ^classic/benchmark/(agclassic/benchmark/|tests/|poetry\.lock$)
-        types: [file]
-        language: system
-        pass_filenames: false
+      - id: mypy
 
   - repo: local
     hooks:
-      - id: pytest-autogpt
-        name: Run tests - AutoGPT (excl. slow tests)
-        entry: bash -c 'cd classic/original_autogpt && poetry run pytest --cov=autogpt -m "not slow" tests/unit tests/integration'
-        # include forge source (since it's a path dependency) but exclude *_test.py files:
-        files: ^(classic/original_autogpt/((autogpt|tests)/|poetry\.lock$)|classic/forge/(classic/forge/.*(?<!_test)\.py|poetry\.lock)$)
-        language: system
-        pass_filenames: false
-
-      - id: pytest-forge
-        name: Run tests - Forge (excl. slow tests)
-        entry: bash -c 'cd classic/forge && poetry run pytest --cov=forge -m "not slow"'
-        files: ^classic/forge/(classic/forge/|tests/|poetry\.lock$)
-        language: system
-        pass_filenames: false
-
-      - id: pytest-benchmark
-        name: Run tests - Benchmark
-        entry: bash -c 'cd classic/benchmark && poetry run pytest --cov=benchmark'
-        files: ^classic/benchmark/(agclassic/benchmark/|tests/|poetry\.lock$)
+      - id: autoflake
+        name: autoflake
+        entry: autoflake --in-place --remove-all-unused-imports --recursive --ignore-init-module-imports --ignore-pass-after-docstring autogpt tests
+        language: python
+        types: [ python ]
+      - id: pytest-check
+        name: pytest-check
+        entry: pytest --cov=autogpt tests/unit
         language: system
         pass_filenames: false
+        always_run: true

.vscode/all-projects.code-workspace

@@ -1,61 +0,0 @@
-{
-  "folders": [
-    {
-      "name": "autogpt_server",
-      "path": "../autogpt_platform/autogpt_server"
-    },
-    {
-      "name": "autogpt_builder",
-      "path": "../autogpt_platform/autogpt_builder"
-    },
-    {
-      "name": "market",
-      "path": "../autogpt_platform/market"
-    },
-    {
-      "name": "lib",
-      "path": "../autogpt_platform/autogpt_libs"
-    },
-    {
-      "name": "infra",
-      "path": "../autogpt_platform/infra"
-    },
-    {
-      "name": "docs",
-      "path": "../docs"
-    },
-    {
-      "name": "[root]",
-      "path": ".."
-    },
-    {
-      "name": "classic - autogpt",
-      "path": "../classic/original_autogpt"
-    },
-    {
-      "name": "classic - benchmark",
-      "path": "../classic/benchmark"
-    },
-    {
-      "name": "classic - forge",
-      "path": "../classic/forge"
-    },
-    {
-      "name": "classic - frontend",
-      "path": "../classic/frontend"
-    },
-  ],
-  "settings": {
-    "python.analysis.typeCheckingMode": "basic"
-  },
-  "extensions": {
-    "recommendations": [
-      "charliermarsh.ruff",
-      "dart-code.flutter",
-      "ms-python.black-formatter",
-      "ms-python.vscode-pylance",
-      "prisma.prisma",
-      "qwtel.sqlite-viewer"
-    ]
-  }
-}

BULLETIN.md

@@ -0,0 +1,27 @@
+# QUICK LINKS 🔗
+# --------------
+🌎 *Official Website*: https://agpt.co.
+📖 *User Guide*: https://docs.agpt.co.
+👩 *Contributors Wiki*: https://github.com/Significant-Gravitas/Auto-GPT/wiki/Contributing.
+
+# v0.4.6 RELEASE HIGHLIGHTS! 🚀
+# -----------------------------
+This release includes under-the-hood improvements and bug fixes, including better UTF-8
+special character support, workspace write access for sandboxed Python execution,
+more robust path resolution for config files and the workspace, and a full restructure
+of the Agent class, the "brain" of Auto-GPT, to make it more extensible.
+
+We have also released some documentation updates, including:
+
+- *How to share your system logs*
+  Visit [docs/share-your-logs.md] to learn how to how to share logs with us
+  via a log analyzer graciously contributed by https://www.e2b.dev/
+
+- *Auto-GPT re-architecture documentation*
+  You can learn more about the inner-workings of the Auto-GPT re-architecture
+  released last cycle, via these links:
+  * [autogpt/core/README.md]
+  * [autogpt/core/ARCHITECTURE_NOTES.md]
+
+Take a look at the Release Notes on Github for the full changelog!
+https://github.com/Significant-Gravitas/Auto-GPT/releases.

CITATION.cff

@@ -1,21 +0,0 @@
-# This CITATION.cff file was generated with cffinit.
-# Visit https://bit.ly/cffinit to generate yours today!
-
-cff-version: 1.2.0
-title: AutoGPT
-message: >-
-  If you use this software, please cite it using the
-  metadata from this file.
-type: software
-authors:
-  - name: Significant Gravitas
-    website: 'https://agpt.co'
-repository-code: 'https://github.com/Significant-Gravitas/AutoGPT'
-url: 'https://agpt.co'
-abstract: >-
-  A collection of tools and experimental open-source attempts to make GPT-4 fully
-  autonomous.
-keywords:
-  - AI
-  - Agent
-license: MIT

CODE_OF_CONDUCT.md

@@ -1,12 +1,12 @@
-# Code of Conduct for AutoGPT
+# Code of Conduct for Auto-GPT
 
 ## 1. Purpose
 
-The purpose of this Code of Conduct is to provide guidelines for contributors to the AutoGPT projects on GitHub. We aim to create a positive and inclusive environment where all participants can contribute and collaborate effectively. By participating in this project, you agree to abide by this Code of Conduct.
+The purpose of this Code of Conduct is to provide guidelines for contributors to the auto-gpt project on GitHub. We aim to create a positive and inclusive environment where all participants can contribute and collaborate effectively. By participating in this project, you agree to abide by this Code of Conduct.
 
 ## 2. Scope
 
-This Code of Conduct applies to all contributors, maintainers, and users of the AutoGPT project. It extends to all project spaces, including but not limited to issues, pull requests, code reviews, comments, and other forms of communication within the project.
+This Code of Conduct applies to all contributors, maintainers, and users of the auto-gpt project. It extends to all project spaces, including but not limited to issues, pull requests, code reviews, comments, and other forms of communication within the project.
 
 ## 3. Our Standards
 
@@ -36,5 +36,4 @@ This Code of Conduct is adapted from the [Contributor Covenant](https://www.cont
 
 ## 6. Contact
 
-If you have any questions or concerns, please contact the project maintainers on Discord:
-https://discord.gg/autogpt
+If you have any questions or concerns, please contact the project maintainers.

CONTRIBUTING.md

@@ -1,38 +1,14 @@
-# AutoGPT Contribution Guide
-If you are reading this, you are probably looking for the full **[contribution guide]**,
-which is part of our [wiki].
+We maintain a knowledgebase at this [wiki](https://github.com/Significant-Gravitas/Nexus/wiki)
 
-Also check out our [🚀 Roadmap][roadmap] for information about our priorities and associated tasks.
-<!-- You can find our immediate priorities and their progress on our public [kanban board]. -->
+We would like to say "We value all contributions". After all, we are an open-source project, so we should say something fluffy like this, right?
 
-[contribution guide]: https://github.com/Significant-Gravitas/AutoGPT/wiki/Contributing
-[wiki]: https://github.com/Significant-Gravitas/AutoGPT/wiki
-[roadmap]: https://github.com/Significant-Gravitas/AutoGPT/discussions/6971
-[kanban board]: https://github.com/orgs/Significant-Gravitas/projects/1
+However the reality is that some contributions are SUPER-valuable, while others create more trouble than they are worth and actually _create_ work for the core team.
 
-## In short
-1. Avoid duplicate work, issues, PRs etc.
-2. We encourage you to collaborate with fellow community members on some of our bigger
-   [todo's][roadmap]!
-   * We highly recommend to post your idea and discuss it in the [dev channel].
-3. Create a draft PR when starting work on bigger changes.
-4. Adhere to the [Code Guidelines]
-5. Clearly explain your changes when submitting a PR.
-6. Don't submit broken code: test/validate your changes.
-7. Avoid making unnecessary changes, especially if they're purely based on your personal
-   preferences. Doing so is the maintainers' job. ;-)
-8. Please also consider contributing something other than code; see the
-   [contribution guide] for options.
+If you wish to contribute, please look through the wiki [contributing](https://github.com/Significant-Gravitas/Nexus/wiki/Contributing) page.
 
-[dev channel]: https://discord.com/channels/1092243196446249134/1095817829405704305
-[code guidelines]: https://github.com/Significant-Gravitas/AutoGPT/wiki/Contributing#code-guidelines
+If you wish to involve with the project (beyond just contributing PRs), please read the wiki [catalyzing](https://github.com/Significant-Gravitas/Nexus/wiki/Catalyzing) page.
 
-If you wish to involve with the project (beyond just contributing PRs), please read the
-wiki page about [Catalyzing](https://github.com/Significant-Gravitas/AutoGPT/wiki/Catalyzing).
-
-In fact, why not just look through the whole wiki (it's only a few pages) and
-hop on our Discord. See you there! :-)
+In fact, why not just look through the whole wiki (it's only a few pages) and hop on our discord (you'll find it in the wiki).
 
 ❤️ & 🔆
-The team @ AutoGPT
-https://discord.gg/autogpt
+The team @ Auto-GPT

Dockerfile

@@ -0,0 +1,46 @@
+# 'dev' or 'release' container build
+ARG BUILD_TYPE=dev
+
+# Use an official Python base image from the Docker Hub
+FROM python:3.10-slim AS autogpt-base
+
+# Install browsers
+RUN apt-get update && apt-get install -y \
+    chromium-driver firefox-esr ca-certificates \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+# Install utilities
+RUN apt-get update && apt-get install -y \
+    curl jq wget git \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+# Set environment variables
+ENV PIP_NO_CACHE_DIR=yes \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+# Install the required python packages globally
+ENV PATH="$PATH:/root/.local/bin"
+COPY requirements.txt .
+
+# Set the entrypoint
+ENTRYPOINT ["python", "-m", "autogpt", "--install-plugin-deps"]
+
+# dev build -> include everything
+FROM autogpt-base as autogpt-dev
+RUN pip install --no-cache-dir -r requirements.txt
+WORKDIR /app
+ONBUILD COPY . ./
+
+# release build -> include bare minimum
+FROM autogpt-base as autogpt-release
+RUN sed -i '/Items below this point will not be included in the Docker Image/,$d' requirements.txt && \
+	pip install --no-cache-dir -r requirements.txt
+WORKDIR /app
+ONBUILD COPY autogpt/ ./autogpt
+ONBUILD COPY scripts/ ./scripts
+ONBUILD COPY plugins/ ./plugins
+ONBUILD COPY prompt_settings.yaml ./prompt_settings.yaml
+ONBUILD RUN mkdir ./data
+
+FROM autogpt-${BUILD_TYPE} AS auto-gpt

autogpt/__init__.py

@@ -2,6 +2,13 @@ import os
 import random
 import sys
 
+from dotenv import load_dotenv
+
 if "pytest" in sys.argv or "pytest" in sys.modules or os.getenv("CI"):
     print("Setting random seed to 42")
     random.seed(42)
+
+# Load the users .env file into environment variables
+load_dotenv(verbose=True, override=True)
+
+del load_dotenv

autogpt/__main__.py

@@ -0,0 +1,5 @@
+"""Auto-GPT: A GPT powered AI Assistant"""
+import autogpt.app.cli
+
+if __name__ == "__main__":
+    autogpt.app.cli.main()

autogpt/agents/__init__.py

@@ -0,0 +1,4 @@
+from .agent import Agent
+from .base import AgentThoughts, BaseAgent, CommandArgs, CommandName
+
+__all__ = ["BaseAgent", "Agent", "CommandName", "CommandArgs", "AgentThoughts"]

autogpt/agents/agent.py

@@ -0,0 +1,298 @@
+from __future__ import annotations
+
+import json
+import time
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, Optional
+
+if TYPE_CHECKING:
+    from autogpt.config import AIConfig, Config
+    from autogpt.llm.base import ChatModelResponse, ChatSequence
+    from autogpt.memory.vector import VectorMemory
+    from autogpt.models.command_registry import CommandRegistry
+
+from autogpt.json_utils.utilities import extract_dict_from_response, validate_dict
+from autogpt.llm.api_manager import ApiManager
+from autogpt.llm.base import Message
+from autogpt.llm.utils import count_string_tokens
+from autogpt.logs import logger
+from autogpt.logs.log_cycle import (
+    FULL_MESSAGE_HISTORY_FILE_NAME,
+    NEXT_ACTION_FILE_NAME,
+    USER_INPUT_FILE_NAME,
+    LogCycleHandler,
+)
+from autogpt.workspace import Workspace
+
+from .base import AgentThoughts, BaseAgent, CommandArgs, CommandName
+
+
+class Agent(BaseAgent):
+    """Agent class for interacting with Auto-GPT."""
+
+    def __init__(
+        self,
+        ai_config: AIConfig,
+        command_registry: CommandRegistry,
+        memory: VectorMemory,
+        triggering_prompt: str,
+        config: Config,
+        cycle_budget: Optional[int] = None,
+    ):
+        super().__init__(
+            ai_config=ai_config,
+            command_registry=command_registry,
+            config=config,
+            default_cycle_instruction=triggering_prompt,
+            cycle_budget=cycle_budget,
+        )
+
+        self.memory = memory
+        """VectorMemoryProvider used to manage the agent's context (TODO)"""
+
+        self.workspace = Workspace(config.workspace_path, config.restrict_to_workspace)
+        """Workspace that the agent has access to, e.g. for reading/writing files."""
+
+        self.created_at = datetime.now().strftime("%Y%m%d_%H%M%S")
+        """Timestamp the agent was created; only used for structured debug logging."""
+
+        self.log_cycle_handler = LogCycleHandler()
+        """LogCycleHandler for structured debug logging."""
+
+    def construct_base_prompt(self, *args, **kwargs) -> ChatSequence:
+        if kwargs.get("prepend_messages") is None:
+            kwargs["prepend_messages"] = []
+
+        # Clock
+        kwargs["prepend_messages"].append(
+            Message("system", f"The current time and date is {time.strftime('%c')}"),
+        )
+
+        # Add budget information (if any) to prompt
+        api_manager = ApiManager()
+        if api_manager.get_total_budget() > 0.0:
+            remaining_budget = (
+                api_manager.get_total_budget() - api_manager.get_total_cost()
+            )
+            if remaining_budget < 0:
+                remaining_budget = 0
+
+            budget_msg = Message(
+                "system",
+                f"Your remaining API budget is ${remaining_budget:.3f}"
+                + (
+                    " BUDGET EXCEEDED! SHUT DOWN!\n\n"
+                    if remaining_budget == 0
+                    else " Budget very nearly exceeded! Shut down gracefully!\n\n"
+                    if remaining_budget < 0.005
+                    else " Budget nearly exceeded. Finish up.\n\n"
+                    if remaining_budget < 0.01
+                    else ""
+                ),
+            )
+            logger.debug(budget_msg)
+
+            if kwargs.get("append_messages") is None:
+                kwargs["append_messages"] = []
+            kwargs["append_messages"].append(budget_msg)
+
+        return super().construct_base_prompt(*args, **kwargs)
+
+    def on_before_think(self, *args, **kwargs) -> ChatSequence:
+        prompt = super().on_before_think(*args, **kwargs)
+
+        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,
+            self.history.raw(),
+            FULL_MESSAGE_HISTORY_FILE_NAME,
+        )
+        return prompt
+
+    def execute(
+        self,
+        command_name: str | None,
+        command_args: dict[str, str] | None,
+        user_input: str | None,
+    ) -> str:
+        # Execute command
+        if command_name is not None and command_name.lower().startswith("error"):
+            result = f"Could not execute command: {command_name}{command_args}"
+        elif command_name == "human_feedback":
+            result = f"Human feedback: {user_input}"
+            self.log_cycle_handler.log_cycle(
+                self.ai_config.ai_name,
+                self.created_at,
+                self.cycle_count,
+                user_input,
+                USER_INPUT_FILE_NAME,
+            )
+
+        else:
+            for plugin in self.config.plugins:
+                if not plugin.can_handle_pre_command():
+                    continue
+                command_name, arguments = plugin.pre_command(command_name, command_args)
+            command_result = execute_command(
+                command_name=command_name,
+                arguments=command_args,
+                agent=self,
+            )
+            result = f"Command {command_name} returned: " f"{command_result}"
+
+            result_tlength = count_string_tokens(str(command_result), self.llm.name)
+            memory_tlength = count_string_tokens(
+                str(self.history.summary_message()), self.llm.name
+            )
+            if result_tlength + memory_tlength > self.send_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)
+        # Check if there's a result from the command append it to the message
+        if result is None:
+            self.history.add("system", "Unable to execute command", "action_result")
+        else:
+            self.history.add("system", result, "action_result")
+
+        return result
+
+    def parse_and_process_response(
+        self, llm_response: ChatModelResponse, *args, **kwargs
+    ) -> tuple[CommandName | None, CommandArgs | None, AgentThoughts]:
+        if not llm_response.content:
+            raise SyntaxError("Assistant response has no text content")
+
+        assistant_reply_dict = extract_dict_from_response(llm_response.content)
+
+        valid, errors = validate_dict(assistant_reply_dict, self.config)
+        if not valid:
+            raise SyntaxError(
+                "Validation of response failed:\n  "
+                + ";\n  ".join([str(e) for e in errors])
+            )
+
+        for plugin in self.config.plugins:
+            if not plugin.can_handle_post_planning():
+                continue
+            assistant_reply_dict = plugin.post_planning(assistant_reply_dict)
+
+        response = None, None, assistant_reply_dict
+
+        # Print Assistant thoughts
+        if assistant_reply_dict != {}:
+            # Get command name and arguments
+            try:
+                command_name, arguments = extract_command(
+                    assistant_reply_dict, llm_response, self.config
+                )
+                response = command_name, arguments, assistant_reply_dict
+            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_dict,
+            NEXT_ACTION_FILE_NAME,
+        )
+        return response
+
+
+def extract_command(
+    assistant_reply_json: dict, assistant_reply: ChatModelResponse, config: Config
+) -> tuple[str, dict[str, str]]:
+    """Parse the response and return the command name and arguments
+
+    Args:
+        assistant_reply_json (dict): The response object from the AI
+        assistant_reply (ChatModelResponse): The model response from the AI
+        config (Config): The config object
+
+    Returns:
+        tuple: The command name and arguments
+
+    Raises:
+        json.decoder.JSONDecodeError: If the response is not valid JSON
+
+        Exception: If any other error occurs
+    """
+    if config.openai_functions:
+        if assistant_reply.function_call is None:
+            return "Error:", {"message": "No 'function_call' in assistant reply"}
+        assistant_reply_json["command"] = {
+            "name": assistant_reply.function_call.name,
+            "args": json.loads(assistant_reply.function_call.arguments),
+        }
+    try:
+        if "command" not in assistant_reply_json:
+            return "Error:", {"message": "Missing 'command' object in JSON"}
+
+        if not isinstance(assistant_reply_json, dict):
+            return (
+                "Error:",
+                {
+                    "message": f"The previous message sent was not a dictionary {assistant_reply_json}"
+                },
+            )
+
+        command = assistant_reply_json["command"]
+        if not isinstance(command, dict):
+            return "Error:", {"message": "'command' object is not a dictionary"}
+
+        if "name" not in command:
+            return "Error:", {"message": "Missing 'name' field in 'command' object"}
+
+        command_name = command["name"]
+
+        # Use an empty dictionary if 'args' field is not present in 'command' object
+        arguments = command.get("args", {})
+
+        return command_name, arguments
+    except json.decoder.JSONDecodeError:
+        return "Error:", {"message": "Invalid JSON"}
+    # All other errors, return "Error: + error message"
+    except Exception as e:
+        return "Error:", {"message": str(e)}
+
+
+def execute_command(
+    command_name: str,
+    arguments: dict[str, str],
+    agent: Agent,
+) -> Any:
+    """Execute the command and return the result
+
+    Args:
+        command_name (str): The name of the command to execute
+        arguments (dict): The arguments for the command
+        agent (Agent): The agent that is executing the command
+
+    Returns:
+        str: The result of the command
+    """
+    try:
+        # Execute a native command with the same name or alias, if it exists
+        if command := agent.command_registry.get_command(command_name):
+            return command(**arguments, agent=agent)
+
+        # Handle non-native commands (e.g. from plugins)
+        for command in agent.ai_config.prompt_generator.commands:
+            if (
+                command_name == command["label"].lower()
+                or command_name == command["name"].lower()
+            ):
+                return command["function"](**arguments)
+
+        raise RuntimeError(
+            f"Cannot execute '{command_name}': unknown command."
+            " Do not try to use this command again."
+        )
+    except Exception as e:
+        return f"Error: {str(e)}"

autogpt/agents/base.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from typing import TYPE_CHECKING, Any, Optional
+
+if TYPE_CHECKING:
+    from autogpt.config import AIConfig, Config
+
+    from autogpt.models.command_registry import CommandRegistry
+
+from autogpt.llm.base import ChatModelResponse, ChatSequence, Message
+from autogpt.llm.providers.openai import OPEN_AI_CHAT_MODELS, get_openai_command_specs
+from autogpt.llm.utils import count_message_tokens, create_chat_completion
+from autogpt.logs import logger
+from autogpt.memory.message_history import MessageHistory
+from autogpt.prompts.prompt import DEFAULT_TRIGGERING_PROMPT
+
+CommandName = str
+CommandArgs = dict[str, str]
+AgentThoughts = dict[str, Any]
+
+
+class BaseAgent(metaclass=ABCMeta):
+    """Base class for all Auto-GPT agents."""
+
+    def __init__(
+        self,
+        ai_config: AIConfig,
+        command_registry: CommandRegistry,
+        config: Config,
+        big_brain: bool = True,
+        default_cycle_instruction: str = DEFAULT_TRIGGERING_PROMPT,
+        cycle_budget: Optional[int] = 1,
+        send_token_limit: Optional[int] = None,
+        summary_max_tlength: Optional[int] = None,
+    ):
+        self.ai_config = ai_config
+        """The AIConfig or "personality" object associated with this agent."""
+
+        self.command_registry = command_registry
+        """The registry containing all commands available to the agent."""
+
+        self.config = config
+        """The applicable application configuration."""
+
+        self.big_brain = big_brain
+        """
+        Whether this agent uses the configured smart LLM (default) to think,
+        as opposed to the configured fast LLM.
+        """
+
+        self.default_cycle_instruction = default_cycle_instruction
+        """The default instruction passed to the AI for a thinking cycle."""
+
+        self.cycle_budget = cycle_budget
+        """
+        The number of cycles that the agent is allowed to run unsupervised.
+
+        `None` for unlimited continuous execution,
+        `1` to require user approval for every step,
+        `0` to stop the agent.
+        """
+
+        self.cycles_remaining = cycle_budget
+        """The number of cycles remaining within the `cycle_budget`."""
+
+        self.cycle_count = 0
+        """The number of cycles that the agent has run since its initialization."""
+
+        self.system_prompt = ai_config.construct_full_prompt(config)
+        """
+        The system prompt sets up the AI's personality and explains its goals,
+        available resources, and restrictions.
+        """
+
+        llm_name = self.config.smart_llm if self.big_brain else self.config.fast_llm
+        self.llm = OPEN_AI_CHAT_MODELS[llm_name]
+        """The LLM that the agent uses to think."""
+
+        self.send_token_limit = send_token_limit or self.llm.max_tokens * 3 // 4
+        """
+        The token limit for prompt construction. Should leave room for the completion;
+        defaults to 75% of `llm.max_tokens`.
+        """
+
+        self.history = MessageHistory(
+            self.llm,
+            max_summary_tlength=summary_max_tlength or self.send_token_limit // 6,
+        )
+
+    def think(
+        self,
+        instruction: Optional[str] = None,
+    ) -> tuple[CommandName | None, CommandArgs | None, AgentThoughts]:
+        """Runs the agent for one cycle.
+
+        Params:
+            instruction: The instruction to put at the end of the prompt.
+
+        Returns:
+            The command name and arguments, if any, and the agent's thoughts.
+        """
+
+        instruction = instruction or self.default_cycle_instruction
+
+        prompt: ChatSequence = self.construct_prompt(instruction)
+        prompt = self.on_before_think(prompt, instruction)
+
+        raw_response = create_chat_completion(
+            prompt,
+            self.config,
+            functions=get_openai_command_specs(self.command_registry)
+            if self.config.openai_functions
+            else None,
+        )
+        self.cycle_count += 1
+
+        return self.on_response(raw_response, prompt, instruction)
+
+    @abstractmethod
+    def execute(
+        self,
+        command_name: str | None,
+        command_args: dict[str, str] | None,
+        user_input: str | None,
+    ) -> str:
+        """Executes the given command, if any, and returns the agent's response.
+
+        Params:
+            command_name: The name of the command to execute, if any.
+            command_args: The arguments to pass to the command, if any.
+            user_input: The user's input, if any.
+
+        Returns:
+            The results of the command.
+        """
+        ...
+
+    def construct_base_prompt(
+        self,
+        prepend_messages: list[Message] = [],
+        append_messages: list[Message] = [],
+        reserve_tokens: int = 0,
+    ) -> ChatSequence:
+        """Constructs and returns a prompt with the following structure:
+        1. System prompt
+        2. `prepend_messages`
+        3. Message history of the agent, truncated & prepended with running summary as needed
+        4. `append_messages`
+
+        Params:
+            prepend_messages: Messages to insert between the system prompt and message history
+            append_messages: Messages to insert after the message history
+            reserve_tokens: Number of tokens to reserve for content that is added later
+        """
+
+        prompt = ChatSequence.for_model(
+            self.llm.name,
+            [Message("system", self.system_prompt)] + prepend_messages,
+        )
+
+        # Reserve tokens for messages to be appended later, if any
+        reserve_tokens += self.history.max_summary_tlength
+        if append_messages:
+            reserve_tokens += count_message_tokens(append_messages, self.llm.name)
+
+        # Fill message history, up to a margin of reserved_tokens.
+        # Trim remaining historical messages and add them to the running summary.
+        history_start_index = len(prompt)
+        trimmed_history = add_history_upto_token_limit(
+            prompt, self.history, self.send_token_limit - reserve_tokens
+        )
+        if trimmed_history:
+            new_summary_msg, _ = self.history.trim_messages(list(prompt), self.config)
+            prompt.insert(history_start_index, new_summary_msg)
+
+        if append_messages:
+            prompt.extend(append_messages)
+
+        return prompt
+
+    def construct_prompt(self, cycle_instruction: str) -> ChatSequence:
+        """Constructs and returns a prompt with the following structure:
+        1. System prompt
+        2. Message history of the agent, truncated & prepended with running summary as needed
+        3. `cycle_instruction`
+
+        Params:
+            cycle_instruction: The final instruction for a thinking cycle
+        """
+
+        if not cycle_instruction:
+            raise ValueError("No instruction given")
+
+        cycle_instruction_msg = Message("user", cycle_instruction)
+        cycle_instruction_tlength = count_message_tokens(
+            cycle_instruction_msg, self.llm.name
+        )
+        prompt = self.construct_base_prompt(reserve_tokens=cycle_instruction_tlength)
+
+        # ADD user input message ("triggering prompt")
+        prompt.append(cycle_instruction_msg)
+
+        return prompt
+
+    def on_before_think(self, prompt: ChatSequence, instruction: str) -> ChatSequence:
+        """Called after constructing the prompt but before executing it.
+
+        Calls the `on_planning` hook of any enabled and capable plugins, adding their
+        output to the prompt.
+
+        Params:
+            instruction: The instruction for the current cycle, also used in constructing the prompt
+
+        Returns:
+            The prompt to execute
+        """
+        current_tokens_used = prompt.token_length
+        plugin_count = len(self.config.plugins)
+        for i, plugin in enumerate(self.config.plugins):
+            if not plugin.can_handle_on_planning():
+                continue
+            plugin_response = plugin.on_planning(
+                self.ai_config.prompt_generator, prompt.raw()
+            )
+            if not plugin_response or plugin_response == "":
+                continue
+            message_to_add = Message("system", plugin_response)
+            tokens_to_add = count_message_tokens(message_to_add, self.llm.name)
+            if current_tokens_used + tokens_to_add > self.send_token_limit:
+                logger.debug(f"Plugin response too long, skipping: {plugin_response}")
+                logger.debug(f"Plugins remaining at stop: {plugin_count - i}")
+                break
+            prompt.insert(
+                -1, message_to_add
+            )  # HACK: assumes cycle instruction to be at the end
+            current_tokens_used += tokens_to_add
+        return prompt
+
+    def on_response(
+        self, llm_response: ChatModelResponse, prompt: ChatSequence, instruction: str
+    ) -> tuple[CommandName | None, CommandArgs | None, AgentThoughts]:
+        """Called upon receiving a response from the chat model.
+
+        Adds the last/newest message in the prompt and the response to `history`,
+        and calls `self.parse_and_process_response()` to do the rest.
+
+        Params:
+            llm_response: The raw response from the chat model
+            prompt: The prompt that was executed
+            instruction: The instruction for the current cycle, also used in constructing the prompt
+
+        Returns:
+            The parsed command name and command args, if any, and the agent thoughts.
+        """
+
+        # Save assistant reply to message history
+        self.history.append(prompt[-1])
+        self.history.add(
+            "assistant", llm_response.content, "ai_response"
+        )  # FIXME: support function calls
+
+        try:
+            return self.parse_and_process_response(llm_response, prompt, instruction)
+        except SyntaxError as e:
+            logger.error(f"Response could not be parsed: {e}")
+            # TODO: tune this message
+            self.history.add(
+                "system",
+                f"Your response could not be parsed: {e}"
+                "\n\nRemember to only respond using the specified format above!",
+            )
+            return None, None, {}
+
+        # TODO: update memory/context
+
+    @abstractmethod
+    def parse_and_process_response(
+        self, llm_response: ChatModelResponse, prompt: ChatSequence, instruction: str
+    ) -> tuple[CommandName | None, CommandArgs | None, AgentThoughts]:
+        """Validate, parse & process the LLM's response.
+
+        Must be implemented by derivative classes: no base implementation is provided,
+        since the implementation depends on the role of the derivative Agent.
+
+        Params:
+            llm_response: The raw response from the chat model
+            prompt: The prompt that was executed
+            instruction: The instruction for the current cycle, also used in constructing the prompt
+
+        Returns:
+            The parsed command name and command args, if any, and the agent thoughts.
+        """
+        pass
+
+
+def add_history_upto_token_limit(
+    prompt: ChatSequence, history: MessageHistory, t_limit: int
+) -> list[Message]:
+    current_prompt_length = prompt.token_length
+    insertion_index = len(prompt)
+    limit_reached = False
+    trimmed_messages: list[Message] = []
+    for cycle in reversed(list(history.per_cycle())):
+        messages_to_add = [msg for msg in cycle if msg is not None]
+        tokens_to_add = count_message_tokens(messages_to_add, prompt.model.name)
+        if current_prompt_length + tokens_to_add > t_limit:
+            limit_reached = True
+
+        if not limit_reached:
+            # Add the most recent message to the start of the chain,
+            #  after the system prompts.
+            prompt.insert(insertion_index, *messages_to_add)
+            current_prompt_length += tokens_to_add
+        else:
+            trimmed_messages = messages_to_add + trimmed_messages
+
+    return trimmed_messages

autogpt/app/cli.py

@@ -0,0 +1,147 @@
+"""Main script for the autogpt package."""
+from pathlib import Path
+from typing import Optional
+
+import click
+
+
+@click.group(invoke_without_command=True)
+@click.option("-c", "--continuous", is_flag=True, help="Enable Continuous Mode")
+@click.option(
+    "--skip-reprompt",
+    "-y",
+    is_flag=True,
+    help="Skips the re-prompting messages at the beginning of the script",
+)
+@click.option(
+    "--ai-settings",
+    "-C",
+    help=(
+        "Specifies which ai_settings.yaml file to use, relative to the Auto-GPT"
+        " root directory. Will also automatically skip the re-prompt."
+    ),
+)
+@click.option(
+    "--prompt-settings",
+    "-P",
+    help="Specifies which prompt_settings.yaml file to use.",
+)
+@click.option(
+    "-l",
+    "--continuous-limit",
+    type=int,
+    help="Defines the number of times to run in continuous mode",
+)
+@click.option("--speak", is_flag=True, help="Enable Speak Mode")
+@click.option("--debug", is_flag=True, help="Enable Debug Mode")
+@click.option("--gpt3only", is_flag=True, help="Enable GPT3.5 Only Mode")
+@click.option("--gpt4only", is_flag=True, help="Enable GPT4 Only Mode")
+@click.option(
+    "--use-memory",
+    "-m",
+    "memory_type",
+    type=str,
+    help="Defines which Memory backend to use",
+)
+@click.option(
+    "-b",
+    "--browser-name",
+    help="Specifies which web-browser to use when using selenium to scrape the web.",
+)
+@click.option(
+    "--allow-downloads",
+    is_flag=True,
+    help="Dangerous: Allows Auto-GPT to download files natively.",
+)
+@click.option(
+    "--skip-news",
+    is_flag=True,
+    help="Specifies whether to suppress the output of latest news on startup.",
+)
+@click.option(
+    # TODO: this is a hidden option for now, necessary for integration testing.
+    #   We should make this public once we're ready to roll out agent specific workspaces.
+    "--workspace-directory",
+    "-w",
+    type=click.Path(),
+    hidden=True,
+)
+@click.option(
+    "--install-plugin-deps",
+    is_flag=True,
+    help="Installs external dependencies for 3rd party plugins.",
+)
+@click.option(
+    "--ai-name",
+    type=str,
+    help="AI name override",
+)
+@click.option(
+    "--ai-role",
+    type=str,
+    help="AI role override",
+)
+@click.option(
+    "--ai-goal",
+    type=str,
+    multiple=True,
+    help="AI goal override; may be used multiple times to pass multiple goals",
+)
+@click.pass_context
+def main(
+    ctx: click.Context,
+    continuous: bool,
+    continuous_limit: int,
+    ai_settings: str,
+    prompt_settings: str,
+    skip_reprompt: bool,
+    speak: bool,
+    debug: bool,
+    gpt3only: bool,
+    gpt4only: bool,
+    memory_type: str,
+    browser_name: str,
+    allow_downloads: bool,
+    skip_news: bool,
+    workspace_directory: str,
+    install_plugin_deps: bool,
+    ai_name: Optional[str],
+    ai_role: Optional[str],
+    ai_goal: tuple[str],
+) -> None:
+    """
+    Welcome to AutoGPT an experimental open-source application showcasing the capabilities of the GPT-4 pushing the boundaries of AI.
+
+    Start an Auto-GPT assistant.
+    """
+    # Put imports inside function to avoid importing everything when starting the CLI
+    from autogpt.app.main import run_auto_gpt
+
+    if ctx.invoked_subcommand is None:
+        run_auto_gpt(
+            continuous=continuous,
+            continuous_limit=continuous_limit,
+            ai_settings=ai_settings,
+            prompt_settings=prompt_settings,
+            skip_reprompt=skip_reprompt,
+            speak=speak,
+            debug=debug,
+            gpt3only=gpt3only,
+            gpt4only=gpt4only,
+            memory_type=memory_type,
+            browser_name=browser_name,
+            allow_downloads=allow_downloads,
+            skip_news=skip_news,
+            working_directory=Path(
+                __file__
+            ).parent.parent.parent,  # TODO: make this an option
+            workspace_directory=workspace_directory,
+            install_plugin_deps=install_plugin_deps,
+            ai_name=ai_name,
+            ai_role=ai_role,
+            ai_goals=ai_goal,
+        )
+
+
+if __name__ == "__main__":
+    main()

autogpt/app/configurator.py

@@ -0,0 +1,187 @@
+"""Configurator module."""
+from __future__ import annotations
+
+from typing import Literal
+
+import click
+from colorama import Back, Fore, Style
+
+from autogpt import utils
+from autogpt.config import Config
+from autogpt.config.config import GPT_3_MODEL, GPT_4_MODEL
+from autogpt.llm.api_manager import ApiManager
+from autogpt.logs import logger
+from autogpt.memory.vector import get_supported_memory_backends
+
+
+def create_config(
+    config: Config,
+    continuous: bool,
+    continuous_limit: int,
+    ai_settings_file: str,
+    prompt_settings_file: str,
+    skip_reprompt: bool,
+    speak: bool,
+    debug: bool,
+    gpt3only: bool,
+    gpt4only: bool,
+    memory_type: str,
+    browser_name: str,
+    allow_downloads: bool,
+    skip_news: bool,
+) -> None:
+    """Updates the config object with the given arguments.
+
+    Args:
+        continuous (bool): Whether to run in continuous mode
+        continuous_limit (int): The number of times to run in continuous mode
+        ai_settings_file (str): The path to the ai_settings.yaml file
+        prompt_settings_file (str): The path to the prompt_settings.yaml file
+        skip_reprompt (bool): Whether to skip the re-prompting messages at the beginning of the script
+        speak (bool): Whether to enable speak mode
+        debug (bool): Whether to enable debug mode
+        gpt3only (bool): Whether to enable GPT3.5 only mode
+        gpt4only (bool): Whether to enable GPT4 only mode
+        memory_type (str): The type of memory backend to use
+        browser_name (str): The name of the browser to use when using selenium to scrape the web
+        allow_downloads (bool): Whether to allow Auto-GPT to download files natively
+        skips_news (bool): Whether to suppress the output of latest news on startup
+    """
+    config.debug_mode = False
+    config.continuous_mode = False
+    config.speak_mode = False
+
+    if debug:
+        logger.typewriter_log("Debug Mode: ", Fore.GREEN, "ENABLED")
+        config.debug_mode = True
+
+    if continuous:
+        logger.typewriter_log("Continuous Mode: ", Fore.RED, "ENABLED")
+        logger.typewriter_log(
+            "WARNING: ",
+            Fore.RED,
+            "Continuous mode is not recommended. It is potentially dangerous and may"
+            " cause your AI to run forever or carry out actions you would not usually"
+            " authorise. Use at your own risk.",
+        )
+        config.continuous_mode = True
+
+        if continuous_limit:
+            logger.typewriter_log(
+                "Continuous Limit: ", Fore.GREEN, f"{continuous_limit}"
+            )
+            config.continuous_limit = continuous_limit
+
+    # Check if continuous limit is used without continuous mode
+    if continuous_limit and not continuous:
+        raise click.UsageError("--continuous-limit can only be used with --continuous")
+
+    if speak:
+        logger.typewriter_log("Speak Mode: ", Fore.GREEN, "ENABLED")
+        config.speak_mode = True
+
+    # Set the default LLM models
+    if gpt3only:
+        logger.typewriter_log("GPT3.5 Only Mode: ", Fore.GREEN, "ENABLED")
+        # --gpt3only should always use gpt-3.5-turbo, despite user's FAST_LLM config
+        config.fast_llm = GPT_3_MODEL
+        config.smart_llm = GPT_3_MODEL
+    elif (
+        gpt4only
+        and check_model(GPT_4_MODEL, model_type="smart_llm", config=config)
+        == GPT_4_MODEL
+    ):
+        logger.typewriter_log("GPT4 Only Mode: ", Fore.GREEN, "ENABLED")
+        # --gpt4only should always use gpt-4, despite user's SMART_LLM config
+        config.fast_llm = GPT_4_MODEL
+        config.smart_llm = GPT_4_MODEL
+    else:
+        config.fast_llm = check_model(config.fast_llm, "fast_llm", config=config)
+        config.smart_llm = check_model(config.smart_llm, "smart_llm", config=config)
+
+    if memory_type:
+        supported_memory = get_supported_memory_backends()
+        chosen = memory_type
+        if chosen not in supported_memory:
+            logger.typewriter_log(
+                "ONLY THE FOLLOWING MEMORY BACKENDS ARE SUPPORTED: ",
+                Fore.RED,
+                f"{supported_memory}",
+            )
+            logger.typewriter_log("Defaulting to: ", Fore.YELLOW, config.memory_backend)
+        else:
+            config.memory_backend = chosen
+
+    if skip_reprompt:
+        logger.typewriter_log("Skip Re-prompt: ", Fore.GREEN, "ENABLED")
+        config.skip_reprompt = True
+
+    if ai_settings_file:
+        file = ai_settings_file
+
+        # Validate file
+        (validated, message) = utils.validate_yaml_file(file)
+        if not validated:
+            logger.typewriter_log("FAILED FILE VALIDATION", Fore.RED, message)
+            logger.double_check()
+            exit(1)
+
+        logger.typewriter_log("Using AI Settings File:", Fore.GREEN, file)
+        config.ai_settings_file = file
+        config.skip_reprompt = True
+
+    if prompt_settings_file:
+        file = prompt_settings_file
+
+        # Validate file
+        (validated, message) = utils.validate_yaml_file(file)
+        if not validated:
+            logger.typewriter_log("FAILED FILE VALIDATION", Fore.RED, message)
+            logger.double_check()
+            exit(1)
+
+        logger.typewriter_log("Using Prompt Settings File:", Fore.GREEN, file)
+        config.prompt_settings_file = file
+
+    if browser_name:
+        config.selenium_web_browser = browser_name
+
+    if allow_downloads:
+        logger.typewriter_log("Native Downloading:", Fore.GREEN, "ENABLED")
+        logger.typewriter_log(
+            "WARNING: ",
+            Fore.YELLOW,
+            f"{Back.LIGHTYELLOW_EX}Auto-GPT will now be able to download and save files to your machine.{Back.RESET} "
+            + "It is recommended that you monitor any files it downloads carefully.",
+        )
+        logger.typewriter_log(
+            "WARNING: ",
+            Fore.YELLOW,
+            f"{Back.RED + Style.BRIGHT}ALWAYS REMEMBER TO NEVER OPEN FILES YOU AREN'T SURE OF!{Style.RESET_ALL}",
+        )
+        config.allow_downloads = True
+
+    if skip_news:
+        config.skip_news = True
+
+
+def check_model(
+    model_name: str,
+    model_type: Literal["smart_llm", "fast_llm"],
+    config: Config,
+) -> str:
+    """Check if model is available for use. If not, return gpt-3.5-turbo."""
+    openai_credentials = config.get_openai_credentials(model_name)
+    api_manager = ApiManager()
+    models = api_manager.get_models(**openai_credentials)
+
+    if any(model_name in m["id"] for m in models):
+        return model_name
+
+    logger.typewriter_log(
+        "WARNING: ",
+        Fore.YELLOW,
+        f"You do not have access to {model_name}. Setting {model_type} to "
+        f"gpt-3.5-turbo.",
+    )
+    return "gpt-3.5-turbo"

autogpt/app/main.py

@@ -0,0 +1,597 @@
+"""The application entry point.  Can be invoked by a CLI or any other front end application."""
+import enum
+import logging
+import math
+import signal
+import sys
+from pathlib import Path
+from types import FrameType
+from typing import Optional
+
+from colorama import Fore, Style
+
+from autogpt.agents import Agent, AgentThoughts, CommandArgs, CommandName
+from autogpt.app.configurator import create_config
+from autogpt.app.setup import prompt_user
+from autogpt.commands import COMMAND_CATEGORIES
+from autogpt.config import AIConfig, Config, ConfigBuilder, check_openai_api_key
+from autogpt.llm.api_manager import ApiManager
+from autogpt.logs import logger
+from autogpt.memory.vector import get_memory
+from autogpt.models.command_registry import CommandRegistry
+from autogpt.plugins import scan_plugins
+from autogpt.prompts.prompt import DEFAULT_TRIGGERING_PROMPT
+from autogpt.speech import say_text
+from autogpt.spinner import Spinner
+from autogpt.utils import (
+    clean_input,
+    get_current_git_branch,
+    get_latest_bulletin,
+    get_legal_warning,
+    markdown_to_ansi_style,
+)
+from autogpt.workspace import Workspace
+from scripts.install_plugin_deps import install_plugin_dependencies
+
+
+def run_auto_gpt(
+    continuous: bool,
+    continuous_limit: int,
+    ai_settings: str,
+    prompt_settings: str,
+    skip_reprompt: bool,
+    speak: bool,
+    debug: bool,
+    gpt3only: bool,
+    gpt4only: bool,
+    memory_type: str,
+    browser_name: str,
+    allow_downloads: bool,
+    skip_news: bool,
+    working_directory: Path,
+    workspace_directory: str | Path,
+    install_plugin_deps: bool,
+    ai_name: Optional[str] = None,
+    ai_role: Optional[str] = None,
+    ai_goals: tuple[str] = tuple(),
+):
+    # Configure logging before we do anything else.
+    logger.set_level(logging.DEBUG if debug else logging.INFO)
+
+    config = ConfigBuilder.build_config_from_env(workdir=working_directory)
+
+    # HACK: This is a hack to allow the config into the logger without having to pass it around everywhere
+    # or import it directly.
+    logger.config = config
+
+    # TODO: fill in llm values here
+    check_openai_api_key(config)
+
+    create_config(
+        config,
+        continuous,
+        continuous_limit,
+        ai_settings,
+        prompt_settings,
+        skip_reprompt,
+        speak,
+        debug,
+        gpt3only,
+        gpt4only,
+        memory_type,
+        browser_name,
+        allow_downloads,
+        skip_news,
+    )
+
+    if config.continuous_mode:
+        for line in get_legal_warning().split("\n"):
+            logger.warn(markdown_to_ansi_style(line), "LEGAL:", Fore.RED)
+
+    if not config.skip_news:
+        motd, is_new_motd = get_latest_bulletin()
+        if motd:
+            motd = markdown_to_ansi_style(motd)
+            for motd_line in motd.split("\n"):
+                logger.info(motd_line, "NEWS:", Fore.GREEN)
+            if is_new_motd and not config.chat_messages_enabled:
+                input(
+                    Fore.MAGENTA
+                    + Style.BRIGHT
+                    + "NEWS: Bulletin was updated! Press Enter to continue..."
+                    + Style.RESET_ALL
+                )
+
+        git_branch = get_current_git_branch()
+        if git_branch and git_branch != "stable":
+            logger.typewriter_log(
+                "WARNING: ",
+                Fore.RED,
+                f"You are running on `{git_branch}` branch "
+                "- this is not a supported branch.",
+            )
+        if sys.version_info < (3, 10):
+            logger.typewriter_log(
+                "WARNING: ",
+                Fore.RED,
+                "You are running on an older version of Python. "
+                "Some people have observed problems with certain "
+                "parts of Auto-GPT with this version. "
+                "Please consider upgrading to Python 3.10 or higher.",
+            )
+
+    if install_plugin_deps:
+        install_plugin_dependencies()
+
+    # TODO: have this directory live outside the repository (e.g. in a user's
+    #   home directory) and have it come in as a command line argument or part of
+    #   the env file.
+    Workspace.set_workspace_directory(config, workspace_directory)
+
+    # HACK: doing this here to collect some globals that depend on the workspace.
+    Workspace.set_file_logger_path(config, config.workspace_path)
+
+    config.plugins = scan_plugins(config, config.debug_mode)
+    # Create a CommandRegistry instance and scan default folder
+    command_registry = CommandRegistry()
+
+    logger.debug(
+        f"The following command categories are disabled: {config.disabled_command_categories}"
+    )
+    enabled_command_categories = [
+        x for x in COMMAND_CATEGORIES if x not in config.disabled_command_categories
+    ]
+
+    logger.debug(
+        f"The following command categories are enabled: {enabled_command_categories}"
+    )
+
+    for command_category in enabled_command_categories:
+        command_registry.import_commands(command_category)
+
+    # Unregister commands that are incompatible with the current config
+    incompatible_commands = []
+    for command in command_registry.commands.values():
+        if callable(command.enabled) and not command.enabled(config):
+            command.enabled = False
+            incompatible_commands.append(command)
+
+    for command in incompatible_commands:
+        command_registry.unregister(command)
+        logger.debug(
+            f"Unregistering incompatible command: {command.name}, "
+            f"reason - {command.disabled_reason or 'Disabled by current config.'}"
+        )
+
+    ai_config = construct_main_ai_config(
+        config,
+        name=ai_name,
+        role=ai_role,
+        goals=ai_goals,
+    )
+    ai_config.command_registry = command_registry
+    # print(prompt)
+
+    # add chat plugins capable of report to logger
+    if config.chat_messages_enabled:
+        for plugin in config.plugins:
+            if hasattr(plugin, "can_handle_report") and plugin.can_handle_report():
+                logger.info(f"Loaded plugin into logger: {plugin.__class__.__name__}")
+                logger.chat_plugins.append(plugin)
+
+    # Initialize memory and make sure it is empty.
+    # this is particularly important for indexing and referencing pinecone memory
+    memory = get_memory(config)
+    memory.clear()
+    logger.typewriter_log(
+        "Using memory of type:", Fore.GREEN, f"{memory.__class__.__name__}"
+    )
+    logger.typewriter_log("Using Browser:", Fore.GREEN, config.selenium_web_browser)
+
+    agent = Agent(
+        memory=memory,
+        command_registry=command_registry,
+        triggering_prompt=DEFAULT_TRIGGERING_PROMPT,
+        ai_config=ai_config,
+        config=config,
+    )
+
+    run_interaction_loop(agent)
+
+
+def _get_cycle_budget(continuous_mode: bool, continuous_limit: int) -> int | None:
+    # Translate from the continuous_mode/continuous_limit config
+    # to a cycle_budget (maximum number of cycles to run without checking in with the
+    # user) and a count of cycles_remaining before we check in..
+    if continuous_mode:
+        cycle_budget = continuous_limit if continuous_limit else math.inf
+    else:
+        cycle_budget = 1
+
+    return cycle_budget
+
+
+class UserFeedback(str, enum.Enum):
+    """Enum for user feedback."""
+
+    AUTHORIZE = "GENERATE NEXT COMMAND JSON"
+    EXIT = "EXIT"
+    TEXT = "TEXT"
+
+
+def run_interaction_loop(
+    agent: Agent,
+) -> None:
+    """Run the main interaction loop for the agent.
+
+    Args:
+        agent: The agent to run the interaction loop for.
+
+    Returns:
+        None
+    """
+    # These contain both application config and agent config, so grab them here.
+    config = agent.config
+    ai_config = agent.ai_config
+    logger.debug(f"{ai_config.ai_name} System Prompt: {agent.system_prompt}")
+
+    cycle_budget = cycles_remaining = _get_cycle_budget(
+        config.continuous_mode, config.continuous_limit
+    )
+    spinner = Spinner("Thinking...", plain_output=config.plain_output)
+
+    def graceful_agent_interrupt(signum: int, frame: Optional[FrameType]) -> None:
+        nonlocal cycle_budget, cycles_remaining, spinner
+        if cycles_remaining in [0, 1, math.inf]:
+            logger.typewriter_log(
+                "Interrupt signal received. Stopping continuous command execution "
+                "immediately.",
+                Fore.RED,
+            )
+            sys.exit()
+        else:
+            restart_spinner = spinner.running
+            if spinner.running:
+                spinner.stop()
+
+            logger.typewriter_log(
+                "Interrupt signal received. Stopping continuous command execution.",
+                Fore.RED,
+            )
+            cycles_remaining = 1
+            if restart_spinner:
+                spinner.start()
+
+    # Set up an interrupt signal for the agent.
+    signal.signal(signal.SIGINT, graceful_agent_interrupt)
+
+    #########################
+    # Application Main Loop #
+    #########################
+
+    while cycles_remaining > 0:
+        logger.debug(f"Cycle budget: {cycle_budget}; remaining: {cycles_remaining}")
+
+        ########
+        # Plan #
+        ########
+        # Have the agent determine the next action to take.
+        with spinner:
+            command_name, command_args, assistant_reply_dict = agent.think()
+
+        ###############
+        # Update User #
+        ###############
+        # Print the assistant's thoughts and the next command to the user.
+        update_user(config, ai_config, command_name, command_args, assistant_reply_dict)
+
+        ##################
+        # Get user input #
+        ##################
+        if cycles_remaining == 1:  # Last cycle
+            user_feedback, user_input, new_cycles_remaining = get_user_feedback(
+                config,
+                ai_config,
+            )
+
+            if user_feedback == UserFeedback.AUTHORIZE:
+                if new_cycles_remaining is not None:
+                    # Case 1: User is altering the cycle budget.
+                    if cycle_budget > 1:
+                        cycle_budget = new_cycles_remaining + 1
+                    # Case 2: User is running iteratively and
+                    #   has initiated a one-time continuous cycle
+                    cycles_remaining = new_cycles_remaining + 1
+                else:
+                    # Case 1: Continuous iteration was interrupted -> resume
+                    if cycle_budget > 1:
+                        logger.typewriter_log(
+                            "RESUMING CONTINUOUS EXECUTION: ",
+                            Fore.MAGENTA,
+                            f"The cycle budget is {cycle_budget}.",
+                        )
+                    # Case 2: The agent used up its cycle budget -> reset
+                    cycles_remaining = cycle_budget + 1
+                logger.typewriter_log(
+                    "-=-=-=-=-=-=-= COMMAND AUTHORISED BY USER -=-=-=-=-=-=-=",
+                    Fore.MAGENTA,
+                    "",
+                )
+            elif user_feedback == UserFeedback.EXIT:
+                logger.typewriter_log("Exiting...", Fore.YELLOW)
+                exit()
+            else:  # user_feedback == UserFeedback.TEXT
+                command_name = "human_feedback"
+        else:
+            user_input = None
+            # First log new-line so user can differentiate sections better in console
+            logger.typewriter_log("\n")
+            if cycles_remaining != math.inf:
+                # Print authorized commands left value
+                logger.typewriter_log(
+                    "AUTHORISED COMMANDS LEFT: ", Fore.CYAN, f"{cycles_remaining}"
+                )
+
+        ###################
+        # Execute Command #
+        ###################
+        # Decrement the cycle counter first to reduce the likelihood of a SIGINT
+        # happening during command execution, setting the cycles remaining to 1,
+        # and then having the decrement set it to 0, exiting the application.
+        if command_name != "human_feedback":
+            cycles_remaining -= 1
+        result = agent.execute(command_name, command_args, user_input)
+
+        if result is not None:
+            logger.typewriter_log("SYSTEM: ", Fore.YELLOW, result)
+        else:
+            logger.typewriter_log("SYSTEM: ", Fore.YELLOW, "Unable to execute command")
+
+
+def update_user(
+    config: Config,
+    ai_config: AIConfig,
+    command_name: CommandName | None,
+    command_args: CommandArgs | None,
+    assistant_reply_dict: AgentThoughts,
+) -> None:
+    """Prints the assistant's thoughts and the next command to the user.
+
+    Args:
+        config: The program's configuration.
+        ai_config: The AI's configuration.
+        command_name: The name of the command to execute.
+        command_args: The arguments for the command.
+        assistant_reply_dict: The assistant's reply.
+    """
+
+    print_assistant_thoughts(ai_config.ai_name, assistant_reply_dict, config)
+
+    if command_name is not None:
+        if config.speak_mode:
+            say_text(f"I want to execute {command_name}", config)
+
+        # 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}{remove_ansi_escape(command_name)}{Style.RESET_ALL}  "
+            f"ARGUMENTS = {Fore.CYAN}{command_args}{Style.RESET_ALL}",
+        )
+    elif command_name.lower().startswith("error"):
+        logger.typewriter_log(
+            "ERROR: ",
+            Fore.RED,
+            f"The Agent failed to select an action. " f"Error message: {command_name}",
+        )
+    else:
+        logger.typewriter_log(
+            "NO ACTION SELECTED: ",
+            Fore.RED,
+            f"The Agent failed to select an action.",
+        )
+
+
+def get_user_feedback(
+    config: Config,
+    ai_config: AIConfig,
+) -> tuple[UserFeedback, str, int | None]:
+    """Gets the user's feedback on the assistant's reply.
+
+    Args:
+        config: The program's configuration.
+        ai_config: The AI's configuration.
+
+    Returns:
+        A tuple of the user's feedback, the user's input, and the number of
+        cycles remaining if the user has initiated a continuous cycle.
+    """
+    # ### GET USER AUTHORIZATION TO EXECUTE COMMAND ###
+    # Get key press: Prompt the user to press enter to continue or escape
+    # to exit
+    logger.info(
+        f"Enter '{config.authorise_key}' to authorise command, "
+        f"'{config.authorise_key} -N' to run N continuous commands, "
+        f"'{config.exit_key}' to exit program, or enter feedback for "
+        f"{ai_config.ai_name}..."
+    )
+
+    user_feedback = None
+    user_input = ""
+    new_cycles_remaining = None
+
+    while user_feedback is None:
+        # Get input from user
+        if config.chat_messages_enabled:
+            console_input = clean_input(config, "Waiting for your response...")
+        else:
+            console_input = clean_input(
+                config, Fore.MAGENTA + "Input:" + Style.RESET_ALL
+            )
+
+        # Parse user input
+        if console_input.lower().strip() == config.authorise_key:
+            user_feedback = UserFeedback.AUTHORIZE
+        elif console_input.lower().strip() == "":
+            logger.warn("Invalid input format.")
+        elif console_input.lower().startswith(f"{config.authorise_key} -"):
+            try:
+                user_feedback = UserFeedback.AUTHORIZE
+                new_cycles_remaining = abs(int(console_input.split(" ")[1]))
+            except ValueError:
+                logger.warn(
+                    f"Invalid input format. "
+                    f"Please enter '{config.authorise_key} -N'"
+                    " where N is the number of continuous tasks."
+                )
+        elif console_input.lower() in [config.exit_key, "exit"]:
+            user_feedback = UserFeedback.EXIT
+        else:
+            user_feedback = UserFeedback.TEXT
+            user_input = console_input
+
+    return user_feedback, user_input, new_cycles_remaining
+
+
+def construct_main_ai_config(
+    config: Config,
+    name: Optional[str] = None,
+    role: Optional[str] = None,
+    goals: tuple[str] = tuple(),
+) -> AIConfig:
+    """Construct the prompt for the AI to respond to
+
+    Returns:
+        str: The prompt string
+    """
+    ai_config = AIConfig.load(config.workdir / config.ai_settings_file)
+
+    # Apply overrides
+    if name:
+        ai_config.ai_name = name
+    if role:
+        ai_config.ai_role = role
+    if goals:
+        ai_config.ai_goals = list(goals)
+
+    if (
+        all([name, role, goals])
+        or config.skip_reprompt
+        and all([ai_config.ai_name, ai_config.ai_role, ai_config.ai_goals])
+    ):
+        logger.typewriter_log("Name :", Fore.GREEN, ai_config.ai_name)
+        logger.typewriter_log("Role :", Fore.GREEN, ai_config.ai_role)
+        logger.typewriter_log("Goals:", Fore.GREEN, f"{ai_config.ai_goals}")
+        logger.typewriter_log(
+            "API Budget:",
+            Fore.GREEN,
+            "infinite" if ai_config.api_budget <= 0 else f"${ai_config.api_budget}",
+        )
+    elif all([ai_config.ai_name, ai_config.ai_role, ai_config.ai_goals]):
+        logger.typewriter_log(
+            "Welcome back! ",
+            Fore.GREEN,
+            f"Would you like me to return to being {ai_config.ai_name}?",
+            speak_text=True,
+        )
+        should_continue = clean_input(
+            config,
+            f"""Continue with the last settings?
+Name:  {ai_config.ai_name}
+Role:  {ai_config.ai_role}
+Goals: {ai_config.ai_goals}
+API Budget: {"infinite" if ai_config.api_budget <= 0 else f"${ai_config.api_budget}"}
+Continue ({config.authorise_key}/{config.exit_key}): """,
+        )
+        if should_continue.lower() == config.exit_key:
+            ai_config = AIConfig()
+
+    if any([not ai_config.ai_name, not ai_config.ai_role, not ai_config.ai_goals]):
+        ai_config = prompt_user(config)
+        ai_config.save(config.workdir / config.ai_settings_file)
+
+    if config.restrict_to_workspace:
+        logger.typewriter_log(
+            "NOTE:All files/directories created by this agent can be found inside its workspace at:",
+            Fore.YELLOW,
+            f"{config.workspace_path}",
+        )
+    # set the total api budget
+    api_manager = ApiManager()
+    api_manager.set_total_budget(ai_config.api_budget)
+
+    # Agent Created, print message
+    logger.typewriter_log(
+        ai_config.ai_name,
+        Fore.LIGHTBLUE_EX,
+        "has been created with the following details:",
+        speak_text=True,
+    )
+
+    # Print the ai_config details
+    # Name
+    logger.typewriter_log("Name:", Fore.GREEN, ai_config.ai_name, speak_text=False)
+    # Role
+    logger.typewriter_log("Role:", Fore.GREEN, ai_config.ai_role, speak_text=False)
+    # Goals
+    logger.typewriter_log("Goals:", Fore.GREEN, "", speak_text=False)
+    for goal in ai_config.ai_goals:
+        logger.typewriter_log("-", Fore.GREEN, goal, speak_text=False)
+
+    return ai_config
+
+
+def print_assistant_thoughts(
+    ai_name: str,
+    assistant_reply_json_valid: dict,
+    config: Config,
+) -> None:
+    from autogpt.speech import say_text
+
+    assistant_thoughts_reasoning = None
+    assistant_thoughts_plan = None
+    assistant_thoughts_speak = None
+    assistant_thoughts_criticism = None
+
+    assistant_thoughts = assistant_reply_json_valid.get("thoughts", {})
+    assistant_thoughts_text = remove_ansi_escape(assistant_thoughts.get("text", ""))
+    if assistant_thoughts:
+        assistant_thoughts_reasoning = remove_ansi_escape(
+            assistant_thoughts.get("reasoning", "")
+        )
+        assistant_thoughts_plan = remove_ansi_escape(assistant_thoughts.get("plan", ""))
+        assistant_thoughts_criticism = remove_ansi_escape(
+            assistant_thoughts.get("criticism", "")
+        )
+        assistant_thoughts_speak = remove_ansi_escape(
+            assistant_thoughts.get("speak", "")
+        )
+    logger.typewriter_log(
+        f"{ai_name.upper()} THOUGHTS:", Fore.YELLOW, assistant_thoughts_text
+    )
+    logger.typewriter_log("REASONING:", Fore.YELLOW, str(assistant_thoughts_reasoning))
+    if assistant_thoughts_plan:
+        logger.typewriter_log("PLAN:", Fore.YELLOW, "")
+        # If it's a list, join it into a string
+        if isinstance(assistant_thoughts_plan, list):
+            assistant_thoughts_plan = "\n".join(assistant_thoughts_plan)
+        elif isinstance(assistant_thoughts_plan, dict):
+            assistant_thoughts_plan = str(assistant_thoughts_plan)
+
+        # Split the input_string using the newline character and dashes
+        lines = assistant_thoughts_plan.split("\n")
+        for line in lines:
+            line = line.lstrip("- ")
+            logger.typewriter_log("- ", Fore.GREEN, line.strip())
+    logger.typewriter_log("CRITICISM:", Fore.YELLOW, f"{assistant_thoughts_criticism}")
+    # Speak the assistant's thoughts
+    if assistant_thoughts_speak:
+        if config.speak_mode:
+            say_text(assistant_thoughts_speak, config)
+        else:
+            logger.typewriter_log("SPEAK:", Fore.YELLOW, f"{assistant_thoughts_speak}")
+
+
+def remove_ansi_escape(s: str) -> str:
+    return s.replace("\x1B", "")

autogpt/app/setup.py

@@ -0,0 +1,238 @@
+"""Set up the AI and its goals"""
+import re
+from typing import Optional
+
+from colorama import Fore, Style
+from jinja2 import Template
+
+from autogpt import utils
+from autogpt.config import Config
+from autogpt.config.ai_config import AIConfig
+from autogpt.llm.base import ChatSequence, Message
+from autogpt.llm.utils import create_chat_completion
+from autogpt.logs import logger
+from autogpt.prompts.default_prompts import (
+    DEFAULT_SYSTEM_PROMPT_AICONFIG_AUTOMATIC,
+    DEFAULT_TASK_PROMPT_AICONFIG_AUTOMATIC,
+    DEFAULT_USER_DESIRE_PROMPT,
+)
+
+
+def prompt_user(
+    config: Config, ai_config_template: Optional[AIConfig] = None
+) -> AIConfig:
+    """Prompt the user for input
+
+    Params:
+        config (Config): The Config object
+        ai_config_template (AIConfig): The AIConfig object to use as a template
+
+    Returns:
+        AIConfig: The AIConfig object tailored to the user's input
+    """
+
+    # Construct the prompt
+    logger.typewriter_log(
+        "Welcome to Auto-GPT! ",
+        Fore.GREEN,
+        "run with '--help' for more information.",
+        speak_text=True,
+    )
+
+    ai_config_template_provided = ai_config_template is not None and any(
+        [
+            ai_config_template.ai_goals,
+            ai_config_template.ai_name,
+            ai_config_template.ai_role,
+        ]
+    )
+
+    user_desire = ""
+    if not ai_config_template_provided:
+        # Get user desire if command line overrides have not been passed in
+        logger.typewriter_log(
+            "Create an AI-Assistant:",
+            Fore.GREEN,
+            "input '--manual' to enter manual mode.",
+            speak_text=True,
+        )
+
+        user_desire = utils.clean_input(
+            config, f"{Fore.LIGHTBLUE_EX}I want Auto-GPT to{Style.RESET_ALL}: "
+        )
+
+    if user_desire.strip() == "":
+        user_desire = DEFAULT_USER_DESIRE_PROMPT  # Default prompt
+
+    # If user desire contains "--manual" or we have overridden any of the AI configuration
+    if "--manual" in user_desire or ai_config_template_provided:
+        logger.typewriter_log(
+            "Manual Mode Selected",
+            Fore.GREEN,
+            speak_text=True,
+        )
+        return generate_aiconfig_manual(config, ai_config_template)
+
+    else:
+        try:
+            return generate_aiconfig_automatic(user_desire, config)
+        except Exception as e:
+            logger.typewriter_log(
+                "Unable to automatically generate AI Config based on user desire.",
+                Fore.RED,
+                "Falling back to manual mode.",
+                speak_text=True,
+            )
+
+            return generate_aiconfig_manual(config)
+
+
+def generate_aiconfig_manual(
+    config: Config, ai_config_template: Optional[AIConfig] = None
+) -> AIConfig:
+    """
+    Interactively create an AI configuration by prompting the user to provide the name, role, and goals of the AI.
+
+    This function guides the user through a series of prompts to collect the necessary information to create
+    an AIConfig object. The user will be asked to provide a name and role for the AI, as well as up to five
+    goals. If the user does not provide a value for any of the fields, default values will be used.
+
+    Params:
+        config (Config): The Config object
+        ai_config_template (AIConfig): The AIConfig object to use as a template
+
+    Returns:
+        AIConfig: An AIConfig object containing the user-defined or default AI name, role, and goals.
+    """
+
+    # Manual Setup Intro
+    logger.typewriter_log(
+        "Create an AI-Assistant:",
+        Fore.GREEN,
+        "Enter the name of your AI and its role below. Entering nothing will load"
+        " defaults.",
+        speak_text=True,
+    )
+
+    if ai_config_template and ai_config_template.ai_name:
+        ai_name = ai_config_template.ai_name
+    else:
+        ai_name = ""
+        # Get AI Name from User
+        logger.typewriter_log(
+            "Name your AI: ", Fore.GREEN, "For example, 'Entrepreneur-GPT'"
+        )
+        ai_name = utils.clean_input(config, "AI Name: ")
+    if ai_name == "":
+        ai_name = "Entrepreneur-GPT"
+
+    logger.typewriter_log(
+        f"{ai_name} here!", Fore.LIGHTBLUE_EX, "I am at your service.", speak_text=True
+    )
+
+    if ai_config_template and ai_config_template.ai_role:
+        ai_role = ai_config_template.ai_role
+    else:
+        # Get AI Role from User
+        logger.typewriter_log(
+            "Describe your AI's role: ",
+            Fore.GREEN,
+            "For example, 'an AI designed to autonomously develop and run businesses with"
+            " the sole goal of increasing your net worth.'",
+        )
+        ai_role = utils.clean_input(config, f"{ai_name} is: ")
+    if ai_role == "":
+        ai_role = "an AI designed to autonomously develop and run businesses with the"
+        " sole goal of increasing your net worth."
+
+    if ai_config_template and ai_config_template.ai_goals:
+        ai_goals = ai_config_template.ai_goals
+    else:
+        # Enter up to 5 goals for the AI
+        logger.typewriter_log(
+            "Enter up to 5 goals for your AI: ",
+            Fore.GREEN,
+            "For example: \nIncrease net worth, Grow Twitter Account, Develop and manage"
+            " multiple businesses autonomously'",
+        )
+        logger.info("Enter nothing to load defaults, enter nothing when finished.")
+        ai_goals = []
+        for i in range(5):
+            ai_goal = utils.clean_input(
+                config, f"{Fore.LIGHTBLUE_EX}Goal{Style.RESET_ALL} {i+1}: "
+            )
+            if ai_goal == "":
+                break
+            ai_goals.append(ai_goal)
+    if not ai_goals:
+        ai_goals = [
+            "Increase net worth",
+            "Grow Twitter Account",
+            "Develop and manage multiple businesses autonomously",
+        ]
+
+    # Get API Budget from User
+    logger.typewriter_log(
+        "Enter your budget for API calls: ",
+        Fore.GREEN,
+        "For example: $1.50",
+    )
+    logger.info("Enter nothing to let the AI run without monetary limit")
+    api_budget_input = utils.clean_input(
+        config, f"{Fore.LIGHTBLUE_EX}Budget{Style.RESET_ALL}: $"
+    )
+    if api_budget_input == "":
+        api_budget = 0.0
+    else:
+        try:
+            api_budget = float(api_budget_input.replace("$", ""))
+        except ValueError:
+            logger.typewriter_log(
+                "Invalid budget input. Setting budget to unlimited.", Fore.RED
+            )
+            api_budget = 0.0
+
+    return AIConfig(ai_name, ai_role, ai_goals, api_budget)
+
+
+def generate_aiconfig_automatic(user_prompt: str, config: Config) -> AIConfig:
+    """Generates an AIConfig object from the given string.
+
+    Returns:
+    AIConfig: The AIConfig object tailored to the user's input
+    """
+
+    system_prompt = DEFAULT_SYSTEM_PROMPT_AICONFIG_AUTOMATIC
+    prompt_ai_config_automatic = Template(
+        DEFAULT_TASK_PROMPT_AICONFIG_AUTOMATIC
+    ).render(user_prompt=user_prompt)
+    # Call LLM with the string as user input
+    output = create_chat_completion(
+        ChatSequence.for_model(
+            config.fast_llm,
+            [
+                Message("system", system_prompt),
+                Message("user", prompt_ai_config_automatic),
+            ],
+        ),
+        config,
+    ).content
+
+    # Debug LLM Output
+    logger.debug(f"AI Config Generator Raw Output: {output}")
+
+    # Parse the output
+    ai_name = re.search(r"Name(?:\s*):(?:\s*)(.*)", output, re.IGNORECASE).group(1)
+    ai_role = (
+        re.search(
+            r"Description(?:\s*):(?:\s*)(.*?)(?:(?:\n)|Goals)",
+            output,
+            re.IGNORECASE | re.DOTALL,
+        )
+        .group(1)
+        .strip()
+    )
+    ai_goals = re.findall(r"(?<=\n)-\s*(.*)", output)
+    api_budget = 0.0  # TODO: parse api budget using a regular expression
+
+    return AIConfig(ai_name, ai_role, ai_goals, api_budget)

autogpt/command_decorator.py

@@ -0,0 +1,57 @@
+import functools
+from typing import Any, Callable, Optional, TypedDict
+
+from autogpt.config import Config
+from autogpt.models.command import Command, CommandParameter
+
+# Unique identifier for auto-gpt commands
+AUTO_GPT_COMMAND_IDENTIFIER = "auto_gpt_command"
+
+
+class CommandParameterSpec(TypedDict):
+    type: str
+    description: str
+    required: bool
+
+
+def command(
+    name: str,
+    description: str,
+    parameters: dict[str, CommandParameterSpec],
+    enabled: bool | Callable[[Config], bool] = True,
+    disabled_reason: Optional[str] = None,
+    aliases: list[str] = [],
+) -> Callable[..., Any]:
+    """The command decorator is used to create Command objects from ordinary functions."""
+
+    def decorator(func: Callable[..., Any]) -> Command:
+        typed_parameters = [
+            CommandParameter(
+                name=param_name,
+                description=parameter.get("description"),
+                type=parameter.get("type", "string"),
+                required=parameter.get("required", False),
+            )
+            for param_name, parameter in parameters.items()
+        ]
+        cmd = Command(
+            name=name,
+            description=description,
+            method=func,
+            parameters=typed_parameters,
+            enabled=enabled,
+            disabled_reason=disabled_reason,
+            aliases=aliases,
+        )
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            return func(*args, **kwargs)
+
+        wrapper.command = cmd
+
+        setattr(wrapper, AUTO_GPT_COMMAND_IDENTIFIER, True)
+
+        return wrapper
+
+    return decorator

autogpt/commands/__init__.py

@@ -0,0 +1,7 @@
+COMMAND_CATEGORIES = [
+    "autogpt.commands.execute_code",
+    "autogpt.commands.file_operations",
+    "autogpt.commands.web_search",
+    "autogpt.commands.web_selenium",
+    "autogpt.commands.task_statuses",
+]

autogpt/commands/decorators.py

@@ -0,0 +1,64 @@
+import functools
+from pathlib import Path
+from typing import Callable
+
+from autogpt.agents.agent import Agent
+from autogpt.logs import logger
+
+
+def sanitize_path_arg(arg_name: str):
+    def decorator(func: Callable):
+        # Get position of path parameter, in case it is passed as a positional argument
+        try:
+            arg_index = list(func.__annotations__.keys()).index(arg_name)
+        except ValueError:
+            raise TypeError(
+                f"Sanitized parameter '{arg_name}' absent or not annotated on function '{func.__name__}'"
+            )
+
+        # Get position of agent parameter, in case it is passed as a positional argument
+        try:
+            agent_arg_index = list(func.__annotations__.keys()).index("agent")
+        except ValueError:
+            raise TypeError(
+                f"Parameter 'agent' absent or not annotated on function '{func.__name__}'"
+            )
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            logger.debug(f"Sanitizing arg '{arg_name}' on function '{func.__name__}'")
+            logger.debug(f"Function annotations: {func.__annotations__}")
+
+            # Get Agent from the called function's arguments
+            agent = kwargs.get(
+                "agent", len(args) > agent_arg_index and args[agent_arg_index]
+            )
+            logger.debug(f"Args: {args}")
+            logger.debug(f"KWArgs: {kwargs}")
+            logger.debug(f"Agent argument lifted from function call: {agent}")
+            if not isinstance(agent, Agent):
+                raise RuntimeError("Could not get Agent from decorated command's args")
+
+            # Sanitize the specified path argument, if one is given
+            given_path: str | Path | None = kwargs.get(
+                arg_name, len(args) > arg_index and args[arg_index] or None
+            )
+            if given_path:
+                if given_path in {"", "/"}:
+                    sanitized_path = str(agent.workspace.root)
+                else:
+                    sanitized_path = str(agent.workspace.get_path(given_path))
+
+                if arg_name in kwargs:
+                    kwargs[arg_name] = sanitized_path
+                else:
+                    # args is an immutable tuple; must be converted to a list to update
+                    arg_list = list(args)
+                    arg_list[arg_index] = sanitized_path
+                    args = tuple(arg_list)
+
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

autogpt/commands/execute_code.py

@@ -0,0 +1,306 @@
+"""Execute code in a Docker container"""
+import os
+import subprocess
+from pathlib import Path
+
+import docker
+from docker.errors import DockerException, ImageNotFound
+from docker.models.containers import Container as DockerContainer
+
+from autogpt.agents.agent import Agent
+from autogpt.command_decorator import command
+from autogpt.config import Config
+from autogpt.logs import logger
+
+from .decorators import sanitize_path_arg
+
+ALLOWLIST_CONTROL = "allowlist"
+DENYLIST_CONTROL = "denylist"
+
+
+@command(
+    "execute_python_code",
+    "Creates a Python file and executes it",
+    {
+        "code": {
+            "type": "string",
+            "description": "The Python code to run",
+            "required": True,
+        },
+        "name": {
+            "type": "string",
+            "description": "A name to be given to the python file",
+            "required": True,
+        },
+    },
+)
+def execute_python_code(code: str, name: str, agent: Agent) -> str:
+    """Create and execute a Python file in a Docker container and return the STDOUT of the
+    executed code. If there is any data that needs to be captured use a print statement
+
+    Args:
+        code (str): The Python code to run
+        name (str): A name to be given to the Python file
+
+    Returns:
+        str: The STDOUT captured from the code when it ran
+    """
+    ai_name = agent.ai_config.ai_name
+    code_dir = agent.workspace.get_path(Path(ai_name, "executed_code"))
+    os.makedirs(code_dir, exist_ok=True)
+
+    if not name.endswith(".py"):
+        name = name + ".py"
+
+    # The `name` arg is not covered by @sanitize_path_arg,
+    # so sanitization must be done here to prevent path traversal.
+    file_path = agent.workspace.get_path(code_dir / name)
+    if not file_path.is_relative_to(code_dir):
+        return "Error: 'name' argument resulted in path traversal, operation aborted"
+
+    try:
+        with open(file_path, "w+", encoding="utf-8") as f:
+            f.write(code)
+
+        return execute_python_file(str(file_path), agent)
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+@command(
+    "execute_python_file",
+    "Executes an existing Python file",
+    {
+        "filename": {
+            "type": "string",
+            "description": "The name of te file to execute",
+            "required": True,
+        },
+    },
+)
+@sanitize_path_arg("filename")
+def execute_python_file(filename: str, agent: Agent) -> str:
+    """Execute a Python file in a Docker container and return the output
+
+    Args:
+        filename (str): The name of the file to execute
+
+    Returns:
+        str: The output of the file
+    """
+    logger.info(
+        f"Executing python file '{filename}' in working directory '{agent.config.workspace_path}'"
+    )
+
+    if not filename.endswith(".py"):
+        return "Error: Invalid file type. Only .py files are allowed."
+
+    file_path = Path(filename)
+    if not file_path.is_file():
+        # Mimic the response that you get from the command line so that it's easier to identify
+        return (
+            f"python: can't open file '{filename}': [Errno 2] No such file or directory"
+        )
+
+    if we_are_running_in_a_docker_container():
+        logger.debug(
+            f"Auto-GPT is running in a Docker container; executing {file_path} directly..."
+        )
+        result = subprocess.run(
+            ["python", str(file_path)],
+            capture_output=True,
+            encoding="utf8",
+            cwd=agent.config.workspace_path,
+        )
+        if result.returncode == 0:
+            return result.stdout
+        else:
+            return f"Error: {result.stderr}"
+
+    logger.debug("Auto-GPT is not running in a Docker container")
+    try:
+        client = docker.from_env()
+        # You can replace this with the desired Python image/version
+        # You can find available Python images on Docker Hub:
+        # https://hub.docker.com/_/python
+        image_name = "python:3-alpine"
+        try:
+            client.images.get(image_name)
+            logger.debug(f"Image '{image_name}' found locally")
+        except ImageNotFound:
+            logger.info(
+                f"Image '{image_name}' not found locally, pulling from Docker Hub..."
+            )
+            # Use the low-level API to stream the pull response
+            low_level_client = docker.APIClient()
+            for line in low_level_client.pull(image_name, stream=True, decode=True):
+                # Print the status and progress, if available
+                status = line.get("status")
+                progress = line.get("progress")
+                if status and progress:
+                    logger.info(f"{status}: {progress}")
+                elif status:
+                    logger.info(status)
+
+        logger.debug(f"Running {file_path} in a {image_name} container...")
+        container: DockerContainer = client.containers.run(
+            image_name,
+            [
+                "python",
+                file_path.relative_to(agent.workspace.root).as_posix(),
+            ],
+            volumes={
+                str(agent.config.workspace_path): {
+                    "bind": "/workspace",
+                    "mode": "rw",
+                }
+            },
+            working_dir="/workspace",
+            stderr=True,
+            stdout=True,
+            detach=True,
+        )  # type: ignore
+
+        container.wait()
+        logs = container.logs().decode("utf-8")
+        container.remove()
+
+        # print(f"Execution complete. Output: {output}")
+        # print(f"Logs: {logs}")
+
+        return logs
+
+    except DockerException as e:
+        logger.warn(
+            "Could not run the script in a container. If you haven't already, please install Docker https://docs.docker.com/get-docker/"
+        )
+        return f"Error: {str(e)}"
+
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def validate_command(command: str, config: Config) -> bool:
+    """Validate a command to ensure it is allowed
+
+    Args:
+        command (str): The command to validate
+        config (Config): The config to use to validate the command
+
+    Returns:
+        bool: True if the command is allowed, False otherwise
+    """
+    if not command:
+        return False
+
+    command_name = command.split()[0]
+
+    if config.shell_command_control == ALLOWLIST_CONTROL:
+        return command_name in config.shell_allowlist
+    else:
+        return command_name not in config.shell_denylist
+
+
+@command(
+    "execute_shell",
+    "Executes a Shell Command, non-interactive commands only",
+    {
+        "command_line": {
+            "type": "string",
+            "description": "The command line to execute",
+            "required": True,
+        }
+    },
+    enabled=lambda config: config.execute_local_commands,
+    disabled_reason="You are not allowed to run local shell commands. To execute"
+    " shell commands, EXECUTE_LOCAL_COMMANDS must be set to 'True' "
+    "in your config file: .env - do not attempt to bypass the restriction.",
+)
+def execute_shell(command_line: str, agent: Agent) -> str:
+    """Execute a shell command and return the output
+
+    Args:
+        command_line (str): The command line to execute
+
+    Returns:
+        str: The output of the command
+    """
+    if not validate_command(command_line, agent.config):
+        logger.info(f"Command '{command_line}' not allowed")
+        return "Error: This Shell Command is not allowed."
+
+    current_dir = Path.cwd()
+    # Change dir into workspace if necessary
+    if not current_dir.is_relative_to(agent.config.workspace_path):
+        os.chdir(agent.config.workspace_path)
+
+    logger.info(
+        f"Executing command '{command_line}' in working directory '{os.getcwd()}'"
+    )
+
+    result = subprocess.run(command_line, capture_output=True, shell=True)
+    output = f"STDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+
+    # Change back to whatever the prior working dir was
+
+    os.chdir(current_dir)
+    return output
+
+
+@command(
+    "execute_shell_popen",
+    "Executes a Shell Command, non-interactive commands only",
+    {
+        "query": {
+            "type": "string",
+            "description": "The search query",
+            "required": True,
+        }
+    },
+    lambda config: config.execute_local_commands,
+    "You are not allowed to run local shell commands. To execute"
+    " shell commands, EXECUTE_LOCAL_COMMANDS must be set to 'True' "
+    "in your config. Do not attempt to bypass the restriction.",
+)
+def execute_shell_popen(command_line, agent: Agent) -> str:
+    """Execute a shell command with Popen and returns an english description
+    of the event and the process id
+
+    Args:
+        command_line (str): The command line to execute
+
+    Returns:
+        str: Description of the fact that the process started and its id
+    """
+    if not validate_command(command_line, agent.config):
+        logger.info(f"Command '{command_line}' not allowed")
+        return "Error: This Shell Command is not allowed."
+
+    current_dir = os.getcwd()
+    # Change dir into workspace if necessary
+    if agent.config.workspace_path not in current_dir:
+        os.chdir(agent.config.workspace_path)
+
+    logger.info(
+        f"Executing command '{command_line}' in working directory '{os.getcwd()}'"
+    )
+
+    do_not_show_output = subprocess.DEVNULL
+    process = subprocess.Popen(
+        command_line, shell=True, stdout=do_not_show_output, stderr=do_not_show_output
+    )
+
+    # Change back to whatever the prior working dir was
+
+    os.chdir(current_dir)
+
+    return f"Subprocess started with PID:'{str(process.pid)}'"
+
+
+def we_are_running_in_a_docker_container() -> bool:
+    """Check if we are running in a Docker container
+
+    Returns:
+        bool: True if we are running in a Docker container, False otherwise
+    """
+    return os.path.exists("/.dockerenv")

autogpt/commands/file_operations.py

@@ -0,0 +1,340 @@
+"""File operations for AutoGPT"""
+from __future__ import annotations
+
+import contextlib
+import hashlib
+import os
+import os.path
+from pathlib import Path
+from typing import Generator, Literal
+
+from autogpt.agents.agent import Agent
+from autogpt.command_decorator import command
+from autogpt.logs import logger
+from autogpt.memory.vector import MemoryItem, VectorMemory
+
+from .decorators import sanitize_path_arg
+from .file_operations_utils import read_textual_file
+
+Operation = Literal["write", "append", "delete"]
+
+
+def text_checksum(text: str) -> str:
+    """Get the hex checksum for the given text."""
+    return hashlib.md5(text.encode("utf-8")).hexdigest()
+
+
+def operations_from_log(
+    log_path: str,
+) -> Generator[tuple[Operation, str, str | None], None, None]:
+    """Parse the file operations log and return a tuple containing the log entries"""
+    try:
+        log = open(log_path, "r", encoding="utf-8")
+    except FileNotFoundError:
+        return
+
+    for line in log:
+        line = line.replace("File Operation Logger", "").strip()
+        if not line:
+            continue
+        operation, tail = line.split(": ", maxsplit=1)
+        operation = operation.strip()
+        if operation in ("write", "append"):
+            try:
+                path, checksum = (x.strip() for x in tail.rsplit(" #", maxsplit=1))
+            except ValueError:
+                logger.warn(f"File log entry lacks checksum: '{line}'")
+                path, checksum = tail.strip(), None
+            yield (operation, path, checksum)
+        elif operation == "delete":
+            yield (operation, tail.strip(), None)
+
+    log.close()
+
+
+def file_operations_state(log_path: str) -> dict[str, str]:
+    """Iterates over the operations log and returns the expected state.
+
+    Parses a log file at config.file_logger_path to construct a dictionary that maps
+    each file path written or appended to its checksum. Deleted files are removed
+    from the dictionary.
+
+    Returns:
+        A dictionary mapping file paths to their checksums.
+
+    Raises:
+        FileNotFoundError: If config.file_logger_path is not found.
+        ValueError: If the log file content is not in the expected format.
+    """
+    state = {}
+    for operation, path, checksum in operations_from_log(log_path):
+        if operation in ("write", "append"):
+            state[path] = checksum
+        elif operation == "delete":
+            del state[path]
+    return state
+
+
+@sanitize_path_arg("filename")
+def is_duplicate_operation(
+    operation: Operation, filename: str, agent: Agent, checksum: str | None = None
+) -> bool:
+    """Check if the operation has already been performed
+
+    Args:
+        operation: The operation to check for
+        filename: The name of the file to check for
+        agent: The agent
+        checksum: The checksum of the contents to be written
+
+    Returns:
+        True if the operation has already been performed on the file
+    """
+    # Make the filename into a relative path if possible
+    with contextlib.suppress(ValueError):
+        filename = str(Path(filename).relative_to(agent.workspace.root))
+
+    state = file_operations_state(agent.config.file_logger_path)
+    if operation == "delete" and filename not in state:
+        return True
+    if operation == "write" and state.get(filename) == checksum:
+        return True
+    return False
+
+
+@sanitize_path_arg("filename")
+def log_operation(
+    operation: Operation, filename: str, agent: Agent, checksum: str | None = None
+) -> None:
+    """Log the file operation to the file_logger.txt
+
+    Args:
+        operation: The operation to log
+        filename: The name of the file the operation was performed on
+        checksum: The checksum of the contents to be written
+    """
+    # Make the filename into a relative path if possible
+    with contextlib.suppress(ValueError):
+        filename = str(Path(filename).relative_to(agent.workspace.root))
+
+    log_entry = f"{operation}: {filename}"
+    if checksum is not None:
+        log_entry += f" #{checksum}"
+    logger.debug(f"Logging file operation: {log_entry}")
+    append_to_file(
+        agent.config.file_logger_path, f"{log_entry}\n", agent, should_log=False
+    )
+
+
+@command(
+    "read_file",
+    "Read an existing file",
+    {
+        "filename": {
+            "type": "string",
+            "description": "The path of the file to read",
+            "required": True,
+        }
+    },
+)
+@sanitize_path_arg("filename")
+def read_file(filename: str, agent: Agent) -> str:
+    """Read a file and return the contents
+
+    Args:
+        filename (str): The name of the file to read
+
+    Returns:
+        str: The contents of the file
+    """
+    try:
+        content = read_textual_file(filename, logger)
+
+        # TODO: invalidate/update memory when file is edited
+        file_memory = MemoryItem.from_text_file(content, filename, agent.config)
+        if len(file_memory.chunks) > 1:
+            return file_memory.summary
+
+        return content
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def ingest_file(
+    filename: str,
+    memory: VectorMemory,
+) -> None:
+    """
+    Ingest a file by reading its content, splitting it into chunks with a specified
+    maximum length and overlap, and adding the chunks to the memory storage.
+
+    Args:
+        filename: The name of the file to ingest
+        memory: An object with an add() method to store the chunks in memory
+    """
+    try:
+        logger.info(f"Ingesting file {filename}")
+        content = read_file(filename)
+
+        # TODO: differentiate between different types of files
+        file_memory = MemoryItem.from_text_file(content, filename)
+        logger.debug(f"Created memory: {file_memory.dump(True)}")
+        memory.add(file_memory)
+
+        logger.info(f"Ingested {len(file_memory.e_chunks)} chunks from {filename}")
+    except Exception as err:
+        logger.warn(f"Error while ingesting file '{filename}': {err}")
+
+
+@command(
+    "write_to_file",
+    "Writes to a file",
+    {
+        "filename": {
+            "type": "string",
+            "description": "The name of the file to write to",
+            "required": True,
+        },
+        "text": {
+            "type": "string",
+            "description": "The text to write to the file",
+            "required": True,
+        },
+    },
+    aliases=["write_file", "create_file"],
+)
+@sanitize_path_arg("filename")
+def write_to_file(filename: str, text: str, agent: Agent) -> str:
+    """Write text to a file
+
+    Args:
+        filename (str): The name of the file to write to
+        text (str): The text to write to the file
+
+    Returns:
+        str: A message indicating success or failure
+    """
+    checksum = text_checksum(text)
+    if is_duplicate_operation("write", filename, agent, checksum):
+        return "Error: File has already been updated."
+    try:
+        directory = os.path.dirname(filename)
+        os.makedirs(directory, exist_ok=True)
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write(text)
+        log_operation("write", filename, agent, checksum)
+        return "File written to successfully."
+    except Exception as err:
+        return f"Error: {err}"
+
+
+@command(
+    "append_to_file",
+    "Appends to a file",
+    {
+        "filename": {
+            "type": "string",
+            "description": "The name of the file to write to",
+            "required": True,
+        },
+        "text": {
+            "type": "string",
+            "description": "The text to write to the file",
+            "required": True,
+        },
+    },
+)
+@sanitize_path_arg("filename")
+def append_to_file(
+    filename: str, text: str, agent: Agent, should_log: bool = True
+) -> str:
+    """Append text to a file
+
+    Args:
+        filename (str): The name of the file to append to
+        text (str): The text to append to the file
+        should_log (bool): Should log output
+
+    Returns:
+        str: A message indicating success or failure
+    """
+    try:
+        directory = os.path.dirname(filename)
+        os.makedirs(directory, exist_ok=True)
+        with open(filename, "a", encoding="utf-8") as f:
+            f.write(text)
+
+        if should_log:
+            with open(filename, "r", encoding="utf-8") as f:
+                checksum = text_checksum(f.read())
+            log_operation("append", filename, agent, checksum=checksum)
+
+        return "Text appended successfully."
+    except Exception as err:
+        return f"Error: {err}"
+
+
+@command(
+    "delete_file",
+    "Deletes a file",
+    {
+        "filename": {
+            "type": "string",
+            "description": "The name of the file to delete",
+            "required": True,
+        }
+    },
+)
+@sanitize_path_arg("filename")
+def delete_file(filename: str, agent: Agent) -> str:
+    """Delete a file
+
+    Args:
+        filename (str): The name of the file to delete
+
+    Returns:
+        str: A message indicating success or failure
+    """
+    if is_duplicate_operation("delete", filename, agent):
+        return "Error: File has already been deleted."
+    try:
+        os.remove(filename)
+        log_operation("delete", filename, agent)
+        return "File deleted successfully."
+    except Exception as err:
+        return f"Error: {err}"
+
+
+@command(
+    "list_files",
+    "Lists Files in a Directory",
+    {
+        "directory": {
+            "type": "string",
+            "description": "The directory to list files in",
+            "required": True,
+        }
+    },
+)
+@sanitize_path_arg("directory")
+def list_files(directory: str, agent: Agent) -> list[str]:
+    """lists files in a directory recursively
+
+    Args:
+        directory (str): The directory to search in
+
+    Returns:
+        list[str]: A list of files found in the directory
+    """
+    found_files = []
+
+    for root, _, files in os.walk(directory):
+        for file in files:
+            if file.startswith("."):
+                continue
+            relative_path = os.path.relpath(
+                os.path.join(root, file), agent.config.workspace_path
+            )
+            found_files.append(relative_path)
+
+    return found_files

autogpt/commands/file_operations_utils.py

@@ -0,0 +1,161 @@
+import json
+import os
+
+import charset_normalizer
+import docx
+import markdown
+import PyPDF2
+import yaml
+from bs4 import BeautifulSoup
+from pylatexenc.latex2text import LatexNodes2Text
+
+from autogpt import logs
+from autogpt.logs import logger
+
+
+class ParserStrategy:
+    def read(self, file_path: str) -> str:
+        raise NotImplementedError
+
+
+# Basic text file reading
+class TXTParser(ParserStrategy):
+    def read(self, file_path: str) -> str:
+        charset_match = charset_normalizer.from_path(file_path).best()
+        logger.debug(f"Reading '{file_path}' with encoding '{charset_match.encoding}'")
+        return str(charset_match)
+
+
+# Reading text from binary file using pdf parser
+class PDFParser(ParserStrategy):
+    def read(self, file_path: str) -> str:
+        parser = PyPDF2.PdfReader(file_path)
+        text = ""
+        for page_idx in range(len(parser.pages)):
+            text += parser.pages[page_idx].extract_text()
+        return text
+
+
+# Reading text from binary file using docs parser
+class DOCXParser(ParserStrategy):
+    def read(self, file_path: str) -> str:
+        doc_file = docx.Document(file_path)
+        text = ""
+        for para in doc_file.paragraphs:
+            text += para.text
+        return text
+
+
+# Reading as dictionary and returning string format
+class JSONParser(ParserStrategy):
+    def read(self, file_path: str) -> str:
+        with open(file_path, "r") as f:
+            data = json.load(f)
+            text = str(data)
+        return text
+
+
+class XMLParser(ParserStrategy):
+    def read(self, file_path: str) -> str:
+        with open(file_path, "r") as f:
+            soup = BeautifulSoup(f, "xml")
+            text = soup.get_text()
+        return text
+
+
+# Reading as dictionary and returning string format
+class YAMLParser(ParserStrategy):
+    def read(self, file_path: str) -> str:
+        with open(file_path, "r") as f:
+            data = yaml.load(f, Loader=yaml.FullLoader)
+            text = str(data)
+        return text
+
+
+class HTMLParser(ParserStrategy):
+    def read(self, file_path: str) -> str:
+        with open(file_path, "r") as f:
+            soup = BeautifulSoup(f, "html.parser")
+            text = soup.get_text()
+        return text
+
+
+class MarkdownParser(ParserStrategy):
+    def read(self, file_path: str) -> str:
+        with open(file_path, "r") as f:
+            html = markdown.markdown(f.read())
+            text = "".join(BeautifulSoup(html, "html.parser").findAll(string=True))
+        return text
+
+
+class LaTeXParser(ParserStrategy):
+    def read(self, file_path: str) -> str:
+        with open(file_path, "r") as f:
+            latex = f.read()
+        text = LatexNodes2Text().latex_to_text(latex)
+        return text
+
+
+class FileContext:
+    def __init__(self, parser: ParserStrategy, logger: logs.Logger):
+        self.parser = parser
+        self.logger = logger
+
+    def set_parser(self, parser: ParserStrategy) -> None:
+        self.logger.debug(f"Setting Context Parser to {parser}")
+        self.parser = parser
+
+    def read_file(self, file_path) -> str:
+        self.logger.debug(f"Reading file {file_path} with parser {self.parser}")
+        return self.parser.read(file_path)
+
+
+extension_to_parser = {
+    ".txt": TXTParser(),
+    ".csv": TXTParser(),
+    ".pdf": PDFParser(),
+    ".docx": DOCXParser(),
+    ".json": JSONParser(),
+    ".xml": XMLParser(),
+    ".yaml": YAMLParser(),
+    ".yml": YAMLParser(),
+    ".html": HTMLParser(),
+    ".htm": HTMLParser(),
+    ".xhtml": HTMLParser(),
+    ".md": MarkdownParser(),
+    ".markdown": MarkdownParser(),
+    ".tex": LaTeXParser(),
+}
+
+
+def is_file_binary_fn(file_path: str):
+    """Given a file path load all its content and checks if the null bytes is present
+
+    Args:
+        file_path (_type_): _description_
+
+    Returns:
+        bool: is_binary
+    """
+    with open(file_path, "rb") as f:
+        file_data = f.read()
+    if b"\x00" in file_data:
+        return True
+    return False
+
+
+def read_textual_file(file_path: str, logger: logs.Logger) -> str:
+    if not os.path.isfile(file_path):
+        raise FileNotFoundError(
+            f"read_file {file_path} failed: no such file or directory"
+        )
+    is_binary = is_file_binary_fn(file_path)
+    file_extension = os.path.splitext(file_path)[1].lower()
+    parser = extension_to_parser.get(file_extension)
+    if not parser:
+        if is_binary:
+            raise ValueError(f"Unsupported binary file format: {file_extension}")
+        # fallback to txt file parser (to support script and code files loading)
+        parser = TXTParser()
+    file_context = FileContext(parser, logger)
+    return file_context.read_file(file_path)

autogpt/commands/git_operations.py

@@ -0,0 +1,52 @@
+"""Git operations for autogpt"""
+
+from git.repo import Repo
+
+from autogpt.agents.agent import Agent
+from autogpt.command_decorator import command
+from autogpt.url_utils.validators import validate_url
+
+from .decorators import sanitize_path_arg
+
+
+@command(
+    "clone_repository",
+    "Clones a Repository",
+    {
+        "url": {
+            "type": "string",
+            "description": "The URL of the repository to clone",
+            "required": True,
+        },
+        "clone_path": {
+            "type": "string",
+            "description": "The path to clone the repository to",
+            "required": True,
+        },
+    },
+    lambda config: bool(config.github_username and config.github_api_key),
+    "Configure github_username and github_api_key.",
+)
+@sanitize_path_arg("clone_path")
+@validate_url
+def clone_repository(url: str, clone_path: str, agent: Agent) -> str:
+    """Clone a GitHub repository locally.
+
+    Args:
+        url (str): The URL of the repository to clone.
+        clone_path (str): The path to clone the repository to.
+
+    Returns:
+        str: The result of the clone operation.
+    """
+    split_url = url.split("//")
+    auth_repo_url = (
+        f"//{agent.config.github_username}:{agent.config.github_api_key}@".join(
+            split_url
+        )
+    )
+    try:
+        Repo.clone_from(url=auth_repo_url, to_path=clone_path)
+        return f"""Cloned {url} to {clone_path}"""
+    except Exception as e:
+        return f"Error: {str(e)}"

autogpt/commands/image_gen.py

@@ -0,0 +1,200 @@
+""" Image Generation Module for AutoGPT."""
+import io
+import json
+import time
+import uuid
+from base64 import b64decode
+
+import openai
+import requests
+from PIL import Image
+
+from autogpt.agents.agent import Agent
+from autogpt.command_decorator import command
+from autogpt.logs import logger
+
+
+@command(
+    "generate_image",
+    "Generates an Image",
+    {
+        "prompt": {
+            "type": "string",
+            "description": "The prompt used to generate the image",
+            "required": True,
+        },
+    },
+    lambda config: bool(config.image_provider),
+    "Requires a image provider to be set.",
+)
+def generate_image(prompt: str, agent: Agent, size: int = 256) -> str:
+    """Generate an image from a prompt.
+
+    Args:
+        prompt (str): The prompt to use
+        size (int, optional): The size of the image. Defaults to 256. (Not supported by HuggingFace)
+
+    Returns:
+        str: The filename of the image
+    """
+    filename = agent.config.workspace_path / f"{str(uuid.uuid4())}.jpg"
+
+    # DALL-E
+    if agent.config.image_provider == "dalle":
+        return generate_image_with_dalle(prompt, filename, size, agent)
+    # HuggingFace
+    elif agent.config.image_provider == "huggingface":
+        return generate_image_with_hf(prompt, filename, agent)
+    # SD WebUI
+    elif agent.config.image_provider == "sdwebui":
+        return generate_image_with_sd_webui(prompt, filename, agent, size)
+    return "No Image Provider Set"
+
+
+def generate_image_with_hf(prompt: str, filename: str, agent: Agent) -> str:
+    """Generate an image with HuggingFace's API.
+
+    Args:
+        prompt (str): The prompt to use
+        filename (str): The filename to save the image to
+
+    Returns:
+        str: The filename of the image
+    """
+    API_URL = f"https://api-inference.huggingface.co/models/{agent.config.huggingface_image_model}"
+    if agent.config.huggingface_api_token is None:
+        raise ValueError(
+            "You need to set your Hugging Face API token in the config file."
+        )
+    headers = {
+        "Authorization": f"Bearer {agent.config.huggingface_api_token}",
+        "X-Use-Cache": "false",
+    }
+
+    retry_count = 0
+    while retry_count < 10:
+        response = requests.post(
+            API_URL,
+            headers=headers,
+            json={
+                "inputs": prompt,
+            },
+        )
+
+        if response.ok:
+            try:
+                image = Image.open(io.BytesIO(response.content))
+                logger.info(f"Image Generated for prompt:{prompt}")
+                image.save(filename)
+                return f"Saved to disk:{filename}"
+            except Exception as e:
+                logger.error(e)
+                break
+        else:
+            try:
+                error = json.loads(response.text)
+                if "estimated_time" in error:
+                    delay = error["estimated_time"]
+                    logger.debug(response.text)
+                    logger.info("Retrying in", delay)
+                    time.sleep(delay)
+                else:
+                    break
+            except Exception as e:
+                logger.error(e)
+                break
+
+        retry_count += 1
+
+    return f"Error creating image."
+
+
+def generate_image_with_dalle(
+    prompt: str, filename: str, size: int, agent: Agent
+) -> str:
+    """Generate an image with DALL-E.
+
+    Args:
+        prompt (str): The prompt to use
+        filename (str): The filename to save the image to
+        size (int): The size of the image
+
+    Returns:
+        str: The filename of the image
+    """
+
+    # Check for supported image sizes
+    if size not in [256, 512, 1024]:
+        closest = min([256, 512, 1024], key=lambda x: abs(x - size))
+        logger.info(
+            f"DALL-E only supports image sizes of 256x256, 512x512, or 1024x1024. Setting to {closest}, was {size}."
+        )
+        size = closest
+
+    response = openai.Image.create(
+        prompt=prompt,
+        n=1,
+        size=f"{size}x{size}",
+        response_format="b64_json",
+        api_key=agent.config.openai_api_key,
+    )
+
+    logger.info(f"Image Generated for prompt:{prompt}")
+
+    image_data = b64decode(response["data"][0]["b64_json"])
+
+    with open(filename, mode="wb") as png:
+        png.write(image_data)
+
+    return f"Saved to disk:{filename}"
+
+
+def generate_image_with_sd_webui(
+    prompt: str,
+    filename: str,
+    agent: Agent,
+    size: int = 512,
+    negative_prompt: str = "",
+    extra: dict = {},
+) -> str:
+    """Generate an image with Stable Diffusion webui.
+    Args:
+        prompt (str): The prompt to use
+        filename (str): The filename to save the image to
+        size (int, optional): The size of the image. Defaults to 256.
+        negative_prompt (str, optional): The negative prompt to use. Defaults to "".
+        extra (dict, optional): Extra parameters to pass to the API. Defaults to {}.
+    Returns:
+        str: The filename of the image
+    """
+    # Create a session and set the basic auth if needed
+    s = requests.Session()
+    if agent.config.sd_webui_auth:
+        username, password = agent.config.sd_webui_auth.split(":")
+        s.auth = (username, password or "")
+
+    # Generate the images
+    response = requests.post(
+        f"{agent.config.sd_webui_url}/sdapi/v1/txt2img",
+        json={
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "sampler_index": "DDIM",
+            "steps": 20,
+            "config_scale": 7.0,
+            "width": size,
+            "height": size,
+            "n_iter": 1,
+            **extra,
+        },
+    )
+
+    logger.info(f"Image Generated for prompt:{prompt}")
+
+    # Save the image to disk
+    response = response.json()
+    b64 = b64decode(response["images"][0].split(",", 1)[0])
+    image = Image.open(io.BytesIO(b64))
+    image.save(filename)
+
+    return f"Saved to disk:{filename}"

autogpt/commands/task_statuses.py

@@ -0,0 +1,33 @@
+"""Task Statuses module."""
+from __future__ import annotations
+
+from typing import NoReturn
+
+from autogpt.agents.agent import Agent
+from autogpt.command_decorator import command
+from autogpt.logs import logger
+
+
+@command(
+    "goals_accomplished",
+    "Goals are accomplished and there is nothing left to do",
+    {
+        "reason": {
+            "type": "string",
+            "description": "A summary to the user of how the goals were accomplished",
+            "required": True,
+        }
+    },
+)
+def task_complete(reason: str, agent: Agent) -> NoReturn:
+    """
+    A function that takes in a string and exits the program
+
+    Parameters:
+        reason (str): A summary to the user of how the goals were accomplished.
+    Returns:
+        A result string from create chat completion. A list of suggestions to
+            improve the code.
+    """
+    logger.info(title="Shutting down...\n", message=reason)
+    quit()

autogpt/commands/times.py

@@ -0,0 +1,10 @@
+from datetime import datetime
+
+
+def get_datetime() -> str:
+    """Return the current date and time
+
+    Returns:
+        str: The current date and time
+    """
+    return "Current date and time: " + datetime.now().strftime("%Y-%m-%d %H:%M:%S")

autogpt/commands/web_search.py

@@ -0,0 +1,143 @@
+"""Google search command for Autogpt."""
+from __future__ import annotations
+
+import json
+import time
+from itertools import islice
+
+from duckduckgo_search import DDGS
+
+from autogpt.agents.agent import Agent
+from autogpt.command_decorator import command
+
+DUCKDUCKGO_MAX_ATTEMPTS = 3
+
+
+@command(
+    "web_search",
+    "Searches the web",
+    {
+        "query": {
+            "type": "string",
+            "description": "The search query",
+            "required": True,
+        }
+    },
+    aliases=["search"],
+)
+def web_search(query: str, agent: Agent, num_results: int = 8) -> str:
+    """Return the results of a Google search
+
+    Args:
+        query (str): The search query.
+        num_results (int): The number of results to return.
+
+    Returns:
+        str: The results of the search.
+    """
+    search_results = []
+    attempts = 0
+
+    while attempts < DUCKDUCKGO_MAX_ATTEMPTS:
+        if not query:
+            return json.dumps(search_results)
+
+        results = DDGS().text(query)
+        search_results = list(islice(results, num_results))
+
+        if search_results:
+            break
+
+        time.sleep(1)
+        attempts += 1
+
+    results = json.dumps(search_results, ensure_ascii=False, indent=4)
+    return safe_google_results(results)
+
+
+@command(
+    "google",
+    "Google Search",
+    {
+        "query": {
+            "type": "string",
+            "description": "The search query",
+            "required": True,
+        }
+    },
+    lambda config: bool(config.google_api_key)
+    and bool(config.google_custom_search_engine_id),
+    "Configure google_api_key and custom_search_engine_id.",
+    aliases=["search"],
+)
+def google(query: str, agent: Agent, num_results: int = 8) -> str | list[str]:
+    """Return the results of a Google search using the official Google API
+
+    Args:
+        query (str): The search query.
+        num_results (int): The number of results to return.
+
+    Returns:
+        str: The results of the search.
+    """
+
+    from googleapiclient.discovery import build
+    from googleapiclient.errors import HttpError
+
+    try:
+        # Get the Google API key and Custom Search Engine ID from the config file
+        api_key = agent.config.google_api_key
+        custom_search_engine_id = agent.config.google_custom_search_engine_id
+
+        # Initialize the Custom Search API service
+        service = build("customsearch", "v1", developerKey=api_key)
+
+        # Send the search query and retrieve the results
+        result = (
+            service.cse()
+            .list(q=query, cx=custom_search_engine_id, num=num_results)
+            .execute()
+        )
+
+        # Extract the search result items from the response
+        search_results = result.get("items", [])
+
+        # Create a list of only the URLs from the search results
+        search_results_links = [item["link"] for item in search_results]
+
+    except HttpError as e:
+        # Handle errors in the API call
+        error_details = json.loads(e.content.decode())
+
+        # Check if the error is related to an invalid or missing API key
+        if error_details.get("error", {}).get(
+            "code"
+        ) == 403 and "invalid API key" in error_details.get("error", {}).get(
+            "message", ""
+        ):
+            return "Error: The provided Google API key is invalid or missing."
+        else:
+            return f"Error: {e}"
+    # google_result can be a list or a string depending on the search results
+
+    # Return the list of search result URLs
+    return safe_google_results(search_results_links)
+
+
+def safe_google_results(results: str | list) -> str:
+    """
+        Return the results of a Google search in a safe format.
+
+    Args:
+        results (str | list): The search results.
+
+    Returns:
+        str: The results of the search.
+    """
+    if isinstance(results, list):
+        safe_message = json.dumps(
+            [result.encode("utf-8", "ignore").decode("utf-8") for result in results]
+        )
+    else:
+        safe_message = results.encode("utf-8", "ignore").decode("utf-8")
+    return safe_message

autogpt/commands/web_selenium.py

@@ -0,0 +1,237 @@
+"""Selenium web scraping module."""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from sys import platform
+from typing import Optional, Type
+
+from bs4 import BeautifulSoup
+from selenium.common.exceptions import WebDriverException
+from selenium.webdriver.chrome.options import Options as ChromeOptions
+from selenium.webdriver.chrome.service import Service as ChromeDriverService
+from selenium.webdriver.chrome.webdriver import WebDriver as ChromeDriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.edge.options import Options as EdgeOptions
+from selenium.webdriver.edge.service import Service as EdgeDriverService
+from selenium.webdriver.edge.webdriver import WebDriver as EdgeDriver
+from selenium.webdriver.firefox.options import Options as FirefoxOptions
+from selenium.webdriver.firefox.service import Service as GeckoDriverService
+from selenium.webdriver.firefox.webdriver import WebDriver as FirefoxDriver
+from selenium.webdriver.remote.webdriver import WebDriver
+from selenium.webdriver.safari.options import Options as SafariOptions
+from selenium.webdriver.safari.webdriver import WebDriver as SafariDriver
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.wait import WebDriverWait
+from webdriver_manager.chrome import ChromeDriverManager
+from webdriver_manager.firefox import GeckoDriverManager
+from webdriver_manager.microsoft import EdgeChromiumDriverManager as EdgeDriverManager
+
+from autogpt.agents.agent import Agent
+from autogpt.command_decorator import command
+from autogpt.logs import logger
+from autogpt.memory.vector import MemoryItem, get_memory
+from autogpt.processing.html import extract_hyperlinks, format_hyperlinks
+from autogpt.url_utils.validators import validate_url
+
+BrowserOptions = ChromeOptions | EdgeOptions | FirefoxOptions | SafariOptions
+
+FILE_DIR = Path(__file__).parent.parent
+
+
+@command(
+    "browse_website",
+    "Browses a Website",
+    {
+        "url": {"type": "string", "description": "The URL to visit", "required": True},
+        "question": {
+            "type": "string",
+            "description": "What you want to find on the website",
+            "required": True,
+        },
+    },
+)
+@validate_url
+def browse_website(url: str, question: str, agent: Agent) -> str:
+    """Browse a website and return the answer and links to the user
+
+    Args:
+        url (str): The url of the website to browse
+        question (str): The question asked by the user
+
+    Returns:
+        Tuple[str, WebDriver]: The answer and links to the user and the webdriver
+    """
+    try:
+        driver, text = scrape_text_with_selenium(url, agent)
+    except WebDriverException as e:
+        # These errors are often quite long and include lots of context.
+        # Just grab the first line.
+        msg = e.msg.split("\n")[0]
+        return f"Error: {msg}"
+
+    add_header(driver)
+    summary = summarize_memorize_webpage(url, text, question, agent, driver)
+    links = scrape_links_with_selenium(driver, url)
+
+    # Limit links to 5
+    if len(links) > 5:
+        links = links[:5]
+    close_browser(driver)
+    return f"Answer gathered from website: {summary}\n\nLinks: {links}"
+
+
+def scrape_text_with_selenium(url: str, agent: Agent) -> tuple[WebDriver, str]:
+    """Scrape text from a website using selenium
+
+    Args:
+        url (str): The url of the website to scrape
+
+    Returns:
+        Tuple[WebDriver, str]: The webdriver and the text scraped from the website
+    """
+    logging.getLogger("selenium").setLevel(logging.CRITICAL)
+
+    options_available: dict[str, Type[BrowserOptions]] = {
+        "chrome": ChromeOptions,
+        "edge": EdgeOptions,
+        "firefox": FirefoxOptions,
+        "safari": SafariOptions,
+    }
+
+    options: BrowserOptions = options_available[agent.config.selenium_web_browser]()
+    options.add_argument(
+        "user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.5615.49 Safari/537.36"
+    )
+
+    if agent.config.selenium_web_browser == "firefox":
+        if agent.config.selenium_headless:
+            options.headless = True
+            options.add_argument("--disable-gpu")
+        driver = FirefoxDriver(
+            service=GeckoDriverService(GeckoDriverManager().install()), options=options
+        )
+    elif agent.config.selenium_web_browser == "edge":
+        driver = EdgeDriver(
+            service=EdgeDriverService(EdgeDriverManager().install()), options=options
+        )
+    elif agent.config.selenium_web_browser == "safari":
+        # Requires a bit more setup on the users end
+        # See https://developer.apple.com/documentation/webkit/testing_with_webdriver_in_safari
+        driver = SafariDriver(options=options)
+    else:
+        if platform == "linux" or platform == "linux2":
+            options.add_argument("--disable-dev-shm-usage")
+            options.add_argument("--remote-debugging-port=9222")
+
+        options.add_argument("--no-sandbox")
+        if agent.config.selenium_headless:
+            options.add_argument("--headless=new")
+            options.add_argument("--disable-gpu")
+
+        chromium_driver_path = Path("/usr/bin/chromedriver")
+
+        driver = ChromeDriver(
+            service=ChromeDriverService(str(chromium_driver_path))
+            if chromium_driver_path.exists()
+            else ChromeDriverService(ChromeDriverManager().install()),
+            options=options,
+        )
+    driver.get(url)
+
+    WebDriverWait(driver, 10).until(
+        EC.presence_of_element_located((By.TAG_NAME, "body"))
+    )
+
+    # Get the HTML content directly from the browser's DOM
+    page_source = driver.execute_script("return document.body.outerHTML;")
+    soup = BeautifulSoup(page_source, "html.parser")
+
+    for script in soup(["script", "style"]):
+        script.extract()
+
+    text = soup.get_text()
+    lines = (line.strip() for line in text.splitlines())
+    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+    text = "\n".join(chunk for chunk in chunks if chunk)
+    return driver, text
+
+
+def scrape_links_with_selenium(driver: WebDriver, url: str) -> list[str]:
+    """Scrape links from a website using selenium
+
+    Args:
+        driver (WebDriver): The webdriver to use to scrape the links
+
+    Returns:
+        List[str]: The links scraped from the website
+    """
+    page_source = driver.page_source
+    soup = BeautifulSoup(page_source, "html.parser")
+
+    for script in soup(["script", "style"]):
+        script.extract()
+
+    hyperlinks = extract_hyperlinks(soup, url)
+
+    return format_hyperlinks(hyperlinks)
+
+
+def close_browser(driver: WebDriver) -> None:
+    """Close the browser
+
+    Args:
+        driver (WebDriver): The webdriver to close
+
+    Returns:
+        None
+    """
+    driver.quit()
+
+
+def add_header(driver: WebDriver) -> None:
+    """Add a header to the website
+
+    Args:
+        driver (WebDriver): The webdriver to use to add the header
+
+    Returns:
+        None
+    """
+    try:
+        with open(f"{FILE_DIR}/js/overlay.js", "r") as overlay_file:
+            overlay_script = overlay_file.read()
+        driver.execute_script(overlay_script)
+    except Exception as e:
+        print(f"Error executing overlay.js: {e}")
+
+
+def summarize_memorize_webpage(
+    url: str,
+    text: str,
+    question: str,
+    agent: Agent,
+    driver: Optional[WebDriver] = None,
+) -> str:
+    """Summarize text using the OpenAI API
+
+    Args:
+        url (str): The url of the text
+        text (str): The text to summarize
+        question (str): The question to ask the model
+        driver (WebDriver): The webdriver to use to scroll the page
+
+    Returns:
+        str: The summary of the text
+    """
+    if not text:
+        return "Error: No text to summarize"
+
+    text_length = len(text)
+    logger.info(f"Text length: {text_length} characters")
+
+    memory = get_memory(agent.config)
+
+    new_memory = MemoryItem.from_webpage(text, url, agent.config, question=question)
+    memory.add(new_memory)
+    return new_memory.summary

autogpt/config/__init__.py

@@ -0,0 +1,12 @@
+"""
+This module contains the configuration classes for AutoGPT.
+"""
+from .ai_config import AIConfig
+from .config import Config, ConfigBuilder, check_openai_api_key
+
+__all__ = [
+    "check_openai_api_key",
+    "AIConfig",
+    "Config",
+    "ConfigBuilder",
+]

autogpt/config/ai_config.py

@@ -0,0 +1,159 @@
+# sourcery skip: do-not-use-staticmethod
+"""
+A module that contains the AIConfig class object that contains the configuration
+"""
+from __future__ import annotations
+
+import platform
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+import distro
+import yaml
+
+if TYPE_CHECKING:
+    from autogpt.models.command_registry import CommandRegistry
+    from autogpt.prompts.generator import PromptGenerator
+
+
+class AIConfig:
+    """
+    A class object that contains the configuration information for the AI
+
+    Attributes:
+        ai_name (str): The name of the AI.
+        ai_role (str): The description of the AI's role.
+        ai_goals (list): The list of objectives the AI is supposed to complete.
+        api_budget (float): The maximum dollar value for API calls (0.0 means infinite)
+    """
+
+    def __init__(
+        self,
+        ai_name: str = "",
+        ai_role: str = "",
+        ai_goals: list[str] = [],
+        api_budget: float = 0.0,
+    ) -> None:
+        """
+        Initialize a class instance
+
+        Parameters:
+            ai_name (str): The name of the AI.
+            ai_role (str): The description of the AI's role.
+            ai_goals (list): The list of objectives the AI is supposed to complete.
+            api_budget (float): The maximum dollar value for API calls (0.0 means infinite)
+        Returns:
+            None
+        """
+        self.ai_name = ai_name
+        self.ai_role = ai_role
+        self.ai_goals = ai_goals
+        self.api_budget = api_budget
+        self.prompt_generator: PromptGenerator | None = None
+        self.command_registry: CommandRegistry | None = None
+
+    @staticmethod
+    def load(ai_settings_file: str | Path) -> "AIConfig":
+        """
+        Returns class object with parameters (ai_name, ai_role, ai_goals, api_budget)
+        loaded from yaml file if yaml file exists, else returns class with no parameters.
+
+        Parameters:
+            ai_settings_file (Path): The path to the config yaml file.
+
+        Returns:
+            cls (object): An instance of given cls object
+        """
+
+        try:
+            with open(ai_settings_file, encoding="utf-8") as file:
+                config_params = yaml.load(file, Loader=yaml.FullLoader) or {}
+        except FileNotFoundError:
+            config_params = {}
+
+        ai_name = config_params.get("ai_name", "")
+        ai_role = config_params.get("ai_role", "")
+        ai_goals = [
+            str(goal).strip("{}").replace("'", "").replace('"', "")
+            if isinstance(goal, dict)
+            else str(goal)
+            for goal in config_params.get("ai_goals", [])
+        ]
+        api_budget = config_params.get("api_budget", 0.0)
+
+        return AIConfig(ai_name, ai_role, ai_goals, api_budget)
+
+    def save(self, ai_settings_file: str | Path) -> None:
+        """
+        Saves the class parameters to the specified file yaml file path as a yaml file.
+
+        Parameters:
+            ai_settings_file (Path): The path to the config yaml file.
+
+        Returns:
+            None
+        """
+
+        config = {
+            "ai_name": self.ai_name,
+            "ai_role": self.ai_role,
+            "ai_goals": self.ai_goals,
+            "api_budget": self.api_budget,
+        }
+        with open(ai_settings_file, "w", encoding="utf-8") as file:
+            yaml.dump(config, file, allow_unicode=True)
+
+    def construct_full_prompt(
+        self, config, prompt_generator: Optional[PromptGenerator] = None
+    ) -> str:
+        """
+        Returns a prompt to the user with the class information in an organized fashion.
+
+        Parameters:
+            None
+
+        Returns:
+            full_prompt (str): A string containing the initial prompt for the user
+              including the ai_name, ai_role, ai_goals, and api_budget.
+        """
+
+        prompt_start = (
+            "Your decisions must always be made independently without"
+            " seeking user assistance. Play to your strengths as an LLM and pursue"
+            " simple strategies with no legal complications."
+            ""
+        )
+
+        from autogpt.prompts.prompt import build_default_prompt_generator
+
+        if prompt_generator is None:
+            prompt_generator = build_default_prompt_generator(config)
+        prompt_generator.goals = self.ai_goals
+        prompt_generator.name = self.ai_name
+        prompt_generator.role = self.ai_role
+        prompt_generator.command_registry = self.command_registry
+        for plugin in config.plugins:
+            if not plugin.can_handle_post_prompt():
+                continue
+            prompt_generator = plugin.post_prompt(prompt_generator)
+
+        if config.execute_local_commands:
+            # add OS info to prompt
+            os_name = platform.system()
+            os_info = (
+                platform.platform(terse=True)
+                if os_name != "Linux"
+                else distro.name(pretty=True)
+            )
+
+            prompt_start += f"\nThe OS you are running on is: {os_info}"
+
+        # Construct full prompt
+        full_prompt = f"You are {prompt_generator.name}, {prompt_generator.role}\n{prompt_start}\n\nGOALS:\n\n"
+        for i, goal in enumerate(self.ai_goals):
+            full_prompt += f"{i+1}. {goal}\n"
+        if self.api_budget > 0.0:
+            full_prompt += f"\nIt takes money to let you run. Your API budget is ${self.api_budget:.3f}"
+        self.prompt_generator = prompt_generator
+        full_prompt += f"\n\n{prompt_generator.generate_prompt_string(config)}"
+        return full_prompt

autogpt/config/config.py

@@ -0,0 +1,399 @@
+"""Configuration class to store the state of bools for different scripts access."""
+from __future__ import annotations
+
+import contextlib
+import os
+import re
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+import yaml
+from auto_gpt_plugin_template import AutoGPTPluginTemplate
+from colorama import Fore
+from pydantic import Field, validator
+
+from autogpt.core.configuration.schema import Configurable, SystemSettings
+from autogpt.plugins.plugins_config import PluginsConfig
+
+AI_SETTINGS_FILE = "ai_settings.yaml"
+AZURE_CONFIG_FILE = "azure.yaml"
+PLUGINS_CONFIG_FILE = "plugins_config.yaml"
+PROMPT_SETTINGS_FILE = "prompt_settings.yaml"
+
+GPT_4_MODEL = "gpt-4"
+GPT_3_MODEL = "gpt-3.5-turbo"
+
+
+class Config(SystemSettings, arbitrary_types_allowed=True):
+    name: str = "Auto-GPT configuration"
+    description: str = "Default configuration for the Auto-GPT application."
+    ########################
+    # Application Settings #
+    ########################
+    skip_news: bool = False
+    skip_reprompt: bool = False
+    authorise_key: str = "y"
+    exit_key: str = "n"
+    debug_mode: bool = False
+    plain_output: bool = False
+    chat_messages_enabled: bool = True
+    # TTS configuration
+    speak_mode: bool = False
+    text_to_speech_provider: str = "gtts"
+    streamelements_voice: str = "Brian"
+    elevenlabs_voice_id: Optional[str] = None
+
+    ##########################
+    # Agent Control Settings #
+    ##########################
+    # Paths
+    ai_settings_file: str = AI_SETTINGS_FILE
+    prompt_settings_file: str = PROMPT_SETTINGS_FILE
+    workdir: Path = None
+    workspace_path: Optional[Path] = None
+    file_logger_path: Optional[str] = None
+    # Model configuration
+    fast_llm: str = "gpt-3.5-turbo"
+    smart_llm: str = "gpt-4"
+    temperature: float = 0
+    openai_functions: bool = False
+    embedding_model: str = "text-embedding-ada-002"
+    browse_spacy_language_model: str = "en_core_web_sm"
+    # Run loop configuration
+    continuous_mode: bool = False
+    continuous_limit: int = 0
+
+    ##########
+    # Memory #
+    ##########
+    memory_backend: str = "json_file"
+    memory_index: str = "auto-gpt-memory"
+    redis_host: str = "localhost"
+    redis_port: int = 6379
+    redis_password: str = ""
+    wipe_redis_on_start: bool = True
+
+    ############
+    # Commands #
+    ############
+    # General
+    disabled_command_categories: list[str] = Field(default_factory=list)
+    # File ops
+    restrict_to_workspace: bool = True
+    allow_downloads: bool = False
+    # Shell commands
+    shell_command_control: str = "denylist"
+    execute_local_commands: bool = False
+    shell_denylist: list[str] = Field(default_factory=lambda: ["sudo", "su"])
+    shell_allowlist: list[str] = Field(default_factory=list)
+    # Text to image
+    image_provider: Optional[str] = None
+    huggingface_image_model: str = "CompVis/stable-diffusion-v1-4"
+    sd_webui_url: Optional[str] = "http://localhost:7860"
+    image_size: int = 256
+    # Audio to text
+    audio_to_text_provider: str = "huggingface"
+    huggingface_audio_to_text_model: Optional[str] = None
+    # Web browsing
+    selenium_web_browser: str = "chrome"
+    selenium_headless: bool = True
+    user_agent: str = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36"
+
+    ###################
+    # Plugin Settings #
+    ###################
+    plugins_dir: str = "plugins"
+    plugins_config_file: str = PLUGINS_CONFIG_FILE
+    plugins_config: PluginsConfig = Field(
+        default_factory=lambda: PluginsConfig(plugins={})
+    )
+    plugins: list[AutoGPTPluginTemplate] = Field(default_factory=list, exclude=True)
+    plugins_allowlist: list[str] = Field(default_factory=list)
+    plugins_denylist: list[str] = Field(default_factory=list)
+    plugins_openai: list[str] = Field(default_factory=list)
+
+    ###############
+    # Credentials #
+    ###############
+    # OpenAI
+    openai_api_key: Optional[str] = None
+    openai_api_type: Optional[str] = None
+    openai_api_base: Optional[str] = None
+    openai_api_version: Optional[str] = None
+    openai_organization: Optional[str] = None
+    use_azure: bool = False
+    azure_config_file: Optional[str] = AZURE_CONFIG_FILE
+    azure_model_to_deployment_id_map: Optional[Dict[str, str]] = None
+    # Elevenlabs
+    elevenlabs_api_key: Optional[str] = None
+    # Github
+    github_api_key: Optional[str] = None
+    github_username: Optional[str] = None
+    # Google
+    google_api_key: Optional[str] = None
+    google_custom_search_engine_id: Optional[str] = None
+    # Huggingface
+    huggingface_api_token: Optional[str] = None
+    # Stable Diffusion
+    sd_webui_auth: Optional[str] = None
+
+    @validator("plugins", each_item=True)
+    def validate_plugins(cls, p: AutoGPTPluginTemplate | Any):
+        assert issubclass(
+            p.__class__, AutoGPTPluginTemplate
+        ), f"{p} does not subclass AutoGPTPluginTemplate"
+        assert (
+            p.__class__.__name__ != "AutoGPTPluginTemplate"
+        ), f"Plugins must subclass AutoGPTPluginTemplate; {p} is a template instance"
+        return p
+
+    def get_openai_credentials(self, model: str) -> dict[str, str]:
+        credentials = {
+            "api_key": self.openai_api_key,
+            "api_base": self.openai_api_base,
+            "organization": self.openai_organization,
+        }
+        if self.use_azure:
+            azure_credentials = self.get_azure_credentials(model)
+            credentials.update(azure_credentials)
+        return credentials
+
+    def get_azure_credentials(self, model: str) -> dict[str, str]:
+        """Get the kwargs for the Azure API."""
+
+        # Fix --gpt3only and --gpt4only in combination with Azure
+        fast_llm = (
+            self.fast_llm
+            if not (
+                self.fast_llm == self.smart_llm
+                and self.fast_llm.startswith(GPT_4_MODEL)
+            )
+            else f"not_{self.fast_llm}"
+        )
+        smart_llm = (
+            self.smart_llm
+            if not (
+                self.smart_llm == self.fast_llm
+                and self.smart_llm.startswith(GPT_3_MODEL)
+            )
+            else f"not_{self.smart_llm}"
+        )
+
+        deployment_id = {
+            fast_llm: self.azure_model_to_deployment_id_map.get(
+                "fast_llm_deployment_id",
+                self.azure_model_to_deployment_id_map.get(
+                    "fast_llm_model_deployment_id"  # backwards compatibility
+                ),
+            ),
+            smart_llm: self.azure_model_to_deployment_id_map.get(
+                "smart_llm_deployment_id",
+                self.azure_model_to_deployment_id_map.get(
+                    "smart_llm_model_deployment_id"  # backwards compatibility
+                ),
+            ),
+            self.embedding_model: self.azure_model_to_deployment_id_map.get(
+                "embedding_model_deployment_id"
+            ),
+        }.get(model, None)
+
+        kwargs = {
+            "api_type": self.openai_api_type,
+            "api_base": self.openai_api_base,
+            "api_version": self.openai_api_version,
+        }
+        if model == self.embedding_model:
+            kwargs["engine"] = deployment_id
+        else:
+            kwargs["deployment_id"] = deployment_id
+        return kwargs
+
+
+class ConfigBuilder(Configurable[Config]):
+    default_settings = Config()
+
+    @classmethod
+    def build_config_from_env(cls, workdir: Path) -> Config:
+        """Initialize the Config class"""
+        config_dict = {
+            "workdir": workdir,
+            "authorise_key": os.getenv("AUTHORISE_COMMAND_KEY"),
+            "exit_key": os.getenv("EXIT_KEY"),
+            "plain_output": os.getenv("PLAIN_OUTPUT", "False") == "True",
+            "shell_command_control": os.getenv("SHELL_COMMAND_CONTROL"),
+            "ai_settings_file": os.getenv("AI_SETTINGS_FILE", AI_SETTINGS_FILE),
+            "prompt_settings_file": os.getenv(
+                "PROMPT_SETTINGS_FILE", PROMPT_SETTINGS_FILE
+            ),
+            "fast_llm": os.getenv("FAST_LLM", os.getenv("FAST_LLM_MODEL")),
+            "smart_llm": os.getenv("SMART_LLM", os.getenv("SMART_LLM_MODEL")),
+            "embedding_model": os.getenv("EMBEDDING_MODEL"),
+            "browse_spacy_language_model": os.getenv("BROWSE_SPACY_LANGUAGE_MODEL"),
+            "openai_api_key": os.getenv("OPENAI_API_KEY"),
+            "use_azure": os.getenv("USE_AZURE") == "True",
+            "azure_config_file": os.getenv("AZURE_CONFIG_FILE", AZURE_CONFIG_FILE),
+            "execute_local_commands": os.getenv("EXECUTE_LOCAL_COMMANDS", "False")
+            == "True",
+            "restrict_to_workspace": os.getenv("RESTRICT_TO_WORKSPACE", "True")
+            == "True",
+            "openai_functions": os.getenv("OPENAI_FUNCTIONS", "False") == "True",
+            "elevenlabs_api_key": os.getenv("ELEVENLABS_API_KEY"),
+            "streamelements_voice": os.getenv("STREAMELEMENTS_VOICE"),
+            "text_to_speech_provider": os.getenv("TEXT_TO_SPEECH_PROVIDER"),
+            "github_api_key": os.getenv("GITHUB_API_KEY"),
+            "github_username": os.getenv("GITHUB_USERNAME"),
+            "google_api_key": os.getenv("GOOGLE_API_KEY"),
+            "image_provider": os.getenv("IMAGE_PROVIDER"),
+            "huggingface_api_token": os.getenv("HUGGINGFACE_API_TOKEN"),
+            "huggingface_image_model": os.getenv("HUGGINGFACE_IMAGE_MODEL"),
+            "audio_to_text_provider": os.getenv("AUDIO_TO_TEXT_PROVIDER"),
+            "huggingface_audio_to_text_model": os.getenv(
+                "HUGGINGFACE_AUDIO_TO_TEXT_MODEL"
+            ),
+            "sd_webui_url": os.getenv("SD_WEBUI_URL"),
+            "sd_webui_auth": os.getenv("SD_WEBUI_AUTH"),
+            "selenium_web_browser": os.getenv("USE_WEB_BROWSER"),
+            "selenium_headless": os.getenv("HEADLESS_BROWSER", "True") == "True",
+            "user_agent": os.getenv("USER_AGENT"),
+            "memory_backend": os.getenv("MEMORY_BACKEND"),
+            "memory_index": os.getenv("MEMORY_INDEX"),
+            "redis_host": os.getenv("REDIS_HOST"),
+            "redis_password": os.getenv("REDIS_PASSWORD"),
+            "wipe_redis_on_start": os.getenv("WIPE_REDIS_ON_START", "True") == "True",
+            "plugins_dir": os.getenv("PLUGINS_DIR"),
+            "plugins_config_file": os.getenv(
+                "PLUGINS_CONFIG_FILE", PLUGINS_CONFIG_FILE
+            ),
+            "chat_messages_enabled": os.getenv("CHAT_MESSAGES_ENABLED") == "True",
+        }
+
+        config_dict["disabled_command_categories"] = _safe_split(
+            os.getenv("DISABLED_COMMAND_CATEGORIES")
+        )
+
+        config_dict["shell_denylist"] = _safe_split(
+            os.getenv("SHELL_DENYLIST", os.getenv("DENY_COMMANDS"))
+        )
+        config_dict["shell_allowlist"] = _safe_split(
+            os.getenv("SHELL_ALLOWLIST", os.getenv("ALLOW_COMMANDS"))
+        )
+
+        config_dict["google_custom_search_engine_id"] = os.getenv(
+            "GOOGLE_CUSTOM_SEARCH_ENGINE_ID", os.getenv("CUSTOM_SEARCH_ENGINE_ID")
+        )
+
+        config_dict["elevenlabs_voice_id"] = os.getenv(
+            "ELEVENLABS_VOICE_ID", os.getenv("ELEVENLABS_VOICE_1_ID")
+        )
+        if not config_dict["text_to_speech_provider"]:
+            if os.getenv("USE_MAC_OS_TTS"):
+                default_tts_provider = "macos"
+            elif config_dict["elevenlabs_api_key"]:
+                default_tts_provider = "elevenlabs"
+            elif os.getenv("USE_BRIAN_TTS"):
+                default_tts_provider = "streamelements"
+            else:
+                default_tts_provider = "gtts"
+            config_dict["text_to_speech_provider"] = default_tts_provider
+
+        config_dict["plugins_allowlist"] = _safe_split(os.getenv("ALLOWLISTED_PLUGINS"))
+        config_dict["plugins_denylist"] = _safe_split(os.getenv("DENYLISTED_PLUGINS"))
+
+        with contextlib.suppress(TypeError):
+            config_dict["image_size"] = int(os.getenv("IMAGE_SIZE"))
+        with contextlib.suppress(TypeError):
+            config_dict["redis_port"] = int(os.getenv("REDIS_PORT"))
+        with contextlib.suppress(TypeError):
+            config_dict["temperature"] = float(os.getenv("TEMPERATURE"))
+
+        if config_dict["use_azure"]:
+            azure_config = cls.load_azure_config(
+                workdir / config_dict["azure_config_file"]
+            )
+            config_dict.update(azure_config)
+
+        elif os.getenv("OPENAI_API_BASE_URL"):
+            config_dict["openai_api_base"] = os.getenv("OPENAI_API_BASE_URL")
+
+        openai_organization = os.getenv("OPENAI_ORGANIZATION")
+        if openai_organization is not None:
+            config_dict["openai_organization"] = openai_organization
+
+        config_dict_without_none_values = {
+            k: v for k, v in config_dict.items() if v is not None
+        }
+
+        config = cls.build_agent_configuration(config_dict_without_none_values)
+
+        # Set secondary config variables (that depend on other config variables)
+
+        config.plugins_config = PluginsConfig.load_config(
+            config.workdir / config.plugins_config_file,
+            config.plugins_denylist,
+            config.plugins_allowlist,
+        )
+
+        return config
+
+    @classmethod
+    def load_azure_config(cls, config_file: Path) -> Dict[str, str]:
+        """
+        Loads the configuration parameters for Azure hosting from the specified file
+          path as a yaml file.
+
+        Parameters:
+            config_file (Path): The path to the config yaml file.
+
+        Returns:
+            Dict
+        """
+        with open(config_file) as file:
+            config_params = yaml.load(file, Loader=yaml.FullLoader) or {}
+
+        return {
+            "openai_api_type": config_params.get("azure_api_type", "azure"),
+            "openai_api_base": config_params.get("azure_api_base", ""),
+            "openai_api_version": config_params.get(
+                "azure_api_version", "2023-03-15-preview"
+            ),
+            "azure_model_to_deployment_id_map": config_params.get(
+                "azure_model_map", {}
+            ),
+        }
+
+
+def check_openai_api_key(config: Config) -> None:
+    """Check if the OpenAI API key is set in config.py or as an environment variable."""
+    if not config.openai_api_key:
+        print(
+            Fore.RED
+            + "Please set your OpenAI API key in .env or as an environment variable."
+            + Fore.RESET
+        )
+        print("You can get your key from https://platform.openai.com/account/api-keys")
+        openai_api_key = input(
+            "If you do have the key, please enter your OpenAI API key now:\n"
+        )
+        key_pattern = r"^sk-\w{48}"
+        openai_api_key = openai_api_key.strip()
+        if re.search(key_pattern, openai_api_key):
+            os.environ["OPENAI_API_KEY"] = openai_api_key
+            config.openai_api_key = openai_api_key
+            print(
+                Fore.GREEN
+                + "OpenAI API key successfully set!\n"
+                + Fore.YELLOW
+                + "NOTE: The API key you've set is only temporary.\n"
+                + "For longer sessions, please set it in .env file"
+                + Fore.RESET
+            )
+        else:
+            print("Invalid OpenAI API key!")
+            exit(1)
+
+
+def _safe_split(s: Union[str, None], sep: str = ",") -> list[str]:
+    """Split a string by a separator. Return an empty list if the string is None."""
+    if s is None:
+        return []
+    return s.split(sep)

autogpt/config/prompt_config.py

@@ -0,0 +1,47 @@
+# sourcery skip: do-not-use-staticmethod
+"""
+A module that contains the PromptConfig class object that contains the configuration
+"""
+import yaml
+from colorama import Fore
+
+from autogpt import utils
+from autogpt.logs import logger
+
+
+class PromptConfig:
+    """
+    A class object that contains the configuration information for the prompt, which will be used by the prompt generator
+
+    Attributes:
+        constraints (list): Constraints list for the prompt generator.
+        resources (list): Resources list for the prompt generator.
+        performance_evaluations (list): Performance evaluation list for the prompt generator.
+    """
+
+    def __init__(self, prompt_settings_file: str) -> None:
+        """
+        Initialize a class instance with parameters (constraints, resources, performance_evaluations) loaded from
+          yaml file if yaml file exists,
+        else raises error.
+
+        Parameters:
+            constraints (list): Constraints list for the prompt generator.
+            resources (list): Resources list for the prompt generator.
+            performance_evaluations (list): Performance evaluation list for the prompt generator.
+        Returns:
+            None
+        """
+        # Validate file
+        (validated, message) = utils.validate_yaml_file(prompt_settings_file)
+        if not validated:
+            logger.typewriter_log("FAILED FILE VALIDATION", Fore.RED, message)
+            logger.double_check()
+            exit(1)
+
+        with open(prompt_settings_file, encoding="utf-8") as file:
+            config_params = yaml.load(file, Loader=yaml.FullLoader)
+
+        self.constraints = config_params.get("constraints", [])
+        self.resources = config_params.get("resources", [])
+        self.performance_evaluations = config_params.get("performance_evaluations", [])

autogpt/core/ARCHITECTURE_NOTES.md

@@ -0,0 +1,272 @@
+# Re-architecture Notes
+
+## Key Documents
+
+- [Planned Agent Workflow](https://whimsical.com/agent-workflow-v2-NmnTQ8R7sVo7M3S43XgXmZ)
+- [Original Architecture Diagram](https://www.figma.com/file/fwdj44tPR7ArYtnGGUKknw/Modular-Architecture?type=whiteboard&node-id=0-1) - This is sadly well out of date at this point.
+- [Kanban](https://github.com/orgs/Significant-Gravitas/projects/1/views/1?filterQuery=label%3Are-arch)
+
+## The Motivation
+
+The `master` branch of Auto-GPT is an organically grown amalgamation of many thoughts 
+and ideas about agent-driven autonomous systems.  It lacks clear abstraction boundaries, 
+has issues of global state and poorly encapsulated state, and is generally just hard to 
+make effective changes to.  Mainly it's just a system that's hard to make changes to.  
+And research in the field is moving fast, so we want to be able to try new ideas 
+quickly.  
+
+## Initial Planning
+
+A large group of maintainers and contributors met do discuss the architectural 
+challenges associated with the existing codebase. Many much-desired features (building 
+new user interfaces, enabling project-specific agents, enabling multi-agent systems) 
+are bottlenecked by the global state in the system. We discussed the tradeoffs between 
+an incremental system transition and a big breaking version change and decided to go 
+for the breaking version change. We justified this by saying:
+
+- We can maintain, in essence, the same user experience as now even with a radical 
+  restructuring of the codebase
+- Our developer audience is struggling to use the existing codebase to build 
+  applications and libraries of their own, so this breaking change will largely be 
+  welcome.
+
+## Primary Goals
+
+- Separate the AutoGPT application code from the library code.
+- Remove global state from the system
+- Allow for multiple agents per user (with facilities for running simultaneously)
+- Create a serializable representation of an Agent
+- Encapsulate the core systems in abstractions with clear boundaries.
+
+## Secondary goals
+
+- Use existing tools to ditch any unneccesary cruft in the codebase (document loading, 
+  json parsing, anything easier to replace than to port).
+- Bring in the [core agent loop updates](https://whimsical.com/agent-workflow-v2-NmnTQ8R7sVo7M3S43XgXmZ)
+  being developed simultaneously by @Pwuts 
+
+# The Agent Subsystems
+
+## Configuration
+
+We want a lot of things from a configuration system. We lean heavily on it in the 
+`master` branch to allow several parts of the system to communicate with each other.  
+[Recent work](https://github.com/Significant-Gravitas/Auto-GPT/pull/4737) has made it 
+so that the config is no longer a singleton object that is materialized from the import 
+state, but it's still treated as a 
+[god object](https://en.wikipedia.org/wiki/God_object) containing all information about
+the system and _critically_ allowing any system to reference configuration information 
+about other parts of the system.  
+
+### What we want
+
+- It should still be reasonable to collate the entire system configuration in a 
+  sensible way.
+- The configuration should be validatable and validated.
+- The system configuration should be a _serializable_ representation of an `Agent`.
+- The configuration system should provide a clear (albeit very low-level) contract 
+  about user-configurable aspects of the system.
+- The configuration should reasonably manage default values and user-provided overrides.
+- The configuration system needs to handle credentials in a reasonable way.
+- The configuration should be the representation of some amount of system state, like 
+  api budgets and resource usage.  These aspects are recorded in the configuration and 
+  updated by the system itself.
+- Agent systems should have encapsulated views of the configuration.  E.g. the memory 
+  system should know about memory configuration but nothing about command configuration.
+
+## Workspace
+
+There are two ways to think about the workspace:
+
+- The workspace is a scratch space for an agent where it can store files, write code, 
+  and do pretty much whatever else it likes.
+- The workspace is, at any given point in time, the single source of truth for what an 
+  agent is.  It contains the serializable state (the configuration) as well as all 
+  other working state (stored files, databases, memories, custom code).  
+
+In the existing system there is **one** workspace.  And because the workspace holds so 
+much agent state, that means a user can only work with one agent at a time.
+
+## Memory
+
+The memory system has been under extremely active development. 
+See [#3536](https://github.com/Significant-Gravitas/Auto-GPT/issues/3536) and 
+[#4208](https://github.com/Significant-Gravitas/Auto-GPT/pull/4208) for discussion and 
+work in the `master` branch.  The TL;DR is 
+that we noticed a couple of months ago that the `Agent` performed **worse** with 
+permanent memory than without it.  Since then the knowledge storage and retrieval 
+system has been [redesigned](https://whimsical.com/memory-system-8Ae6x6QkjDwQAUe9eVJ6w1) 
+and partially implemented in the `master` branch.
+
+## Planning/Prompt-Engineering
+
+The planning system is the system that translates user desires/agent intentions into
+language model prompts.  In the course of development, it has become pretty clear 
+that `Planning` is the wrong name for this system
+
+### What we want
+
+- It should be incredibly obvious what's being passed to a language model, when it's
+  being passed, and what the language model response is. The landscape of language 
+  model research is developing very rapidly, so building complex abstractions between 
+  users/contributors and the language model interactions is going to make it very 
+  difficult for us to nimbly respond to new research developments.
+- Prompt-engineering should ideally be exposed in a parameterizeable way to users. 
+- We should, where possible, leverage OpenAI's new  
+  [function calling api](https://openai.com/blog/function-calling-and-other-api-updates) 
+  to get outputs in a standard machine-readable format and avoid the deep pit of 
+  parsing json (and fixing unparsable json).
+
+### Planning Strategies
+
+The [new agent workflow](https://whimsical.com/agent-workflow-v2-NmnTQ8R7sVo7M3S43XgXmZ) 
+has many, many interaction points for language models.  We really would like to not 
+distribute prompt templates and raw strings all through the system. The re-arch solution 
+is to encapsulate language model interactions into planning strategies. 
+These strategies are defined by 
+
+- The `LanguageModelClassification` they use (`FAST` or `SMART`)
+- A function `build_prompt` that takes strategy specific arguments and constructs a 
+  `LanguageModelPrompt` (a simple container for lists of messages and functions to
+  pass to the language model)
+- A function `parse_content` that parses the response content (a dict) into a better 
+  formatted dict.  Contracts here are intentionally loose and will tighten once we have 
+  at least one other language model provider.
+
+## Resources
+
+Resources are kinds of services we consume from external APIs.  They may have associated 
+credentials and costs we need to manage.  Management of those credentials is implemented 
+as manipulation of the resource configuration.  We have two categories of resources 
+currently
+
+- AI/ML model providers (including language model providers and embedding model providers, ie OpenAI)
+- Memory providers (e.g. Pinecone, Weaviate, ChromaDB, etc.)
+
+### What we want
+
+- Resource abstractions should provide a common interface to different service providers 
+  for a particular kind of service.  
+- Resource abstractions should manipulate the configuration to manage their credentials 
+  and budget/accounting.
+- Resource abstractions should be composable over an API (e.g. I should be able to make 
+  an OpenAI provider that is both a LanguageModelProvider and an EmbeddingModelProvider
+  and use it wherever I need those services).
+
+## Abilities
+
+Along with planning and memory usage, abilities are one of the major augmentations of 
+augmented language models.  They allow us to expand the scope of what language models
+can do by hooking them up to code they can execute to obtain new knowledge or influence
+the world.  
+
+### What we want
+
+- Abilities should have an extremely clear interface that users can write to.
+- Abilities should have an extremely clear interface that a language model can 
+  understand
+- Abilities should be declarative about their dependencies so the system can inject them
+- Abilities should be executable (where sensible) in an async run loop.
+- Abilities should be not have side effects unless those side effects are clear in 
+  their representation to an agent (e.g. the BrowseWeb ability shouldn't write a file,
+  but the WriteFile ability can).
+
+## Plugins
+
+Users want to add lots of features that we don't want to support as first-party. 
+Or solution to this is a plugin system to allow users to plug in their functionality or
+to construct their agent from a public plugin marketplace.  Our primary concern in the
+re-arch is to build a stateless plugin service interface and a simple implementation 
+that can load plugins from installed packages or from zip files.  Future efforts will 
+expand this system to allow plugins to load from a marketplace or some other kind 
+of service.
+
+### What is a Plugin
+
+Plugins are a kind of garbage term.  They refer to a number of things.
+
+- New commands for the agent to execute.  This is the most common usage.
+- Replacements for entire subsystems like memory or language model providers
+- Application plugins that do things like send emails or communicate via whatsapp
+- The repositories contributors create that may themselves have multiple plugins in them.
+
+### Usage in the existing system
+
+The current plugin system is _hook-based_.  This means plugins don't correspond to 
+kinds of objects in the system, but rather to times in the system at which we defer 
+execution to them.  The main advantage of this setup is that user code can hijack 
+pretty much any behavior of the agent by injecting code that supercedes the normal 
+agent execution.  The disadvantages to this approach are numerous:
+
+- We have absolutely no mechanisms to enforce any security measures because the threat 
+  surface is everything.
+- We cannot reason about agent behavior in a cohesive way because control flow can be
+  ceded to user code at pretty much any point and arbitrarily change or break the
+  agent behavior
+- The interface for designing a plugin is kind of terrible and difficult to standardize
+- The hook based implementation means we couple ourselves to a particular flow of 
+  control (or otherwise risk breaking plugin behavior).  E.g. many of the hook targets
+  in the [old workflow](https://whimsical.com/agent-workflow-VAzeKcup3SR7awpNZJKTyK) 
+  are not present or mean something entirely different in the 
+  [new workflow](https://whimsical.com/agent-workflow-v2-NmnTQ8R7sVo7M3S43XgXmZ).
+- Etc.
+
+### What we want
+
+- A concrete definition of a plugin that is narrow enough in scope that we can define 
+  it well and reason about how it will work in the system.
+- A set of abstractions that let us define a plugin by its storage format and location 
+- A service interface that knows how to parse the plugin abstractions and turn them 
+  into concrete classes and objects.
+
+
+## Some Notes on how and why we'll use OO in this project
+
+First and foremost, Python itself is an object-oriented language. It's 
+underlying [data model](https://docs.python.org/3/reference/datamodel.html) is built 
+with object-oriented programming in mind. It offers useful tools like abstract base 
+classes to communicate interfaces to developers who want to, e.g., write plugins, or 
+help work on implementations. If we were working in a different language that offered 
+different tools, we'd use a different paradigm.
+
+While many things are classes in the re-arch, they are not classes in the same way. 
+There are three kinds of things (roughly) that are written as classes in the re-arch:
+1.  **Configuration**:  Auto-GPT has *a lot* of configuration.  This configuration 
+    is *data* and we use **[Pydantic](https://docs.pydantic.dev/latest/)** to manage it as 
+    pydantic is basically industry standard for this stuff. It provides runtime validation 
+    for all the configuration and allows us to easily serialize configuration to both basic 
+    python types (dicts, lists, and primatives) as well as serialize to json, which is 
+    important for us being able to put representations of agents 
+    [on the wire](https://en.wikipedia.org/wiki/Wire_protocol) for web applications and 
+    agent-to-agent communication. *These are essentially 
+    [structs](https://en.wikipedia.org/wiki/Struct_(C_programming_language)) rather than 
+    traditional classes.*
+2.  **Internal Data**: Very similar to configuration, Auto-GPT passes around boatloads 
+    of internal data.  We are interacting with language models and language model APIs 
+    which means we are handling lots of *structured* but *raw* text.  Here we also 
+    leverage **pydantic** to both *parse* and *validate* the internal data and also to 
+    give us concrete types which we can use static type checkers to validate against 
+    and discover problems before they show up as bugs at runtime. *These are 
+    essentially [structs](https://en.wikipedia.org/wiki/Struct_(C_programming_language)) 
+    rather than traditional classes.*
+3.  **System Interfaces**: This is our primary traditional use of classes in the 
+    re-arch.  We have a bunch of systems. We want many of those systems to have 
+    alternative implementations (e.g. via plugins). We use abstract base classes to 
+    define interfaces to communicate with people who might want to provide those 
+    plugins. We provide a single concrete implementation of most of those systems as a 
+    subclass of the interface. This should not be controversial.
+
+The approach is consistent with 
+[prior](https://github.com/Significant-Gravitas/Auto-GPT/issues/2458)
+[work](https://github.com/Significant-Gravitas/Auto-GPT/pull/2442) done by other 
+maintainers in this direction.
+
+From an organization standpoint, OO programming is by far the most popular programming 
+paradigm (especially for Python). It's the one most often taught in programming classes
+and the one with the most available online training for people interested in 
+contributing.   
+
+Finally, and importantly, we scoped the plan and initial design of the re-arch as a 
+large group of maintainers and collaborators early on. This is consistent with the 
+design we chose and no-one offered alternatives.
+ 

autogpt/core/README.md

@@ -0,0 +1,94 @@
+# Auto-GPT Core
+
+This subpackage contains the ongoing work for the 
+[Auto-GPT Re-arch](https://github.com/Significant-Gravitas/Auto-GPT/issues/4770). It is 
+a work in progress and is not yet feature complete.  In particular, it does not yet
+have many of the Auto-GPT commands implemented and is pending ongoing work to 
+[re-incorporate vector-based memory and knowledge retrieval](https://github.com/Significant-Gravitas/Auto-GPT/issues/3536).
+
+## [Overview](ARCHITECTURE_NOTES.md)
+
+The Auto-GPT Re-arch is a re-implementation of the Auto-GPT agent that is designed to be more modular,
+more extensible, and more maintainable than the original Auto-GPT agent.  It is also designed to be
+more accessible to new developers and to be easier to contribute to. The re-arch is a work in progress
+and is not yet feature complete.  It is also not yet ready for production use.
+
+## Running the Re-arch Code
+
+There are two client applications for Auto-GPT included. 
+
+Unlike the main version of Auto-GPT, the re-arch requires you to actually install Auto-GPT in your python 
+environment to run this application.  To do so, run
+
+```
+pip install -e REPOSITORY_ROOT
+```
+
+where `REPOSITORY_ROOT` is the root of the Auto-GPT repository on your machine. The `REPOSITORY_ROOT` 
+is the directory that contains the `setup.py` file and is the main, top-level directory of the repository 
+when you clone it.
+
+## CLI Application
+
+:star2: **This is the reference application I'm working with for now** :star2: 
+
+The first app is a straight CLI application.  I have not done anything yet to port all the friendly display stuff from the `logger.typewriter_log` logic.  
+
+- [Entry Point](https://github.com/Significant-Gravitas/Auto-GPT/blob/master/autogpt/core/runner/cli_app/cli.py)
+- [Client Application](https://github.com/Significant-Gravitas/Auto-GPT/blob/master/autogpt/core/runner/cli_app/main.py)
+
+You'll then need a settings file.  Run
+
+```
+ python REPOSITORY_ROOT/autogpt/core/runner/cli_app/cli.py make-settings
+ ```
+
+This will write a file called `default_agent_settings.yaml` with all the user-modifiable 
+configuration keys to `~/auto-gpt/default_agent_settings.yml` and make the `auto-gpt` directory 
+in your user directory if it doesn't exist). Your user directory is located in different places 
+depending on your operating system:
+
+- On Linux, it's `/home/USERNAME`
+- On Windows, it's `C:\Users\USERNAME`
+- On Mac, it's `/Users/USERNAME`
+
+At a bare minimum, you'll need to set `openai.credentials.api_key` to your OpenAI API Key to run 
+the model.
+
+You can then run Auto-GPT with 
+
+```
+python REPOSITORY_ROOT/autogpt/core/runner/cli_app/cli.py run
+```
+
+to launch the interaction loop.
+
+### CLI Web App
+
+:warning: I am not actively developing this application.  I am primarily working with the traditional CLI app
+described above.  It is a very good place to get involved if you have web application design experience and are 
+looking to get involved in the re-arch.
+
+The second app is still a CLI, but it sets up a local webserver that the client application talks to
+rather than invoking calls to the Agent library code directly.  This application is essentially a sketch 
+at this point as the folks who were driving it have had less time (and likely not enough clarity) to proceed.
+
+- [Entry Point](https://github.com/Significant-Gravitas/Auto-GPT/blob/master/autogpt/core/runner/cli_web_app/cli.py)
+- [Client Application](https://github.com/Significant-Gravitas/Auto-GPT/blob/master/autogpt/core/runner/cli_web_app/client/client.py)
+- [Server API](https://github.com/Significant-Gravitas/Auto-GPT/blob/master/autogpt/core/runner/cli_web_app/server/api.py)
+
+To run, you still need to generate a default configuration.  You can do 
+
+```
+python REPOSITORY_ROOT/autogpt/core/runner/cli_web_app/cli.py make-settings
+```
+
+It invokes the same command as the bare CLI app, so follow the instructions above about setting your API key.
+
+To run, do 
+
+```
+python REPOSITORY_ROOT/autogpt/core/runner/cli_web_app/cli.py client
+```
+
+This will launch a webserver and then start the client cli application to communicate with it.

autogpt/core/ability/__init__.py

@@ -0,0 +1,4 @@
+"""The command system provides a way to extend the functionality of the AI agent."""
+from autogpt.core.ability.base import Ability, AbilityRegistry
+from autogpt.core.ability.schema import AbilityResult
+from autogpt.core.ability.simple import AbilityRegistrySettings, SimpleAbilityRegistry

autogpt/core/ability/base.py

@@ -0,0 +1,92 @@
+import abc
+from pprint import pformat
+from typing import ClassVar
+
+import inflection
+from pydantic import Field
+
+from autogpt.core.ability.schema import AbilityResult
+from autogpt.core.configuration import SystemConfiguration
+from autogpt.core.planning.simple import LanguageModelConfiguration
+
+
+class AbilityConfiguration(SystemConfiguration):
+    """Struct for model configuration."""
+
+    from autogpt.core.plugin.base import PluginLocation
+
+    location: PluginLocation
+    packages_required: list[str] = Field(default_factory=list)
+    language_model_required: LanguageModelConfiguration = None
+    memory_provider_required: bool = False
+    workspace_required: bool = False
+
+
+class Ability(abc.ABC):
+    """A class representing an agent ability."""
+
+    default_configuration: ClassVar[AbilityConfiguration]
+
+    @classmethod
+    def name(cls) -> str:
+        """The name of the ability."""
+        return inflection.underscore(cls.__name__)
+
+    @classmethod
+    @abc.abstractmethod
+    def description(cls) -> str:
+        """A detailed description of what the ability does."""
+        ...
+
+    @classmethod
+    @abc.abstractmethod
+    def arguments(cls) -> dict:
+        """A dict of arguments in standard json schema format."""
+        ...
+
+    @classmethod
+    def required_arguments(cls) -> list[str]:
+        """A list of required arguments."""
+        return []
+
+    @abc.abstractmethod
+    async def __call__(self, *args, **kwargs) -> AbilityResult:
+        ...
+
+    def __str__(self) -> str:
+        return pformat(self.dump)
+
+    def dump(self) -> dict:
+        return {
+            "name": self.name(),
+            "description": self.description(),
+            "parameters": {
+                "type": "object",
+                "properties": self.arguments(),
+                "required": self.required_arguments(),
+            },
+        }
+
+
+class AbilityRegistry(abc.ABC):
+    @abc.abstractmethod
+    def register_ability(
+        self, ability_name: str, ability_configuration: AbilityConfiguration
+    ) -> None:
+        ...
+
+    @abc.abstractmethod
+    def list_abilities(self) -> list[str]:
+        ...
+
+    @abc.abstractmethod
+    def dump_abilities(self) -> list[dict]:
+        ...
+
+    @abc.abstractmethod
+    def get_ability(self, ability_name: str) -> Ability:
+        ...
+
+    @abc.abstractmethod
+    def perform(self, ability_name: str, **kwargs) -> AbilityResult:
+        ...

autogpt/core/ability/builtins/__init__.py

@@ -0,0 +1,6 @@
+from autogpt.core.ability.builtins.create_new_ability import CreateNewAbility
+from autogpt.core.ability.builtins.query_language_model import QueryLanguageModel
+
+BUILTIN_ABILITIES = {
+    QueryLanguageModel.name(): QueryLanguageModel,
+}

autogpt/core/ability/builtins/create_new_ability.py

@@ -0,0 +1,102 @@
+import logging
+
+from autogpt.core.ability.base import Ability, AbilityConfiguration
+from autogpt.core.ability.schema import AbilityResult
+from autogpt.core.plugin.simple import PluginLocation, PluginStorageFormat
+
+
+class CreateNewAbility(Ability):
+    default_configuration = AbilityConfiguration(
+        location=PluginLocation(
+            storage_format=PluginStorageFormat.INSTALLED_PACKAGE,
+            storage_route="autogpt.core.ability.builtins.CreateNewAbility",
+        ),
+    )
+
+    def __init__(
+        self,
+        logger: logging.Logger,
+        configuration: AbilityConfiguration,
+    ):
+        self._logger = logger
+        self._configuration = configuration
+
+    @classmethod
+    def description(cls) -> str:
+        return "Create a new ability by writing python code."
+
+    @classmethod
+    def arguments(cls) -> dict:
+        return {
+            "ability_name": {
+                "type": "string",
+                "description": "A meaningful and concise name for the new ability.",
+            },
+            "description": {
+                "type": "string",
+                "description": "A detailed description of the ability and its uses, including any limitations.",
+            },
+            "arguments": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "name": {
+                            "type": "string",
+                            "description": "The name of the argument.",
+                        },
+                        "type": {
+                            "type": "string",
+                            "description": "The type of the argument. Must be a standard json schema type.",
+                        },
+                        "description": {
+                            "type": "string",
+                            "description": "A detailed description of the argument and its uses.",
+                        },
+                    },
+                },
+                "description": "A list of arguments that the ability will accept.",
+            },
+            "required_arguments": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "description": "The names of the arguments that are required.",
+                },
+                "description": "A list of the names of the arguments that are required.",
+            },
+            "package_requirements": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "description": "The of the Python package that is required to execute the ability.",
+                },
+                "description": "A list of the names of the Python packages that are required to execute the ability.",
+            },
+            "code": {
+                "type": "string",
+                "description": "The Python code that will be executed when the ability is called.",
+            },
+        }
+
+    @classmethod
+    def required_arguments(cls) -> list[str]:
+        return [
+            "ability_name",
+            "description",
+            "arguments",
+            "required_arguments",
+            "package_requirements",
+            "code",
+        ]
+
+    async def __call__(
+        self,
+        ability_name: str,
+        description: str,
+        arguments: list[dict],
+        required_arguments: list[str],
+        package_requirements: list[str],
+        code: str,
+    ) -> AbilityResult:
+        raise NotImplementedError

autogpt/core/ability/builtins/file_operations.py

@@ -0,0 +1,167 @@
+import logging
+import os
+
+from autogpt.core.ability.base import Ability, AbilityConfiguration
+from autogpt.core.ability.schema import AbilityResult, ContentType, Knowledge
+from autogpt.core.workspace import Workspace
+
+
+class ReadFile(Ability):
+    default_configuration = AbilityConfiguration(
+        packages_required=["unstructured"],
+        workspace_required=True,
+    )
+
+    def __init__(
+        self,
+        logger: logging.Logger,
+        workspace: Workspace,
+    ):
+        self._logger = logger
+        self._workspace = workspace
+
+    @property
+    def description(self) -> str:
+        return "Read and parse all text from a file."
+
+    @property
+    def arguments(self) -> dict:
+        return {
+            "filename": {
+                "type": "string",
+                "description": "The name of the file to read.",
+            },
+        }
+
+    def _check_preconditions(self, filename: str) -> AbilityResult | None:
+        message = ""
+        try:
+            pass
+        except ImportError:
+            message = "Package charset_normalizer is not installed."
+
+        try:
+            file_path = self._workspace.get_path(filename)
+            if not file_path.exists():
+                message = f"File {filename} does not exist."
+            if not file_path.is_file():
+                message = f"{filename} is not a file."
+        except ValueError as e:
+            message = str(e)
+
+        if message:
+            return AbilityResult(
+                ability_name=self.name(),
+                ability_args={"filename": filename},
+                success=False,
+                message=message,
+                data=None,
+            )
+
+    def __call__(self, filename: str) -> AbilityResult:
+        if result := self._check_preconditions(filename):
+            return result
+
+        from unstructured.partition.auto import partition
+
+        file_path = self._workspace.get_path(filename)
+        try:
+            elements = partition(str(file_path))
+            # TODO: Lots of other potentially useful information is available
+            #   in the partitioned file. Consider returning more of it.
+            new_knowledge = Knowledge(
+                content="\n\n".join([element.text for element in elements]),
+                content_type=ContentType.TEXT,
+                content_metadata={"filename": filename},
+            )
+            success = True
+            message = f"File {file_path} read successfully."
+        except IOError as e:
+            new_knowledge = None
+            success = False
+            message = str(e)
+
+        return AbilityResult(
+            ability_name=self.name(),
+            ability_args={"filename": filename},
+            success=success,
+            message=message,
+            new_knowledge=new_knowledge,
+        )
+
+
+class WriteFile(Ability):
+    default_configuration = AbilityConfiguration(
+        packages_required=["unstructured"],
+        workspace_required=True,
+    )
+
+    def __init__(
+        self,
+        logger: logging.Logger,
+        workspace: Workspace,
+    ):
+        self._logger = logger
+        self._workspace = workspace
+
+    @property
+    def description(self) -> str:
+        return "Write text to a file."
+
+    @property
+    def arguments(self) -> dict:
+        return {
+            "filename": {
+                "type": "string",
+                "description": "The name of the file to write.",
+            },
+            "contents": {
+                "type": "string",
+                "description": "The contents of the file to write.",
+            },
+        }
+
+    def _check_preconditions(
+        self, filename: str, contents: str
+    ) -> AbilityResult | None:
+        message = ""
+        try:
+            file_path = self._workspace.get_path(filename)
+            if file_path.exists():
+                message = f"File {filename} already exists."
+            if len(contents):
+                message = f"File {filename} was not given any content."
+        except ValueError as e:
+            message = str(e)
+
+        if message:
+            return AbilityResult(
+                ability_name=self.name(),
+                ability_args={"filename": filename, "contents": contents},
+                success=False,
+                message=message,
+                data=None,
+            )
+
+    def __call__(self, filename: str, contents: str) -> AbilityResult:
+        if result := self._check_preconditions(filename, contents):
+            return result
+
+        file_path = self._workspace.get_path(filename)
+        try:
+            directory = os.path.dirname(file_path)
+            os.makedirs(directory)
+            with open(filename, "w", encoding="utf-8") as f:
+                f.write(contents)
+            success = True
+            message = f"File {file_path} written successfully."
+        except IOError as e:
+            success = False
+            message = str(e)
+
+        return AbilityResult(
+            ability_name=self.name(),
+            ability_args={"filename": filename},
+            success=success,
+            message=message,
+        )

autogpt/core/ability/builtins/query_language_model.py

@@ -0,0 +1,78 @@
+import logging
+
+from autogpt.core.ability.base import Ability, AbilityConfiguration
+from autogpt.core.ability.schema import AbilityResult
+from autogpt.core.planning.simple import LanguageModelConfiguration
+from autogpt.core.plugin.simple import PluginLocation, PluginStorageFormat
+from autogpt.core.resource.model_providers import (
+    LanguageModelMessage,
+    LanguageModelProvider,
+    MessageRole,
+    ModelProviderName,
+    OpenAIModelName,
+)
+
+
+class QueryLanguageModel(Ability):
+    default_configuration = AbilityConfiguration(
+        location=PluginLocation(
+            storage_format=PluginStorageFormat.INSTALLED_PACKAGE,
+            storage_route="autogpt.core.ability.builtins.QueryLanguageModel",
+        ),
+        language_model_required=LanguageModelConfiguration(
+            model_name=OpenAIModelName.GPT3,
+            provider_name=ModelProviderName.OPENAI,
+            temperature=0.9,
+        ),
+    )
+
+    def __init__(
+        self,
+        logger: logging.Logger,
+        configuration: AbilityConfiguration,
+        language_model_provider: LanguageModelProvider,
+    ):
+        self._logger = logger
+        self._configuration = configuration
+        self._language_model_provider = language_model_provider
+
+    @classmethod
+    def description(cls) -> str:
+        return "Query a language model. A query should be a question and any relevant context."
+
+    @classmethod
+    def arguments(cls) -> dict:
+        return {
+            "query": {
+                "type": "string",
+                "description": "A query for a language model. A query should contain a question and any relevant context.",
+            },
+        }
+
+    @classmethod
+    def required_arguments(cls) -> list[str]:
+        return ["query"]
+
+    async def __call__(self, query: str) -> AbilityResult:
+        messages = [
+            LanguageModelMessage(
+                content=query,
+                role=MessageRole.USER,
+            ),
+        ]
+        model_response = await self._language_model_provider.create_language_completion(
+            model_prompt=messages,
+            functions=[],
+            model_name=self._configuration.language_model_required.model_name,
+            completion_parser=self._parse_response,
+        )
+        return AbilityResult(
+            ability_name=self.name(),
+            ability_args={"query": query},
+            success=True,
+            message=model_response.content["content"],
+        )
+
+    @staticmethod
+    def _parse_response(response_content: dict) -> dict:
+        return {"content": response_content["content"]}

autogpt/core/ability/schema.py

@@ -0,0 +1,30 @@
+import enum
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class ContentType(str, enum.Enum):
+    # TBD what these actually are.
+    TEXT = "text"
+    CODE = "code"
+
+
+class Knowledge(BaseModel):
+    content: str
+    content_type: ContentType
+    content_metadata: dict[str, Any]
+
+
+class AbilityResult(BaseModel):
+    """The AbilityResult is a standard response struct for an ability."""
+
+    ability_name: str
+    ability_args: dict[str, str]
+    success: bool
+    message: str
+    new_knowledge: Knowledge = None
+
+    def summary(self) -> str:
+        kwargs = ", ".join(f"{k}={v}" for k, v in self.ability_args.items())
+        return f"{self.ability_name}({kwargs}): {self.message}"

autogpt/core/ability/simple.py

@@ -0,0 +1,96 @@
+import logging
+
+from autogpt.core.ability.base import Ability, AbilityConfiguration, AbilityRegistry
+from autogpt.core.ability.builtins import BUILTIN_ABILITIES
+from autogpt.core.ability.schema import AbilityResult
+from autogpt.core.configuration import Configurable, SystemConfiguration, SystemSettings
+from autogpt.core.memory.base import Memory
+from autogpt.core.plugin.simple import SimplePluginService
+from autogpt.core.resource.model_providers import (
+    LanguageModelProvider,
+    ModelProviderName,
+)
+from autogpt.core.workspace.base import Workspace
+
+
+class AbilityRegistryConfiguration(SystemConfiguration):
+    """Configuration for the AbilityRegistry subsystem."""
+
+    abilities: dict[str, AbilityConfiguration]
+
+
+class AbilityRegistrySettings(SystemSettings):
+    configuration: AbilityRegistryConfiguration
+
+
+class SimpleAbilityRegistry(AbilityRegistry, Configurable):
+    default_settings = AbilityRegistrySettings(
+        name="simple_ability_registry",
+        description="A simple ability registry.",
+        configuration=AbilityRegistryConfiguration(
+            abilities={
+                ability_name: ability.default_configuration
+                for ability_name, ability in BUILTIN_ABILITIES.items()
+            },
+        ),
+    )
+
+    def __init__(
+        self,
+        settings: AbilityRegistrySettings,
+        logger: logging.Logger,
+        memory: Memory,
+        workspace: Workspace,
+        model_providers: dict[ModelProviderName, LanguageModelProvider],
+    ):
+        self._configuration = settings.configuration
+        self._logger = logger
+        self._memory = memory
+        self._workspace = workspace
+        self._model_providers = model_providers
+        self._abilities = []
+        for (
+            ability_name,
+            ability_configuration,
+        ) in self._configuration.abilities.items():
+            self.register_ability(ability_name, ability_configuration)
+
+    def register_ability(
+        self, ability_name: str, ability_configuration: AbilityConfiguration
+    ) -> None:
+        ability_class = SimplePluginService.get_plugin(ability_configuration.location)
+        ability_args = {
+            "logger": self._logger.getChild(ability_name),
+            "configuration": ability_configuration,
+        }
+        if ability_configuration.packages_required:
+            # TODO: Check packages are installed and maybe install them.
+            pass
+        if ability_configuration.memory_provider_required:
+            ability_args["memory"] = self._memory
+        if ability_configuration.workspace_required:
+            ability_args["workspace"] = self._workspace
+        if ability_configuration.language_model_required:
+            ability_args["language_model_provider"] = self._model_providers[
+                ability_configuration.language_model_required.provider_name
+            ]
+        ability = ability_class(**ability_args)
+        self._abilities.append(ability)
+
+    def list_abilities(self) -> list[str]:
+        return [
+            f"{ability.name()}: {ability.description()}" for ability in self._abilities
+        ]
+
+    def dump_abilities(self) -> list[dict]:
+        return [ability.dump() for ability in self._abilities]
+
+    def get_ability(self, ability_name: str) -> Ability:
+        for ability in self._abilities:
+            if ability.name() == ability_name:
+                return ability
+        raise ValueError(f"Ability '{ability_name}' not found.")
+
+    async def perform(self, ability_name: str, **kwargs) -> AbilityResult:
+        ability = self.get_ability(ability_name)
+        return await ability(**kwargs)

autogpt/core/agent/__init__.py

@@ -0,0 +1,3 @@
+"""The Agent is an autonomouos entity guided by a LLM provider."""
+from autogpt.core.agent.base import Agent
+from autogpt.core.agent.simple import AgentSettings, SimpleAgent

autogpt/core/agent/base.py

@@ -0,0 +1,26 @@
+import abc
+import logging
+from pathlib import Path
+
+
+class Agent(abc.ABC):
+    @abc.abstractmethod
+    def __init__(self, *args, **kwargs):
+        ...
+
+    @classmethod
+    @abc.abstractmethod
+    def from_workspace(
+        cls,
+        workspace_path: Path,
+        logger: logging.Logger,
+    ) -> "Agent":
+        ...
+
+    @abc.abstractmethod
+    async def determine_next_ability(self, *args, **kwargs):
+        ...
+
+    @abc.abstractmethod
+    def __repr__(self):
+        ...

autogpt/core/agent/simple.py

@@ -0,0 +1,391 @@
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+from autogpt.core.ability import (
+    AbilityRegistrySettings,
+    AbilityResult,
+    SimpleAbilityRegistry,
+)
+from autogpt.core.agent.base import Agent
+from autogpt.core.configuration import Configurable, SystemConfiguration, SystemSettings
+from autogpt.core.memory import MemorySettings, SimpleMemory
+from autogpt.core.planning import PlannerSettings, SimplePlanner, Task, TaskStatus
+from autogpt.core.plugin.simple import (
+    PluginLocation,
+    PluginStorageFormat,
+    SimplePluginService,
+)
+from autogpt.core.resource.model_providers import OpenAIProvider, OpenAISettings
+from autogpt.core.workspace.simple import SimpleWorkspace, WorkspaceSettings
+
+
+class AgentSystems(SystemConfiguration):
+    ability_registry: PluginLocation
+    memory: PluginLocation
+    openai_provider: PluginLocation
+    planning: PluginLocation
+    workspace: PluginLocation
+
+
+class AgentConfiguration(SystemConfiguration):
+    cycle_count: int
+    max_task_cycle_count: int
+    creation_time: str
+    name: str
+    role: str
+    goals: list[str]
+    systems: AgentSystems
+
+
+class AgentSystemSettings(SystemSettings):
+    configuration: AgentConfiguration
+
+
+class AgentSettings(BaseModel):
+    agent: AgentSystemSettings
+    ability_registry: AbilityRegistrySettings
+    memory: MemorySettings
+    openai_provider: OpenAISettings
+    planning: PlannerSettings
+    workspace: WorkspaceSettings
+
+    def update_agent_name_and_goals(self, agent_goals: dict) -> None:
+        self.agent.configuration.name = agent_goals["agent_name"]
+        self.agent.configuration.role = agent_goals["agent_role"]
+        self.agent.configuration.goals = agent_goals["agent_goals"]
+
+
+class SimpleAgent(Agent, Configurable):
+    default_settings = AgentSystemSettings(
+        name="simple_agent",
+        description="A simple agent.",
+        configuration=AgentConfiguration(
+            name="Entrepreneur-GPT",
+            role=(
+                "An AI designed to autonomously develop and run businesses with "
+                "the sole goal of increasing your net worth."
+            ),
+            goals=[
+                "Increase net worth",
+                "Grow Twitter Account",
+                "Develop and manage multiple businesses autonomously",
+            ],
+            cycle_count=0,
+            max_task_cycle_count=3,
+            creation_time="",
+            systems=AgentSystems(
+                ability_registry=PluginLocation(
+                    storage_format=PluginStorageFormat.INSTALLED_PACKAGE,
+                    storage_route="autogpt.core.ability.SimpleAbilityRegistry",
+                ),
+                memory=PluginLocation(
+                    storage_format=PluginStorageFormat.INSTALLED_PACKAGE,
+                    storage_route="autogpt.core.memory.SimpleMemory",
+                ),
+                openai_provider=PluginLocation(
+                    storage_format=PluginStorageFormat.INSTALLED_PACKAGE,
+                    storage_route="autogpt.core.resource.model_providers.OpenAIProvider",
+                ),
+                planning=PluginLocation(
+                    storage_format=PluginStorageFormat.INSTALLED_PACKAGE,
+                    storage_route="autogpt.core.planning.SimplePlanner",
+                ),
+                workspace=PluginLocation(
+                    storage_format=PluginStorageFormat.INSTALLED_PACKAGE,
+                    storage_route="autogpt.core.workspace.SimpleWorkspace",
+                ),
+            ),
+        ),
+    )
+
+    def __init__(
+        self,
+        settings: AgentSystemSettings,
+        logger: logging.Logger,
+        ability_registry: SimpleAbilityRegistry,
+        memory: SimpleMemory,
+        openai_provider: OpenAIProvider,
+        planning: SimplePlanner,
+        workspace: SimpleWorkspace,
+    ):
+        self._configuration = settings.configuration
+        self._logger = logger
+        self._ability_registry = ability_registry
+        self._memory = memory
+        # FIXME: Need some work to make this work as a dict of providers
+        #  Getting the construction of the config to work is a bit tricky
+        self._openai_provider = openai_provider
+        self._planning = planning
+        self._workspace = workspace
+        self._task_queue = []
+        self._completed_tasks = []
+        self._current_task = None
+        self._next_ability = None
+
+    @classmethod
+    def from_workspace(
+        cls,
+        workspace_path: Path,
+        logger: logging.Logger,
+    ) -> "SimpleAgent":
+        agent_settings = SimpleWorkspace.load_agent_settings(workspace_path)
+        agent_args = {}
+
+        agent_args["settings"] = agent_settings.agent
+        agent_args["logger"] = logger
+        agent_args["workspace"] = cls._get_system_instance(
+            "workspace",
+            agent_settings,
+            logger,
+        )
+        agent_args["openai_provider"] = cls._get_system_instance(
+            "openai_provider",
+            agent_settings,
+            logger,
+        )
+        agent_args["planning"] = cls._get_system_instance(
+            "planning",
+            agent_settings,
+            logger,
+            model_providers={"openai": agent_args["openai_provider"]},
+        )
+        agent_args["memory"] = cls._get_system_instance(
+            "memory",
+            agent_settings,
+            logger,
+            workspace=agent_args["workspace"],
+        )
+
+        agent_args["ability_registry"] = cls._get_system_instance(
+            "ability_registry",
+            agent_settings,
+            logger,
+            workspace=agent_args["workspace"],
+            memory=agent_args["memory"],
+            model_providers={"openai": agent_args["openai_provider"]},
+        )
+
+        return cls(**agent_args)
+
+    async def build_initial_plan(self) -> dict:
+        plan = await self._planning.make_initial_plan(
+            agent_name=self._configuration.name,
+            agent_role=self._configuration.role,
+            agent_goals=self._configuration.goals,
+            abilities=self._ability_registry.list_abilities(),
+        )
+        tasks = [Task.parse_obj(task) for task in plan.content["task_list"]]
+
+        # TODO: Should probably do a step to evaluate the quality of the generated tasks,
+        #  and ensure that they have actionable ready and acceptance criteria
+
+        self._task_queue.extend(tasks)
+        self._task_queue.sort(key=lambda t: t.priority, reverse=True)
+        self._task_queue[-1].context.status = TaskStatus.READY
+        return plan.content
+
+    async def determine_next_ability(self, *args, **kwargs):
+        if not self._task_queue:
+            return {"response": "I don't have any tasks to work on right now."}
+
+        self._configuration.cycle_count += 1
+        task = self._task_queue.pop()
+        self._logger.info(f"Working on task: {task}")
+
+        task = await self._evaluate_task_and_add_context(task)
+        next_ability = await self._choose_next_ability(
+            task,
+            self._ability_registry.dump_abilities(),
+        )
+        self._current_task = task
+        self._next_ability = next_ability.content
+        return self._current_task, self._next_ability
+
+    async def execute_next_ability(self, user_input: str, *args, **kwargs):
+        if user_input == "y":
+            ability = self._ability_registry.get_ability(
+                self._next_ability["next_ability"]
+            )
+            ability_response = await ability(**self._next_ability["ability_arguments"])
+            await self._update_tasks_and_memory(ability_response)
+            if self._current_task.context.status == TaskStatus.DONE:
+                self._completed_tasks.append(self._current_task)
+            else:
+                self._task_queue.append(self._current_task)
+            self._current_task = None
+            self._next_ability = None
+
+            return ability_response.dict()
+        else:
+            raise NotImplementedError
+
+    async def _evaluate_task_and_add_context(self, task: Task) -> Task:
+        """Evaluate the task and add context to it."""
+        if task.context.status == TaskStatus.IN_PROGRESS:
+            # Nothing to do here
+            return task
+        else:
+            self._logger.debug(f"Evaluating task {task} and adding relevant context.")
+            # TODO: Look up relevant memories (need working memory system)
+            # TODO: Evaluate whether there is enough information to start the task (language model call).
+            task.context.enough_info = True
+            task.context.status = TaskStatus.IN_PROGRESS
+            return task
+
+    async def _choose_next_ability(self, task: Task, ability_schema: list[dict]):
+        """Choose the next ability to use for the task."""
+        self._logger.debug(f"Choosing next ability for task {task}.")
+        if task.context.cycle_count > self._configuration.max_task_cycle_count:
+            # Don't hit the LLM, just set the next action as "breakdown_task" with an appropriate reason
+            raise NotImplementedError
+        elif not task.context.enough_info:
+            # Don't ask the LLM, just set the next action as "breakdown_task" with an appropriate reason
+            raise NotImplementedError
+        else:
+            next_ability = await self._planning.determine_next_ability(
+                task, ability_schema
+            )
+            return next_ability
+
+    async def _update_tasks_and_memory(self, ability_result: AbilityResult):
+        self._current_task.context.cycle_count += 1
+        self._current_task.context.prior_actions.append(ability_result)
+        # TODO: Summarize new knowledge
+        # TODO: store knowledge and summaries in memory and in relevant tasks
+        # TODO: evaluate whether the task is complete
+
+    def __repr__(self):
+        return "SimpleAgent()"
+
+    ################################################################
+    # Factory interface for agent bootstrapping and initialization #
+    ################################################################
+
+    @classmethod
+    def build_user_configuration(cls) -> dict[str, Any]:
+        """Build the user's configuration."""
+        configuration_dict = {
+            "agent": cls.get_user_config(),
+        }
+
+        system_locations = configuration_dict["agent"]["configuration"]["systems"]
+        for system_name, system_location in system_locations.items():
+            system_class = SimplePluginService.get_plugin(system_location)
+            configuration_dict[system_name] = system_class.get_user_config()
+        configuration_dict = _prune_empty_dicts(configuration_dict)
+        return configuration_dict
+
+    @classmethod
+    def compile_settings(
+        cls, logger: logging.Logger, user_configuration: dict
+    ) -> AgentSettings:
+        """Compile the user's configuration with the defaults."""
+        logger.debug("Processing agent system configuration.")
+        configuration_dict = {
+            "agent": cls.build_agent_configuration(
+                user_configuration.get("agent", {})
+            ).dict(),
+        }
+
+        system_locations = configuration_dict["agent"]["configuration"]["systems"]
+
+        # Build up default configuration
+        for system_name, system_location in system_locations.items():
+            logger.debug(f"Compiling configuration for system {system_name}")
+            system_class = SimplePluginService.get_plugin(system_location)
+            configuration_dict[system_name] = system_class.build_agent_configuration(
+                user_configuration.get(system_name, {})
+            ).dict()
+
+        return AgentSettings.parse_obj(configuration_dict)
+
+    @classmethod
+    async def determine_agent_name_and_goals(
+        cls,
+        user_objective: str,
+        agent_settings: AgentSettings,
+        logger: logging.Logger,
+    ) -> dict:
+        logger.debug("Loading OpenAI provider.")
+        provider: OpenAIProvider = cls._get_system_instance(
+            "openai_provider",
+            agent_settings,
+            logger=logger,
+        )
+        logger.debug("Loading agent planner.")
+        agent_planner: SimplePlanner = cls._get_system_instance(
+            "planning",
+            agent_settings,
+            logger=logger,
+            model_providers={"openai": provider},
+        )
+        logger.debug("determining agent name and goals.")
+        model_response = await agent_planner.decide_name_and_goals(
+            user_objective,
+        )
+
+        return model_response.content
+
+    @classmethod
+    def provision_agent(
+        cls,
+        agent_settings: AgentSettings,
+        logger: logging.Logger,
+    ):
+        agent_settings.agent.configuration.creation_time = datetime.now().strftime(
+            "%Y%m%d_%H%M%S"
+        )
+        workspace: SimpleWorkspace = cls._get_system_instance(
+            "workspace",
+            agent_settings,
+            logger=logger,
+        )
+        return workspace.setup_workspace(agent_settings, logger)
+
+    @classmethod
+    def _get_system_instance(
+        cls,
+        system_name: str,
+        agent_settings: AgentSettings,
+        logger: logging.Logger,
+        *args,
+        **kwargs,
+    ):
+        system_locations = agent_settings.agent.configuration.systems.dict()
+
+        system_settings = getattr(agent_settings, system_name)
+        system_class = SimplePluginService.get_plugin(system_locations[system_name])
+        system_instance = system_class(
+            system_settings,
+            *args,
+            logger=logger.getChild(system_name),
+            **kwargs,
+        )
+        return system_instance
+
+
+def _prune_empty_dicts(d: dict) -> dict:
+    """
+    Prune branches from a nested dictionary if the branch only contains empty dictionaries at the leaves.
+
+    Args:
+        d: The dictionary to prune.
+
+    Returns:
+        The pruned dictionary.
+    """
+    pruned = {}
+    for key, value in d.items():
+        if isinstance(value, dict):
+            pruned_value = _prune_empty_dicts(value)
+            if (
+                pruned_value
+            ):  # if the pruned dictionary is not empty, add it to the result
+                pruned[key] = pruned_value
+        else:
+            pruned[key] = value
+    return pruned

autogpt/core/configuration/__init__.py

@@ -0,0 +1,7 @@
+"""The configuration encapsulates settings for all Agent subsystems."""
+from autogpt.core.configuration.schema import (
+    Configurable,
+    SystemConfiguration,
+    SystemSettings,
+    UserConfigurable,
+)

autogpt/core/configuration/schema.py

@@ -0,0 +1,107 @@
+import abc
+import typing
+from typing import Any, Generic, TypeVar
+
+from pydantic import BaseModel, Field
+
+
+def UserConfigurable(*args, **kwargs):
+    return Field(*args, **kwargs, user_configurable=True)
+
+
+class SystemConfiguration(BaseModel):
+    def get_user_config(self) -> dict[str, Any]:
+        return _get_user_config_fields(self)
+
+    class Config:
+        extra = "forbid"
+        use_enum_values = True
+
+
+class SystemSettings(BaseModel):
+    """A base class for all system settings."""
+
+    name: str
+    description: str
+
+    class Config:
+        extra = "forbid"
+        use_enum_values = True
+
+
+S = TypeVar("S", bound=SystemSettings)
+
+
+class Configurable(abc.ABC, Generic[S]):
+    """A base class for all configurable objects."""
+
+    prefix: str = ""
+    default_settings: typing.ClassVar[S]
+
+    @classmethod
+    def get_user_config(cls) -> dict[str, Any]:
+        return _get_user_config_fields(cls.default_settings)
+
+    @classmethod
+    def build_agent_configuration(cls, configuration: dict) -> S:
+        """Process the configuration for this object."""
+
+        defaults = cls.default_settings.dict()
+        final_configuration = deep_update(defaults, configuration)
+
+        return cls.default_settings.__class__.parse_obj(final_configuration)
+
+
+def _get_user_config_fields(instance: BaseModel) -> dict[str, Any]:
+    """
+    Get the user config fields of a Pydantic model instance.
+
+    Args:
+        instance: The Pydantic model instance.
+
+    Returns:
+        The user config fields of the instance.
+    """
+    user_config_fields = {}
+
+    for name, value in instance.__dict__.items():
+        field_info = instance.__fields__[name]
+        if "user_configurable" in field_info.field_info.extra:
+            user_config_fields[name] = value
+        elif isinstance(value, SystemConfiguration):
+            user_config_fields[name] = value.get_user_config()
+        elif isinstance(value, list) and all(
+            isinstance(i, SystemConfiguration) for i in value
+        ):
+            user_config_fields[name] = [i.get_user_config() for i in value]
+        elif isinstance(value, dict) and all(
+            isinstance(i, SystemConfiguration) for i in value.values()
+        ):
+            user_config_fields[name] = {
+                k: v.get_user_config() for k, v in value.items()
+            }
+
+    return user_config_fields
+
+
+def deep_update(original_dict: dict, update_dict: dict) -> dict:
+    """
+    Recursively update a dictionary.
+
+    Args:
+        original_dict (dict): The dictionary to be updated.
+        update_dict (dict): The dictionary to update with.
+
+    Returns:
+        dict: The updated dictionary.
+    """
+    for key, value in update_dict.items():
+        if (
+            key in original_dict
+            and isinstance(original_dict[key], dict)
+            and isinstance(value, dict)
+        ):
+            original_dict[key] = deep_update(original_dict[key], value)
+        else:
+            original_dict[key] = value
+    return original_dict

autogpt/core/memory/__init__.py

@@ -0,0 +1,3 @@
+"""The memory subsystem manages the Agent's long-term memory."""
+from autogpt.core.memory.base import Memory
+from autogpt.core.memory.simple import MemorySettings, SimpleMemory

autogpt/core/memory/base.py

@@ -0,0 +1,13 @@
+import abc
+
+
+class Memory(abc.ABC):
+    pass
+
+
+class MemoryItem(abc.ABC):
+    pass
+
+
+class MessageHistory(abc.ABC):
+    pass

autogpt/core/memory/simple.py

@@ -0,0 +1,47 @@
+import json
+import logging
+
+from autogpt.core.configuration import Configurable, SystemConfiguration, SystemSettings
+from autogpt.core.memory.base import Memory
+from autogpt.core.workspace import Workspace
+
+
+class MemoryConfiguration(SystemConfiguration):
+    pass
+
+
+class MemorySettings(SystemSettings):
+    configuration: MemoryConfiguration
+
+
+class MessageHistory:
+    def __init__(self, previous_message_history: list[str]):
+        self._message_history = previous_message_history
+
+
+class SimpleMemory(Memory, Configurable):
+    default_settings = MemorySettings(
+        name="simple_memory",
+        description="A simple memory.",
+        configuration=MemoryConfiguration(),
+    )
+
+    def __init__(
+        self,
+        settings: MemorySettings,
+        logger: logging.Logger,
+        workspace: Workspace,
+    ):
+        self._configuration = settings.configuration
+        self._logger = logger
+        self._message_history = self._load_message_history(workspace)
+
+    @staticmethod
+    def _load_message_history(workspace: Workspace):
+        message_history_path = workspace.get_path("message_history.json")
+        if message_history_path.exists():
+            with message_history_path.open("r") as f:
+                message_history = json.load(f)
+        else:
+            message_history = []
+        return MessageHistory(message_history)

autogpt/core/planning/__init__.py

@@ -0,0 +1,10 @@
+"""The planning system organizes the Agent's activities."""
+from autogpt.core.planning.schema import (
+    LanguageModelClassification,
+    LanguageModelPrompt,
+    LanguageModelResponse,
+    Task,
+    TaskStatus,
+    TaskType,
+)
+from autogpt.core.planning.simple import PlannerSettings, SimplePlanner

autogpt/core/planning/base.py

@@ -0,0 +1,76 @@
+import abc
+
+from autogpt.core.configuration import SystemConfiguration
+from autogpt.core.planning.schema import (
+    LanguageModelClassification,
+    LanguageModelPrompt,
+)
+
+# class Planner(abc.ABC):
+#     """Manages the agent's planning and goal-setting by constructing language model prompts."""
+#
+#     @staticmethod
+#     @abc.abstractmethod
+#     async def decide_name_and_goals(
+#         user_objective: str,
+#     ) -> LanguageModelResponse:
+#         """Decide the name and goals of an Agent from a user-defined objective.
+#
+#         Args:
+#             user_objective: The user-defined objective for the agent.
+#
+#         Returns:
+#             The agent name and goals as a response from the language model.
+#
+#         """
+#         ...
+#
+#     @abc.abstractmethod
+#     async def plan(self, context: PlanningContext) -> LanguageModelResponse:
+#         """Plan the next ability for the Agent.
+#
+#         Args:
+#             context: A context object containing information about the agent's
+#                        progress, result, memories, and feedback.
+#
+#
+#         Returns:
+#             The next ability the agent should take along with thoughts and reasoning.
+#
+#         """
+#         ...
+#
+#     @abc.abstractmethod
+#     def reflect(
+#         self,
+#         context: ReflectionContext,
+#     ) -> LanguageModelResponse:
+#         """Reflect on a planned ability and provide self-criticism.
+#
+#
+#         Args:
+#             context: A context object containing information about the agent's
+#                        reasoning, plan, thoughts, and criticism.
+#
+#         Returns:
+#             Self-criticism about the agent's plan.
+#
+#         """
+#         ...
+
+
+class PromptStrategy(abc.ABC):
+    default_configuration: SystemConfiguration
+
+    @property
+    @abc.abstractmethod
+    def model_classification(self) -> LanguageModelClassification:
+        ...
+
+    @abc.abstractmethod
+    def build_prompt(self, *_, **kwargs) -> LanguageModelPrompt:
+        ...
+
+    @abc.abstractmethod
+    def parse_response_content(self, response_content: dict) -> dict:
+        ...