Fix test

.dockerignore

@@ -0,0 +1,40 @@
+# Ignore everything by default, selectively add things to context
+classic/run
+
+# AutoGPT
+!classic/original_autogpt/autogpt/
+!classic/original_autogpt/pyproject.toml
+!classic/original_autogpt/poetry.lock
+!classic/original_autogpt/README.md
+!classic/original_autogpt/tests/
+
+# Benchmark
+!classic/benchmark/agbenchmark/
+!classic/benchmark/pyproject.toml
+!classic/benchmark/poetry.lock
+!classic/benchmark/README.md
+
+# Forge
+!classic/forge/
+!classic/forge/pyproject.toml
+!classic/forge/poetry.lock
+!classic/forge/README.md
+
+# Frontend
+!classic/frontend/build/web/
+
+# Platform
+!autogpt_platform/
+
+# Explicitly re-ignore some folders
+.*
+**/__pycache__
+
+autogpt_platform/frontend/.next/
+autogpt_platform/frontend/node_modules
+autogpt_platform/frontend/.env.example
+autogpt_platform/frontend/.env.local
+autogpt_platform/backend/.env
+autogpt_platform/backend/.venv/
+
+autogpt_platform/market/.env

.gitattributes

@@ -0,0 +1,10 @@
+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
+
+* text=auto

.github/CODEOWNERS

@@ -0,0 +1,7 @@
+* @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/ISSUE_TEMPLATE/1.bug.yml

@@ -0,0 +1,173 @@
+name: Bug report 🐛
+description: Create a bug report for AutoGPT.
+labels: ['status: needs triage']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ### ⚠️ Before you continue
+        * Check out our [backlog], [roadmap] and join our [discord] to discuss what's going on
+        * If you need help, you can ask in the [discussions] section or in [#tech-support]
+        * **Thoroughly search the [existing issues] before creating a new one**
+        * Read our [wiki page on Contributing]
+        [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
+        [#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
+
+  - type: checkboxes
+    attributes:
+      label: ⚠️ Search for existing issues first ⚠️
+      description: >
+        Please [search the history](https://github.com/Significant-Gravitas/AutoGPT/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
+          required: true
+
+  - type: markdown
+    attributes:
+      value: |
+        Please confirm that the issue you have is described well and precise in the title above ⬆️.
+        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.
+        
+        ⚠️ SUPER-busy repo, please help the volunteer maintainers.
+        The less time we spend here, the more time we can spend building AutoGPT.
+        
+        Please help us help you by following these steps:
+        - Search for existing issues, adding a comment when you have the same or similar issue is tidier than "new issue" and 
+          newer issues will not be reviewed earlier, this is dependent on the current priorities set by our wonderful team
+        - Ask on our Discord if your issue is known when you are unsure (https://discord.gg/autogpt)
+        - Provide relevant info:
+          - Provide commit-hash (`git rev-parse HEAD` gets it) if possible
+          - If it's a pip/packages issue, mention this in the title and provide pip version, python version
+          - If it's a crash, provide traceback and describe the error you got as precise as possible in the title.
+
+  - type: dropdown
+    attributes:
+      label: Which Operating System are you using?
+      description: >
+        Please select the operating system you were using to run AutoGPT when this problem occurred.
+      options:
+        - Windows
+        - Linux
+        - MacOS
+        - Docker
+        - Devcontainer / Codespace
+        - Windows Subsystem for Linux (WSL)
+        - Other
+    validations:
+      required: true
+      nested_fields:
+        - type: text
+          attributes:
+            label: Specify the system
+            description: Please specify the system you are working on.
+
+  - type: dropdown
+    attributes:
+      label: Which version of AutoGPT 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.
+      options:
+        - Latest Release
+        - Stable (branch)
+        - Master (branch)
+    validations:
+      required: true
+
+  - type: dropdown
+    attributes:
+      label: What LLM Provider do you use?
+      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.
+      options:
+        - Azure
+        - Groq
+        - Anthropic
+        - Llamafile
+        - Other (detail in issue)
+    validations:
+      required: true
+
+  - type: dropdown
+    attributes:
+      label: Which area covers your issue best?
+      description: >
+        Select the area related to the issue you are reporting.
+      options:
+        - Installation and setup
+        - Memory
+        - Performance
+        - Prompt
+        - Commands
+        - Plugins
+        - AI Model Limitations
+        - Challenges
+        - Documentation
+        - Logging
+        - Agents
+        - Other
+    validations:
+      required: true
+      autolabels: true
+      nested_fields:
+        - type: text
+          attributes:
+            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
+    validations:
+      required: true
+
+  #Following are optional file content uploads
+  - type: markdown
+    attributes:
+      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."
+
+  - 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. ⚠️
+    validations:
+      required: false
+
+  - type: textarea
+    attributes:
+      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. ⚠️
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/2.feature.yml

@@ -0,0 +1,28 @@
+name: Feature request 🚀
+description: Suggest a new idea for AutoGPT!
+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)
+        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.
+      options:
+        - label: I have searched the existing issues
+          required: true
+  - type: textarea
+    attributes:
+      label: Summary 💡
+      description: Describe how it should work.
+  - type: textarea
+    attributes:
+      label: Examples 🌈
+      description: Provide a link to other implementations, or screenshots of the expected behavior.
+  - type: textarea
+    attributes:
+      label: Motivation 🔦
+      description: What are you trying to accomplish? How has the lack of this feature affected you? Providing context helps us come up with a solution that is more useful in the real world.

.github/PULL_REQUEST_TEMPLATE.md

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

.github/labeler.yml

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

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

@@ -0,0 +1,138 @@
+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-cache-clean.yml

@@ -0,0 +1,60 @@
+name: Classic - Purge Auto-GPT Docker CI cache
+
+on:
+  schedule:
+    - cron: 20 4 * * 1,4
+
+env:
+  BASE_BRANCH: development
+  IMAGE_NAME: auto-gpt
+
+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
+
+    - 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 }}
+        load: true    # save to docker images
+        # use GHA cache as read-only
+        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.schedule }}
+
+        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.sha }}
+        source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.sha) }}
+        push_forced_label:
+
+        new_commits_json: ${{ null }}
+        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

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

@@ -0,0 +1,166 @@
+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-autogpt-docker-release.yml

@@ -0,0 +1,87 @@
+name: Classic - AutoGPT Docker Release
+
+on:
+  release:
+    types: [ published, edited ]
+
+  workflow_dispatch:
+    inputs:
+      no_cache:
+        type: boolean
+        description: 'Build from scratch, without using cached layers'
+
+env:
+  IMAGE_NAME: auto-gpt
+  DEPLOY_IMAGE_NAME: ${{ secrets.DOCKER_USER }}/auto-gpt
+
+jobs:
+  build:
+    if: startsWith(github.ref, 'refs/tags/autogpt-')
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - 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
+
+      # 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
+      env:
+        raw_tag: ${{ github.ref_name }}
+
+    - id: build
+      name: Build image
+      uses: docker/build-push-action@v5
+      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
+        tags: >
+          ${{ 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
+
+    - name: Push image to Docker Hub
+      run: docker push --all-tags ${{ env.DEPLOY_IMAGE_NAME }}
+
+    - name: Generate build report
+      env:
+        event_name: ${{ github.event_name }}
+        event_ref: ${{ github.event.ref }}
+        event_ref_type: ${{ github.event.ref}}
+        inputs_no_cache: ${{ inputs.no_cache }}
+
+        prod_branch: master
+        dev_branch: development
+        repository: ${{ github.repository }}
+        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'development' && 'development' || 'master' }}
+
+        ref_type: ${{ github.ref_type }}
+        current_ref: ${{ github.ref_name }}
+        commit_hash: ${{ github.sha }}
+        source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.event.release && github.event.release.tag_name || github.sha) }}
+
+        github_context_json: ${{ toJSON(github) }}
+        job_env_json: ${{ toJSON(env) }}
+        vars_json: ${{ toJSON(vars) }}
+
+      run: .github/workflows/scripts/docker-release-summary.sh >> $GITHUB_STEP_SUMMARY
+      continue-on-error: true

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

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

@@ -0,0 +1,169 @@
+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 '(agbenchmark/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

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

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

@@ -0,0 +1,60 @@
+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/classic-frontend-ci.yml'
+  pull_request:
+    paths:
+      - 'classic/frontend/**'
+      - '.github/workflows/classic-frontend-ci.yml'
+
+jobs:
+  build:
+    permissions:
+      contents: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    env:
+      BUILD_BRANCH: ${{ format('classic-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

@@ -0,0 +1,151 @@
+name: Classic - Python checks
+
+on:
+  push:
+    branches: [ master, development, ci-test* ]
+    paths:
+      - '.github/workflows/classic-python-checks-ci.yml'
+      - 'classic/original_autogpt/**'
+      - 'classic/forge/**'
+      - 'classic/benchmark/**'
+      - '**.py'
+      - '!classic/forge/tests/vcr_cassettes'
+  pull_request:
+    branches: [ master, development, release-* ]
+    paths:
+      - '.github/workflows/classic-python-checks-ci.yml'
+      - 'classic/original_autogpt/**'
+      - 'classic/forge/**'
+      - 'classic/benchmark/**'
+      - '**.py'
+      - '!classic/forge/tests/vcr_cassettes'
+
+concurrency:
+  group: ${{ format('classic-python-checks-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/codeql.yml

@@ -0,0 +1,97 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master", "release-*" ]
+  pull_request:
+    branches: [ "master", "release-*" ]
+  schedule:
+    - cron: '15 4 * * 0'
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners (GitHub.com only)
+    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # required to fetch internal or private CodeQL packs
+      packages: read
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - language: typescript
+          build-mode: none
+        - language: python
+          build-mode: none
+        # CodeQL supports the following values keywords for 'language': 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        build-mode: ${{ matrix.build-mode }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        config: |
+          paths-ignore:
+            - classic/frontend/build/**
+
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+    # If the analyze step fails for one of the languages you are analyzing with
+    # "We were unable to automatically build your code", modify the matrix above
+    # to set the build mode to "manual" for that language. Then modify this step
+    # to build your code.
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+    - if: matrix.build-mode == 'manual'
+      shell: bash
+      run: |
+        echo 'If you are using a "manual" build mode for one or more of the' \
+          'languages you are analyzing, replace this with the commands to build' \
+          'your code, for example:'
+        echo '  make bootstrap'
+        echo '  make release'
+        exit 1
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:${{matrix.language}}"

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

@@ -0,0 +1,56 @@
+name: AutoGPT Platform - Infra
+
+on:
+  push:
+    branches: [ master ]
+    paths:
+      - '.github/workflows/platform-autogpt-infra-ci.yml'
+      - 'autogpt_platform/infra/**'
+  pull_request:
+    paths:
+      - '.github/workflows/platform-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-backend-ci.yml

@@ -0,0 +1,121 @@
+name: AutoGPT Platform - Backend CI
+
+on:
+  push:
+    branches: [master, development, ci-test*]
+    paths:
+      - ".github/workflows/platform-backend-ci.yml"
+      - "autogpt_platform/backend/**"
+  pull_request:
+    branches: [master, development, release-*]
+    paths:
+      - ".github/workflows/platform-backend-ci.yml"
+      - "autogpt_platform/backend/**"
+
+concurrency:
+  group: ${{ format('backend-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/backend
+
+jobs:
+  test:
+    permissions:
+      contents: read
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10"]
+    runs-on: ubuntu-latest
+
+    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: Setup Supabase
+        uses: supabase/setup-cli@v1
+        with:
+          version: latest
+
+      - id: get_date
+        name: Get date
+        run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
+
+      - name: Set up Python dependency cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pypoetry
+          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
+
+      - name: Install Poetry (Unix)
+        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 Python dependencies
+        run: poetry install
+
+      - name: Generate Prisma Client
+        run: poetry run prisma generate
+
+      - id: supabase
+        name: Start Supabase
+        working-directory: .
+        run: |
+          supabase init
+          supabase start --exclude postgres-meta,realtime,storage-api,imgproxy,inbucket,studio,edge-runtime,logflare,vector,supavisor
+          supabase status -o env | sed 's/="/=/; s/"$//' >> $GITHUB_OUTPUT
+        # outputs:
+        # DB_URL, API_URL, GRAPHQL_URL, ANON_KEY, SERVICE_ROLE_KEY, JWT_SECRET
+
+      - name: Run Database Migrations
+        run: poetry run prisma migrate dev --name updates
+        env:
+          DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
+
+      - 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' }}
+          DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
+          SUPABASE_URL: ${{ steps.supabase.outputs.API_URL }}
+          SUPABASE_SERVICE_ROLE_KEY: ${{ steps.supabase.outputs.SERVICE_ROLE_KEY }}
+          SUPABASE_JWT_SECRET: ${{ steps.supabase.outputs.JWT_SECRET }}
+    env:
+      CI: true
+      PLAIN_OUTPUT: True
+      RUN_ENV: local
+      PORT: 8080
+      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+
+      # - name: Upload coverage reports to Codecov
+      #   uses: codecov/codecov-action@v4
+      #   with:
+      #     token: ${{ secrets.CODECOV_TOKEN }}
+      #     flags: backend,${{ runner.os }}

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

@@ -0,0 +1,83 @@
+name: AutoGPT Platform - Frontend CI
+
+on:
+  push:
+    branches: [master]
+    paths:
+      - ".github/workflows/platform-frontend-ci.yml"
+      - "autogpt_platform/frontend/**"
+  pull_request:
+    paths:
+      - ".github/workflows/platform-frontend-ci.yml"
+      - "autogpt_platform/frontend/**"
+
+defaults:
+  run:
+    shell: bash
+    working-directory: autogpt_platform/frontend
+
+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
+
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "21"
+
+      - name: Copy default supabase .env
+        run: |
+          cp ../supabase/docker/.env.example ../.env
+
+      - name: Run docker compose
+        run: |
+          docker compose -f ../docker-compose.yml up -d
+
+      - name: Install dependencies
+        run: |
+          npm install
+
+      - name: Setup Builder .env
+        run: |
+          cp .env.example .env
+
+      - name: Install Playwright Browsers
+        run: npx playwright install --with-deps
+
+      - name: Run tests
+        run: |
+          npm run test
+
+      - uses: actions/upload-artifact@v4
+        if: ${{ !cancelled() }}
+        with:
+          name: playwright-report
+          path: playwright-report/
+          retention-days: 30

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

@@ -0,0 +1,34 @@
+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-pr-label.yml

@@ -0,0 +1,66 @@
+name: Repo - Pull Request auto-label
+
+on:
+  # So that PRs touching the same files as the push are updated
+  push:
+    branches: [ master, development, release-* ]
+    paths-ignore:
+      - 'classic/forge/tests/vcr_cassettes'
+      - 'classic/benchmark/reports/**'
+  # 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
+  pull_request_target:
+    types: [ opened, synchronize ]
+
+concurrency:
+  group: ${{ format('pr-label-{0}', github.event.pull_request.number || github.sha) }}
+  cancel-in-progress: true
+
+jobs:
+  conflicts:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - name: Update PRs with conflict labels
+        uses: eps1lon/actions-label-merge-conflict@releases/2.x
+        with:
+          dirtyLabel: "conflicts"
+          #removeOnDirtyLabel: "PR: ready to ship"
+          repoToken: "${{ secrets.GITHUB_TOKEN }}"
+          commentOnDirty: "This pull request has conflicts with the base branch, please resolve those so we can evaluate the pull request."
+          commentOnClean: "Conflicts have been resolved! 🎉 A maintainer will review the pull request shortly."
+
+  size:
+    if: ${{ github.event_name == 'pull_request_target' }}
+    permissions:
+      issues: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: codelytv/pr-size-labeler@v1
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          xs_label: 'size/xs'
+          xs_max_size: 2
+          s_label: 'size/s'
+          s_max_size: 10
+          m_label: 'size/m'
+          m_max_size: 100
+          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

.github/workflows/repo-stats.yml

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

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

@@ -0,0 +1,111 @@
+import json
+import os
+import requests
+import sys
+import time
+from typing import Dict, List, Tuple
+
+CHECK_INTERVAL = 30
+
+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. "
+            f"Waiting {CHECK_INTERVAL} seconds before checking again..."
+        )
+        time.sleep(CHECK_INTERVAL)
+
+    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()

.github/workflows/scripts/docker-ci-summary.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+meta=$(docker image inspect "$IMAGE_NAME" | jq '.[0]')
+head_compare_url=$(sed "s/{base}/$base_branch/; s/{head}/$current_ref/" <<< $compare_url_template)
+ref_compare_url=$(sed "s/{base}/$base_branch/; s/{head}/$commit_hash/" <<< $compare_url_template)
+
+EOF=$(dd if=/dev/urandom bs=15 count=1 status=none | base64)
+
+cat << $EOF
+# Docker Build summary 🔨
+
+**Source:** branch \`$current_ref\` -> [$repository@\`${commit_hash:0:7}\`]($source_url)
+
+**Build type:** \`$build_type\`
+
+**Image size:** $((`jq -r .Size <<< $meta` / 10**6))MB
+
+## Image details
+
+**Tags:**
+$(jq -r '.RepoTags | map("* `\(.)`") | join("\n")' <<< $meta)
+
+<details>
+<summary><h3>Layers</h3></summary>
+
+|    Age    |  Size  | Created by instruction |
+| --------- | ------ | ---------------------- |
+$(docker history --no-trunc --format "{{.CreatedSince}}\t{{.Size}}\t\`{{.CreatedBy}}\`\t{{.Comment}}" $IMAGE_NAME \
+    | grep 'buildkit.dockerfile' `# filter for layers created in this build process`\
+    | cut -f-3                   `# yeet Comment column`\
+    | sed 's/ ago//'             `# fix Layer age`\
+    | sed 's/ # buildkit//'      `# remove buildkit comment from instructions`\
+    | sed 's/\$/\\$/g'           `# escape variable and shell expansions`\
+    | sed 's/|/\\|/g'            `# escape pipes so they don't interfere with column separators`\
+    | column -t -s$'\t' -o' | '  `# align columns and add separator`\
+    | sed 's/^/| /; s/$/ |/'     `# add table row start and end pipes`)
+</details>
+
+<details>
+<summary><h3>ENV</h3></summary>
+
+| Variable | Value    |
+| -------- | -------- |
+$(jq -r \
+    '.Config.Env
+    | map(
+    split("=")
+    | "\(.[0]) | `\(.[1] | gsub("\\s+"; " "))`"
+    )
+    | map("| \(.) |")
+    | .[]' <<< $meta
+)
+</details>
+
+<details>
+<summary>Raw metadata</summary>
+
+\`\`\`JSON
+$meta
+\`\`\`
+</details>
+
+## Build details
+**Build trigger:** $push_forced_label $event_name \`$event_ref\`
+
+<details>
+<summary><code>github</code> context</summary>
+
+\`\`\`JSON
+$github_context_json
+\`\`\`
+</details>
+
+### Source
+**HEAD:** [$repository@\`${commit_hash:0:7}\`]($source_url) on branch [$current_ref]($ref_compare_url)
+
+**Diff with previous HEAD:** $head_compare_url
+
+#### New commits
+$(jq -r 'map([
+    "**Commit [`\(.id[0:7])`](\(.url)) by \(if .author.username then "@"+.author.username else .author.name end):**",
+    .message,
+    (if .committer.name != .author.name then "\n> <sub>**Committer:** \(.committer.name) <\(.committer.email)></sub>" else "" end),
+    "<sub>**Timestamp:** \(.timestamp)</sub>"
+] | map("> \(.)\n") | join("")) | join("\n")' <<< $new_commits_json)
+
+### Job environment
+
+#### \`vars\` context:
+\`\`\`JSON
+$vars_json
+\`\`\`
+
+#### \`env\` context:
+\`\`\`JSON
+$job_env_json
+\`\`\`
+
+$EOF

.github/workflows/scripts/docker-release-summary.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+meta=$(docker image inspect "$IMAGE_NAME" | jq '.[0]')
+
+EOF=$(dd if=/dev/urandom bs=15 count=1 status=none | base64)
+
+cat << $EOF
+# Docker Release Build summary 🚀🔨
+
+**Source:** $ref_type \`$current_ref\` -> [$repository@\`${commit_hash:0:7}\`]($source_url)
+
+**Image size:** $((`jq -r .Size <<< $meta` / 10**6))MB
+
+## Image details
+
+**Tags:**
+$(jq -r '.RepoTags | map("* `\(.)`") | join("\n")' <<< $meta)
+
+<details>
+<summary><h3>Layers</h3></summary>
+
+|    Age    |  Size  | Created by instruction |
+| --------- | ------ | ---------------------- |
+$(docker history --no-trunc --format "{{.CreatedSince}}\t{{.Size}}\t\`{{.CreatedBy}}\`\t{{.Comment}}" $IMAGE_NAME \
+    | grep 'buildkit.dockerfile' `# filter for layers created in this build process`\
+    | cut -f-3                   `# yeet Comment column`\
+    | sed 's/ ago//'             `# fix Layer age`\
+    | sed 's/ # buildkit//'      `# remove buildkit comment from instructions`\
+    | sed 's/\$/\\$/g'           `# escape variable and shell expansions`\
+    | sed 's/|/\\|/g'            `# escape pipes so they don't interfere with column separators`\
+    | column -t -s$'\t' -o' | '  `# align columns and add separator`\
+    | sed 's/^/| /; s/$/ |/'     `# add table row start and end pipes`)
+</details>
+
+<details>
+<summary><h3>ENV</h3></summary>
+
+| Variable | Value    |
+| -------- | -------- |
+$(jq -r \
+    '.Config.Env
+    | map(
+    split("=")
+    | "\(.[0]) | `\(.[1] | gsub("\\s+"; " "))`"
+    )
+    | map("| \(.) |")
+    | .[]' <<< $meta
+)
+</details>
+
+<details>
+<summary>Raw metadata</summary>
+
+\`\`\`JSON
+$meta
+\`\`\`
+</details>
+
+## Build details
+**Build trigger:** $event_name \`$current_ref\`
+
+| Parameter      | Value        |
+| -------------- | ------------ |
+| \`no_cache\`   | \`$inputs_no_cache\` |
+
+<details>
+<summary><code>github</code> context</summary>
+
+\`\`\`JSON
+$github_context_json
+\`\`\`
+</details>
+
+### Job environment
+
+#### \`vars\` context:
+\`\`\`JSON
+$vars_json
+\`\`\`
+
+#### \`env\` context:
+\`\`\`JSON
+$job_env_json
+\`\`\`
+
+$EOF

.gitignore

@@ -0,0 +1,173 @@
+## Original ignores
+.github_access_token
+classic/original_autogpt/keys.py
+classic/original_autogpt/*.json
+auto_gpt_workspace/*
+*.mpeg
+.env
+azure.yaml
+.vscode
+.idea/*
+auto-gpt.json
+log.txt
+log-ingestion.txt
+/logs
+*.log
+*.mp3
+mem.sqlite3
+venvAutoGPT
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+site/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.direnv/
+.env
+.venv
+env/
+venv*/
+ENV/
+env.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+llama-*
+vicuna-*
+
+# mac
+.DS_Store
+
+openai/
+
+# news
+CURRENT_BULLETIN.md
+
+# AgBenchmark
+classic/benchmark/agbenchmark/reports/
+
+# Nodejs
+package-lock.json
+
+
+# Allow for locally private items
+# private
+pri* 
+# ignore
+ig*
+.github_access_token
+LICENSE.rtf
+autogpt_platform/backend/settings.py

.gitmodules

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

.pr_agent.toml

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

.pre-commit-config.yaml

@@ -0,0 +1,127 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+      - id: check-added-large-files
+        args: ["--maxkb=500"]
+      - id: fix-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).
+    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)
+        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.
+    hooks:
+      - id: flake8
+        name: Lint (Flake8) - AutoGPT
+        alias: flake8-autogpt
+        files: ^classic/original_autogpt/(autogpt|scripts|tests)/
+        args: [--config=classic/original_autogpt/.flake8]
+
+      - 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.
+    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/(agbenchmark/|tests/|poetry\.lock$)
+        types: [file]
+        language: system
+        pass_filenames: false
+
+  - 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/(agbenchmark/|tests/|poetry\.lock$)
+        language: system
+        pass_filenames: false

.vscode/all-projects.code-workspace

@@ -0,0 +1,62 @@
+{
+  "folders": [
+    {
+      "name": "frontend",
+      "path": "../autogpt_platform/frontend"
+    },
+    {
+      "name": "backend",
+      "path": "../autogpt_platform/backend"
+    },
+    {
+      "name": "market",
+      "path": "../autogpt_platform/market"
+    },
+    {
+      "name": "lib",
+      "path": "../autogpt_platform/autogpt_libs"
+    },
+    {
+      "name": "infra",
+      "path": "../autogpt_platform/infra"
+    },
+    {
+      "name": "docs",
+      "path": "../docs"
+    },
+
+    {
+      "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"
+    },
+    {
+      "name": "[root]",
+      "path": ".."
+    }
+  ],
+  "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"
+    ]
+  }
+}

CITATION.cff

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

@@ -0,0 +1,40 @@
+# Code of Conduct for AutoGPT
+
+## 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.
+
+## 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.
+
+## 3. Our Standards
+
+We encourage the following behavior:
+
+* Being respectful and considerate to others
+* Actively seeking diverse perspectives
+* Providing constructive feedback and assistance
+* Demonstrating empathy and understanding
+
+We discourage the following behavior:
+
+* Harassment or discrimination of any kind
+* Disrespectful, offensive, or inappropriate language or content
+* Personal attacks or insults
+* Unwarranted criticism or negativity
+
+## 4. Reporting and Enforcement
+
+If you witness or experience any violations of this Code of Conduct, please report them to the project maintainers by email or other appropriate means. The maintainers will investigate and take appropriate action, which may include warnings, temporary or permanent bans, or other measures as necessary.
+
+Maintainers are responsible for ensuring compliance with this Code of Conduct and may take action to address any violations.
+
+## 5. Acknowledgements
+
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org/version/2/0/code_of_conduct.html).
+
+## 6. Contact
+
+If you have any questions or concerns, please contact the project maintainers on Discord:
+https://discord.gg/autogpt

CONTRIBUTING.md

@@ -0,0 +1,41 @@
+# AutoGPT Contribution Guide
+If you are reading this, you are probably looking for the full **[contribution guide]**,
+which is part of our [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]. -->
+
+[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
+
+## Contributing to the AutoGPT Platform Folder
+All contributions to [the autogpt_platform folder](https://github.com/Significant-Gravitas/AutoGPT/blob/master/autogpt_platform) will be under our [Contribution License Agreement](https://github.com/Significant-Gravitas/AutoGPT/blob/master/autogpt_platform/Contributor%20License%20Agreement%20(CLA).md). By making a pull request contributing to this folder, you agree to the terms of our CLA for your contribution.
+
+## 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.
+
+[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 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! :-)
+
+❤️ & 🔆
+The team @ AutoGPT
+https://discord.gg/autogpt

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Toran Bruce Richards
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,161 @@
+# AutoGPT: Build, Deploy, and Run AI Agents
+
+[![Discord Follow](https://dcbadge.vercel.app/api/server/autogpt?style=flat)](https://discord.gg/autogpt)  
+[![Twitter Follow](https://img.shields.io/twitter/follow/Auto_GPT?style=social)](https://twitter.com/Auto_GPT)  
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**AutoGPT** is a powerful platform that allows you to create, deploy, and manage continuous AI agents that automate complex workflows. 
+
+## Hosting Options 
+   - Download to self-host
+   - [Join the Waitlist](https://bit.ly/3ZDijAI) for the cloud-hosted beta  
+
+## How to Setup for Self-Hosting
+> [!NOTE]
+> Setting up and hosting the AutoGPT Platform yourself is a technical process. 
+> If you'd rather something that just works, we recommend [joining the waitlist](https://bit.ly/3ZDijAI) for the cloud-hosted beta.
+
+https://github.com/user-attachments/assets/d04273a5-b36a-4a37-818e-f631ce72d603
+
+This tutorial assumes you have Docker, VSCode, git and npm installed.
+
+### 🧱 AutoGPT Frontend
+
+The AutoGPT frontend is where users interact with our powerful AI automation platform. It offers multiple ways to engage with and leverage our AI agents. This is the interface where you'll bring your AI automation ideas to life:
+
+   **Agent Builder:** For those who want to customize, our intuitive, low-code interface allows you to design and configure your own AI agents. 
+   
+   **Workflow Management:** Build, modify, and optimize your automation workflows with ease. You build your agent by connecting blocks, where each block     performs a single action.
+   
+   **Deployment Controls:** Manage the lifecycle of your agents, from testing to production.
+   
+   **Ready-to-Use Agents:** Don't want to build? Simply select from our library of pre-configured agents and put them to work immediately.
+   
+   **Agent Interaction:** Whether you've built your own or are using pre-configured agents, easily run and interact with them through our user-friendly      interface.
+
+   **Monitoring and Analytics:** Keep track of your agents' performance and gain insights to continually improve your automation processes.
+
+[Read this guide](https://docs.agpt.co/server/new_blocks/) to learn how to build your own custom blocks.
+
+### 💽 AutoGPT Server
+
+The AutoGPT Server is the powerhouse of our platform This is where your agents run. Once deployed, agents can be triggered by external sources and can operate continuously. It contains all the essential components that make AutoGPT run smoothly.
+
+   **Source Code:** The core logic that drives our agents and automation processes.
+   
+   **Infrastructure:** Robust systems that ensure reliable and scalable performance.
+   
+   **Marketplace:** A comprehensive marketplace where you can find and deploy a wide range of pre-built agents.
+
+### 🐙 Example Agents
+
+Here are two examples of what you can do with AutoGPT:
+
+1. **Generate Viral Videos from Trending Topics**
+   - This agent reads topics on Reddit.
+   - It identifies trending topics.
+   - It then automatically creates a short-form video based on the content. 
+
+2. **Identify Top Quotes from Videos for Social Media**
+   - This agent subscribes to your YouTube channel.
+   - When you post a new video, it transcribes it.
+   - It uses AI to identify the most impactful quotes to generate a summary.
+   - Then, it writes a post to automatically publish to your social media. 
+
+These examples show just a glimpse of what you can achieve with AutoGPT! You can create customized workflows to build agents for any use case.
+
+---
+Our mission is to provide the tools, so that you can focus on what matters:
+
+- 🏗️ **Building** - Lay the foundation for something amazing.
+- 🧪 **Testing** - Fine-tune your agent to perfection.
+- 🤝 **Delegating** - Let AI work for you, and have your ideas come to life.
+
+Be part of the revolution! **AutoGPT** is here to stay, at the forefront of AI innovation.
+
+**📖 [Documentation](https://docs.agpt.co)**
+ | 
+**🚀 [Contributing](CONTRIBUTING.md)**
+
+
+---
+## 🤖 AutoGPT Classic
+> Below is information about the classic version of AutoGPT.
+
+**🛠️ [Build your own Agent - Quickstart](classic/FORGE-QUICKSTART.md)**
+
+### 🏗️ Forge
+
+**Forge your own agent!** – Forge is a ready-to-go toolkit to build your own agent application. It handles most of the boilerplate code, letting you channel all your creativity into the things that set *your* agent apart. All tutorials are located [here](https://medium.com/@aiedge/autogpt-forge-e3de53cc58ec). Components from [`forge`](/classic/forge/) can also be used individually to speed up development and reduce boilerplate in your agent project.
+
+🚀 [**Getting Started with Forge**](https://github.com/Significant-Gravitas/AutoGPT/blob/master/classic/forge/tutorials/001_getting_started.md) –
+This guide will walk you through the process of creating your own agent and using the benchmark and user interface.
+
+📘 [Learn More](https://github.com/Significant-Gravitas/AutoGPT/tree/master/classic/forge) about Forge
+
+### 🎯 Benchmark
+
+**Measure your agent's performance!** The `agbenchmark` can be used with any agent that supports the agent protocol, and the integration with the project's [CLI] makes it even easier to use with AutoGPT and forge-based agents. The benchmark offers a stringent testing environment. Our framework allows for autonomous, objective performance evaluations, ensuring your agents are primed for real-world action.
+
+<!-- TODO: insert visual demonstrating the benchmark -->
+
+📦 [`agbenchmark`](https://pypi.org/project/agbenchmark/) on Pypi
+&ensp;|&ensp;
+📘 [Learn More](https://github.com/Significant-Gravitas/AutoGPT/blob/master/benchmark) about the Benchmark
+
+### 💻 UI
+
+**Makes agents easy to use!** The `frontend` gives you a user-friendly interface to control and monitor your agents. It connects to agents through the [agent protocol](#-agent-protocol), ensuring compatibility with many agents from both inside and outside of our ecosystem.
+
+<!-- TODO: insert screenshot of front end -->
+
+The frontend works out-of-the-box with all agents in the repo. Just use the [CLI] to run your agent of choice!
+
+📘 [Learn More](https://github.com/Significant-Gravitas/AutoGPT/tree/master/classic/frontend) about the Frontend
+
+### ⌨️ CLI
+
+[CLI]: #-cli
+
+To make it as easy as possible to use all of the tools offered by the repository, a CLI is included at the root of the repo:
+
+```shell
+$ ./run
+Usage: cli.py [OPTIONS] COMMAND [ARGS]...
+
+Options:
+  --help  Show this message and exit.
+
+Commands:
+  agent      Commands to create, start and stop agents
+  benchmark  Commands to start the benchmark and list tests and categories
+  setup      Installs dependencies needed for your system.
+```
+
+Just clone the repo, install dependencies with `./run setup`, and you should be good to go!
+
+## 🤔 Questions? Problems? Suggestions?
+
+### Get help - [Discord 💬](https://discord.gg/autogpt)
+
+[![Join us on Discord](https://invidget.switchblade.xyz/autogpt)](https://discord.gg/autogpt)
+
+To report a bug or request a feature, create a [GitHub Issue](https://github.com/Significant-Gravitas/AutoGPT/issues/new/choose). Please ensure someone else hasn’t created an issue for the same topic.
+
+## 🤝 Sister projects
+
+### 🔄 Agent Protocol
+
+To maintain a uniform standard and ensure seamless compatibility with many current and future applications, AutoGPT employs the [agent protocol](https://agentprotocol.ai/) standard by the AI Engineer Foundation. This standardizes the communication pathways from your agent to the frontend and benchmark.
+
+---
+
+<p align="center">
+<a href="https://star-history.com/#Significant-Gravitas/AutoGPT">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=Significant-Gravitas/AutoGPT&type=Date&theme=dark" />
+    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=Significant-Gravitas/AutoGPT&type=Date" />
+    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=Significant-Gravitas/AutoGPT&type=Date" />
+  </picture>
+</a>
+</p>

autogpt_platform/Contributor License Agreement (CLA).md

@@ -0,0 +1,21 @@
+**Determinist Ltd** 
+
+**Contributor License Agreement (“Agreement”)**
+
+Thank you for your interest in the AutoGPT open source project at [https://github.com/Significant-Gravitas/AutoGPT](https://github.com/Significant-Gravitas/AutoGPT) stewarded by Determinist Ltd (“**Determinist**”), with offices at 3rd Floor 1 Ashley Road, Altrincham, Cheshire, WA14 2DT, United Kingdom. The form of license below is a document that clarifies the terms under which You, the person listed below, may contribute software code described below (the “**Contribution**”) to the project.  We appreciate your participation in our project, and your help in improving our products, so we want you to understand what will be done with the Contributions.  This license is for your protection as well as the protection of Determinist and its licensees; it does not change your rights to use your own Contributions for any other purpose.        
+
+By submitting a Pull Request which modifies the content of the “autogpt\_platform” folder at [https://github.com/Significant-Gravitas/AutoGPT/tree/master/autogpt\_platform](https://github.com/Significant-Gravitas/AutoGPT/tree/master/autogpt_platform), You hereby agree:  
+
+1\.	**You grant us the ability to use the Contributions in any way**.  You hereby grant to Determinist  a non-exclusive, irrevocable, worldwide, royalty-free, sublicenseable, transferable license under all of Your relevant intellectual property rights (including copyright, patent, and any other rights), to use, copy, prepare derivative works of, distribute and publicly perform and display the Contributions on any licensing terms, including without limitation: (a) open source licenses like the GNU General Public License (GPL), the GNU Lesser General Public License (LGPL), the Common Public License, or the Berkeley Science Division license (BSD); and (b) binary, proprietary, or commercial licenses.
+
+2\. 	**Grant of Patent License**. You hereby grant to Determinist a worldwide, non-exclusive, royalty-free, irrevocable, license, under any rights you may have, now or in the future, in any patents or patent applications, to make, have made, use, offer to sell, sell, and import products containing the Contribution or portions of the Contribution.  This license extends to patent claims that are infringed by the Contribution alone or by combination of the Contribution with other inventions.  
+
+4\. 	**Limitations on Licenses**.  The licenses granted in this Agreement will continue for the duration of the applicable patent or intellectual property right under which such license is granted.   The licenses granted in this Agreement will include the right to grant and authorize sublicenses, so long as the sublicenses are within the scope of the licenses granted in this Agreement.  Except for the licenses granted herein, You reserve all right, title, and interest in and to the Contribution.    
+
+5\. 	**You are able to grant us these rights**.  You represent that You are legally entitled to grant the above license.  If Your employer has rights to intellectual property that You create, You represent that You are authorized to make the Contributions on behalf of that employer, or that Your employer has waived such rights for the Contributions.  
+
+3\.	**The Contributions are your original work**.  You represent that the Contributions are Your original works of authorship, and to Your knowledge, no other person claims, or has the right to claim, any right in any invention or patent related to the Contributions.  You also represent that You are not legally obligated, whether by entering into an agreement or otherwise, in any way that conflicts with the terms of this license.  For example, if you have signed an agreement requiring you to assign the intellectual property rights in the Contributions to an employer or customer, that would conflict with the terms of this license.  
+    
+6\.  **We determine the code that is in our products**.  You understand that the decision to include the Contribution in any product or source repository is entirely that of Determinist, and this agreement does not guarantee that the Contributions will be included in any product. 
+
+7\. **No Implied Warranties.**  Determinist acknowledges that, except as explicitly described in this Agreement, the Contribution is provided on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT   LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.    

autogpt_platform/LICENCE.txt

@@ -0,0 +1,164 @@
+# PolyForm Shield License 1.0.0
+
+<https://polyformproject.org/licenses/shield/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the
+software to do everything you might do with the software
+that would otherwise infringe the licensor's copyright
+in it for any permitted purpose.  However, you may
+only distribute the software according to [Distribution
+License](#distribution-license) and make changes or new works
+based on the software according to [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license
+to distribute copies of the software.  Your license
+to distribute covers distributing the software with
+changes and new works permitted by [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of
+the software from you also gets a copy of these terms or the
+URL for them above, as well as copies of any plain-text lines
+beginning with `Required Notice:` that the licensor provided
+with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Noncompete
+
+Any purpose is a permitted purpose, except for providing any
+product that competes with the software or any product the
+licensor or any of its affiliates provides using the software.
+
+## Competition
+
+Goods and services compete even when they provide functionality
+through different kinds of interfaces or for different technical
+platforms.  Applications can compete with services, libraries
+with plugins, frameworks with development tools, and so on,
+even if they're written in different programming languages
+or for different computer architectures.  Goods and services
+compete even when provided free of charge.  If you market a
+product as a practical substitute for the software or another
+product, it definitely competes.
+
+## New Products
+
+If you are using the software to provide a product that does
+not compete, but the licensor or any of its affiliates brings
+your product into competition by providing a new version of
+the software or another product using the software, you may
+continue using versions of the software available under these
+terms beforehand to provide your competing product, but not
+any later versions.
+
+## Discontinued Products
+
+You may begin using the software to compete with a product
+or service that the licensor or any of its affiliates has
+stopped providing, unless the licensor includes a plain-text
+line beginning with `Licensor Line of Business:` with the
+software that mentions that line of business.  For example:
+
+> Licensor Line of Business: YoyodyneCMS Content Management
+System (http://example.com/cms)
+
+## Sales of Business
+
+If the licensor or any of its affiliates sells a line of
+business developing the software or using the software
+to provide a product, the buyer can also enforce
+[Noncompete](#noncompete) for that product.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else.  These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice.  Otherwise, all your licenses
+end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+A **product** can be a good or service, or a combination
+of them.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+its affiliates.
+
+**Affiliates** means the other organizations than an
+organization has control over, is under the control of, or is
+under common control with.
+
+**Control** means ownership of substantially all the assets of
+an entity, or the power to direct its management and policies
+by vote, contract, or otherwise.  Control can be direct or
+indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.

autogpt_platform/README.md

@@ -0,0 +1,154 @@
+# AutoGPT Platform
+
+Welcome to the AutoGPT Platform - a powerful system for creating and running AI agents to solve business problems. This platform enables you to harness the power of artificial intelligence to automate tasks, analyze data, and generate insights for your organization.
+
+## Getting Started
+
+### Prerequisites
+
+- Docker
+- Docker Compose V2 (comes with Docker Desktop, or can be installed separately)
+- Node.js & NPM (for running the frontend application)
+
+### Running the System
+
+To run the AutoGPT Platform, follow these steps:
+
+1. Clone this repository to your local machine and navigate to the `autogpt_platform` directory within the repository:
+   ```
+   git clone <https://github.com/Significant-Gravitas/AutoGPT.git | git@github.com:Significant-Gravitas/AutoGPT.git>
+   cd AutoGPT/autogpt_platform
+   ```
+
+2. Run the following command:
+   ```
+   git submodule update --init --recursive
+   ```
+   This command will initialize and update the submodules in the repository. The `supabase` folder will be cloned to the root directory.
+
+3. Run the following command:
+   ```
+   cp supabase/docker/.env.example .env
+   ```
+   This command will copy the `.env.example` file to `.env` in the `supabase/docker` directory. You can modify the `.env` file to add your own environment variables.
+
+4. Run the following command:
+   ```
+   docker compose up -d
+   ```
+   This command will start all the necessary backend services defined in the `docker-compose.yml` file in detached mode.
+
+5. Navigate to `frontend` within the `autogpt_platform` directory:
+   ```
+   cd frontend
+   ```
+   You will need to run your frontend application separately on your local machine.
+
+6. Run the following command: 
+   ```
+   cp .env.example .env
+   ```
+   This command will copy the `.env.example` file to `.env` in the `frontend` directory. You can modify the `.env` within this folder to add your own environment variables for the frontend application.
+
+7. Run the following command:
+   ```
+   npm install
+   npm run dev
+   ```
+   This command will install the necessary dependencies and start the frontend application in development mode.
+   If you are using Yarn, you can run the following commands instead:
+   ```
+   yarn install && yarn dev
+   ```
+
+8. Open your browser and navigate to `http://localhost:3000` to access the AutoGPT Platform frontend.
+
+### Docker Compose Commands
+
+Here are some useful Docker Compose commands for managing your AutoGPT Platform:
+
+- `docker compose up -d`: Start the services in detached mode.
+- `docker compose stop`: Stop the running services without removing them.
+- `docker compose rm`: Remove stopped service containers.
+- `docker compose build`: Build or rebuild services.
+- `docker compose down`: Stop and remove containers, networks, and volumes.
+- `docker compose watch`: Watch for changes in your services and automatically update them.
+
+
+### Sample Scenarios
+
+Here are some common scenarios where you might use multiple Docker Compose commands:
+
+1. Updating and restarting a specific service:
+   ```
+   docker compose build api_srv
+   docker compose up -d --no-deps api_srv
+   ```
+   This rebuilds the `api_srv` service and restarts it without affecting other services.
+
+2. Viewing logs for troubleshooting:
+   ```
+   docker compose logs -f api_srv ws_srv
+   ```
+   This shows and follows the logs for both `api_srv` and `ws_srv` services.
+
+3. Scaling a service for increased load:
+   ```
+   docker compose up -d --scale executor=3
+   ```
+   This scales the `executor` service to 3 instances to handle increased load.
+
+4. Stopping the entire system for maintenance:
+   ```
+   docker compose stop
+   docker compose rm -f
+   docker compose pull
+   docker compose up -d
+   ```
+   This stops all services, removes containers, pulls the latest images, and restarts the system.
+
+5. Developing with live updates:
+   ```
+   docker compose watch
+   ```
+   This watches for changes in your code and automatically updates the relevant services.
+
+6. Checking the status of services:
+   ```
+   docker compose ps
+   ```
+   This shows the current status of all services defined in your docker-compose.yml file.
+
+These scenarios demonstrate how to use Docker Compose commands in combination to manage your AutoGPT Platform effectively.
+
+
+### Persisting Data
+
+To persist data for PostgreSQL and Redis, you can modify the `docker-compose.yml` file to add volumes. Here's how:
+
+1. Open the `docker-compose.yml` file in a text editor.
+2. Add volume configurations for PostgreSQL and Redis services:
+
+   ```yaml
+   services:
+     postgres:
+       # ... other configurations ...
+       volumes:
+         - postgres_data:/var/lib/postgresql/data
+
+     redis:
+       # ... other configurations ...
+       volumes:
+         - redis_data:/data
+
+   volumes:
+     postgres_data:
+     redis_data:
+   ```
+
+3. Save the file and run `docker compose up -d` to apply the changes.
+
+This configuration will create named volumes for PostgreSQL and Redis, ensuring that your data persists across container restarts.
+
+
+

autogpt_platform/autogpt_libs/README.md

@@ -0,0 +1,3 @@
+# AutoGPT Libs
+
+This is a new project to store shared functionality across different services in NextGen AutoGPT (e.g. authentication)

autogpt_platform/autogpt_libs/autogpt_libs/auth/__init__.py

@@ -0,0 +1,14 @@
+from .config import Settings
+from .depends import requires_admin_user, requires_user
+from .jwt_utils import parse_jwt_token
+from .middleware import auth_middleware
+from .models import User
+
+__all__ = [
+    "Settings",
+    "parse_jwt_token",
+    "requires_user",
+    "requires_admin_user",
+    "auth_middleware",
+    "User",
+]

autogpt_platform/autogpt_libs/autogpt_libs/auth/config.py

@@ -0,0 +1,18 @@
+import os
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class Settings:
+    JWT_SECRET_KEY: str = os.getenv("SUPABASE_JWT_SECRET", "")
+    ENABLE_AUTH: bool = os.getenv("ENABLE_AUTH", "false").lower() == "true"
+    JWT_ALGORITHM: str = "HS256"
+
+    @property
+    def is_configured(self) -> bool:
+        return bool(self.JWT_SECRET_KEY)
+
+
+settings = Settings()

autogpt_platform/autogpt_libs/autogpt_libs/auth/depends.py

@@ -0,0 +1,32 @@
+import fastapi
+
+from .middleware import auth_middleware
+from .models import User
+
+
+def requires_user(payload: dict = fastapi.Depends(auth_middleware)) -> User:
+    return verify_user(payload, admin_only=False)
+
+
+def requires_admin_user(
+    payload: dict = fastapi.Depends(auth_middleware),
+) -> User:
+    return verify_user(payload, admin_only=True)
+
+
+def verify_user(payload: dict | None, admin_only: bool) -> User:
+    if not payload:
+        # This handles the case when authentication is disabled
+        payload = {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "admin"}
+
+    user_id = payload.get("sub")
+
+    if not user_id:
+        raise fastapi.HTTPException(
+            status_code=401, detail="User ID not found in token"
+        )
+
+    if admin_only and payload["role"] != "admin":
+        raise fastapi.HTTPException(status_code=403, detail="Admin access required")
+
+    return User.from_payload(payload)

autogpt_platform/autogpt_libs/autogpt_libs/auth/depends_tests.py

@@ -0,0 +1,68 @@
+import pytest
+
+from .depends import requires_admin_user, requires_user, verify_user
+
+
+def test_verify_user_no_payload():
+    user = verify_user(None, admin_only=False)
+    assert user.user_id == "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
+    assert user.role == "admin"
+
+
+def test_verify_user_no_user_id():
+    with pytest.raises(Exception):
+        verify_user({"role": "admin"}, admin_only=False)
+
+
+def test_verify_user_not_admin():
+    with pytest.raises(Exception):
+        verify_user(
+            {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "user"},
+            admin_only=True,
+        )
+
+
+def test_verify_user_with_admin_role():
+    user = verify_user(
+        {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "admin"},
+        admin_only=True,
+    )
+    assert user.user_id == "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
+    assert user.role == "admin"
+
+
+def test_verify_user_with_user_role():
+    user = verify_user(
+        {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "user"},
+        admin_only=False,
+    )
+    assert user.user_id == "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
+    assert user.role == "user"
+
+
+def test_requires_user():
+    user = requires_user(
+        {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "user"}
+    )
+    assert user.user_id == "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
+    assert user.role == "user"
+
+
+def test_requires_user_no_user_id():
+    with pytest.raises(Exception):
+        requires_user({"role": "user"})
+
+
+def test_requires_admin_user():
+    user = requires_admin_user(
+        {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "admin"}
+    )
+    assert user.user_id == "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
+    assert user.role == "admin"
+
+
+def test_requires_admin_user_not_admin():
+    with pytest.raises(Exception):
+        requires_admin_user(
+            {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "user"}
+        )

autogpt_platform/autogpt_libs/autogpt_libs/auth/jwt_utils.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict
+
+import jwt
+
+from .config import settings
+
+
+def parse_jwt_token(token: str) -> Dict[str, Any]:
+    """
+    Parse and validate a JWT token.
+
+    :param token: The token to parse
+    :return: The decoded payload
+    :raises ValueError: If the token is invalid or expired
+    """
+    try:
+        payload = jwt.decode(
+            token,
+            settings.JWT_SECRET_KEY,
+            algorithms=[settings.JWT_ALGORITHM],
+            audience="authenticated",
+        )
+        return payload
+    except jwt.ExpiredSignatureError:
+        raise ValueError("Token has expired")
+    except jwt.InvalidTokenError as e:
+        raise ValueError(f"Invalid token: {str(e)}")

autogpt_platform/autogpt_libs/autogpt_libs/auth/middleware.py

@@ -0,0 +1,31 @@
+import logging
+
+from fastapi import HTTPException, Request
+from fastapi.security import HTTPBearer
+
+from .config import settings
+from .jwt_utils import parse_jwt_token
+
+security = HTTPBearer()
+logger = logging.getLogger(__name__)
+
+
+async def auth_middleware(request: Request):
+    if not settings.ENABLE_AUTH:
+        # If authentication is disabled, allow the request to proceed
+        logger.warn("Auth disabled")
+        return {}
+
+    security = HTTPBearer()
+    credentials = await security(request)
+
+    if not credentials:
+        raise HTTPException(status_code=401, detail="Authorization header is missing")
+
+    try:
+        payload = parse_jwt_token(credentials.credentials)
+        request.state.user = payload
+        logger.debug("Token decoded successfully")
+    except ValueError as e:
+        raise HTTPException(status_code=401, detail=str(e))
+    return payload

autogpt_platform/autogpt_libs/autogpt_libs/auth/models.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+
+
+# Using dataclass here to avoid adding dependency on pydantic
+@dataclass(frozen=True)
+class User:
+    user_id: str
+    email: str
+    phone_number: str
+    role: str
+
+    @classmethod
+    def from_payload(cls, payload):
+        return cls(
+            user_id=payload["sub"],
+            email=payload.get("email", ""),
+            phone_number=payload.get("phone", ""),
+            role=payload["role"],
+        )

autogpt_platform/autogpt_libs/autogpt_libs/logging/__init__.py

@@ -0,0 +1,9 @@
+from .config import configure_logging
+from .filters import BelowLevelFilter
+from .formatters import FancyConsoleFormatter
+
+__all__ = [
+    "configure_logging",
+    "BelowLevelFilter",
+    "FancyConsoleFormatter",
+]

autogpt_platform/autogpt_libs/autogpt_libs/logging/config.py

@@ -0,0 +1,166 @@
+"""Logging module for Auto-GPT."""
+
+import logging
+import sys
+from pathlib import Path
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from .filters import BelowLevelFilter
+from .formatters import AGPTFormatter, StructuredLoggingFormatter
+
+LOG_DIR = Path(__file__).parent.parent.parent.parent / "logs"
+LOG_FILE = "activity.log"
+DEBUG_LOG_FILE = "debug.log"
+ERROR_LOG_FILE = "error.log"
+
+SIMPLE_LOG_FORMAT = "%(asctime)s %(levelname)s  %(title)s%(message)s"
+
+DEBUG_LOG_FORMAT = (
+    "%(asctime)s %(levelname)s %(filename)s:%(lineno)d" "  %(title)s%(message)s"
+)
+
+
+class LoggingConfig(BaseSettings):
+
+    level: str = Field(
+        default="INFO",
+        description="Logging level",
+        validation_alias="LOG_LEVEL",
+    )
+
+    enable_cloud_logging: bool = Field(
+        default=False,
+        description="Enable logging to Google Cloud Logging",
+    )
+
+    enable_file_logging: bool = Field(
+        default=False,
+        description="Enable logging to file",
+    )
+    # File output
+    log_dir: Path = Field(
+        default=LOG_DIR,
+        description="Log directory",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("level", mode="before")
+    @classmethod
+    def parse_log_level(cls, v):
+        if isinstance(v, str):
+            v = v.upper()
+            if v not in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
+                raise ValueError(f"Invalid log level: {v}")
+            return v
+        return v
+
+
+def configure_logging(force_cloud_logging: bool = False) -> None:
+    """Configure the native logging module based on the LoggingConfig settings.
+
+    This function sets up logging handlers and formatters according to the
+    configuration specified in the LoggingConfig object. It supports various
+    logging outputs including console, file, cloud, and JSON logging.
+
+    The function uses the LoggingConfig object to determine which logging
+    features to enable and how to configure them. This includes setting
+    log levels, log formats, and output destinations.
+
+    No arguments are required as the function creates its own LoggingConfig
+    instance internally.
+
+    Note: This function is typically called at the start of the application
+    to set up the logging infrastructure.
+    """
+
+    config = LoggingConfig()
+
+    log_handlers: list[logging.Handler] = []
+
+    # Cloud logging setup
+    if config.enable_cloud_logging or force_cloud_logging:
+        import google.cloud.logging
+        from google.cloud.logging.handlers import CloudLoggingHandler
+        from google.cloud.logging_v2.handlers.transports.sync import SyncTransport
+
+        client = google.cloud.logging.Client()
+        cloud_handler = CloudLoggingHandler(
+            client,
+            name="autogpt_logs",
+            transport=SyncTransport,
+        )
+        cloud_handler.setLevel(config.level)
+        cloud_handler.setFormatter(StructuredLoggingFormatter())
+        log_handlers.append(cloud_handler)
+        print("Cloud logging enabled")
+    else:
+        # Console output handlers
+        stdout = logging.StreamHandler(stream=sys.stdout)
+        stdout.setLevel(config.level)
+        stdout.addFilter(BelowLevelFilter(logging.WARNING))
+        if config.level == logging.DEBUG:
+            stdout.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
+        else:
+            stdout.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
+
+        stderr = logging.StreamHandler()
+        stderr.setLevel(logging.WARNING)
+        if config.level == logging.DEBUG:
+            stderr.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
+        else:
+            stderr.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
+
+        log_handlers += [stdout, stderr]
+        print("Console logging enabled")
+
+    # File logging setup
+    if config.enable_file_logging:
+        # create log directory if it doesn't exist
+        if not config.log_dir.exists():
+            config.log_dir.mkdir(parents=True, exist_ok=True)
+
+        print(f"Log directory: {config.log_dir}")
+
+        # Activity log handler (INFO and above)
+        activity_log_handler = logging.FileHandler(
+            config.log_dir / LOG_FILE, "a", "utf-8"
+        )
+        activity_log_handler.setLevel(config.level)
+        activity_log_handler.setFormatter(
+            AGPTFormatter(SIMPLE_LOG_FORMAT, no_color=True)
+        )
+        log_handlers.append(activity_log_handler)
+
+        if config.level == logging.DEBUG:
+            # Debug log handler (all levels)
+            debug_log_handler = logging.FileHandler(
+                config.log_dir / DEBUG_LOG_FILE, "a", "utf-8"
+            )
+            debug_log_handler.setLevel(logging.DEBUG)
+            debug_log_handler.setFormatter(
+                AGPTFormatter(DEBUG_LOG_FORMAT, no_color=True)
+            )
+            log_handlers.append(debug_log_handler)
+
+        # Error log handler (ERROR and above)
+        error_log_handler = logging.FileHandler(
+            config.log_dir / ERROR_LOG_FILE, "a", "utf-8"
+        )
+        error_log_handler.setLevel(logging.ERROR)
+        error_log_handler.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT, no_color=True))
+        log_handlers.append(error_log_handler)
+        print("File logging enabled")
+
+    # Configure the root logger
+    logging.basicConfig(
+        format=DEBUG_LOG_FORMAT if config.level == logging.DEBUG else SIMPLE_LOG_FORMAT,
+        level=config.level,
+        handlers=log_handlers,
+    )

autogpt_platform/autogpt_libs/autogpt_libs/logging/filters.py

@@ -0,0 +1,12 @@
+import logging
+
+
+class BelowLevelFilter(logging.Filter):
+    """Filter for logging levels below a certain threshold."""
+
+    def __init__(self, below_level: int):
+        super().__init__()
+        self.below_level = below_level
+
+    def filter(self, record: logging.LogRecord):
+        return record.levelno < self.below_level

autogpt_platform/autogpt_libs/autogpt_libs/logging/formatters.py

@@ -0,0 +1,95 @@
+import logging
+
+from colorama import Fore, Style
+from google.cloud.logging_v2.handlers import CloudLoggingFilter, StructuredLogHandler
+
+from .utils import remove_color_codes
+
+
+class FancyConsoleFormatter(logging.Formatter):
+    """
+    A custom logging formatter designed for console output.
+
+    This formatter enhances the standard logging output with color coding. The color
+    coding is based on the level of the log message, making it easier to distinguish
+    between different types of messages in the console output.
+
+    The color for each level is defined in the LEVEL_COLOR_MAP class attribute.
+    """
+
+    # level -> (level & text color, title color)
+    LEVEL_COLOR_MAP = {
+        logging.DEBUG: Fore.LIGHTBLACK_EX,
+        logging.INFO: Fore.BLUE,
+        logging.WARNING: Fore.YELLOW,
+        logging.ERROR: Fore.RED,
+        logging.CRITICAL: Fore.RED + Style.BRIGHT,
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        # Make sure `msg` is a string
+        if not hasattr(record, "msg"):
+            record.msg = ""
+        elif type(record.msg) is not str:
+            record.msg = str(record.msg)
+
+        # Determine default color based on error level
+        level_color = ""
+        if record.levelno in self.LEVEL_COLOR_MAP:
+            level_color = self.LEVEL_COLOR_MAP[record.levelno]
+            record.levelname = f"{level_color}{record.levelname}{Style.RESET_ALL}"
+
+        # Determine color for message
+        color = getattr(record, "color", level_color)
+        color_is_specified = hasattr(record, "color")
+
+        # Don't color INFO messages unless the color is explicitly specified.
+        if color and (record.levelno != logging.INFO or color_is_specified):
+            record.msg = f"{color}{record.msg}{Style.RESET_ALL}"
+
+        return super().format(record)
+
+
+class AGPTFormatter(FancyConsoleFormatter):
+    def __init__(self, *args, no_color: bool = False, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.no_color = no_color
+
+    def format(self, record: logging.LogRecord) -> str:
+        # Make sure `msg` is a string
+        if not hasattr(record, "msg"):
+            record.msg = ""
+        elif type(record.msg) is not str:
+            record.msg = str(record.msg)
+
+        # Strip color from the message to prevent color spoofing
+        if record.msg and not getattr(record, "preserve_color", False):
+            record.msg = remove_color_codes(record.msg)
+
+        # Determine color for title
+        title = getattr(record, "title", "")
+        title_color = getattr(record, "title_color", "") or self.LEVEL_COLOR_MAP.get(
+            record.levelno, ""
+        )
+        if title and title_color:
+            title = f"{title_color + Style.BRIGHT}{title}{Style.RESET_ALL}"
+        # Make sure record.title is set, and padded with a space if not empty
+        record.title = f"{title} " if title else ""
+
+        if self.no_color:
+            return remove_color_codes(super().format(record))
+        else:
+            return super().format(record)
+
+
+class StructuredLoggingFormatter(StructuredLogHandler, logging.Formatter):
+    def __init__(self):
+        # Set up CloudLoggingFilter to add diagnostic info to the log records
+        self.cloud_logging_filter = CloudLoggingFilter()
+
+        # Init StructuredLogHandler
+        super().__init__()
+
+    def format(self, record: logging.LogRecord) -> str:
+        self.cloud_logging_filter.filter(record)
+        return super().format(record)

autogpt_platform/autogpt_libs/autogpt_libs/logging/handlers.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import json
+import logging
+
+
+class JsonFileHandler(logging.FileHandler):
+    def format(self, record: logging.LogRecord) -> str:
+        record.json_data = json.loads(record.getMessage())
+        return json.dumps(getattr(record, "json_data"), ensure_ascii=False, indent=4)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        with open(self.baseFilename, "w", encoding="utf-8") as f:
+            f.write(self.format(record))

autogpt_platform/autogpt_libs/autogpt_libs/logging/test_utils.py

@@ -0,0 +1,36 @@
+import pytest
+
+from .utils import remove_color_codes
+
+
+@pytest.mark.parametrize(
+    "raw_text, clean_text",
+    [
+        (
+            "COMMAND = \x1b[36mbrowse_website\x1b[0m  "
+            "ARGUMENTS = \x1b[36m{'url': 'https://www.google.com',"
+            " 'question': 'What is the capital of France?'}\x1b[0m",
+            "COMMAND = browse_website  "
+            "ARGUMENTS = {'url': 'https://www.google.com',"
+            " 'question': 'What is the capital of France?'}",
+        ),
+        (
+            "{'Schaue dir meine Projekte auf github () an, als auch meine Webseiten': "
+            "'https://github.com/Significant-Gravitas/AutoGPT,"
+            " https://discord.gg/autogpt und https://twitter.com/Auto_GPT'}",
+            "{'Schaue dir meine Projekte auf github () an, als auch meine Webseiten': "
+            "'https://github.com/Significant-Gravitas/AutoGPT,"
+            " https://discord.gg/autogpt und https://twitter.com/Auto_GPT'}",
+        ),
+        ("", ""),
+        ("hello", "hello"),
+        ("hello\x1B[31m world", "hello world"),
+        ("\x1B[36mHello,\x1B[32m World!", "Hello, World!"),
+        (
+            "\x1B[1m\x1B[31mError:\x1B[0m\x1B[31m file not found",
+            "Error: file not found",
+        ),
+    ],
+)
+def test_remove_color_codes(raw_text, clean_text):
+    assert remove_color_codes(raw_text) == clean_text

autogpt_platform/autogpt_libs/autogpt_libs/logging/utils.py

@@ -0,0 +1,27 @@
+import logging
+import re
+from typing import Any
+
+from colorama import Fore
+
+
+def remove_color_codes(s: str) -> str:
+    return re.sub(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])", "", s)
+
+
+def fmt_kwargs(kwargs: dict) -> str:
+    return ", ".join(f"{n}={repr(v)}" for n, v in kwargs.items())
+
+
+def print_attribute(
+    title: str, value: Any, title_color: str = Fore.GREEN, value_color: str = ""
+) -> None:
+    logger = logging.getLogger()
+    logger.info(
+        str(value),
+        extra={
+            "title": f"{title.rstrip(':')}:",
+            "title_color": title_color,
+            "color": value_color,
+        },
+    )

autogpt_platform/autogpt_libs/autogpt_libs/supabase_integration_credentials_store/__init__.py

@@ -0,0 +1,8 @@
+from .store import SupabaseIntegrationCredentialsStore
+from .types import APIKeyCredentials, OAuth2Credentials
+
+__all__ = [
+    "SupabaseIntegrationCredentialsStore",
+    "APIKeyCredentials",
+    "OAuth2Credentials",
+]

autogpt_platform/autogpt_libs/autogpt_libs/supabase_integration_credentials_store/store.py

@@ -0,0 +1,145 @@
+import secrets
+from datetime import datetime, timedelta, timezone
+from typing import cast
+
+from supabase import Client
+
+from .types import (
+    Credentials,
+    OAuth2Credentials,
+    OAuthState,
+    UserMetadata,
+    UserMetadataRaw,
+)
+
+
+class SupabaseIntegrationCredentialsStore:
+    def __init__(self, supabase: Client):
+        self.supabase = supabase
+
+    def add_creds(self, user_id: str, credentials: Credentials) -> None:
+        if self.get_creds_by_id(user_id, credentials.id):
+            raise ValueError(
+                f"Can not re-create existing credentials with ID {credentials.id} "
+                f"for user with ID {user_id}"
+            )
+        self._set_user_integration_creds(
+            user_id, [*self.get_all_creds(user_id), credentials]
+        )
+
+    def get_all_creds(self, user_id: str) -> list[Credentials]:
+        user_metadata = self._get_user_metadata(user_id)
+        return UserMetadata.model_validate(user_metadata).integration_credentials
+
+    def get_creds_by_id(self, user_id: str, credentials_id: str) -> Credentials | None:
+        credentials = self.get_all_creds(user_id)
+        return next((c for c in credentials if c.id == credentials_id), None)
+
+    def get_creds_by_provider(self, user_id: str, provider: str) -> list[Credentials]:
+        credentials = self.get_all_creds(user_id)
+        return [c for c in credentials if c.provider == provider]
+
+    def get_authorized_providers(self, user_id: str) -> list[str]:
+        credentials = self.get_all_creds(user_id)
+        return list(set(c.provider for c in credentials))
+
+    def update_creds(self, user_id: str, updated: Credentials) -> None:
+        current = self.get_creds_by_id(user_id, updated.id)
+        if not current:
+            raise ValueError(
+                f"Credentials with ID {updated.id} "
+                f"for user with ID {user_id} not found"
+            )
+        if type(current) is not type(updated):
+            raise TypeError(
+                f"Can not update credentials with ID {updated.id} "
+                f"from type {type(current)} "
+                f"to type {type(updated)}"
+            )
+
+        # Ensure no scopes are removed when updating credentials
+        if (
+            isinstance(updated, OAuth2Credentials)
+            and isinstance(current, OAuth2Credentials)
+            and not set(updated.scopes).issuperset(current.scopes)
+        ):
+            raise ValueError(
+                f"Can not update credentials with ID {updated.id} "
+                f"and scopes {current.scopes} "
+                f"to more restrictive set of scopes {updated.scopes}"
+            )
+
+        # Update the credentials
+        updated_credentials_list = [
+            updated if c.id == updated.id else c for c in self.get_all_creds(user_id)
+        ]
+        self._set_user_integration_creds(user_id, updated_credentials_list)
+
+    def delete_creds_by_id(self, user_id: str, credentials_id: str) -> None:
+        filtered_credentials = [
+            c for c in self.get_all_creds(user_id) if c.id != credentials_id
+        ]
+        self._set_user_integration_creds(user_id, filtered_credentials)
+
+    async def store_state_token(self, user_id: str, provider: str) -> str:
+        token = secrets.token_urlsafe(32)
+        expires_at = datetime.now(timezone.utc) + timedelta(minutes=10)
+
+        state = OAuthState(
+            token=token, provider=provider, expires_at=int(expires_at.timestamp())
+        )
+
+        user_metadata = self._get_user_metadata(user_id)
+        oauth_states = user_metadata.get("integration_oauth_states", [])
+        oauth_states.append(state.model_dump())
+        user_metadata["integration_oauth_states"] = oauth_states
+
+        self.supabase.auth.admin.update_user_by_id(
+            user_id, {"user_metadata": user_metadata}
+        )
+
+        return token
+
+    async def verify_state_token(self, user_id: str, token: str, provider: str) -> bool:
+        user_metadata = self._get_user_metadata(user_id)
+        oauth_states = user_metadata.get("integration_oauth_states", [])
+
+        now = datetime.now(timezone.utc)
+        valid_state = next(
+            (
+                state
+                for state in oauth_states
+                if state["token"] == token
+                and state["provider"] == provider
+                and state["expires_at"] > now.timestamp()
+            ),
+            None,
+        )
+
+        if valid_state:
+            # Remove the used state
+            oauth_states.remove(valid_state)
+            user_metadata["integration_oauth_states"] = oauth_states
+            self.supabase.auth.admin.update_user_by_id(
+                user_id, {"user_metadata": user_metadata}
+            )
+            return True
+
+        return False
+
+    def _set_user_integration_creds(
+        self, user_id: str, credentials: list[Credentials]
+    ) -> None:
+        raw_metadata = self._get_user_metadata(user_id)
+        raw_metadata.update(
+            {"integration_credentials": [c.model_dump() for c in credentials]}
+        )
+        self.supabase.auth.admin.update_user_by_id(
+            user_id, {"user_metadata": raw_metadata}
+        )
+
+    def _get_user_metadata(self, user_id: str) -> UserMetadataRaw:
+        response = self.supabase.auth.admin.get_user_by_id(user_id)
+        if not response.user:
+            raise ValueError(f"User with ID {user_id} not found")
+        return cast(UserMetadataRaw, response.user.user_metadata)

autogpt_platform/autogpt_libs/autogpt_libs/supabase_integration_credentials_store/types.py

@@ -0,0 +1,69 @@
+from typing import Annotated, Any, Literal, Optional, TypedDict
+from uuid import uuid4
+
+from pydantic import BaseModel, Field, SecretStr, field_serializer
+
+
+class _BaseCredentials(BaseModel):
+    id: str = Field(default_factory=lambda: str(uuid4()))
+    provider: str
+    title: Optional[str]
+
+    @field_serializer("*")
+    def dump_secret_strings(value: Any, _info):
+        if isinstance(value, SecretStr):
+            return value.get_secret_value()
+        return value
+
+
+class OAuth2Credentials(_BaseCredentials):
+    type: Literal["oauth2"] = "oauth2"
+    username: Optional[str]
+    """Username of the third-party service user that these credentials belong to"""
+    access_token: SecretStr
+    access_token_expires_at: Optional[int]
+    """Unix timestamp (seconds) indicating when the access token expires (if at all)"""
+    refresh_token: Optional[SecretStr]
+    refresh_token_expires_at: Optional[int]
+    """Unix timestamp (seconds) indicating when the refresh token expires (if at all)"""
+    scopes: list[str]
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+    def bearer(self) -> str:
+        return f"Bearer {self.access_token.get_secret_value()}"
+
+
+class APIKeyCredentials(_BaseCredentials):
+    type: Literal["api_key"] = "api_key"
+    api_key: SecretStr
+    expires_at: Optional[int]
+    """Unix timestamp (seconds) indicating when the API key expires (if at all)"""
+
+    def bearer(self) -> str:
+        return f"Bearer {self.api_key.get_secret_value()}"
+
+
+Credentials = Annotated[
+    OAuth2Credentials | APIKeyCredentials,
+    Field(discriminator="type"),
+]
+
+
+CredentialsType = Literal["api_key", "oauth2"]
+
+
+class OAuthState(BaseModel):
+    token: str
+    provider: str
+    expires_at: int
+    """Unix timestamp (seconds) indicating when this OAuth state expires"""
+
+
+class UserMetadata(BaseModel):
+    integration_credentials: list[Credentials] = Field(default_factory=list)
+    integration_oauth_states: list[OAuthState] = Field(default_factory=list)
+
+
+class UserMetadataRaw(TypedDict, total=False):
+    integration_credentials: list[dict]
+    integration_oauth_states: list[dict]

autogpt_platform/autogpt_libs/pyproject.toml

@@ -0,0 +1,21 @@
+[tool.poetry]
+name = "autogpt-libs"
+version = "0.2.0"
+description = "Shared libraries across NextGen AutoGPT"
+authors = ["Aarushi <aarushik93@gmail.com>"]
+readme = "README.md"
+packages = [{ include = "autogpt_libs" }]
+
+[tool.poetry.dependencies]
+colorama = "^0.4.6"
+google-cloud-logging = "^3.8.0"
+pydantic = "^2.8.2"
+pydantic-settings = "^2.5.2"
+pyjwt = "^2.8.0"
+python = ">=3.10,<4.0"
+python-dotenv = "^1.0.1"
+supabase = "^2.7.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

autogpt_platform/backend/.env.example

@@ -0,0 +1,88 @@
+DB_USER=postgres
+DB_PASS=your-super-secret-and-long-postgres-password
+DB_NAME=postgres
+DB_PORT=5432
+DATABASE_URL="postgresql://${DB_USER}:${DB_PASS}@localhost:${DB_PORT}/${DB_NAME}?connect_timeout=60&schema=platform"
+PRISMA_SCHEMA="postgres/schema.prisma"
+
+BACKEND_CORS_ALLOW_ORIGINS=["http://localhost:3000"]
+
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=password
+
+ENABLE_CREDIT=false
+APP_ENV="local"
+PYRO_HOST=localhost
+SENTRY_DSN=
+
+## User auth with Supabase is required for any of the 3rd party integrations with auth to work.
+ENABLE_AUTH=false
+SUPABASE_URL=http://localhost:8000
+SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJzZXJ2aWNlX3JvbGUiLAogICAgImlzcyI6ICJzdXBhYmFzZS1kZW1vIiwKICAgICJpYXQiOiAxNjQxNzY5MjAwLAogICAgImV4cCI6IDE3OTk1MzU2MDAKfQ.DaYlNEoUrrEn2Ig7tqibS-PHK5vgusbcbo7X36XVt4Q
+SUPABASE_JWT_SECRET=your-super-secret-jwt-token-with-at-least-32-characters-long
+
+# For local development, you may need to set FRONTEND_BASE_URL for the OAuth flow for integrations to work.
+# FRONTEND_BASE_URL=http://localhost:3000
+
+## == INTEGRATION CREDENTIALS == ##
+# Each set of server side credentials is required for the corresponding 3rd party
+# integration to work.
+
+# For the OAuth callback URL, use <your_frontend_url>/auth/integrations/oauth_callback,
+# e.g. http://localhost:3000/auth/integrations/oauth_callback
+
+# GitHub OAuth App server credentials - https://github.com/settings/developers
+GITHUB_CLIENT_ID=
+GITHUB_CLIENT_SECRET=
+
+## ===== OPTIONAL API KEYS ===== ##
+
+# LLM
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+GROQ_API_KEY=
+
+# Reddit
+REDDIT_CLIENT_ID=
+REDDIT_CLIENT_SECRET=
+REDDIT_USERNAME=
+REDDIT_PASSWORD=
+
+# Discord
+DISCORD_BOT_TOKEN=
+
+# SMTP/Email
+SMTP_SERVER=
+SMTP_PORT=
+SMTP_USERNAME=
+SMTP_PASSWORD=
+
+# D-ID
+DID_API_KEY=
+
+# Open Weather Map
+OPENWEATHERMAP_API_KEY=
+
+# SMTP
+SMTP_SERVER=
+SMTP_PORT=
+SMTP_USERNAME=
+SMTP_PASSWORD=
+
+# Medium
+MEDIUM_API_KEY=
+MEDIUM_AUTHOR_ID=
+
+# Google Maps
+GOOGLE_MAPS_API_KEY=
+
+# Replicate
+REPLICATE_API_KEY=
+
+# Logging Configuration
+LOG_LEVEL=INFO
+ENABLE_CLOUD_LOGGING=false
+ENABLE_FILE_LOGGING=false
+# Use to manually set the log directory
+# LOG_DIR=./logs

autogpt_platform/backend/.gitignore

@@ -0,0 +1,8 @@
+database.db
+database.db-journal
+dev.db
+dev.db-journal
+build/
+config.json
+secrets/*
+!secrets/.gitkeep

autogpt_platform/backend/Dockerfile

@@ -0,0 +1,78 @@
+FROM python:3.11-slim-buster AS builder
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+WORKDIR /app
+
+# Install build dependencies
+RUN apt-get update \
+    && apt-get install -y build-essential curl ffmpeg wget libcurl4-gnutls-dev libexpat1-dev gettext libz-dev libssl-dev postgresql-client git \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV POETRY_VERSION=1.8.3 \
+    POETRY_HOME="/opt/poetry" \
+    POETRY_NO_INTERACTION=1 \
+    POETRY_VIRTUALENVS_CREATE=false \
+    PATH="$POETRY_HOME/bin:$PATH"
+
+# Upgrade pip and setuptools to fix security vulnerabilities
+RUN pip3 install --upgrade pip setuptools
+
+RUN pip3 install poetry
+
+# Copy and install dependencies
+COPY autogpt_platform/autogpt_libs /app/autogpt_platform/autogpt_libs
+COPY autogpt_platform/backend/poetry.lock autogpt_platform/backend/pyproject.toml /app/autogpt_platform/backend/
+WORKDIR /app/autogpt_platform/backend
+RUN poetry config virtualenvs.create false \
+    && poetry install --no-interaction --no-ansi
+
+# Generate Prisma client
+COPY autogpt_platform/backend/schema.prisma ./
+RUN poetry config virtualenvs.create false \
+    && poetry run prisma generate
+
+FROM python:3.11-slim-buster AS server_dependencies
+
+WORKDIR /app
+
+ENV POETRY_VERSION=1.8.3 \
+    POETRY_HOME="/opt/poetry" \
+    POETRY_NO_INTERACTION=1 \
+    POETRY_VIRTUALENVS_CREATE=false \
+    PATH="$POETRY_HOME/bin:$PATH"
+
+
+# Upgrade pip and setuptools to fix security vulnerabilities
+RUN pip3 install --upgrade pip setuptools
+
+# Copy only necessary files from builder
+COPY --from=builder /app /app
+COPY --from=builder /usr/local/lib/python3.11 /usr/local/lib/python3.11
+COPY --from=builder /usr/local/bin /usr/local/bin
+# Copy Prisma binaries
+COPY --from=builder /root/.cache/prisma-python/binaries /root/.cache/prisma-python/binaries
+
+
+ENV PATH="/app/.venv/bin:$PATH"
+
+RUN mkdir -p /app/autogpt_platform/autogpt_libs
+RUN mkdir -p /app/autogpt_platform/backend
+
+COPY autogpt_platform/autogpt_libs /app/autogpt_platform/autogpt_libs
+
+COPY autogpt_platform/backend/poetry.lock autogpt_platform/backend/pyproject.toml /app/autogpt_platform/backend/
+
+WORKDIR /app/autogpt_platform/backend
+
+FROM server_dependencies AS server
+
+COPY autogpt_platform/backend /app/autogpt_platform/backend
+
+ENV DATABASE_URL=""
+ENV PORT=8000
+
+CMD ["poetry", "run", "rest"]

autogpt_platform/backend/README.advanced.md

@@ -0,0 +1,75 @@
+# AutoGPT Agent Server Advanced set up
+
+This guide walks you through a dockerized set up, with an external DB (postgres)
+
+## Setup
+
+We use the Poetry to manage the dependencies. To set up the project, follow these steps inside this directory:
+
+0. Install Poetry
+    ```sh
+    pip install poetry
+    ```
+    
+1. Configure Poetry to use .venv in your project directory
+    ```sh
+    poetry config virtualenvs.in-project true
+    ```
+
+2. Enter the poetry shell
+
+   ```sh
+   poetry shell
+   ```
+   
+3. Install dependencies
+
+   ```sh
+   poetry install
+   ```
+   
+4. Copy .env.example to .env
+
+   ```sh
+   cp .env.example .env
+   ```
+
+5. Generate the Prisma client
+
+   ```sh
+   poetry run prisma generate --schema postgres/schema.prisma
+   ```
+   
+
+   > In case Prisma generates the client for the global Python installation instead of the virtual environment, the current mitigation is to just uninstall the global Prisma package:
+   >
+   > ```sh
+   > pip uninstall prisma
+   > ```
+   >
+   > Then run the generation again. The path *should* look something like this:  
+   > `<some path>/pypoetry/virtualenvs/backend-TQIRSwR6-py3.12/bin/prisma`
+
+6. Run the postgres database from the /rnd folder
+
+   ```sh
+   cd autogpt_platform/
+   docker compose up -d
+   ```
+
+7. Run the migrations (from the backend folder)
+
+   ```sh
+   cd ../backend
+   prisma migrate dev --schema postgres/schema.prisma
+   ```
+
+## Running The Server
+
+### Starting the server directly
+
+Run the following command:
+
+```sh
+poetry run app
+```

autogpt_platform/backend/README.md

@@ -0,0 +1,202 @@
+# AutoGPT Agent Server 
+
+This is an initial project for creating the next generation of agent execution, which is an AutoGPT agent server.
+The agent server will enable the creation of composite multi-agent systems that utilize AutoGPT agents and other non-agent components as its primitives.
+
+## Docs
+
+You can access the docs for the [AutoGPT Agent Server here](https://docs.agpt.co/server/setup).
+
+## Setup
+
+We use the Poetry to manage the dependencies. To set up the project, follow these steps inside this directory:
+
+0. Install Poetry
+    ```sh
+    pip install poetry
+    ```
+    
+1. Configure Poetry to use .venv in your project directory
+    ```sh
+    poetry config virtualenvs.in-project true
+    ```
+
+2. Enter the poetry shell
+
+   ```sh
+   poetry shell
+   ```
+   
+3. Install dependencies
+
+   ```sh
+   poetry install
+   ```
+
+4. Copy .env.example to .env
+
+   ```sh
+   cp .env.example .env
+   ```
+   
+5. Generate the Prisma client
+
+   ```sh
+   poetry run prisma generate
+   ```
+   
+
+   > In case Prisma generates the client for the global Python installation instead of the virtual environment, the current mitigation is to just uninstall the global Prisma package:
+   >
+   > ```sh
+   > pip uninstall prisma
+   > ```
+   >
+   > Then run the generation again. The path *should* look something like this:  
+   > `<some path>/pypoetry/virtualenvs/backend-TQIRSwR6-py3.12/bin/prisma`
+
+6. Migrate the database. Be careful because this deletes current data in the database.
+
+   ```sh
+   docker compose up db redis -d
+   poetry run prisma migrate dev 
+   ```
+
+## Running The Server
+
+### Starting the server without Docker
+
+Run the following command to build the dockerfiles:
+
+```sh
+poetry run app
+```
+
+### Starting the server with Docker
+
+Run the following command to build the dockerfiles:
+
+```sh
+docker compose build
+```
+
+Run the following command to run the app:
+
+```sh
+docker compose up
+```
+
+Run the following to automatically rebuild when code changes, in another terminal:
+
+```sh
+docker compose watch
+```
+
+Run the following command to shut down:
+
+```sh
+docker compose down
+```
+
+If you run into issues with dangling orphans, try:
+
+```sh
+docker compose down --volumes --remove-orphans && docker-compose up --force-recreate --renew-anon-volumes --remove-orphans  
+```
+
+## Testing
+
+To run the tests:
+
+```sh
+poetry run test
+```
+
+## Development
+
+### Formatting & Linting
+Auto formatter and linter are set up in the project. To run them:
+
+Install:
+```sh
+poetry install --with dev
+```
+
+Format the code:
+```sh
+poetry run format
+```
+
+Lint the code:
+```sh
+poetry run lint
+```
+
+## Project Outline
+
+The current project has the following main modules:
+
+### **blocks**
+
+This module stores all the Agent Blocks, which are reusable components to build a graph that represents the agent's behavior.
+
+### **data**
+
+This module stores the logical model that is persisted in the database.
+It abstracts the database operations into functions that can be called by the service layer.
+Any code that interacts with Prisma objects or the database should reside in this module.
+The main models are:
+* `block`: anything related to the block used in the graph
+* `execution`: anything related to the execution graph execution
+* `graph`: anything related to the graph, node, and its relations
+
+### **execution**
+
+This module stores the business logic of executing the graph.
+It currently has the following main modules:
+* `manager`: A service that consumes the queue of the graph execution and executes the graph. It contains both pieces of logic.
+* `scheduler`: A service that triggers scheduled graph execution based on a cron expression. It pushes an execution request to the manager.
+
+### **server**
+
+This module stores the logic for the server API.
+It contains all the logic used for the API that allows the client to create, execute, and monitor the graph and its execution.
+This API service interacts with other services like those defined in `manager` and `scheduler`.
+
+### **utils**
+
+This module stores utility functions that are used across the project.
+Currently, it has two main modules:
+* `process`: A module that contains the logic to spawn a new process.
+* `service`: A module that serves as a parent class for all the services in the project.
+
+## Service Communication
+
+Currently, there are only 3 active services:
+
+- AgentServer (the API, defined in `server.py`)
+- ExecutionManager (the executor, defined in `manager.py`)
+- ExecutionScheduler (the scheduler, defined in `scheduler.py`)
+
+The services run in independent Python processes and communicate through an IPC.
+A communication layer (`service.py`) is created to decouple the communication library from the implementation.
+
+Currently, the IPC is done using Pyro5 and abstracted in a way that allows a function decorated with `@expose` to be called from a different process.
+
+
+By default the daemons run on the following ports: 
+
+Execution Manager Daemon: 8002
+Execution Scheduler Daemon: 8003
+Rest Server Daemon: 8004
+
+## Adding a New Agent Block
+
+To add a new agent block, you need to create a new class that inherits from `Block` and provides the following information:
+* All the block code should live in the `blocks` (`backend.blocks`) module.
+* `input_schema`: the schema of the input data, represented by a Pydantic object.
+* `output_schema`: the schema of the output data, represented by a Pydantic object.
+* `run` method: the main logic of the block.
+* `test_input` & `test_output`: the sample input and output data for the block, which will be used to auto-test the block.
+* You can mock the functions declared in the block using the `test_mock` field for your unit tests.
+* Once you finish creating the block, you can test it by running `pytest -s test/block/test_block.py`.

autogpt_platform/backend/backend/app.py

@@ -0,0 +1,40 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from backend.util.process import AppProcess
+
+
+def run_processes(*processes: "AppProcess", **kwargs):
+    """
+    Execute all processes in the app. The last process is run in the foreground.
+    """
+    try:
+        for process in processes[:-1]:
+            process.start(background=True, **kwargs)
+
+        # Run the last process in the foreground
+        processes[-1].start(background=False, **kwargs)
+    finally:
+        for process in processes:
+            process.stop()
+
+
+def main(**kwargs):
+    """
+    Run all the processes required for the AutoGPT-server (REST and WebSocket APIs).
+    """
+
+    from backend.executor import ExecutionManager, ExecutionScheduler
+    from backend.server import AgentServer, WebsocketServer
+
+    run_processes(
+        ExecutionManager(),
+        ExecutionScheduler(),
+        WebsocketServer(),
+        AgentServer(),
+        **kwargs,
+    )
+
+
+if __name__ == "__main__":
+    main()

autogpt_platform/backend/backend/blocks/__init__.py

@@ -0,0 +1,74 @@
+import importlib
+import os
+import re
+from pathlib import Path
+
+from backend.data.block import Block
+
+# Dynamically load all modules under backend.blocks
+AVAILABLE_MODULES = []
+current_dir = Path(__file__).parent
+modules = [
+    str(f.relative_to(current_dir))[:-3].replace(os.path.sep, ".")
+    for f in current_dir.rglob("*.py")
+    if f.is_file() and f.name != "__init__.py"
+]
+for module in modules:
+    if not re.match("^[a-z_.]+$", module):
+        raise ValueError(
+            f"Block module {module} error: module name must be lowercase, "
+            "separated by underscores, and contain only alphabet characters"
+        )
+
+    importlib.import_module(f".{module}", package=__name__)
+    AVAILABLE_MODULES.append(module)
+
+# Load all Block instances from the available modules
+AVAILABLE_BLOCKS = {}
+
+
+def all_subclasses(clz):
+    subclasses = clz.__subclasses__()
+    for subclass in subclasses:
+        subclasses += all_subclasses(subclass)
+    return subclasses
+
+
+for cls in all_subclasses(Block):
+    name = cls.__name__
+
+    if cls.__name__.endswith("Base"):
+        continue
+
+    if not cls.__name__.endswith("Block"):
+        raise ValueError(
+            f"Block class {cls.__name__} does not end with 'Block', If you are creating an abstract class, please name the class with 'Base' at the end"
+        )
+
+    block = cls()
+
+    if not isinstance(block.id, str) or len(block.id) != 36:
+        raise ValueError(f"Block ID {block.name} error: {block.id} is not a valid UUID")
+
+    if block.id in AVAILABLE_BLOCKS:
+        raise ValueError(f"Block ID {block.name} error: {block.id} is already in use")
+
+    # Prevent duplicate field name in input_schema and output_schema
+    duplicate_field_names = set(block.input_schema.model_fields.keys()) & set(
+        block.output_schema.model_fields.keys()
+    )
+    if duplicate_field_names:
+        raise ValueError(
+            f"{block.name} has duplicate field names in input_schema and output_schema: {duplicate_field_names}"
+        )
+
+    for field in block.input_schema.model_fields.values():
+        if field.annotation is bool and field.default not in (True, False):
+            raise ValueError(f"{block.name} has a boolean field with no default value")
+
+    if block.disabled:
+        continue
+
+    AVAILABLE_BLOCKS[block.id] = block
+
+__all__ = ["AVAILABLE_MODULES", "AVAILABLE_BLOCKS"]

autogpt_platform/backend/backend/blocks/basic.py

@@ -0,0 +1,445 @@
+import re
+from typing import Any, List
+
+from jinja2 import BaseLoader, Environment
+from pydantic import Field
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema, BlockType
+from backend.data.model import SchemaField
+from backend.util.mock import MockObject
+
+jinja = Environment(loader=BaseLoader())
+
+
+class StoreValueBlock(Block):
+    """
+    This block allows you to provide a constant value as a block, in a stateless manner.
+    The common use-case is simply pass the `input` data, it will `output` the same data.
+    The block output will be static, the output can be consumed multiple times.
+    """
+
+    class Input(BlockSchema):
+        input: Any = Field(
+            description="Trigger the block to produce the output. "
+            "The value is only used when `data` is None."
+        )
+        data: Any = Field(
+            description="The constant data to be retained in the block. "
+            "This value is passed as `output`.",
+            default=None,
+        )
+
+    class Output(BlockSchema):
+        output: Any
+
+    def __init__(self):
+        super().__init__(
+            id="1ff065e9-88e8-4358-9d82-8dc91f622ba9",
+            description="This block forwards an input value as output, allowing reuse without change.",
+            categories={BlockCategory.BASIC},
+            input_schema=StoreValueBlock.Input,
+            output_schema=StoreValueBlock.Output,
+            test_input=[
+                {"input": "Hello, World!"},
+                {"input": "Hello, World!", "data": "Existing Data"},
+            ],
+            test_output=[
+                ("output", "Hello, World!"),  # No data provided, so trigger is returned
+                ("output", "Existing Data"),  # Data is provided, so data is returned.
+            ],
+            static_output=True,
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        yield "output", input_data.data or input_data.input
+
+
+class PrintToConsoleBlock(Block):
+    class Input(BlockSchema):
+        text: str
+
+    class Output(BlockSchema):
+        status: str
+
+    def __init__(self):
+        super().__init__(
+            id="f3b1c1b2-4c4f-4f0d-8d2f-4c4f0d8d2f4c",
+            description="Print the given text to the console, this is used for a debugging purpose.",
+            categories={BlockCategory.BASIC},
+            input_schema=PrintToConsoleBlock.Input,
+            output_schema=PrintToConsoleBlock.Output,
+            test_input={"text": "Hello, World!"},
+            test_output=("status", "printed"),
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        print(">>>>> Print: ", input_data.text)
+        yield "status", "printed"
+
+
+class FindInDictionaryBlock(Block):
+    class Input(BlockSchema):
+        input: Any = Field(description="Dictionary to lookup from")
+        key: str | int = Field(description="Key to lookup in the dictionary")
+
+    class Output(BlockSchema):
+        output: Any = Field(description="Value found for the given key")
+        missing: Any = Field(description="Value of the input that missing the key")
+
+    def __init__(self):
+        super().__init__(
+            id="b2g2c3d4-5e6f-7g8h-9i0j-k1l2m3n4o5p6",
+            description="Lookup the given key in the input dictionary/object/list and return the value.",
+            input_schema=FindInDictionaryBlock.Input,
+            output_schema=FindInDictionaryBlock.Output,
+            test_input=[
+                {"input": {"apple": 1, "banana": 2, "cherry": 3}, "key": "banana"},
+                {"input": {"x": 10, "y": 20, "z": 30}, "key": "w"},
+                {"input": [1, 2, 3], "key": 1},
+                {"input": [1, 2, 3], "key": 3},
+                {"input": MockObject(value="!!", key="key"), "key": "key"},
+                {"input": [{"k1": "v1"}, {"k2": "v2"}, {"k1": "v3"}], "key": "k1"},
+            ],
+            test_output=[
+                ("output", 2),
+                ("missing", {"x": 10, "y": 20, "z": 30}),
+                ("output", 2),
+                ("missing", [1, 2, 3]),
+                ("output", "key"),
+                ("output", ["v1", "v3"]),
+            ],
+            categories={BlockCategory.BASIC},
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        obj = input_data.input
+        key = input_data.key
+
+        if isinstance(obj, dict) and key in obj:
+            yield "output", obj[key]
+        elif isinstance(obj, list) and isinstance(key, int) and 0 <= key < len(obj):
+            yield "output", obj[key]
+        elif isinstance(obj, list) and isinstance(key, str):
+            if len(obj) == 0:
+                yield "output", []
+            elif isinstance(obj[0], dict) and key in obj[0]:
+                yield "output", [item[key] for item in obj if key in item]
+            else:
+                yield "output", [getattr(val, key) for val in obj if hasattr(val, key)]
+        elif isinstance(obj, object) and isinstance(key, str) and hasattr(obj, key):
+            yield "output", getattr(obj, key)
+        else:
+            yield "missing", input_data.input
+
+
+class AgentInputBlock(Block):
+    """
+    This block is used to provide input to the graph.
+
+    It takes in a value, name, description, default values list and bool to limit selection to default values.
+
+    It Outputs the value passed as input.
+    """
+
+    class Input(BlockSchema):
+        value: Any = SchemaField(description="The value to be passed as input.")
+        name: str = SchemaField(description="The name of the input.")
+        description: str = SchemaField(
+            description="The description of the input.",
+            default="",
+            advanced=True,
+        )
+        placeholder_values: List[Any] = SchemaField(
+            description="The placeholder values to be passed as input.",
+            default=[],
+            advanced=True,
+        )
+        limit_to_placeholder_values: bool = SchemaField(
+            description="Whether to limit the selection to placeholder values.",
+            default=False,
+            advanced=True,
+        )
+
+    class Output(BlockSchema):
+        result: Any = SchemaField(description="The value passed as input.")
+
+    def __init__(self):
+        super().__init__(
+            id="c0a8e994-ebf1-4a9c-a4d8-89d09c86741b",
+            description="This block is used to provide input to the graph.",
+            input_schema=AgentInputBlock.Input,
+            output_schema=AgentInputBlock.Output,
+            test_input=[
+                {
+                    "value": "Hello, World!",
+                    "name": "input_1",
+                    "description": "This is a test input.",
+                    "placeholder_values": [],
+                    "limit_to_placeholder_values": False,
+                },
+                {
+                    "value": "Hello, World!",
+                    "name": "input_2",
+                    "description": "This is a test input.",
+                    "placeholder_values": ["Hello, World!"],
+                    "limit_to_placeholder_values": True,
+                },
+            ],
+            test_output=[
+                ("result", "Hello, World!"),
+                ("result", "Hello, World!"),
+            ],
+            categories={BlockCategory.INPUT, BlockCategory.BASIC},
+            block_type=BlockType.INPUT,
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        yield "result", input_data.value
+
+
+class AgentOutputBlock(Block):
+    """
+    Records the output of the graph for users to see.
+
+    Attributes:
+        recorded_value: The value to be recorded as output.
+        name: The name of the output.
+        description: The description of the output.
+        fmt_string: The format string to be used to format the recorded_value.
+
+    Outputs:
+        output: The formatted recorded_value if fmt_string is provided and the recorded_value
+                can be formatted, otherwise the raw recorded_value.
+
+    Behavior:
+        If fmt_string is provided and the recorded_value is of a type that can be formatted,
+        the block attempts to format the recorded_value using the fmt_string.
+        If formatting fails or no fmt_string is provided, the raw recorded_value is output.
+    """
+
+    class Input(BlockSchema):
+        value: Any = SchemaField(description="The value to be recorded as output.")
+        name: str = SchemaField(description="The name of the output.")
+        description: str = SchemaField(
+            description="The description of the output.",
+            default="",
+            advanced=True,
+        )
+        format: str = SchemaField(
+            description="The format string to be used to format the recorded_value.",
+            default="",
+            advanced=True,
+        )
+
+    class Output(BlockSchema):
+        output: Any = SchemaField(description="The value recorded as output.")
+
+    def __init__(self):
+        super().__init__(
+            id="363ae599-353e-4804-937e-b2ee3cef3da4",
+            description=("Stores the output of the graph for users to see."),
+            input_schema=AgentOutputBlock.Input,
+            output_schema=AgentOutputBlock.Output,
+            test_input=[
+                {
+                    "value": "Hello, World!",
+                    "name": "output_1",
+                    "description": "This is a test output.",
+                    "format": "{{ output_1 }}!!",
+                },
+                {
+                    "value": "42",
+                    "name": "output_2",
+                    "description": "This is another test output.",
+                    "format": "{{ output_2 }}",
+                },
+                {
+                    "value": MockObject(value="!!", key="key"),
+                    "name": "output_3",
+                    "description": "This is a test output with a mock object.",
+                    "format": "{{ output_3 }}",
+                },
+            ],
+            test_output=[
+                ("output", "Hello, World!!!"),
+                ("output", "42"),
+                ("output", MockObject(value="!!", key="key")),
+            ],
+            categories={BlockCategory.OUTPUT, BlockCategory.BASIC},
+            block_type=BlockType.OUTPUT,
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        """
+        Attempts to format the recorded_value using the fmt_string if provided.
+        If formatting fails or no fmt_string is given, returns the original recorded_value.
+        """
+        if input_data.format:
+            try:
+                fmt = re.sub(r"(?<!{){[ a-zA-Z0-9_]+}", r"{\g<0>}", input_data.format)
+                template = jinja.from_string(fmt)
+                yield "output", template.render({input_data.name: input_data.value})
+            except Exception as e:
+                yield "output", f"Error: {e}, {input_data.value}"
+        else:
+            yield "output", input_data.value
+
+
+class AddToDictionaryBlock(Block):
+    class Input(BlockSchema):
+        dictionary: dict | None = SchemaField(
+            default=None,
+            description="The dictionary to add the entry to. If not provided, a new dictionary will be created.",
+            placeholder='{"key1": "value1", "key2": "value2"}',
+        )
+        key: str = SchemaField(
+            description="The key for the new entry.", placeholder="new_key"
+        )
+        value: Any = SchemaField(
+            description="The value for the new entry.", placeholder="new_value"
+        )
+
+    class Output(BlockSchema):
+        updated_dictionary: dict = SchemaField(
+            description="The dictionary with the new entry added."
+        )
+        error: str = SchemaField(description="Error message if the operation failed.")
+
+    def __init__(self):
+        super().__init__(
+            id="31d1064e-7446-4693-a7d4-65e5ca1180d1",
+            description="Adds a new key-value pair to a dictionary. If no dictionary is provided, a new one is created.",
+            categories={BlockCategory.BASIC},
+            input_schema=AddToDictionaryBlock.Input,
+            output_schema=AddToDictionaryBlock.Output,
+            test_input=[
+                {
+                    "dictionary": {"existing_key": "existing_value"},
+                    "key": "new_key",
+                    "value": "new_value",
+                },
+                {"key": "first_key", "value": "first_value"},
+            ],
+            test_output=[
+                (
+                    "updated_dictionary",
+                    {"existing_key": "existing_value", "new_key": "new_value"},
+                ),
+                ("updated_dictionary", {"first_key": "first_value"}),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            # If no dictionary is provided, create a new one
+            if input_data.dictionary is None:
+                updated_dict = {}
+            else:
+                # Create a copy of the input dictionary to avoid modifying the original
+                updated_dict = input_data.dictionary.copy()
+
+            # Add the new key-value pair
+            updated_dict[input_data.key] = input_data.value
+
+            yield "updated_dictionary", updated_dict
+        except Exception as e:
+            yield "error", f"Failed to add entry to dictionary: {str(e)}"
+
+
+class AddToListBlock(Block):
+    class Input(BlockSchema):
+        list: List[Any] | None = SchemaField(
+            default=None,
+            description="The list to add the entry to. If not provided, a new list will be created.",
+            placeholder='[1, "string", {"key": "value"}]',
+        )
+        entry: Any = SchemaField(
+            description="The entry to add to the list. Can be of any type (string, int, dict, etc.).",
+            placeholder='{"new_key": "new_value"}',
+        )
+        position: int | None = SchemaField(
+            default=None,
+            description="The position to insert the new entry. If not provided, the entry will be appended to the end of the list.",
+            placeholder="0",
+        )
+
+    class Output(BlockSchema):
+        updated_list: List[Any] = SchemaField(
+            description="The list with the new entry added."
+        )
+        error: str = SchemaField(description="Error message if the operation failed.")
+
+    def __init__(self):
+        super().__init__(
+            id="aeb08fc1-2fc1-4141-bc8e-f758f183a822",
+            description="Adds a new entry to a list. The entry can be of any type. If no list is provided, a new one is created.",
+            categories={BlockCategory.BASIC},
+            input_schema=AddToListBlock.Input,
+            output_schema=AddToListBlock.Output,
+            test_input=[
+                {
+                    "list": [1, "string", {"existing_key": "existing_value"}],
+                    "entry": {"new_key": "new_value"},
+                    "position": 1,
+                },
+                {"entry": "first_entry"},
+                {"list": ["a", "b", "c"], "entry": "d"},
+            ],
+            test_output=[
+                (
+                    "updated_list",
+                    [
+                        1,
+                        {"new_key": "new_value"},
+                        "string",
+                        {"existing_key": "existing_value"},
+                    ],
+                ),
+                ("updated_list", ["first_entry"]),
+                ("updated_list", ["a", "b", "c", "d"]),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            # If no list is provided, create a new one
+            if input_data.list is None:
+                updated_list = []
+            else:
+                # Create a copy of the input list to avoid modifying the original
+                updated_list = input_data.list.copy()
+
+            # Add the new entry
+            if input_data.position is None:
+                updated_list.append(input_data.entry)
+            else:
+                updated_list.insert(input_data.position, input_data.entry)
+
+            yield "updated_list", updated_list
+        except Exception as e:
+            yield "error", f"Failed to add entry to list: {str(e)}"
+
+
+class NoteBlock(Block):
+    class Input(BlockSchema):
+        text: str = SchemaField(description="The text to display in the sticky note.")
+
+    class Output(BlockSchema):
+        output: str = SchemaField(description="The text to display in the sticky note.")
+
+    def __init__(self):
+        super().__init__(
+            id="31d1064e-7446-4693-o7d4-65e5ca9110d1",
+            description="This block is used to display a sticky note with the given text.",
+            categories={BlockCategory.BASIC},
+            input_schema=NoteBlock.Input,
+            output_schema=NoteBlock.Output,
+            test_input={"text": "Hello, World!"},
+            test_output=[
+                ("output", "Hello, World!"),
+            ],
+            block_type=BlockType.NOTE,
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        yield "output", input_data.text

autogpt_platform/backend/backend/blocks/block.py

@@ -0,0 +1,66 @@
+import os
+import re
+from typing import Type
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+
+
+class BlockInstallationBlock(Block):
+    """
+    This block allows the verification and installation of other blocks in the system.
+
+    NOTE:
+        This block allows remote code execution on the server, and it should be used
+        for development purposes only.
+    """
+
+    class Input(BlockSchema):
+        code: str
+
+    class Output(BlockSchema):
+        success: str
+        error: str
+
+    def __init__(self):
+        super().__init__(
+            id="45e78db5-03e9-447f-9395-308d712f5f08",
+            description="Given a code string, this block allows the verification and installation of a block code into the system.",
+            categories={BlockCategory.BASIC},
+            input_schema=BlockInstallationBlock.Input,
+            output_schema=BlockInstallationBlock.Output,
+            disabled=True,
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        code = input_data.code
+
+        if search := re.search(r"class (\w+)\(Block\):", code):
+            class_name = search.group(1)
+        else:
+            yield "error", "No class found in the code."
+            return
+
+        if search := re.search(r"id=\"(\w+-\w+-\w+-\w+-\w+)\"", code):
+            file_name = search.group(1)
+        else:
+            yield "error", "No UUID found in the code."
+            return
+
+        block_dir = os.path.dirname(__file__)
+        file_path = f"{block_dir}/{file_name}.py"
+        module_name = f"backend.blocks.{file_name}"
+        with open(file_path, "w") as f:
+            f.write(code)
+
+        try:
+            module = __import__(module_name, fromlist=[class_name])
+            block_class: Type[Block] = getattr(module, class_name)
+            block = block_class()
+
+            from backend.util.test import execute_block_test
+
+            execute_block_test(block)
+            yield "success", "Block installed successfully."
+        except Exception as e:
+            os.remove(file_path)
+            yield "error", f"[Code]\n{code}\n\n[Error]\n{str(e)}"

autogpt_platform/backend/backend/blocks/branching.py

@@ -0,0 +1,102 @@
+from enum import Enum
+from typing import Any
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import SchemaField
+
+
+class ComparisonOperator(Enum):
+    EQUAL = "=="
+    NOT_EQUAL = "!="
+    GREATER_THAN = ">"
+    LESS_THAN = "<"
+    GREATER_THAN_OR_EQUAL = ">="
+    LESS_THAN_OR_EQUAL = "<="
+
+
+class ConditionBlock(Block):
+    class Input(BlockSchema):
+        value1: Any = SchemaField(
+            description="Enter the first value for comparison",
+            placeholder="For example: 10 or 'hello' or True",
+        )
+        operator: ComparisonOperator = SchemaField(
+            description="Choose the comparison operator",
+            placeholder="Select an operator",
+        )
+        value2: Any = SchemaField(
+            description="Enter the second value for comparison",
+            placeholder="For example: 20 or 'world' or False",
+        )
+        yes_value: Any = SchemaField(
+            description="(Optional) Value to output if the condition is true. If not provided, value1 will be used.",
+            placeholder="Leave empty to use value1, or enter a specific value",
+            default=None,
+        )
+        no_value: Any = SchemaField(
+            description="(Optional) Value to output if the condition is false. If not provided, value1 will be used.",
+            placeholder="Leave empty to use value1, or enter a specific value",
+            default=None,
+        )
+
+    class Output(BlockSchema):
+        result: bool = SchemaField(
+            description="The result of the condition evaluation (True or False)"
+        )
+        yes_output: Any = SchemaField(
+            description="The output value if the condition is true"
+        )
+        no_output: Any = SchemaField(
+            description="The output value if the condition is false"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="715696a0-e1da-45c8-b209-c2fa9c3b0be6",
+            input_schema=ConditionBlock.Input,
+            output_schema=ConditionBlock.Output,
+            description="Handles conditional logic based on comparison operators",
+            categories={BlockCategory.LOGIC},
+            test_input={
+                "value1": 10,
+                "operator": ComparisonOperator.GREATER_THAN.value,
+                "value2": 5,
+                "yes_value": "Greater",
+                "no_value": "Not greater",
+            },
+            test_output=[
+                ("result", True),
+                ("yes_output", "Greater"),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        value1 = input_data.value1
+        operator = input_data.operator
+        value2 = input_data.value2
+        yes_value = input_data.yes_value if input_data.yes_value is not None else value1
+        no_value = input_data.no_value if input_data.no_value is not None else value1
+
+        comparison_funcs = {
+            ComparisonOperator.EQUAL: lambda a, b: a == b,
+            ComparisonOperator.NOT_EQUAL: lambda a, b: a != b,
+            ComparisonOperator.GREATER_THAN: lambda a, b: a > b,
+            ComparisonOperator.LESS_THAN: lambda a, b: a < b,
+            ComparisonOperator.GREATER_THAN_OR_EQUAL: lambda a, b: a >= b,
+            ComparisonOperator.LESS_THAN_OR_EQUAL: lambda a, b: a <= b,
+        }
+
+        try:
+            result = comparison_funcs[operator](value1, value2)
+
+            yield "result", result
+
+            if result:
+                yield "yes_output", yes_value
+            else:
+                yield "no_output", no_value
+
+        except Exception:
+            yield "result", None
+            yield "yes_output", None
+            yield "no_output", None

autogpt_platform/backend/backend/blocks/csv.py

@@ -0,0 +1,81 @@
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import ContributorDetails
+
+
+class ReadCsvBlock(Block):
+    class Input(BlockSchema):
+        contents: str
+        delimiter: str = ","
+        quotechar: str = '"'
+        escapechar: str = "\\"
+        has_header: bool = True
+        skip_rows: int = 0
+        strip: bool = True
+        skip_columns: list[str] = []
+
+    class Output(BlockSchema):
+        row: dict[str, str]
+        all_data: list[dict[str, str]]
+
+    def __init__(self):
+        super().__init__(
+            id="acf7625e-d2cb-4941-bfeb-2819fc6fc015",
+            input_schema=ReadCsvBlock.Input,
+            output_schema=ReadCsvBlock.Output,
+            description="Reads a CSV file and outputs the data as a list of dictionaries and individual rows via rows.",
+            contributors=[ContributorDetails(name="Nicholas Tindle")],
+            categories={BlockCategory.TEXT},
+            test_input={
+                "contents": "a, b, c\n1,2,3\n4,5,6",
+            },
+            test_output=[
+                ("row", {"a": "1", "b": "2", "c": "3"}),
+                ("row", {"a": "4", "b": "5", "c": "6"}),
+                (
+                    "all_data",
+                    [
+                        {"a": "1", "b": "2", "c": "3"},
+                        {"a": "4", "b": "5", "c": "6"},
+                    ],
+                ),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        import csv
+        from io import StringIO
+
+        csv_file = StringIO(input_data.contents)
+        reader = csv.reader(
+            csv_file,
+            delimiter=input_data.delimiter,
+            quotechar=input_data.quotechar,
+            escapechar=input_data.escapechar,
+        )
+
+        header = None
+        if input_data.has_header:
+            header = next(reader)
+            if input_data.strip:
+                header = [h.strip() for h in header]
+
+        for _ in range(input_data.skip_rows):
+            next(reader)
+
+        def process_row(row):
+            data = {}
+            for i, value in enumerate(row):
+                if i not in input_data.skip_columns:
+                    if input_data.has_header and header:
+                        data[header[i]] = value.strip() if input_data.strip else value
+                    else:
+                        data[str(i)] = value.strip() if input_data.strip else value
+            return data
+
+        all_data = []
+        for row in reader:
+            processed_row = process_row(row)
+            all_data.append(processed_row)
+            yield "row", processed_row
+
+        yield "all_data", all_data

autogpt_platform/backend/backend/blocks/discord.py

@@ -0,0 +1,219 @@
+import asyncio
+
+import aiohttp
+import discord
+from pydantic import Field
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import BlockSecret, SecretField
+
+
+class ReadDiscordMessagesBlock(Block):
+    class Input(BlockSchema):
+        discord_bot_token: BlockSecret = SecretField(
+            key="discord_bot_token", description="Discord bot token"
+        )
+        continuous_read: bool = Field(
+            description="Whether to continuously read messages", default=True
+        )
+
+    class Output(BlockSchema):
+        message_content: str = Field(description="The content of the message received")
+        channel_name: str = Field(
+            description="The name of the channel the message was received from"
+        )
+        username: str = Field(
+            description="The username of the user who sent the message"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="d3f4g5h6-1i2j-3k4l-5m6n-7o8p9q0r1s2t",  # Unique ID for the node
+            input_schema=ReadDiscordMessagesBlock.Input,  # Assign input schema
+            output_schema=ReadDiscordMessagesBlock.Output,  # Assign output schema
+            description="Reads messages from a Discord channel using a bot token.",
+            categories={BlockCategory.SOCIAL},
+            test_input={"discord_bot_token": "test_token", "continuous_read": False},
+            test_output=[
+                (
+                    "message_content",
+                    "Hello!\n\nFile from user: example.txt\nContent: This is the content of the file.",
+                ),
+                ("channel_name", "general"),
+                ("username", "test_user"),
+            ],
+            test_mock={
+                "run_bot": lambda token: asyncio.Future()  # Create a Future object for mocking
+            },
+        )
+
+    async def run_bot(self, token: str):
+        intents = discord.Intents.default()
+        intents.message_content = True
+
+        client = discord.Client(intents=intents)
+
+        self.output_data = None
+        self.channel_name = None
+        self.username = None
+
+        @client.event
+        async def on_ready():
+            print(f"Logged in as {client.user}")
+
+        @client.event
+        async def on_message(message):
+            if message.author == client.user:
+                return
+
+            self.output_data = message.content
+            self.channel_name = message.channel.name
+            self.username = message.author.name
+
+            if message.attachments:
+                attachment = message.attachments[0]  # Process the first attachment
+                if attachment.filename.endswith((".txt", ".py")):
+                    async with aiohttp.ClientSession() as session:
+                        async with session.get(attachment.url) as response:
+                            file_content = await response.text()
+                            self.output_data += f"\n\nFile from user: {attachment.filename}\nContent: {file_content}"
+
+            await client.close()
+
+        await client.start(token)
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        while True:
+            for output_name, output_value in self.__run(input_data):
+                yield output_name, output_value
+            if not input_data.continuous_read:
+                break
+
+    def __run(self, input_data: Input) -> BlockOutput:
+        try:
+            loop = asyncio.get_event_loop()
+            future = self.run_bot(input_data.discord_bot_token.get_secret_value())
+
+            # If it's a Future (mock), set the result
+            if isinstance(future, asyncio.Future):
+                future.set_result(
+                    {
+                        "output_data": "Hello!\n\nFile from user: example.txt\nContent: This is the content of the file.",
+                        "channel_name": "general",
+                        "username": "test_user",
+                    }
+                )
+
+            result = loop.run_until_complete(future)
+
+            # For testing purposes, use the mocked result
+            if isinstance(result, dict):
+                self.output_data = result.get("output_data")
+                self.channel_name = result.get("channel_name")
+                self.username = result.get("username")
+
+            if (
+                self.output_data is None
+                or self.channel_name is None
+                or self.username is None
+            ):
+                raise ValueError("No message, channel name, or username received.")
+
+            yield "message_content", self.output_data
+            yield "channel_name", self.channel_name
+            yield "username", self.username
+
+        except discord.errors.LoginFailure as login_err:
+            raise ValueError(f"Login error occurred: {login_err}")
+        except Exception as e:
+            raise ValueError(f"An error occurred: {e}")
+
+
+class SendDiscordMessageBlock(Block):
+    class Input(BlockSchema):
+        discord_bot_token: BlockSecret = SecretField(
+            key="discord_bot_token", description="Discord bot token"
+        )
+        message_content: str = Field(description="The content of the message received")
+        channel_name: str = Field(
+            description="The name of the channel the message was received from"
+        )
+
+    class Output(BlockSchema):
+        status: str = Field(
+            description="The status of the operation (e.g., 'Message sent', 'Error')"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="h1i2j3k4-5l6m-7n8o-9p0q-r1s2t3u4v5w6",  # Unique ID for the node
+            input_schema=SendDiscordMessageBlock.Input,  # Assign input schema
+            output_schema=SendDiscordMessageBlock.Output,  # Assign output schema
+            description="Sends a message to a Discord channel using a bot token.",
+            categories={BlockCategory.SOCIAL},
+            test_input={
+                "discord_bot_token": "YOUR_DISCORD_BOT_TOKEN",
+                "channel_name": "general",
+                "message_content": "Hello, Discord!",
+            },
+            test_output=[("status", "Message sent")],
+            test_mock={
+                "send_message": lambda token, channel_name, message_content: asyncio.Future()
+            },
+        )
+
+    async def send_message(self, token: str, channel_name: str, message_content: str):
+        intents = discord.Intents.default()
+        intents.guilds = True  # Required for fetching guild/channel information
+        client = discord.Client(intents=intents)
+
+        @client.event
+        async def on_ready():
+            print(f"Logged in as {client.user}")
+            for guild in client.guilds:
+                for channel in guild.text_channels:
+                    if channel.name == channel_name:
+                        # Split message into chunks if it exceeds 2000 characters
+                        for chunk in self.chunk_message(message_content):
+                            await channel.send(chunk)
+                        self.output_data = "Message sent"
+                        await client.close()
+                        return
+
+            self.output_data = "Channel not found"
+            await client.close()
+
+        await client.start(token)
+
+    def chunk_message(self, message: str, limit: int = 2000) -> list:
+        """Splits a message into chunks not exceeding the Discord limit."""
+        return [message[i : i + limit] for i in range(0, len(message), limit)]
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            loop = asyncio.get_event_loop()
+            future = self.send_message(
+                input_data.discord_bot_token.get_secret_value(),
+                input_data.channel_name,
+                input_data.message_content,
+            )
+
+            # If it's a Future (mock), set the result
+            if isinstance(future, asyncio.Future):
+                future.set_result("Message sent")
+
+            result = loop.run_until_complete(future)
+
+            # For testing purposes, use the mocked result
+            if isinstance(result, str):
+                self.output_data = result
+
+            if self.output_data is None:
+                raise ValueError("No status message received.")
+
+            yield "status", self.output_data
+
+        except discord.errors.LoginFailure as login_err:
+            raise ValueError(f"Login error occurred: {login_err}")
+        except Exception as e:
+            raise ValueError(f"An error occurred: {e}")

autogpt_platform/backend/backend/blocks/email_block.py

@@ -0,0 +1,101 @@
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import BlockSecret, SchemaField, SecretField
+
+
+class EmailCredentials(BaseModel):
+    smtp_server: str = Field(
+        default="smtp.gmail.com", description="SMTP server address"
+    )
+    smtp_port: int = Field(default=25, description="SMTP port number")
+    smtp_username: BlockSecret = SecretField(key="smtp_username")
+    smtp_password: BlockSecret = SecretField(key="smtp_password")
+
+    model_config = ConfigDict(title="Email Credentials")
+
+
+class SendEmailBlock(Block):
+    class Input(BlockSchema):
+        to_email: str = SchemaField(
+            description="Recipient email address", placeholder="recipient@example.com"
+        )
+        subject: str = SchemaField(
+            description="Subject of the email", placeholder="Enter the email subject"
+        )
+        body: str = SchemaField(
+            description="Body of the email", placeholder="Enter the email body"
+        )
+        creds: EmailCredentials = Field(
+            description="SMTP credentials",
+            default=EmailCredentials(),
+        )
+
+    class Output(BlockSchema):
+        status: str = SchemaField(description="Status of the email sending operation")
+        error: str = SchemaField(
+            description="Error message if the email sending failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="a1234567-89ab-cdef-0123-456789abcdef",
+            description="This block sends an email using the provided SMTP credentials.",
+            categories={BlockCategory.OUTPUT},
+            input_schema=SendEmailBlock.Input,
+            output_schema=SendEmailBlock.Output,
+            test_input={
+                "to_email": "recipient@example.com",
+                "subject": "Test Email",
+                "body": "This is a test email.",
+                "creds": {
+                    "smtp_server": "smtp.gmail.com",
+                    "smtp_port": 25,
+                    "smtp_username": "your-email@gmail.com",
+                    "smtp_password": "your-gmail-password",
+                },
+            },
+            test_output=[("status", "Email sent successfully")],
+            test_mock={"send_email": lambda *args, **kwargs: "Email sent successfully"},
+        )
+
+    @staticmethod
+    def send_email(
+        creds: EmailCredentials, to_email: str, subject: str, body: str
+    ) -> str:
+        try:
+            smtp_server = creds.smtp_server
+            smtp_port = creds.smtp_port
+            smtp_username = creds.smtp_username.get_secret_value()
+            smtp_password = creds.smtp_password.get_secret_value()
+
+            msg = MIMEMultipart()
+            msg["From"] = smtp_username
+            msg["To"] = to_email
+            msg["Subject"] = subject
+            msg.attach(MIMEText(body, "plain"))
+
+            with smtplib.SMTP(smtp_server, smtp_port) as server:
+                server.starttls()
+                server.login(smtp_username, smtp_password)
+                server.sendmail(smtp_username, to_email, msg.as_string())
+
+            return "Email sent successfully"
+        except Exception as e:
+            return f"Failed to send email: {str(e)}"
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        status = self.send_email(
+            input_data.creds,
+            input_data.to_email,
+            input_data.subject,
+            input_data.body,
+        )
+        if "successfully" in status:
+            yield "status", status
+        else:
+            yield "error", status

autogpt_platform/backend/backend/blocks/github/_auth.py

@@ -0,0 +1,54 @@
+from typing import Literal
+
+from autogpt_libs.supabase_integration_credentials_store.types import (
+    APIKeyCredentials,
+    OAuth2Credentials,
+)
+from pydantic import SecretStr
+
+from backend.data.model import CredentialsField, CredentialsMetaInput
+from backend.util.settings import Secrets
+
+secrets = Secrets()
+GITHUB_OAUTH_IS_CONFIGURED = bool(
+    secrets.github_client_id and secrets.github_client_secret
+)
+
+GithubCredentials = APIKeyCredentials | OAuth2Credentials
+GithubCredentialsInput = CredentialsMetaInput[
+    Literal["github"],
+    Literal["api_key", "oauth2"] if GITHUB_OAUTH_IS_CONFIGURED else Literal["api_key"],
+]
+
+
+def GithubCredentialsField(scope: str) -> GithubCredentialsInput:
+    """
+    Creates a GitHub credentials input on a block.
+
+    Params:
+        scope: The authorization scope needed for the block to work. ([list of available scopes](https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/scopes-for-oauth-apps#available-scopes))
+    """  # noqa
+    return CredentialsField(
+        provider="github",
+        supported_credential_types=(
+            {"api_key", "oauth2"} if GITHUB_OAUTH_IS_CONFIGURED else {"api_key"}
+        ),
+        required_scopes={scope},
+        description="The GitHub integration can be used with OAuth, "
+        "or any API key with sufficient permissions for the blocks it is used on.",
+    )
+
+
+TEST_CREDENTIALS = APIKeyCredentials(
+    id="01234567-89ab-cdef-0123-456789abcdef",
+    provider="github",
+    api_key=SecretStr("mock-github-api-key"),
+    title="Mock GitHub API key",
+    expires_at=None,
+)
+TEST_CREDENTIALS_INPUT = {
+    "provider": TEST_CREDENTIALS.provider,
+    "id": TEST_CREDENTIALS.id,
+    "type": TEST_CREDENTIALS.type,
+    "title": TEST_CREDENTIALS.type,
+}

autogpt_platform/backend/backend/blocks/github/issues.py

@@ -0,0 +1,683 @@
+import requests
+from typing_extensions import TypedDict
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import SchemaField
+
+from ._auth import (
+    TEST_CREDENTIALS,
+    TEST_CREDENTIALS_INPUT,
+    GithubCredentials,
+    GithubCredentialsField,
+    GithubCredentialsInput,
+)
+
+
+class GithubCommentBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        issue_url: str = SchemaField(
+            description="URL of the GitHub issue or pull request",
+            placeholder="https://github.com/owner/repo/issues/1",
+        )
+        comment: str = SchemaField(
+            description="Comment to post on the issue or pull request",
+            placeholder="Enter your comment",
+        )
+
+    class Output(BlockSchema):
+        id: int = SchemaField(description="ID of the created comment")
+        url: str = SchemaField(description="URL to the comment on GitHub")
+        error: str = SchemaField(
+            description="Error message if the comment posting failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="a8db4d8d-db1c-4a25-a1b0-416a8c33602b",
+            description="This block posts a comment on a specified GitHub issue or pull request.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubCommentBlock.Input,
+            output_schema=GithubCommentBlock.Output,
+            test_input={
+                "issue_url": "https://github.com/owner/repo/issues/1",
+                "comment": "This is a test comment.",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                ("id", 1337),
+                ("url", "https://github.com/owner/repo/issues/1#issuecomment-1337"),
+            ],
+            test_mock={
+                "post_comment": lambda *args, **kwargs: (
+                    1337,
+                    "https://github.com/owner/repo/issues/1#issuecomment-1337",
+                )
+            },
+        )
+
+    @staticmethod
+    def post_comment(
+        credentials: GithubCredentials, issue_url: str, body_text: str
+    ) -> tuple[int, str]:
+        if "/pull/" in issue_url:
+            api_url = (
+                issue_url.replace("github.com", "api.github.com/repos").replace(
+                    "/pull/", "/issues/"
+                )
+                + "/comments"
+            )
+        else:
+            api_url = (
+                issue_url.replace("github.com", "api.github.com/repos") + "/comments"
+            )
+
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+        data = {"body": body_text}
+
+        response = requests.post(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
+        comment = response.json()
+        return comment["id"], comment["html_url"]
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            id, url = self.post_comment(
+                credentials,
+                input_data.issue_url,
+                input_data.comment,
+            )
+            yield "id", id
+            yield "url", url
+        except Exception as e:
+            yield "error", f"Failed to post comment: {str(e)}"
+
+
+class GithubMakeIssueBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        repo_url: str = SchemaField(
+            description="URL of the GitHub repository",
+            placeholder="https://github.com/owner/repo",
+        )
+        title: str = SchemaField(
+            description="Title of the issue", placeholder="Enter the issue title"
+        )
+        body: str = SchemaField(
+            description="Body of the issue", placeholder="Enter the issue body"
+        )
+
+    class Output(BlockSchema):
+        number: int = SchemaField(description="Number of the created issue")
+        url: str = SchemaField(description="URL of the created issue")
+        error: str = SchemaField(
+            description="Error message if the issue creation failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="691dad47-f494-44c3-a1e8-05b7990f2dab",
+            description="This block creates a new issue on a specified GitHub repository.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubMakeIssueBlock.Input,
+            output_schema=GithubMakeIssueBlock.Output,
+            test_input={
+                "repo_url": "https://github.com/owner/repo",
+                "title": "Test Issue",
+                "body": "This is a test issue.",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                ("number", 1),
+                ("url", "https://github.com/owner/repo/issues/1"),
+            ],
+            test_mock={
+                "create_issue": lambda *args, **kwargs: (
+                    1,
+                    "https://github.com/owner/repo/issues/1",
+                )
+            },
+        )
+
+    @staticmethod
+    def create_issue(
+        credentials: GithubCredentials, repo_url: str, title: str, body: str
+    ) -> tuple[int, str]:
+        api_url = repo_url.replace("github.com", "api.github.com/repos") + "/issues"
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+        data = {"title": title, "body": body}
+
+        response = requests.post(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
+        issue = response.json()
+        return issue["number"], issue["html_url"]
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            number, url = self.create_issue(
+                credentials,
+                input_data.repo_url,
+                input_data.title,
+                input_data.body,
+            )
+            yield "number", number
+            yield "url", url
+        except Exception as e:
+            yield "error", f"Failed to create issue: {str(e)}"
+
+
+class GithubReadIssueBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        issue_url: str = SchemaField(
+            description="URL of the GitHub issue",
+            placeholder="https://github.com/owner/repo/issues/1",
+        )
+
+    class Output(BlockSchema):
+        title: str = SchemaField(description="Title of the issue")
+        body: str = SchemaField(description="Body of the issue")
+        user: str = SchemaField(description="User who created the issue")
+        error: str = SchemaField(
+            description="Error message if reading the issue failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="6443c75d-032a-4772-9c08-230c707c8acc",
+            description="This block reads the body, title, and user of a specified GitHub issue.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubReadIssueBlock.Input,
+            output_schema=GithubReadIssueBlock.Output,
+            test_input={
+                "issue_url": "https://github.com/owner/repo/issues/1",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                ("title", "Title of the issue"),
+                ("body", "This is the body of the issue."),
+                ("user", "username"),
+            ],
+            test_mock={
+                "read_issue": lambda *args, **kwargs: (
+                    "Title of the issue",
+                    "This is the body of the issue.",
+                    "username",
+                )
+            },
+        )
+
+    @staticmethod
+    def read_issue(
+        credentials: GithubCredentials, issue_url: str
+    ) -> tuple[str, str, str]:
+        api_url = issue_url.replace("github.com", "api.github.com/repos")
+
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+        title = data.get("title", "No title found")
+        body = data.get("body", "No body content found")
+        user = data.get("user", {}).get("login", "No user found")
+
+        return title, body, user
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            title, body, user = self.read_issue(
+                credentials,
+                input_data.issue_url,
+            )
+            yield "title", title
+            yield "body", body
+            yield "user", user
+        except Exception as e:
+            yield "error", f"Failed to read issue: {str(e)}"
+
+
+class GithubListIssuesBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        repo_url: str = SchemaField(
+            description="URL of the GitHub repository",
+            placeholder="https://github.com/owner/repo",
+        )
+
+    class Output(BlockSchema):
+        class IssueItem(TypedDict):
+            title: str
+            url: str
+
+        issue: IssueItem = SchemaField(
+            title="Issue", description="Issues with their title and URL"
+        )
+        error: str = SchemaField(description="Error message if listing issues failed")
+
+    def __init__(self):
+        super().__init__(
+            id="c215bfd7-0e57-4573-8f8c-f7d4963dcd74",
+            description="This block lists all issues for a specified GitHub repository.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubListIssuesBlock.Input,
+            output_schema=GithubListIssuesBlock.Output,
+            test_input={
+                "repo_url": "https://github.com/owner/repo",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                (
+                    "issue",
+                    {
+                        "title": "Issue 1",
+                        "url": "https://github.com/owner/repo/issues/1",
+                    },
+                )
+            ],
+            test_mock={
+                "list_issues": lambda *args, **kwargs: [
+                    {
+                        "title": "Issue 1",
+                        "url": "https://github.com/owner/repo/issues/1",
+                    }
+                ]
+            },
+        )
+
+    @staticmethod
+    def list_issues(
+        credentials: GithubCredentials, repo_url: str
+    ) -> list[Output.IssueItem]:
+        api_url = repo_url.replace("github.com", "api.github.com/repos") + "/issues"
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+        issues: list[GithubListIssuesBlock.Output.IssueItem] = [
+            {"title": issue["title"], "url": issue["html_url"]} for issue in data
+        ]
+
+        return issues
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            issues = self.list_issues(
+                credentials,
+                input_data.repo_url,
+            )
+            yield from (("issue", issue) for issue in issues)
+        except Exception as e:
+            yield "error", f"Failed to list issues: {str(e)}"
+
+
+class GithubAddLabelBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        issue_url: str = SchemaField(
+            description="URL of the GitHub issue or pull request",
+            placeholder="https://github.com/owner/repo/issues/1",
+        )
+        label: str = SchemaField(
+            description="Label to add to the issue or pull request",
+            placeholder="Enter the label",
+        )
+
+    class Output(BlockSchema):
+        status: str = SchemaField(description="Status of the label addition operation")
+        error: str = SchemaField(
+            description="Error message if the label addition failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="98bd6b77-9506-43d5-b669-6b9733c4b1f1",
+            description="This block adds a label to a specified GitHub issue or pull request.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubAddLabelBlock.Input,
+            output_schema=GithubAddLabelBlock.Output,
+            test_input={
+                "issue_url": "https://github.com/owner/repo/issues/1",
+                "label": "bug",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[("status", "Label added successfully")],
+            test_mock={"add_label": lambda *args, **kwargs: "Label added successfully"},
+        )
+
+    @staticmethod
+    def add_label(credentials: GithubCredentials, issue_url: str, label: str) -> str:
+        # Convert the provided GitHub URL to the API URL
+        if "/pull/" in issue_url:
+            api_url = (
+                issue_url.replace("github.com", "api.github.com/repos").replace(
+                    "/pull/", "/issues/"
+                )
+                + "/labels"
+            )
+        else:
+            api_url = (
+                issue_url.replace("github.com", "api.github.com/repos") + "/labels"
+            )
+
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+        data = {"labels": [label]}
+
+        response = requests.post(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
+        return "Label added successfully"
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            status = self.add_label(
+                credentials,
+                input_data.issue_url,
+                input_data.label,
+            )
+            yield "status", status
+        except Exception as e:
+            yield "error", f"Failed to add label: {str(e)}"
+
+
+class GithubRemoveLabelBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        issue_url: str = SchemaField(
+            description="URL of the GitHub issue or pull request",
+            placeholder="https://github.com/owner/repo/issues/1",
+        )
+        label: str = SchemaField(
+            description="Label to remove from the issue or pull request",
+            placeholder="Enter the label",
+        )
+
+    class Output(BlockSchema):
+        status: str = SchemaField(description="Status of the label removal operation")
+        error: str = SchemaField(
+            description="Error message if the label removal failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="78f050c5-3e3a-48c0-9e5b-ef1ceca5589c",
+            description="This block removes a label from a specified GitHub issue or pull request.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubRemoveLabelBlock.Input,
+            output_schema=GithubRemoveLabelBlock.Output,
+            test_input={
+                "issue_url": "https://github.com/owner/repo/issues/1",
+                "label": "bug",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[("status", "Label removed successfully")],
+            test_mock={
+                "remove_label": lambda *args, **kwargs: "Label removed successfully"
+            },
+        )
+
+    @staticmethod
+    def remove_label(credentials: GithubCredentials, issue_url: str, label: str) -> str:
+        # Convert the provided GitHub URL to the API URL
+        if "/pull/" in issue_url:
+            api_url = (
+                issue_url.replace("github.com", "api.github.com/repos").replace(
+                    "/pull/", "/issues/"
+                )
+                + f"/labels/{label}"
+            )
+        else:
+            api_url = (
+                issue_url.replace("github.com", "api.github.com/repos")
+                + f"/labels/{label}"
+            )
+
+        # Log the constructed API URL for debugging
+        print(f"Constructed API URL: {api_url}")
+
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.delete(api_url, headers=headers)
+        response.raise_for_status()
+
+        return "Label removed successfully"
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            status = self.remove_label(
+                credentials,
+                input_data.issue_url,
+                input_data.label,
+            )
+            yield "status", status
+        except Exception as e:
+            yield "error", f"Failed to remove label: {str(e)}"
+
+
+class GithubAssignIssueBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        issue_url: str = SchemaField(
+            description="URL of the GitHub issue",
+            placeholder="https://github.com/owner/repo/issues/1",
+        )
+        assignee: str = SchemaField(
+            description="Username to assign to the issue",
+            placeholder="Enter the username",
+        )
+
+    class Output(BlockSchema):
+        status: str = SchemaField(
+            description="Status of the issue assignment operation"
+        )
+        error: str = SchemaField(
+            description="Error message if the issue assignment failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="90507c72-b0ff-413a-886a-23bbbd66f542",
+            description="This block assigns a user to a specified GitHub issue.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubAssignIssueBlock.Input,
+            output_schema=GithubAssignIssueBlock.Output,
+            test_input={
+                "issue_url": "https://github.com/owner/repo/issues/1",
+                "assignee": "username1",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[("status", "Issue assigned successfully")],
+            test_mock={
+                "assign_issue": lambda *args, **kwargs: "Issue assigned successfully"
+            },
+        )
+
+    @staticmethod
+    def assign_issue(
+        credentials: GithubCredentials,
+        issue_url: str,
+        assignee: str,
+    ) -> str:
+        # Extracting repo path and issue number from the issue URL
+        repo_path, issue_number = issue_url.replace("https://github.com/", "").split(
+            "/issues/"
+        )
+        api_url = (
+            f"https://api.github.com/repos/{repo_path}/issues/{issue_number}/assignees"
+        )
+
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+        data = {"assignees": [assignee]}
+
+        response = requests.post(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
+        return "Issue assigned successfully"
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            status = self.assign_issue(
+                credentials,
+                input_data.issue_url,
+                input_data.assignee,
+            )
+            yield "status", status
+        except Exception as e:
+            yield "error", f"Failed to assign issue: {str(e)}"
+
+
+class GithubUnassignIssueBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        issue_url: str = SchemaField(
+            description="URL of the GitHub issue",
+            placeholder="https://github.com/owner/repo/issues/1",
+        )
+        assignee: str = SchemaField(
+            description="Username to unassign from the issue",
+            placeholder="Enter the username",
+        )
+
+    class Output(BlockSchema):
+        status: str = SchemaField(
+            description="Status of the issue unassignment operation"
+        )
+        error: str = SchemaField(
+            description="Error message if the issue unassignment failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="d154002a-38f4-46c2-962d-2488f2b05ece",
+            description="This block unassigns a user from a specified GitHub issue.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubUnassignIssueBlock.Input,
+            output_schema=GithubUnassignIssueBlock.Output,
+            test_input={
+                "issue_url": "https://github.com/owner/repo/issues/1",
+                "assignee": "username1",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[("status", "Issue unassigned successfully")],
+            test_mock={
+                "unassign_issue": lambda *args, **kwargs: "Issue unassigned successfully"
+            },
+        )
+
+    @staticmethod
+    def unassign_issue(
+        credentials: GithubCredentials,
+        issue_url: str,
+        assignee: str,
+    ) -> str:
+        # Extracting repo path and issue number from the issue URL
+        repo_path, issue_number = issue_url.replace("https://github.com/", "").split(
+            "/issues/"
+        )
+        api_url = (
+            f"https://api.github.com/repos/{repo_path}/issues/{issue_number}/assignees"
+        )
+
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+        data = {"assignees": [assignee]}
+
+        response = requests.delete(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
+        return "Issue unassigned successfully"
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            status = self.unassign_issue(
+                credentials,
+                input_data.issue_url,
+                input_data.assignee,
+            )
+            yield "status", status
+        except Exception as e:
+            yield "error", f"Failed to unassign issue: {str(e)}"

autogpt_platform/backend/backend/blocks/github/pull_requests.py

@@ -0,0 +1,596 @@
+import requests
+from typing_extensions import TypedDict
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import SchemaField
+
+from ._auth import (
+    TEST_CREDENTIALS,
+    TEST_CREDENTIALS_INPUT,
+    GithubCredentials,
+    GithubCredentialsField,
+    GithubCredentialsInput,
+)
+
+
+class GithubListPullRequestsBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        repo_url: str = SchemaField(
+            description="URL of the GitHub repository",
+            placeholder="https://github.com/owner/repo",
+        )
+
+    class Output(BlockSchema):
+        class PRItem(TypedDict):
+            title: str
+            url: str
+
+        pull_request: PRItem = SchemaField(
+            title="Pull Request", description="PRs with their title and URL"
+        )
+        error: str = SchemaField(description="Error message if listing issues failed")
+
+    def __init__(self):
+        super().__init__(
+            id="ffef3c4c-6cd0-48dd-817d-459f975219f4",
+            description="This block lists all pull requests for a specified GitHub repository.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubListPullRequestsBlock.Input,
+            output_schema=GithubListPullRequestsBlock.Output,
+            test_input={
+                "repo_url": "https://github.com/owner/repo",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                (
+                    "pull_request",
+                    {
+                        "title": "Pull request 1",
+                        "url": "https://github.com/owner/repo/pull/1",
+                    },
+                )
+            ],
+            test_mock={
+                "list_prs": lambda *args, **kwargs: [
+                    {
+                        "title": "Pull request 1",
+                        "url": "https://github.com/owner/repo/pull/1",
+                    }
+                ]
+            },
+        )
+
+    @staticmethod
+    def list_prs(credentials: GithubCredentials, repo_url: str) -> list[Output.PRItem]:
+        api_url = repo_url.replace("github.com", "api.github.com/repos") + "/pulls"
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+        pull_requests: list[GithubListPullRequestsBlock.Output.PRItem] = [
+            {"title": pr["title"], "url": pr["html_url"]} for pr in data
+        ]
+
+        return pull_requests
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            pull_requests = self.list_prs(
+                credentials,
+                input_data.repo_url,
+            )
+            yield from (("pull_request", pr) for pr in pull_requests)
+        except Exception as e:
+            yield "error", f"Failed to list pull requests: {str(e)}"
+
+
+class GithubMakePullRequestBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        repo_url: str = SchemaField(
+            description="URL of the GitHub repository",
+            placeholder="https://github.com/owner/repo",
+        )
+        title: str = SchemaField(
+            description="Title of the pull request",
+            placeholder="Enter the pull request title",
+        )
+        body: str = SchemaField(
+            description="Body of the pull request",
+            placeholder="Enter the pull request body",
+        )
+        head: str = SchemaField(
+            description="The name of the branch where your changes are implemented. For cross-repository pull requests in the same network, namespace head with a user like this: username:branch.",
+            placeholder="Enter the head branch",
+        )
+        base: str = SchemaField(
+            description="The name of the branch you want the changes pulled into.",
+            placeholder="Enter the base branch",
+        )
+
+    class Output(BlockSchema):
+        number: int = SchemaField(description="Number of the created pull request")
+        url: str = SchemaField(description="URL of the created pull request")
+        error: str = SchemaField(
+            description="Error message if the pull request creation failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="dfb987f8-f197-4b2e-bf19-111812afd692",
+            description="This block creates a new pull request on a specified GitHub repository.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubMakePullRequestBlock.Input,
+            output_schema=GithubMakePullRequestBlock.Output,
+            test_input={
+                "repo_url": "https://github.com/owner/repo",
+                "title": "Test Pull Request",
+                "body": "This is a test pull request.",
+                "head": "feature-branch",
+                "base": "main",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                ("number", 1),
+                ("url", "https://github.com/owner/repo/pull/1"),
+            ],
+            test_mock={
+                "create_pr": lambda *args, **kwargs: (
+                    1,
+                    "https://github.com/owner/repo/pull/1",
+                )
+            },
+        )
+
+    @staticmethod
+    def create_pr(
+        credentials: GithubCredentials,
+        repo_url: str,
+        title: str,
+        body: str,
+        head: str,
+        base: str,
+    ) -> tuple[int, str]:
+        repo_path = repo_url.replace("https://github.com/", "")
+        api_url = f"https://api.github.com/repos/{repo_path}/pulls"
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+        data = {"title": title, "body": body, "head": head, "base": base}
+
+        response = requests.post(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
+        pr_data = response.json()
+        return pr_data["number"], pr_data["html_url"]
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            number, url = self.create_pr(
+                credentials,
+                input_data.repo_url,
+                input_data.title,
+                input_data.body,
+                input_data.head,
+                input_data.base,
+            )
+            yield "number", number
+            yield "url", url
+        except requests.exceptions.HTTPError as http_err:
+            if http_err.response.status_code == 422:
+                error_details = http_err.response.json()
+                error_message = error_details.get("message", "Unknown error")
+            else:
+                error_message = str(http_err)
+            yield "error", f"Failed to create pull request: {error_message}"
+        except Exception as e:
+            yield "error", f"Failed to create pull request: {str(e)}"
+
+
+class GithubReadPullRequestBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        pr_url: str = SchemaField(
+            description="URL of the GitHub pull request",
+            placeholder="https://github.com/owner/repo/pull/1",
+        )
+        include_pr_changes: bool = SchemaField(
+            description="Whether to include the changes made in the pull request",
+            default=False,
+        )
+
+    class Output(BlockSchema):
+        title: str = SchemaField(description="Title of the pull request")
+        body: str = SchemaField(description="Body of the pull request")
+        author: str = SchemaField(description="User who created the pull request")
+        changes: str = SchemaField(description="Changes made in the pull request")
+        error: str = SchemaField(
+            description="Error message if reading the pull request failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="bf94b2a4-1a30-4600-a783-a8a44ee31301",
+            description="This block reads the body, title, user, and changes of a specified GitHub pull request.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubReadPullRequestBlock.Input,
+            output_schema=GithubReadPullRequestBlock.Output,
+            test_input={
+                "pr_url": "https://github.com/owner/repo/pull/1",
+                "include_pr_changes": True,
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                ("title", "Title of the pull request"),
+                ("body", "This is the body of the pull request."),
+                ("author", "username"),
+                ("changes", "List of changes made in the pull request."),
+            ],
+            test_mock={
+                "read_pr": lambda *args, **kwargs: (
+                    "Title of the pull request",
+                    "This is the body of the pull request.",
+                    "username",
+                ),
+                "read_pr_changes": lambda *args, **kwargs: "List of changes made in the pull request.",
+            },
+        )
+
+    @staticmethod
+    def read_pr(credentials: GithubCredentials, pr_url: str) -> tuple[str, str, str]:
+        api_url = pr_url.replace("github.com", "api.github.com/repos").replace(
+            "/pull/", "/issues/"
+        )
+
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+        title = data.get("title", "No title found")
+        body = data.get("body", "No body content found")
+        author = data.get("user", {}).get("login", "No user found")
+
+        return title, body, author
+
+    @staticmethod
+    def read_pr_changes(credentials: GithubCredentials, pr_url: str) -> str:
+        api_url = (
+            pr_url.replace("github.com", "api.github.com/repos").replace(
+                "/pull/", "/pulls/"
+            )
+            + "/files"
+        )
+
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        files = response.json()
+        changes = []
+        for file in files:
+            filename = file.get("filename")
+            patch = file.get("patch")
+            if filename and patch:
+                changes.append(f"File: {filename}\n{patch}")
+
+        return "\n\n".join(changes)
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            title, body, author = self.read_pr(
+                credentials,
+                input_data.pr_url,
+            )
+            yield "title", title
+            yield "body", body
+            yield "author", author
+
+            if input_data.include_pr_changes:
+                changes = self.read_pr_changes(
+                    credentials,
+                    input_data.pr_url,
+                )
+                yield "changes", changes
+        except Exception as e:
+            yield "error", f"Failed to read pull request: {str(e)}"
+
+
+class GithubAssignPRReviewerBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        pr_url: str = SchemaField(
+            description="URL of the GitHub pull request",
+            placeholder="https://github.com/owner/repo/pull/1",
+        )
+        reviewer: str = SchemaField(
+            description="Username of the reviewer to assign",
+            placeholder="Enter the reviewer's username",
+        )
+
+    class Output(BlockSchema):
+        status: str = SchemaField(
+            description="Status of the reviewer assignment operation"
+        )
+        error: str = SchemaField(
+            description="Error message if the reviewer assignment failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="c0d22c5e-e688-43e3-ba43-d5faba7927fd",
+            description="This block assigns a reviewer to a specified GitHub pull request.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubAssignPRReviewerBlock.Input,
+            output_schema=GithubAssignPRReviewerBlock.Output,
+            test_input={
+                "pr_url": "https://github.com/owner/repo/pull/1",
+                "reviewer": "reviewer_username",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[("status", "Reviewer assigned successfully")],
+            test_mock={
+                "assign_reviewer": lambda *args, **kwargs: "Reviewer assigned successfully"
+            },
+        )
+
+    @staticmethod
+    def assign_reviewer(
+        credentials: GithubCredentials, pr_url: str, reviewer: str
+    ) -> str:
+        # Convert the PR URL to the appropriate API endpoint
+        api_url = (
+            pr_url.replace("github.com", "api.github.com/repos").replace(
+                "/pull/", "/pulls/"
+            )
+            + "/requested_reviewers"
+        )
+
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+        data = {"reviewers": [reviewer]}
+
+        response = requests.post(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
+        return "Reviewer assigned successfully"
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            status = self.assign_reviewer(
+                credentials,
+                input_data.pr_url,
+                input_data.reviewer,
+            )
+            yield "status", status
+        except requests.exceptions.HTTPError as http_err:
+            if http_err.response.status_code == 422:
+                error_msg = (
+                    "Failed to assign reviewer: "
+                    f"The reviewer '{input_data.reviewer}' may not have permission "
+                    "or the pull request is not in a valid state. "
+                    f"Detailed error: {http_err.response.text}"
+                )
+            else:
+                error_msg = f"HTTP error: {http_err} - {http_err.response.text}"
+            yield "error", error_msg
+        except Exception as e:
+            yield "error", f"Failed to assign reviewer: {str(e)}"
+
+
+class GithubUnassignPRReviewerBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        pr_url: str = SchemaField(
+            description="URL of the GitHub pull request",
+            placeholder="https://github.com/owner/repo/pull/1",
+        )
+        reviewer: str = SchemaField(
+            description="Username of the reviewer to unassign",
+            placeholder="Enter the reviewer's username",
+        )
+
+    class Output(BlockSchema):
+        status: str = SchemaField(
+            description="Status of the reviewer unassignment operation"
+        )
+        error: str = SchemaField(
+            description="Error message if the reviewer unassignment failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="9637945d-c602-4875-899a-9c22f8fd30de",
+            description="This block unassigns a reviewer from a specified GitHub pull request.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubUnassignPRReviewerBlock.Input,
+            output_schema=GithubUnassignPRReviewerBlock.Output,
+            test_input={
+                "pr_url": "https://github.com/owner/repo/pull/1",
+                "reviewer": "reviewer_username",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[("status", "Reviewer unassigned successfully")],
+            test_mock={
+                "unassign_reviewer": lambda *args, **kwargs: "Reviewer unassigned successfully"
+            },
+        )
+
+    @staticmethod
+    def unassign_reviewer(
+        credentials: GithubCredentials, pr_url: str, reviewer: str
+    ) -> str:
+        api_url = (
+            pr_url.replace("github.com", "api.github.com/repos").replace(
+                "/pull/", "/pulls/"
+            )
+            + "/requested_reviewers"
+        )
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+        data = {"reviewers": [reviewer]}
+
+        response = requests.delete(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
+        return "Reviewer unassigned successfully"
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            status = self.unassign_reviewer(
+                credentials,
+                input_data.pr_url,
+                input_data.reviewer,
+            )
+            yield "status", status
+        except Exception as e:
+            yield "error", f"Failed to unassign reviewer: {str(e)}"
+
+
+class GithubListPRReviewersBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        pr_url: str = SchemaField(
+            description="URL of the GitHub pull request",
+            placeholder="https://github.com/owner/repo/pull/1",
+        )
+
+    class Output(BlockSchema):
+        class ReviewerItem(TypedDict):
+            username: str
+            url: str
+
+        reviewer: ReviewerItem = SchemaField(
+            title="Reviewer",
+            description="Reviewers with their username and profile URL",
+        )
+        error: str = SchemaField(
+            description="Error message if listing reviewers failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="2646956e-96d5-4754-a3df-034017e7ed96",
+            description="This block lists all reviewers for a specified GitHub pull request.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubListPRReviewersBlock.Input,
+            output_schema=GithubListPRReviewersBlock.Output,
+            test_input={
+                "pr_url": "https://github.com/owner/repo/pull/1",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                (
+                    "reviewer",
+                    {
+                        "username": "reviewer1",
+                        "url": "https://github.com/reviewer1",
+                    },
+                )
+            ],
+            test_mock={
+                "list_reviewers": lambda *args, **kwargs: [
+                    {
+                        "username": "reviewer1",
+                        "url": "https://github.com/reviewer1",
+                    }
+                ]
+            },
+        )
+
+    @staticmethod
+    def list_reviewers(
+        credentials: GithubCredentials, pr_url: str
+    ) -> list[Output.ReviewerItem]:
+        api_url = (
+            pr_url.replace("github.com", "api.github.com/repos").replace(
+                "/pull/", "/pulls/"
+            )
+            + "/requested_reviewers"
+        )
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+        reviewers: list[GithubListPRReviewersBlock.Output.ReviewerItem] = [
+            {"username": reviewer["login"], "url": reviewer["html_url"]}
+            for reviewer in data.get("users", [])
+        ]
+
+        return reviewers
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            reviewers = self.list_reviewers(
+                credentials,
+                input_data.pr_url,
+            )
+            yield from (("reviewer", reviewer) for reviewer in reviewers)
+        except Exception as e:
+            yield "error", f"Failed to list reviewers: {str(e)}"

autogpt_platform/backend/backend/blocks/github/repo.py

@@ -0,0 +1,786 @@
+import base64
+
+import requests
+from typing_extensions import TypedDict
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import SchemaField
+
+from ._auth import (
+    TEST_CREDENTIALS,
+    TEST_CREDENTIALS_INPUT,
+    GithubCredentials,
+    GithubCredentialsField,
+    GithubCredentialsInput,
+)
+
+
+class GithubListTagsBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        repo_url: str = SchemaField(
+            description="URL of the GitHub repository",
+            placeholder="https://github.com/owner/repo",
+        )
+
+    class Output(BlockSchema):
+        class TagItem(TypedDict):
+            name: str
+            url: str
+
+        tag: TagItem = SchemaField(
+            title="Tag", description="Tags with their name and file tree browser URL"
+        )
+        error: str = SchemaField(description="Error message if listing tags failed")
+
+    def __init__(self):
+        super().__init__(
+            id="358924e7-9a11-4d1a-a0f2-13c67fe59e2e",
+            description="This block lists all tags for a specified GitHub repository.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubListTagsBlock.Input,
+            output_schema=GithubListTagsBlock.Output,
+            test_input={
+                "repo_url": "https://github.com/owner/repo",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                (
+                    "tag",
+                    {
+                        "name": "v1.0.0",
+                        "url": "https://github.com/owner/repo/tree/v1.0.0",
+                    },
+                )
+            ],
+            test_mock={
+                "list_tags": lambda *args, **kwargs: [
+                    {
+                        "name": "v1.0.0",
+                        "url": "https://github.com/owner/repo/tree/v1.0.0",
+                    }
+                ]
+            },
+        )
+
+    @staticmethod
+    def list_tags(
+        credentials: GithubCredentials, repo_url: str
+    ) -> list[Output.TagItem]:
+        repo_path = repo_url.replace("https://github.com/", "")
+        api_url = f"https://api.github.com/repos/{repo_path}/tags"
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+        tags: list[GithubListTagsBlock.Output.TagItem] = [
+            {
+                "name": tag["name"],
+                "url": f"https://github.com/{repo_path}/tree/{tag['name']}",
+            }
+            for tag in data
+        ]
+
+        return tags
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            tags = self.list_tags(
+                credentials,
+                input_data.repo_url,
+            )
+            yield from (("tag", tag) for tag in tags)
+        except Exception as e:
+            yield "error", f"Failed to list tags: {str(e)}"
+
+
+class GithubListBranchesBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        repo_url: str = SchemaField(
+            description="URL of the GitHub repository",
+            placeholder="https://github.com/owner/repo",
+        )
+
+    class Output(BlockSchema):
+        class BranchItem(TypedDict):
+            name: str
+            url: str
+
+        branch: BranchItem = SchemaField(
+            title="Branch",
+            description="Branches with their name and file tree browser URL",
+        )
+        error: str = SchemaField(description="Error message if listing branches failed")
+
+    def __init__(self):
+        super().__init__(
+            id="74243e49-2bec-4916-8bf4-db43d44aead5",
+            description="This block lists all branches for a specified GitHub repository.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubListBranchesBlock.Input,
+            output_schema=GithubListBranchesBlock.Output,
+            test_input={
+                "repo_url": "https://github.com/owner/repo",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                (
+                    "branch",
+                    {
+                        "name": "main",
+                        "url": "https://github.com/owner/repo/tree/main",
+                    },
+                )
+            ],
+            test_mock={
+                "list_branches": lambda *args, **kwargs: [
+                    {
+                        "name": "main",
+                        "url": "https://github.com/owner/repo/tree/main",
+                    }
+                ]
+            },
+        )
+
+    @staticmethod
+    def list_branches(
+        credentials: GithubCredentials, repo_url: str
+    ) -> list[Output.BranchItem]:
+        api_url = repo_url.replace("github.com", "api.github.com/repos") + "/branches"
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+        branches: list[GithubListBranchesBlock.Output.BranchItem] = [
+            {"name": branch["name"], "url": branch["commit"]["url"]} for branch in data
+        ]
+
+        return branches
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            branches = self.list_branches(
+                credentials,
+                input_data.repo_url,
+            )
+            yield from (("branch", branch) for branch in branches)
+        except Exception as e:
+            yield "error", f"Failed to list branches: {str(e)}"
+
+
+class GithubListDiscussionsBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        repo_url: str = SchemaField(
+            description="URL of the GitHub repository",
+            placeholder="https://github.com/owner/repo",
+        )
+        num_discussions: int = SchemaField(
+            description="Number of discussions to fetch", default=5
+        )
+
+    class Output(BlockSchema):
+        class DiscussionItem(TypedDict):
+            title: str
+            url: str
+
+        discussion: DiscussionItem = SchemaField(
+            title="Discussion", description="Discussions with their title and URL"
+        )
+        error: str = SchemaField(
+            description="Error message if listing discussions failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="3ef1a419-3d76-4e07-b761-de9dad4d51d7",
+            description="This block lists recent discussions for a specified GitHub repository.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubListDiscussionsBlock.Input,
+            output_schema=GithubListDiscussionsBlock.Output,
+            test_input={
+                "repo_url": "https://github.com/owner/repo",
+                "num_discussions": 3,
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                (
+                    "discussion",
+                    {
+                        "title": "Discussion 1",
+                        "url": "https://github.com/owner/repo/discussions/1",
+                    },
+                )
+            ],
+            test_mock={
+                "list_discussions": lambda *args, **kwargs: [
+                    {
+                        "title": "Discussion 1",
+                        "url": "https://github.com/owner/repo/discussions/1",
+                    }
+                ]
+            },
+        )
+
+    @staticmethod
+    def list_discussions(
+        credentials: GithubCredentials, repo_url: str, num_discussions: int
+    ) -> list[Output.DiscussionItem]:
+        repo_path = repo_url.replace("https://github.com/", "")
+        owner, repo = repo_path.split("/")
+        query = """
+        query($owner: String!, $repo: String!, $num: Int!) {
+            repository(owner: $owner, name: $repo) {
+                discussions(first: $num) {
+                    nodes {
+                        title
+                        url
+                    }
+                }
+            }
+        }
+        """
+        variables = {"owner": owner, "repo": repo, "num": num_discussions}
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.post(
+            "https://api.github.com/graphql",
+            json={"query": query, "variables": variables},
+            headers=headers,
+        )
+        response.raise_for_status()
+
+        data = response.json()
+        discussions: list[GithubListDiscussionsBlock.Output.DiscussionItem] = [
+            {"title": discussion["title"], "url": discussion["url"]}
+            for discussion in data["data"]["repository"]["discussions"]["nodes"]
+        ]
+
+        return discussions
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            discussions = self.list_discussions(
+                credentials, input_data.repo_url, input_data.num_discussions
+            )
+            yield from (("discussion", discussion) for discussion in discussions)
+        except Exception as e:
+            yield "error", f"Failed to list discussions: {str(e)}"
+
+
+class GithubListReleasesBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        repo_url: str = SchemaField(
+            description="URL of the GitHub repository",
+            placeholder="https://github.com/owner/repo",
+        )
+
+    class Output(BlockSchema):
+        class ReleaseItem(TypedDict):
+            name: str
+            url: str
+
+        release: ReleaseItem = SchemaField(
+            title="Release",
+            description="Releases with their name and file tree browser URL",
+        )
+        error: str = SchemaField(description="Error message if listing releases failed")
+
+    def __init__(self):
+        super().__init__(
+            id="3460367a-6ba7-4645-8ce6-47b05d040b92",
+            description="This block lists all releases for a specified GitHub repository.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubListReleasesBlock.Input,
+            output_schema=GithubListReleasesBlock.Output,
+            test_input={
+                "repo_url": "https://github.com/owner/repo",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                (
+                    "release",
+                    {
+                        "name": "v1.0.0",
+                        "url": "https://github.com/owner/repo/releases/tag/v1.0.0",
+                    },
+                )
+            ],
+            test_mock={
+                "list_releases": lambda *args, **kwargs: [
+                    {
+                        "name": "v1.0.0",
+                        "url": "https://github.com/owner/repo/releases/tag/v1.0.0",
+                    }
+                ]
+            },
+        )
+
+    @staticmethod
+    def list_releases(
+        credentials: GithubCredentials, repo_url: str
+    ) -> list[Output.ReleaseItem]:
+        repo_path = repo_url.replace("https://github.com/", "")
+        api_url = f"https://api.github.com/repos/{repo_path}/releases"
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+        releases: list[GithubListReleasesBlock.Output.ReleaseItem] = [
+            {"name": release["name"], "url": release["html_url"]} for release in data
+        ]
+
+        return releases
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            releases = self.list_releases(
+                credentials,
+                input_data.repo_url,
+            )
+            yield from (("release", release) for release in releases)
+        except Exception as e:
+            yield "error", f"Failed to list releases: {str(e)}"
+
+
+class GithubReadFileBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        repo_url: str = SchemaField(
+            description="URL of the GitHub repository",
+            placeholder="https://github.com/owner/repo",
+        )
+        file_path: str = SchemaField(
+            description="Path to the file in the repository",
+            placeholder="path/to/file",
+        )
+        branch: str = SchemaField(
+            description="Branch to read from",
+            placeholder="branch_name",
+            default="master",
+        )
+
+    class Output(BlockSchema):
+        text_content: str = SchemaField(
+            description="Content of the file (decoded as UTF-8 text)"
+        )
+        raw_content: str = SchemaField(
+            description="Raw base64-encoded content of the file"
+        )
+        size: int = SchemaField(description="The size of the file (in bytes)")
+        error: str = SchemaField(description="Error message if the file reading failed")
+
+    def __init__(self):
+        super().__init__(
+            id="87ce6c27-5752-4bbc-8e26-6da40a3dcfd3",
+            description="This block reads the content of a specified file from a GitHub repository.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubReadFileBlock.Input,
+            output_schema=GithubReadFileBlock.Output,
+            test_input={
+                "repo_url": "https://github.com/owner/repo",
+                "file_path": "path/to/file",
+                "branch": "master",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                ("raw_content", "RmlsZSBjb250ZW50"),
+                ("text_content", "File content"),
+                ("size", 13),
+            ],
+            test_mock={"read_file": lambda *args, **kwargs: ("RmlsZSBjb250ZW50", 13)},
+        )
+
+    @staticmethod
+    def read_file(
+        credentials: GithubCredentials, repo_url: str, file_path: str, branch: str
+    ) -> tuple[str, int]:
+        repo_path = repo_url.replace("https://github.com/", "")
+        api_url = f"https://api.github.com/repos/{repo_path}/contents/{file_path}?ref={branch}"
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        content = response.json()
+
+        if isinstance(content, list):
+            # Multiple entries of different types exist at this path
+            if not (file := next((f for f in content if f["type"] == "file"), None)):
+                raise TypeError("Not a file")
+            content = file
+
+        if content["type"] != "file":
+            raise TypeError("Not a file")
+
+        return content["content"], content["size"]
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            raw_content, size = self.read_file(
+                credentials,
+                input_data.repo_url,
+                input_data.file_path.lstrip("/"),
+                input_data.branch,
+            )
+            yield "raw_content", raw_content
+            yield "text_content", base64.b64decode(raw_content).decode("utf-8")
+            yield "size", size
+        except Exception as e:
+            yield "error", f"Failed to read file: {str(e)}"
+
+
+class GithubReadFolderBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        repo_url: str = SchemaField(
+            description="URL of the GitHub repository",
+            placeholder="https://github.com/owner/repo",
+        )
+        folder_path: str = SchemaField(
+            description="Path to the folder in the repository",
+            placeholder="path/to/folder",
+        )
+        branch: str = SchemaField(
+            description="Branch name to read from (defaults to master)",
+            placeholder="branch_name",
+            default="master",
+        )
+
+    class Output(BlockSchema):
+        class DirEntry(TypedDict):
+            name: str
+            path: str
+
+        class FileEntry(TypedDict):
+            name: str
+            path: str
+            size: int
+
+        file: FileEntry = SchemaField(description="Files in the folder")
+        dir: DirEntry = SchemaField(description="Directories in the folder")
+        error: str = SchemaField(
+            description="Error message if reading the folder failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="1355f863-2db3-4d75-9fba-f91e8a8ca400",
+            description="This block reads the content of a specified folder from a GitHub repository.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubReadFolderBlock.Input,
+            output_schema=GithubReadFolderBlock.Output,
+            test_input={
+                "repo_url": "https://github.com/owner/repo",
+                "folder_path": "path/to/folder",
+                "branch": "master",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                (
+                    "file",
+                    {
+                        "name": "file1.txt",
+                        "path": "path/to/folder/file1.txt",
+                        "size": 1337,
+                    },
+                ),
+                ("dir", {"name": "dir2", "path": "path/to/folder/dir2"}),
+            ],
+            test_mock={
+                "read_folder": lambda *args, **kwargs: (
+                    [
+                        {
+                            "name": "file1.txt",
+                            "path": "path/to/folder/file1.txt",
+                            "size": 1337,
+                        }
+                    ],
+                    [{"name": "dir2", "path": "path/to/folder/dir2"}],
+                )
+            },
+        )
+
+    @staticmethod
+    def read_folder(
+        credentials: GithubCredentials, repo_url: str, folder_path: str, branch: str
+    ) -> tuple[list[Output.FileEntry], list[Output.DirEntry]]:
+        repo_path = repo_url.replace("https://github.com/", "")
+        api_url = f"https://api.github.com/repos/{repo_path}/contents/{folder_path}?ref={branch}"
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        content = response.json()
+
+        if isinstance(content, list):
+            # Multiple entries of different types exist at this path
+            if not (dir := next((d for d in content if d["type"] == "dir"), None)):
+                raise TypeError("Not a folder")
+            content = dir
+
+        if content["type"] != "dir":
+            raise TypeError("Not a folder")
+
+        return (
+            [
+                GithubReadFolderBlock.Output.FileEntry(
+                    name=entry["name"],
+                    path=entry["path"],
+                    size=entry["size"],
+                )
+                for entry in content["entries"]
+                if entry["type"] == "file"
+            ],
+            [
+                GithubReadFolderBlock.Output.DirEntry(
+                    name=entry["name"],
+                    path=entry["path"],
+                )
+                for entry in content["entries"]
+                if entry["type"] == "dir"
+            ],
+        )
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            files, dirs = self.read_folder(
+                credentials,
+                input_data.repo_url,
+                input_data.folder_path.lstrip("/"),
+                input_data.branch,
+            )
+            yield from (("file", file) for file in files)
+            yield from (("dir", dir) for dir in dirs)
+        except Exception as e:
+            yield "error", f"Failed to read folder: {str(e)}"
+
+
+class GithubMakeBranchBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        repo_url: str = SchemaField(
+            description="URL of the GitHub repository",
+            placeholder="https://github.com/owner/repo",
+        )
+        new_branch: str = SchemaField(
+            description="Name of the new branch",
+            placeholder="new_branch_name",
+        )
+        source_branch: str = SchemaField(
+            description="Name of the source branch",
+            placeholder="source_branch_name",
+        )
+
+    class Output(BlockSchema):
+        status: str = SchemaField(description="Status of the branch creation operation")
+        error: str = SchemaField(
+            description="Error message if the branch creation failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="944cc076-95e7-4d1b-b6b6-b15d8ee5448d",
+            description="This block creates a new branch from a specified source branch.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubMakeBranchBlock.Input,
+            output_schema=GithubMakeBranchBlock.Output,
+            test_input={
+                "repo_url": "https://github.com/owner/repo",
+                "new_branch": "new_branch_name",
+                "source_branch": "source_branch_name",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[("status", "Branch created successfully")],
+            test_mock={
+                "create_branch": lambda *args, **kwargs: "Branch created successfully"
+            },
+        )
+
+    @staticmethod
+    def create_branch(
+        credentials: GithubCredentials,
+        repo_url: str,
+        new_branch: str,
+        source_branch: str,
+    ) -> str:
+        repo_path = repo_url.replace("https://github.com/", "")
+        ref_api_url = (
+            f"https://api.github.com/repos/{repo_path}/git/refs/heads/{source_branch}"
+        )
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.get(ref_api_url, headers=headers)
+        response.raise_for_status()
+
+        sha = response.json()["object"]["sha"]
+
+        create_branch_api_url = f"https://api.github.com/repos/{repo_path}/git/refs"
+        data = {"ref": f"refs/heads/{new_branch}", "sha": sha}
+
+        response = requests.post(create_branch_api_url, headers=headers, json=data)
+        response.raise_for_status()
+
+        return "Branch created successfully"
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            status = self.create_branch(
+                credentials,
+                input_data.repo_url,
+                input_data.new_branch,
+                input_data.source_branch,
+            )
+            yield "status", status
+        except Exception as e:
+            yield "error", f"Failed to create branch: {str(e)}"
+
+
+class GithubDeleteBranchBlock(Block):
+    class Input(BlockSchema):
+        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
+        repo_url: str = SchemaField(
+            description="URL of the GitHub repository",
+            placeholder="https://github.com/owner/repo",
+        )
+        branch: str = SchemaField(
+            description="Name of the branch to delete",
+            placeholder="branch_name",
+        )
+
+    class Output(BlockSchema):
+        status: str = SchemaField(description="Status of the branch deletion operation")
+        error: str = SchemaField(
+            description="Error message if the branch deletion failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="0d4130f7-e0ab-4d55-adc3-0a40225e80f4",
+            description="This block deletes a specified branch.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=GithubDeleteBranchBlock.Input,
+            output_schema=GithubDeleteBranchBlock.Output,
+            test_input={
+                "repo_url": "https://github.com/owner/repo",
+                "branch": "branch_name",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[("status", "Branch deleted successfully")],
+            test_mock={
+                "delete_branch": lambda *args, **kwargs: "Branch deleted successfully"
+            },
+        )
+
+    @staticmethod
+    def delete_branch(
+        credentials: GithubCredentials, repo_url: str, branch: str
+    ) -> str:
+        repo_path = repo_url.replace("https://github.com/", "")
+        api_url = f"https://api.github.com/repos/{repo_path}/git/refs/heads/{branch}"
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        response = requests.delete(api_url, headers=headers)
+        response.raise_for_status()
+
+        return "Branch deleted successfully"
+
+    def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GithubCredentials,
+        **kwargs,
+    ) -> BlockOutput:
+        try:
+            status = self.delete_branch(
+                credentials,
+                input_data.repo_url,
+                input_data.branch,
+            )
+            yield "status", status
+        except Exception as e:
+            yield "error", f"Failed to delete branch: {str(e)}"

autogpt_platform/backend/backend/blocks/google_maps.py

@@ -0,0 +1,127 @@
+import googlemaps
+from pydantic import BaseModel
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import BlockSecret, SchemaField, SecretField
+
+
+class Place(BaseModel):
+    name: str
+    address: str
+    phone: str
+    rating: float
+    reviews: int
+    website: str
+
+
+class GoogleMapsSearchBlock(Block):
+    class Input(BlockSchema):
+        api_key: BlockSecret = SecretField(
+            key="google_maps_api_key",
+            description="Google Maps API Key",
+        )
+        query: str = SchemaField(
+            description="Search query for local businesses",
+            placeholder="e.g., 'restaurants in New York'",
+        )
+        radius: int = SchemaField(
+            description="Search radius in meters (max 50000)",
+            default=5000,
+            ge=1,
+            le=50000,
+        )
+        max_results: int = SchemaField(
+            description="Maximum number of results to return (max 60)",
+            default=20,
+            ge=1,
+            le=60,
+        )
+
+    class Output(BlockSchema):
+        place: Place = SchemaField(description="Place found")
+        error: str = SchemaField(description="Error message if the search failed")
+
+    def __init__(self):
+        super().__init__(
+            id="f47ac10b-58cc-4372-a567-0e02b2c3d479",
+            description="This block searches for local businesses using Google Maps API.",
+            categories={BlockCategory.SEARCH},
+            input_schema=GoogleMapsSearchBlock.Input,
+            output_schema=GoogleMapsSearchBlock.Output,
+            test_input={
+                "api_key": "your_test_api_key",
+                "query": "restaurants in new york",
+                "radius": 5000,
+                "max_results": 5,
+            },
+            test_output=[
+                (
+                    "place",
+                    {
+                        "name": "Test Restaurant",
+                        "address": "123 Test St, New York, NY 10001",
+                        "phone": "+1 (555) 123-4567",
+                        "rating": 4.5,
+                        "reviews": 100,
+                        "website": "https://testrestaurant.com",
+                    },
+                ),
+            ],
+            test_mock={
+                "search_places": lambda *args, **kwargs: [
+                    {
+                        "name": "Test Restaurant",
+                        "address": "123 Test St, New York, NY 10001",
+                        "phone": "+1 (555) 123-4567",
+                        "rating": 4.5,
+                        "reviews": 100,
+                        "website": "https://testrestaurant.com",
+                    }
+                ]
+            },
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            places = self.search_places(
+                input_data.api_key.get_secret_value(),
+                input_data.query,
+                input_data.radius,
+                input_data.max_results,
+            )
+            for place in places:
+                yield "place", place
+        except Exception as e:
+            yield "error", str(e)
+
+    def search_places(self, api_key, query, radius, max_results):
+        client = googlemaps.Client(key=api_key)
+        return self._search_places(client, query, radius, max_results)
+
+    def _search_places(self, client, query, radius, max_results):
+        results = []
+        next_page_token = None
+        while len(results) < max_results:
+            response = client.places(
+                query=query,
+                radius=radius,
+                page_token=next_page_token,
+            )
+            for place in response["results"]:
+                if len(results) >= max_results:
+                    break
+                place_details = client.place(place["place_id"])["result"]
+                results.append(
+                    Place(
+                        name=place_details.get("name", ""),
+                        address=place_details.get("formatted_address", ""),
+                        phone=place_details.get("formatted_phone_number", ""),
+                        rating=place_details.get("rating", 0),
+                        reviews=place_details.get("user_ratings_total", 0),
+                        website=place_details.get("website", ""),
+                    )
+                )
+            next_page_token = response.get("next_page_token")
+            if not next_page_token:
+                break
+        return results

autogpt_platform/backend/backend/blocks/http.py

@@ -0,0 +1,57 @@
+import json
+from enum import Enum
+
+import requests
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+
+
+class HttpMethod(Enum):
+    GET = "GET"
+    POST = "POST"
+    PUT = "PUT"
+    DELETE = "DELETE"
+    PATCH = "PATCH"
+    OPTIONS = "OPTIONS"
+    HEAD = "HEAD"
+
+
+class SendWebRequestBlock(Block):
+    class Input(BlockSchema):
+        url: str
+        method: HttpMethod = HttpMethod.POST
+        headers: dict[str, str] = {}
+        body: object = {}
+
+    class Output(BlockSchema):
+        response: object
+        client_error: object
+        server_error: object
+
+    def __init__(self):
+        super().__init__(
+            id="6595ae1f-b924-42cb-9a41-551a0611c4b4",
+            description="This block makes an HTTP request to the given URL.",
+            categories={BlockCategory.OUTPUT},
+            input_schema=SendWebRequestBlock.Input,
+            output_schema=SendWebRequestBlock.Output,
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        if isinstance(input_data.body, str):
+            input_data.body = json.loads(input_data.body)
+
+        response = requests.request(
+            input_data.method.value,
+            input_data.url,
+            headers=input_data.headers,
+            json=input_data.body,
+        )
+        if response.status_code // 100 == 2:
+            yield "response", response.json()
+        elif response.status_code // 100 == 4:
+            yield "client_error", response.json()
+        elif response.status_code // 100 == 5:
+            yield "server_error", response.json()
+        else:
+            raise ValueError(f"Unexpected status code: {response.status_code}")

autogpt_platform/backend/backend/blocks/iteration.py

@@ -0,0 +1,37 @@
+from typing import Any, List, Tuple
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import SchemaField
+
+
+class ListIteratorBlock(Block):
+    class Input(BlockSchema):
+        items: List[Any] = SchemaField(
+            description="The list of items to iterate over",
+            placeholder="[1, 2, 3, 4, 5]",
+        )
+
+    class Output(BlockSchema):
+        item: Tuple[int, Any] = SchemaField(
+            description="A tuple with the index and current item in the iteration"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="f8e7d6c5-b4a3-2c1d-0e9f-8g7h6i5j4k3l",
+            input_schema=ListIteratorBlock.Input,
+            output_schema=ListIteratorBlock.Output,
+            description="Iterates over a list of items and outputs each item with its index.",
+            categories={BlockCategory.LOGIC},
+            test_input={"items": [1, "two", {"three": 3}, [4, 5]]},
+            test_output=[
+                ("item", (0, 1)),
+                ("item", (1, "two")),
+                ("item", (2, {"three": 3})),
+                ("item", (3, [4, 5])),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        for index, item in enumerate(input_data.items):
+            yield "item", (index, item)

autogpt_platform/backend/backend/blocks/llm.py

@@ -0,0 +1,624 @@
+import logging
+from enum import Enum
+from json import JSONDecodeError
+from typing import Any, List, NamedTuple
+
+import anthropic
+import ollama
+import openai
+from groq import Groq
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import BlockSecret, SchemaField, SecretField
+from backend.util import json
+
+logger = logging.getLogger(__name__)
+
+LlmApiKeys = {
+    "openai": BlockSecret("openai_api_key"),
+    "anthropic": BlockSecret("anthropic_api_key"),
+    "groq": BlockSecret("groq_api_key"),
+    "ollama": BlockSecret(value=""),
+}
+
+
+class ModelMetadata(NamedTuple):
+    provider: str
+    context_window: int
+    cost_factor: int
+
+
+class LlmModel(str, Enum):
+    # OpenAI models
+    O1_PREVIEW = "o1-preview"
+    O1_MINI = "o1-mini"
+    GPT4O_MINI = "gpt-4o-mini"
+    GPT4O = "gpt-4o"
+    GPT4_TURBO = "gpt-4-turbo"
+    GPT3_5_TURBO = "gpt-3.5-turbo"
+    # Anthropic models
+    CLAUDE_3_5_SONNET = "claude-3-5-sonnet-20240620"
+    CLAUDE_3_HAIKU = "claude-3-haiku-20240307"
+    # Groq models
+    LLAMA3_8B = "llama3-8b-8192"
+    LLAMA3_70B = "llama3-70b-8192"
+    MIXTRAL_8X7B = "mixtral-8x7b-32768"
+    GEMMA_7B = "gemma-7b-it"
+    GEMMA2_9B = "gemma2-9b-it"
+    # New Groq models (Preview)
+    LLAMA3_1_405B = "llama-3.1-405b-reasoning"
+    LLAMA3_1_70B = "llama-3.1-70b-versatile"
+    LLAMA3_1_8B = "llama-3.1-8b-instant"
+    # Ollama models
+    OLLAMA_LLAMA3_8B = "llama3"
+    OLLAMA_LLAMA3_405B = "llama3.1:405b"
+
+    @property
+    def metadata(self) -> ModelMetadata:
+        return MODEL_METADATA[self]
+
+
+MODEL_METADATA = {
+    LlmModel.O1_PREVIEW: ModelMetadata("openai", 32000, cost_factor=60),
+    LlmModel.O1_MINI: ModelMetadata("openai", 62000, cost_factor=30),
+    LlmModel.GPT4O_MINI: ModelMetadata("openai", 128000, cost_factor=10),
+    LlmModel.GPT4O: ModelMetadata("openai", 128000, cost_factor=12),
+    LlmModel.GPT4_TURBO: ModelMetadata("openai", 128000, cost_factor=11),
+    LlmModel.GPT3_5_TURBO: ModelMetadata("openai", 16385, cost_factor=8),
+    LlmModel.CLAUDE_3_5_SONNET: ModelMetadata("anthropic", 200000, cost_factor=14),
+    LlmModel.CLAUDE_3_HAIKU: ModelMetadata("anthropic", 200000, cost_factor=13),
+    LlmModel.LLAMA3_8B: ModelMetadata("groq", 8192, cost_factor=6),
+    LlmModel.LLAMA3_70B: ModelMetadata("groq", 8192, cost_factor=9),
+    LlmModel.MIXTRAL_8X7B: ModelMetadata("groq", 32768, cost_factor=7),
+    LlmModel.GEMMA_7B: ModelMetadata("groq", 8192, cost_factor=6),
+    LlmModel.GEMMA2_9B: ModelMetadata("groq", 8192, cost_factor=7),
+    LlmModel.LLAMA3_1_405B: ModelMetadata("groq", 8192, cost_factor=10),
+    # Limited to 16k during preview
+    LlmModel.LLAMA3_1_70B: ModelMetadata("groq", 131072, cost_factor=15),
+    LlmModel.LLAMA3_1_8B: ModelMetadata("groq", 131072, cost_factor=13),
+    LlmModel.OLLAMA_LLAMA3_8B: ModelMetadata("ollama", 8192, cost_factor=7),
+    LlmModel.OLLAMA_LLAMA3_405B: ModelMetadata("ollama", 8192, cost_factor=11),
+}
+
+for model in LlmModel:
+    if model not in MODEL_METADATA:
+        raise ValueError(f"Missing MODEL_METADATA metadata for model: {model}")
+
+
+class AIStructuredResponseGeneratorBlock(Block):
+    class Input(BlockSchema):
+        prompt: str
+        expected_format: dict[str, str] = SchemaField(
+            description="Expected format of the response. If provided, the response will be validated against this format. "
+            "The keys should be the expected fields in the response, and the values should be the description of the field.",
+        )
+        model: LlmModel = SchemaField(
+            title="LLM Model",
+            default=LlmModel.GPT4_TURBO,
+            description="The language model to use for answering the prompt.",
+            advanced=False,
+        )
+        api_key: BlockSecret = SecretField(value="")
+        sys_prompt: str = ""
+        retry: int = 3
+        prompt_values: dict[str, str] = SchemaField(
+            advanced=False, default={}, description="Values used to fill in the prompt."
+        )
+
+    class Output(BlockSchema):
+        response: dict[str, Any]
+        error: str
+
+    def __init__(self):
+        super().__init__(
+            id="ed55ac19-356e-4243-a6cb-bc599e9b716f",
+            description="Call a Large Language Model (LLM) to generate formatted object based on the given prompt.",
+            categories={BlockCategory.AI},
+            input_schema=AIStructuredResponseGeneratorBlock.Input,
+            output_schema=AIStructuredResponseGeneratorBlock.Output,
+            test_input={
+                "model": LlmModel.GPT4_TURBO,
+                "api_key": "fake-api",
+                "expected_format": {
+                    "key1": "value1",
+                    "key2": "value2",
+                },
+                "prompt": "User prompt",
+            },
+            test_output=("response", {"key1": "key1Value", "key2": "key2Value"}),
+            test_mock={
+                "llm_call": lambda *args, **kwargs: json.dumps(
+                    {
+                        "key1": "key1Value",
+                        "key2": "key2Value",
+                    }
+                )
+            },
+        )
+
+    @staticmethod
+    def llm_call(
+        api_key: str, model: LlmModel, prompt: list[dict], json_format: bool
+    ) -> str:
+        provider = model.metadata.provider
+
+        if provider == "openai":
+            openai.api_key = api_key
+            response_format = None
+
+            if model in [LlmModel.O1_MINI, LlmModel.O1_PREVIEW]:
+                sys_messages = [p["content"] for p in prompt if p["role"] == "system"]
+                usr_messages = [p["content"] for p in prompt if p["role"] != "system"]
+                prompt = [
+                    {"role": "user", "content": "\n".join(sys_messages)},
+                    {"role": "user", "content": "\n".join(usr_messages)},
+                ]
+            elif json_format:
+                response_format = {"type": "json_object"}
+
+            response = openai.chat.completions.create(
+                model=model.value,
+                messages=prompt,  # type: ignore
+                response_format=response_format,  # type: ignore
+            )
+            return response.choices[0].message.content or ""
+        elif provider == "anthropic":
+            system_messages = [p["content"] for p in prompt if p["role"] == "system"]
+            sysprompt = " ".join(system_messages)
+
+            messages = []
+            last_role = None
+            for p in prompt:
+                if p["role"] in ["user", "assistant"]:
+                    if p["role"] != last_role:
+                        messages.append({"role": p["role"], "content": p["content"]})
+                        last_role = p["role"]
+                    else:
+                        # If the role is the same as the last one, combine the content
+                        messages[-1]["content"] += "\n" + p["content"]
+
+            client = anthropic.Anthropic(api_key=api_key)
+            try:
+                response = client.messages.create(
+                    model=model.value,
+                    max_tokens=4096,
+                    system=sysprompt,
+                    messages=messages,
+                )
+                return response.content[0].text if response.content else ""
+            except anthropic.APIError as e:
+                error_message = f"Anthropic API error: {str(e)}"
+                logger.error(error_message)
+                raise ValueError(error_message)
+        elif provider == "groq":
+            client = Groq(api_key=api_key)
+            response_format = {"type": "json_object"} if json_format else None
+            response = client.chat.completions.create(
+                model=model.value,
+                messages=prompt,  # type: ignore
+                response_format=response_format,  # type: ignore
+            )
+            return response.choices[0].message.content or ""
+        elif provider == "ollama":
+            response = ollama.generate(
+                model=model.value,
+                prompt=prompt[0]["content"],
+            )
+            return response["response"]
+        else:
+            raise ValueError(f"Unsupported LLM provider: {provider}")
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        prompt = []
+
+        def trim_prompt(s: str) -> str:
+            lines = s.strip().split("\n")
+            return "\n".join([line.strip().lstrip("|") for line in lines])
+
+        values = input_data.prompt_values
+        if values:
+            input_data.prompt = input_data.prompt.format(**values)
+            input_data.sys_prompt = input_data.sys_prompt.format(**values)
+
+        if input_data.sys_prompt:
+            prompt.append({"role": "system", "content": input_data.sys_prompt})
+
+        if input_data.expected_format:
+            expected_format = [
+                f'"{k}": "{v}"' for k, v in input_data.expected_format.items()
+            ]
+            format_prompt = ",\n  ".join(expected_format)
+            sys_prompt = trim_prompt(
+                f"""
+                  |Reply strictly only in the following JSON format:
+                  |{{
+                  |  {format_prompt}
+                  |}}
+                """
+            )
+            prompt.append({"role": "system", "content": sys_prompt})
+
+        prompt.append({"role": "user", "content": input_data.prompt})
+
+        def parse_response(resp: str) -> tuple[dict[str, Any], str | None]:
+            try:
+                parsed = json.loads(resp)
+                if not isinstance(parsed, dict):
+                    return {}, f"Expected a dictionary, but got {type(parsed)}"
+                miss_keys = set(input_data.expected_format.keys()) - set(parsed.keys())
+                if miss_keys:
+                    return parsed, f"Missing keys: {miss_keys}"
+                return parsed, None
+            except JSONDecodeError as e:
+                return {}, f"JSON decode error: {e}"
+
+        logger.info(f"LLM request: {prompt}")
+        retry_prompt = ""
+        model = input_data.model
+        api_key = (
+            input_data.api_key.get_secret_value()
+            or LlmApiKeys[model.metadata.provider].get_secret_value()
+        )
+
+        for retry_count in range(input_data.retry):
+            try:
+                response_text = self.llm_call(
+                    api_key=api_key,
+                    model=model,
+                    prompt=prompt,
+                    json_format=bool(input_data.expected_format),
+                )
+                logger.info(f"LLM attempt-{retry_count} response: {response_text}")
+
+                if input_data.expected_format:
+                    parsed_dict, parsed_error = parse_response(response_text)
+                    if not parsed_error:
+                        yield "response", {
+                            k: (
+                                json.loads(v)
+                                if isinstance(v, str)
+                                and v.startswith("[")
+                                and v.endswith("]")
+                                else (", ".join(v) if isinstance(v, list) else v)
+                            )
+                            for k, v in parsed_dict.items()
+                        }
+                        return
+                else:
+                    yield "response", {"response": response_text}
+                    return
+
+                retry_prompt = trim_prompt(
+                    f"""
+                  |This is your previous error response:
+                  |--
+                  |{response_text}
+                  |--
+                  |
+                  |And this is the error:
+                  |--
+                  |{parsed_error}
+                  |--
+                """
+                )
+                prompt.append({"role": "user", "content": retry_prompt})
+            except Exception as e:
+                logger.error(f"Error calling LLM: {e}")
+                retry_prompt = f"Error calling LLM: {e}"
+
+        yield "error", retry_prompt
+
+
+class AITextGeneratorBlock(Block):
+    class Input(BlockSchema):
+        prompt: str
+        model: LlmModel = SchemaField(
+            title="LLM Model",
+            default=LlmModel.GPT4_TURBO,
+            description="The language model to use for answering the prompt.",
+            advanced=False,
+        )
+        api_key: BlockSecret = SecretField(value="")
+        sys_prompt: str = ""
+        retry: int = 3
+        prompt_values: dict[str, str] = SchemaField(
+            advanced=False, default={}, description="Values used to fill in the prompt."
+        )
+
+    class Output(BlockSchema):
+        response: str
+        error: str
+
+    def __init__(self):
+        super().__init__(
+            id="1f292d4a-41a4-4977-9684-7c8d560b9f91",
+            description="Call a Large Language Model (LLM) to generate a string based on the given prompt.",
+            categories={BlockCategory.AI},
+            input_schema=AITextGeneratorBlock.Input,
+            output_schema=AITextGeneratorBlock.Output,
+            test_input={"prompt": "User prompt"},
+            test_output=("response", "Response text"),
+            test_mock={"llm_call": lambda *args, **kwargs: "Response text"},
+        )
+
+    @staticmethod
+    def llm_call(input_data: AIStructuredResponseGeneratorBlock.Input) -> str:
+        object_block = AIStructuredResponseGeneratorBlock()
+        for output_name, output_data in object_block.run(input_data):
+            if output_name == "response":
+                return output_data["response"]
+            else:
+                raise RuntimeError(output_data)
+        raise ValueError("Failed to get a response from the LLM.")
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            object_input_data = AIStructuredResponseGeneratorBlock.Input(
+                **{attr: getattr(input_data, attr) for attr in input_data.model_fields},
+                expected_format={},
+            )
+            yield "response", self.llm_call(object_input_data)
+        except Exception as e:
+            yield "error", str(e)
+
+
+class SummaryStyle(Enum):
+    CONCISE = "concise"
+    DETAILED = "detailed"
+    BULLET_POINTS = "bullet points"
+    NUMBERED_LIST = "numbered list"
+
+
+class AITextSummarizerBlock(Block):
+    class Input(BlockSchema):
+        text: str
+        model: LlmModel = SchemaField(
+            title="LLM Model",
+            default=LlmModel.GPT4_TURBO,
+            description="The language model to use for summarizing the text.",
+        )
+        focus: str = "general information"
+        style: SummaryStyle = SummaryStyle.CONCISE
+        api_key: BlockSecret = SecretField(value="")
+        # TODO: Make this dynamic
+        max_tokens: int = 4000  # Adjust based on the model's context window
+        chunk_overlap: int = 100  # Overlap between chunks to maintain context
+
+    class Output(BlockSchema):
+        summary: str
+        error: str
+
+    def __init__(self):
+        super().__init__(
+            id="c3d4e5f6-7g8h-9i0j-1k2l-m3n4o5p6q7r8",
+            description="Utilize a Large Language Model (LLM) to summarize a long text.",
+            categories={BlockCategory.AI, BlockCategory.TEXT},
+            input_schema=AITextSummarizerBlock.Input,
+            output_schema=AITextSummarizerBlock.Output,
+            test_input={"text": "Lorem ipsum..." * 100},
+            test_output=("summary", "Final summary of a long text"),
+            test_mock={
+                "llm_call": lambda input_data: (
+                    {"final_summary": "Final summary of a long text"}
+                    if "final_summary" in input_data.expected_format
+                    else {"summary": "Summary of a chunk of text"}
+                )
+            },
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            for output in self._run(input_data):
+                yield output
+        except Exception as e:
+            yield "error", str(e)
+
+    def _run(self, input_data: Input) -> BlockOutput:
+        chunks = self._split_text(
+            input_data.text, input_data.max_tokens, input_data.chunk_overlap
+        )
+        summaries = []
+
+        for chunk in chunks:
+            chunk_summary = self._summarize_chunk(chunk, input_data)
+            summaries.append(chunk_summary)
+
+        final_summary = self._combine_summaries(summaries, input_data)
+        yield "summary", final_summary
+
+    @staticmethod
+    def _split_text(text: str, max_tokens: int, overlap: int) -> list[str]:
+        words = text.split()
+        chunks = []
+        chunk_size = max_tokens - overlap
+
+        for i in range(0, len(words), chunk_size):
+            chunk = " ".join(words[i : i + max_tokens])
+            chunks.append(chunk)
+
+        return chunks
+
+    @staticmethod
+    def llm_call(
+        input_data: AIStructuredResponseGeneratorBlock.Input,
+    ) -> dict[str, str]:
+        llm_block = AIStructuredResponseGeneratorBlock()
+        for output_name, output_data in llm_block.run(input_data):
+            if output_name == "response":
+                return output_data
+        raise ValueError("Failed to get a response from the LLM.")
+
+    def _summarize_chunk(self, chunk: str, input_data: Input) -> str:
+        prompt = f"Summarize the following text in a {input_data.style} form. Focus your summary on the topic of `{input_data.focus}` if present, otherwise just provide a general summary:\n\n```{chunk}```"
+
+        llm_response = self.llm_call(
+            AIStructuredResponseGeneratorBlock.Input(
+                prompt=prompt,
+                api_key=input_data.api_key,
+                model=input_data.model,
+                expected_format={"summary": "The summary of the given text."},
+            )
+        )
+
+        return llm_response["summary"]
+
+    def _combine_summaries(self, summaries: list[str], input_data: Input) -> str:
+        combined_text = "\n\n".join(summaries)
+
+        if len(combined_text.split()) <= input_data.max_tokens:
+            prompt = f"Provide a final summary of the following section summaries in a {input_data.style} form, focus your summary on the topic of `{input_data.focus}` if present:\n\n ```{combined_text}```\n\n Just respond with the final_summary in the format specified."
+
+            llm_response = self.llm_call(
+                AIStructuredResponseGeneratorBlock.Input(
+                    prompt=prompt,
+                    api_key=input_data.api_key,
+                    model=input_data.model,
+                    expected_format={
+                        "final_summary": "The final summary of all provided summaries."
+                    },
+                )
+            )
+
+            return llm_response["final_summary"]
+        else:
+            # If combined summaries are still too long, recursively summarize
+            return self._run(
+                AITextSummarizerBlock.Input(
+                    text=combined_text,
+                    api_key=input_data.api_key,
+                    model=input_data.model,
+                    max_tokens=input_data.max_tokens,
+                    chunk_overlap=input_data.chunk_overlap,
+                )
+            ).send(None)[
+                1
+            ]  # Get the first yielded value
+
+
+class MessageRole(str, Enum):
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+
+
+class Message(BlockSchema):
+    role: MessageRole
+    content: str
+
+
+class AIConversationBlock(Block):
+    class Input(BlockSchema):
+        messages: List[Message] = SchemaField(
+            description="List of messages in the conversation.", min_length=1
+        )
+        model: LlmModel = SchemaField(
+            title="LLM Model",
+            default=LlmModel.GPT4_TURBO,
+            description="The language model to use for the conversation.",
+        )
+        api_key: BlockSecret = SecretField(
+            value="", description="API key for the chosen language model provider."
+        )
+        max_tokens: int | None = SchemaField(
+            default=None,
+            description="The maximum number of tokens to generate in the chat completion.",
+            ge=1,
+        )
+
+    class Output(BlockSchema):
+        response: str = SchemaField(
+            description="The model's response to the conversation."
+        )
+        error: str = SchemaField(description="Error message if the API call failed.")
+
+    def __init__(self):
+        super().__init__(
+            id="c3d4e5f6-g7h8-i9j0-k1l2-m3n4o5p6q7r8",
+            description="Advanced LLM call that takes a list of messages and sends them to the language model.",
+            categories={BlockCategory.AI},
+            input_schema=AIConversationBlock.Input,
+            output_schema=AIConversationBlock.Output,
+            test_input={
+                "messages": [
+                    {"role": "system", "content": "You are a helpful assistant."},
+                    {"role": "user", "content": "Who won the world series in 2020?"},
+                    {
+                        "role": "assistant",
+                        "content": "The Los Angeles Dodgers won the World Series in 2020.",
+                    },
+                    {"role": "user", "content": "Where was it played?"},
+                ],
+                "model": LlmModel.GPT4_TURBO,
+                "api_key": "test_api_key",
+            },
+            test_output=(
+                "response",
+                "The 2020 World Series was played at Globe Life Field in Arlington, Texas.",
+            ),
+            test_mock={
+                "llm_call": lambda *args, **kwargs: "The 2020 World Series was played at Globe Life Field in Arlington, Texas."
+            },
+        )
+
+    @staticmethod
+    def llm_call(
+        api_key: str,
+        model: LlmModel,
+        messages: List[dict[str, str]],
+        max_tokens: int | None = None,
+    ) -> str:
+        provider = model.metadata.provider
+
+        if provider == "openai":
+            openai.api_key = api_key
+            response = openai.chat.completions.create(
+                model=model.value,
+                messages=messages,  # type: ignore
+                max_tokens=max_tokens,
+            )
+            return response.choices[0].message.content or ""
+        elif provider == "anthropic":
+            client = anthropic.Anthropic(api_key=api_key)
+            response = client.messages.create(
+                model=model.value,
+                max_tokens=max_tokens or 4096,
+                messages=messages,  # type: ignore
+            )
+            return response.content[0].text if response.content else ""
+        elif provider == "groq":
+            client = Groq(api_key=api_key)
+            response = client.chat.completions.create(
+                model=model.value,
+                messages=messages,  # type: ignore
+                max_tokens=max_tokens,
+            )
+            return response.choices[0].message.content or ""
+        elif provider == "ollama":
+            response = ollama.chat(
+                model=model.value,
+                messages=messages,  # type: ignore
+                stream=False,  # type: ignore
+            )
+            return response["message"]["content"]
+        else:
+            raise ValueError(f"Unsupported LLM provider: {provider}")
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            api_key = (
+                input_data.api_key.get_secret_value()
+                or LlmApiKeys[input_data.model.metadata.provider].get_secret_value()
+            )
+
+            messages = [message.model_dump() for message in input_data.messages]
+
+            response = self.llm_call(
+                api_key=api_key,
+                model=input_data.model,
+                messages=messages,
+                max_tokens=input_data.max_tokens,
+            )
+
+            yield "response", response
+        except Exception as e:
+            yield "error", f"Error calling LLM: {str(e)}"

autogpt_platform/backend/backend/blocks/maths.py

@@ -0,0 +1,124 @@
+import operator
+from enum import Enum
+from typing import Any
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import SchemaField
+
+
+class Operation(Enum):
+    ADD = "Add"
+    SUBTRACT = "Subtract"
+    MULTIPLY = "Multiply"
+    DIVIDE = "Divide"
+    POWER = "Power"
+
+
+class CalculatorBlock(Block):
+    class Input(BlockSchema):
+        operation: Operation = SchemaField(
+            description="Choose the math operation you want to perform",
+            placeholder="Select an operation",
+        )
+        a: float = SchemaField(
+            description="Enter the first number (A)", placeholder="For example: 10"
+        )
+        b: float = SchemaField(
+            description="Enter the second number (B)", placeholder="For example: 5"
+        )
+        round_result: bool = SchemaField(
+            description="Do you want to round the result to a whole number?",
+            default=False,
+        )
+
+    class Output(BlockSchema):
+        result: float = SchemaField(description="The result of your calculation")
+
+    def __init__(self):
+        super().__init__(
+            id="b1ab9b19-67a6-406d-abf5-2dba76d00c79",
+            input_schema=CalculatorBlock.Input,
+            output_schema=CalculatorBlock.Output,
+            description="Performs a mathematical operation on two numbers.",
+            categories={BlockCategory.LOGIC},
+            test_input={
+                "operation": Operation.ADD.value,
+                "a": 10.0,
+                "b": 5.0,
+                "round_result": False,
+            },
+            test_output=[
+                ("result", 15.0),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        operation = input_data.operation
+        a = input_data.a
+        b = input_data.b
+
+        operations = {
+            Operation.ADD: operator.add,
+            Operation.SUBTRACT: operator.sub,
+            Operation.MULTIPLY: operator.mul,
+            Operation.DIVIDE: operator.truediv,
+            Operation.POWER: operator.pow,
+        }
+
+        op_func = operations[operation]
+
+        try:
+            if operation == Operation.DIVIDE and b == 0:
+                raise ZeroDivisionError("Cannot divide by zero")
+
+            result = op_func(a, b)
+
+            if input_data.round_result:
+                result = round(result)
+
+            yield "result", result
+
+        except ZeroDivisionError:
+            yield "result", float("inf")  # Return infinity for division by zero
+        except Exception:
+            yield "result", float("nan")  # Return NaN for other errors
+
+
+class CountItemsBlock(Block):
+    class Input(BlockSchema):
+        collection: Any = SchemaField(
+            description="Enter the collection you want to count. This can be a list, dictionary, string, or any other iterable.",
+            placeholder="For example: [1, 2, 3] or {'a': 1, 'b': 2} or 'hello'",
+        )
+
+    class Output(BlockSchema):
+        count: int = SchemaField(description="The number of items in the collection")
+
+    def __init__(self):
+        super().__init__(
+            id="3c9c2f42-b0c3-435f-ba35-05f7a25c772a",
+            input_schema=CountItemsBlock.Input,
+            output_schema=CountItemsBlock.Output,
+            description="Counts the number of items in a collection.",
+            categories={BlockCategory.LOGIC},
+            test_input={"collection": [1, 2, 3, 4, 5]},
+            test_output=[
+                ("count", 5),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        collection = input_data.collection
+
+        try:
+            if isinstance(collection, (str, list, tuple, set, dict)):
+                count = len(collection)
+            elif hasattr(collection, "__iter__"):
+                count = sum(1 for _ in collection)
+            else:
+                raise ValueError("Input is not a countable collection")
+
+            yield "count", count
+
+        except Exception:
+            yield "count", -1  # Return -1 to indicate an error

autogpt_platform/backend/backend/blocks/medium.py

@@ -0,0 +1,168 @@
+from typing import List
+
+import requests
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import BlockSecret, SchemaField, SecretField
+
+
+class PublishToMediumBlock(Block):
+    class Input(BlockSchema):
+        author_id: BlockSecret = SecretField(
+            key="medium_author_id",
+            description="""The Medium AuthorID of the user. You can get this by calling the /me endpoint of the Medium API.\n\ncurl -H "Authorization: Bearer YOUR_ACCESS_TOKEN" https://api.medium.com/v1/me" the response will contain the authorId field.""",
+            placeholder="Enter the author's Medium AuthorID",
+        )
+        title: str = SchemaField(
+            description="The title of your Medium post",
+            placeholder="Enter your post title",
+        )
+        content: str = SchemaField(
+            description="The main content of your Medium post",
+            placeholder="Enter your post content",
+        )
+        content_format: str = SchemaField(
+            description="The format of the content: 'html' or 'markdown'",
+            placeholder="html",
+        )
+        tags: List[str] = SchemaField(
+            description="List of tags for your Medium post (up to 5)",
+            placeholder="['technology', 'AI', 'blogging']",
+        )
+        canonical_url: str | None = SchemaField(
+            default=None,
+            description="The original home of this content, if it was originally published elsewhere",
+            placeholder="https://yourblog.com/original-post",
+        )
+        publish_status: str = SchemaField(
+            description="The publish status: 'public', 'draft', or 'unlisted'",
+            placeholder="public",
+        )
+        license: str = SchemaField(
+            default="all-rights-reserved",
+            description="The license of the post: 'all-rights-reserved', 'cc-40-by', 'cc-40-by-sa', 'cc-40-by-nd', 'cc-40-by-nc', 'cc-40-by-nc-nd', 'cc-40-by-nc-sa', 'cc-40-zero', 'public-domain'",
+            placeholder="all-rights-reserved",
+        )
+        notify_followers: bool = SchemaField(
+            default=False,
+            description="Whether to notify followers that the user has published",
+            placeholder="False",
+        )
+        api_key: BlockSecret = SecretField(
+            key="medium_api_key",
+            description="""The API key for the Medium integration. You can get this from https://medium.com/me/settings/security and scrolling down to "integration Tokens".""",
+            placeholder="Enter your Medium API key",
+        )
+
+    class Output(BlockSchema):
+        post_id: str = SchemaField(description="The ID of the created Medium post")
+        post_url: str = SchemaField(description="The URL of the created Medium post")
+        published_at: int = SchemaField(
+            description="The timestamp when the post was published"
+        )
+        error: str = SchemaField(
+            description="Error message if the post creation failed"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="3f7b2dcb-4a78-4e3f-b0f1-88132e1b89df",
+            input_schema=PublishToMediumBlock.Input,
+            output_schema=PublishToMediumBlock.Output,
+            description="Publishes a post to Medium.",
+            categories={BlockCategory.SOCIAL},
+            test_input={
+                "author_id": "1234567890abcdef",
+                "title": "Test Post",
+                "content": "<h1>Test Content</h1><p>This is a test post.</p>",
+                "content_format": "html",
+                "tags": ["test", "automation"],
+                "license": "all-rights-reserved",
+                "notify_followers": False,
+                "publish_status": "draft",
+                "api_key": "your_test_api_key",
+            },
+            test_output=[
+                ("post_id", "e6f36a"),
+                ("post_url", "https://medium.com/@username/test-post-e6f36a"),
+                ("published_at", 1626282600),
+            ],
+            test_mock={
+                "create_post": lambda *args, **kwargs: {
+                    "data": {
+                        "id": "e6f36a",
+                        "url": "https://medium.com/@username/test-post-e6f36a",
+                        "authorId": "1234567890abcdef",
+                        "publishedAt": 1626282600,
+                    }
+                }
+            },
+        )
+
+    def create_post(
+        self,
+        api_key,
+        author_id,
+        title,
+        content,
+        content_format,
+        tags,
+        canonical_url,
+        publish_status,
+        license,
+        notify_followers,
+    ):
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+        data = {
+            "title": title,
+            "content": content,
+            "contentFormat": content_format,
+            "tags": tags,
+            "canonicalUrl": canonical_url,
+            "publishStatus": publish_status,
+            "license": license,
+            "notifyFollowers": notify_followers,
+        }
+
+        response = requests.post(
+            f"https://api.medium.com/v1/users/{author_id}/posts",
+            headers=headers,
+            json=data,
+        )
+
+        return response.json()
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            response = self.create_post(
+                input_data.api_key.get_secret_value(),
+                input_data.author_id.get_secret_value(),
+                input_data.title,
+                input_data.content,
+                input_data.content_format,
+                input_data.tags,
+                input_data.canonical_url,
+                input_data.publish_status,
+                input_data.license,
+                input_data.notify_followers,
+            )
+
+            if "data" in response:
+                yield "post_id", response["data"]["id"]
+                yield "post_url", response["data"]["url"]
+                yield "published_at", response["data"]["publishedAt"]
+            else:
+                error_message = response.get("errors", [{}])[0].get(
+                    "message", "Unknown error occurred"
+                )
+                yield "error", f"Failed to create Medium post: {error_message}"
+
+        except requests.RequestException as e:
+            yield "error", f"Network error occurred while creating Medium post: {str(e)}"
+        except Exception as e:
+            yield "error", f"Error occurred while creating Medium post: {str(e)}"

autogpt_platform/backend/backend/blocks/reddit.py

@@ -0,0 +1,171 @@
+from datetime import datetime, timezone
+from typing import Iterator
+
+import praw
+from pydantic import BaseModel, ConfigDict, Field
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import BlockSecret, SecretField
+from backend.util.mock import MockObject
+
+
+class RedditCredentials(BaseModel):
+    client_id: BlockSecret = SecretField(key="reddit_client_id")
+    client_secret: BlockSecret = SecretField(key="reddit_client_secret")
+    username: BlockSecret = SecretField(key="reddit_username")
+    password: BlockSecret = SecretField(key="reddit_password")
+    user_agent: str = "AutoGPT:1.0 (by /u/autogpt)"
+
+    model_config = ConfigDict(title="Reddit Credentials")
+
+
+class RedditPost(BaseModel):
+    id: str
+    subreddit: str
+    title: str
+    body: str
+
+
+class RedditComment(BaseModel):
+    post_id: str
+    comment: str
+
+
+def get_praw(creds: RedditCredentials) -> praw.Reddit:
+    client = praw.Reddit(
+        client_id=creds.client_id.get_secret_value(),
+        client_secret=creds.client_secret.get_secret_value(),
+        username=creds.username.get_secret_value(),
+        password=creds.password.get_secret_value(),
+        user_agent=creds.user_agent,
+    )
+    me = client.user.me()
+    if not me:
+        raise ValueError("Invalid Reddit credentials.")
+    print(f"Logged in as Reddit user: {me.name}")
+    return client
+
+
+class GetRedditPostsBlock(Block):
+    class Input(BlockSchema):
+        subreddit: str = Field(description="Subreddit name")
+        creds: RedditCredentials = Field(
+            description="Reddit credentials",
+            default=RedditCredentials(),
+        )
+        last_minutes: int | None = Field(
+            description="Post time to stop minutes ago while fetching posts",
+            default=None,
+        )
+        last_post: str | None = Field(
+            description="Post ID to stop when reached while fetching posts",
+            default=None,
+        )
+        post_limit: int | None = Field(
+            description="Number of posts to fetch", default=10
+        )
+
+    class Output(BlockSchema):
+        post: RedditPost = Field(description="Reddit post")
+
+    def __init__(self):
+        super().__init__(
+            id="c6731acb-4285-4ee1-bc9b-03d0766c370f",
+            description="This block fetches Reddit posts from a defined subreddit name.",
+            categories={BlockCategory.SOCIAL},
+            input_schema=GetRedditPostsBlock.Input,
+            output_schema=GetRedditPostsBlock.Output,
+            test_input={
+                "creds": {
+                    "client_id": "client_id",
+                    "client_secret": "client_secret",
+                    "username": "username",
+                    "password": "password",
+                    "user_agent": "user_agent",
+                },
+                "subreddit": "subreddit",
+                "last_post": "id3",
+                "post_limit": 2,
+            },
+            test_output=[
+                (
+                    "post",
+                    RedditPost(
+                        id="id1", subreddit="subreddit", title="title1", body="body1"
+                    ),
+                ),
+                (
+                    "post",
+                    RedditPost(
+                        id="id2", subreddit="subreddit", title="title2", body="body2"
+                    ),
+                ),
+            ],
+            test_mock={
+                "get_posts": lambda _: [
+                    MockObject(id="id1", title="title1", selftext="body1"),
+                    MockObject(id="id2", title="title2", selftext="body2"),
+                    MockObject(id="id3", title="title2", selftext="body2"),
+                ]
+            },
+        )
+
+    @staticmethod
+    def get_posts(input_data: Input) -> Iterator[praw.reddit.Submission]:
+        client = get_praw(input_data.creds)
+        subreddit = client.subreddit(input_data.subreddit)
+        return subreddit.new(limit=input_data.post_limit)
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        current_time = datetime.now(tz=timezone.utc)
+        for post in self.get_posts(input_data):
+            if input_data.last_minutes:
+                post_datetime = datetime.fromtimestamp(
+                    post.created_utc, tz=timezone.utc
+                )
+                time_difference = current_time - post_datetime
+                if time_difference.total_seconds() / 60 > input_data.last_minutes:
+                    continue
+
+            if input_data.last_post and post.id == input_data.last_post:
+                break
+
+            yield "post", RedditPost(
+                id=post.id,
+                subreddit=input_data.subreddit,
+                title=post.title,
+                body=post.selftext,
+            )
+
+
+class PostRedditCommentBlock(Block):
+    class Input(BlockSchema):
+        creds: RedditCredentials = Field(
+            description="Reddit credentials", default=RedditCredentials()
+        )
+        data: RedditComment = Field(description="Reddit comment")
+
+    class Output(BlockSchema):
+        comment_id: str
+
+    def __init__(self):
+        super().__init__(
+            id="4a92261b-701e-4ffb-8970-675fd28e261f",
+            description="This block posts a Reddit comment on a specified Reddit post.",
+            categories={BlockCategory.SOCIAL},
+            input_schema=PostRedditCommentBlock.Input,
+            output_schema=PostRedditCommentBlock.Output,
+            test_input={"data": {"post_id": "id", "comment": "comment"}},
+            test_output=[("comment_id", "dummy_comment_id")],
+            test_mock={"reply_post": lambda creds, comment: "dummy_comment_id"},
+        )
+
+    @staticmethod
+    def reply_post(creds: RedditCredentials, comment: RedditComment) -> str:
+        client = get_praw(creds)
+        submission = client.submission(id=comment.post_id)
+        comment = submission.reply(comment.comment)
+        return comment.id  # type: ignore
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        yield "comment_id", self.reply_post(input_data.creds, input_data.data)

autogpt_platform/backend/backend/blocks/replicate_flux_advanced.py

@@ -0,0 +1,204 @@
+import os
+from enum import Enum
+
+import replicate
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import BlockSecret, SchemaField, SecretField
+
+
+# Model name enum
+class ReplicateFluxModelName(str, Enum):
+    FLUX_SCHNELL = ("Flux Schnell",)
+    FLUX_PRO = ("Flux Pro",)
+    FLUX_DEV = ("Flux Dev",)
+
+    @property
+    def api_name(self):
+        api_names = {
+            ReplicateFluxModelName.FLUX_SCHNELL: "black-forest-labs/flux-schnell",
+            ReplicateFluxModelName.FLUX_PRO: "black-forest-labs/flux-pro",
+            ReplicateFluxModelName.FLUX_DEV: "black-forest-labs/flux-dev",
+        }
+        return api_names[self]
+
+
+# Image type Enum
+class ImageType(str, Enum):
+    WEBP = "webp"
+    JPG = "jpg"
+    PNG = "png"
+
+
+class ReplicateFluxAdvancedModelBlock(Block):
+    class Input(BlockSchema):
+        api_key: BlockSecret = SecretField(
+            key="replicate_api_key",
+            description="Replicate API Key",
+        )
+        prompt: str = SchemaField(
+            description="Text prompt for image generation",
+            placeholder="e.g., 'A futuristic cityscape at sunset'",
+            title="Prompt",
+        )
+        replicate_model_name: ReplicateFluxModelName = SchemaField(
+            description="The name of the Image Generation Model, i.e Flux Schnell",
+            default=ReplicateFluxModelName.FLUX_SCHNELL,
+            title="Image Generation Model",
+            advanced=False,
+        )
+        seed: int | None = SchemaField(
+            description="Random seed. Set for reproducible generation",
+            default=None,
+            title="Seed",
+        )
+        steps: int = SchemaField(
+            description="Number of diffusion steps",
+            default=25,
+            title="Steps",
+        )
+        guidance: float = SchemaField(
+            description=(
+                "Controls the balance between adherence to the text prompt and image quality/diversity. "
+                "Higher values make the output more closely match the prompt but may reduce overall image quality."
+            ),
+            default=3,
+            title="Guidance",
+        )
+        interval: float = SchemaField(
+            description=(
+                "Interval is a setting that increases the variance in possible outputs. "
+                "Setting this value low will ensure strong prompt following with more consistent outputs."
+            ),
+            default=2,
+            title="Interval",
+        )
+        aspect_ratio: str = SchemaField(
+            description="Aspect ratio for the generated image",
+            default="1:1",
+            title="Aspect Ratio",
+            placeholder="Choose from: 1:1, 16:9, 2:3, 3:2, 4:5, 5:4, 9:16",
+        )
+        output_format: ImageType = SchemaField(
+            description="File format of the output image",
+            default=ImageType.WEBP,
+            title="Output Format",
+        )
+        output_quality: int = SchemaField(
+            description=(
+                "Quality when saving the output images, from 0 to 100. "
+                "Not relevant for .png outputs"
+            ),
+            default=80,
+            title="Output Quality",
+        )
+        safety_tolerance: int = SchemaField(
+            description="Safety tolerance, 1 is most strict and 5 is most permissive",
+            default=2,
+            title="Safety Tolerance",
+        )
+
+    class Output(BlockSchema):
+        result: str = SchemaField(description="Generated output")
+        error: str = SchemaField(description="Error message if the model run failed")
+
+    def __init__(self):
+        super().__init__(
+            id="90f8c45e-e983-4644-aa0b-b4ebe2f531bc",
+            description="This block runs Flux models on Replicate with advanced settings.",
+            categories={BlockCategory.AI},
+            input_schema=ReplicateFluxAdvancedModelBlock.Input,
+            output_schema=ReplicateFluxAdvancedModelBlock.Output,
+            test_input={
+                "api_key": "test_api_key",
+                "replicate_model_name": ReplicateFluxModelName.FLUX_SCHNELL,
+                "prompt": "A beautiful landscape painting of a serene lake at sunrise",
+                "seed": None,
+                "steps": 25,
+                "guidance": 3.0,
+                "interval": 2.0,
+                "aspect_ratio": "1:1",
+                "output_format": ImageType.PNG,
+                "output_quality": 80,
+                "safety_tolerance": 2,
+            },
+            test_output=[
+                (
+                    "result",
+                    "https://replicate.com/output/generated-image-url.jpg",
+                ),
+            ],
+            test_mock={
+                "run_model": lambda api_key, model_name, prompt, seed, steps, guidance, interval, aspect_ratio, output_format, output_quality, safety_tolerance: "https://replicate.com/output/generated-image-url.jpg",
+            },
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        # If the seed is not provided, generate a random seed
+        seed = input_data.seed
+        if seed is None:
+            seed = int.from_bytes(os.urandom(4), "big")
+
+        try:
+            # Run the model using the provided inputs
+            result = self.run_model(
+                api_key=input_data.api_key.get_secret_value(),
+                model_name=input_data.replicate_model_name.api_name,
+                prompt=input_data.prompt,
+                seed=seed,
+                steps=input_data.steps,
+                guidance=input_data.guidance,
+                interval=input_data.interval,
+                aspect_ratio=input_data.aspect_ratio,
+                output_format=input_data.output_format,
+                output_quality=input_data.output_quality,
+                safety_tolerance=input_data.safety_tolerance,
+            )
+            yield "result", result
+        except Exception as e:
+            yield "error", str(e)
+
+    def run_model(
+        self,
+        api_key,
+        model_name,
+        prompt,
+        seed,
+        steps,
+        guidance,
+        interval,
+        aspect_ratio,
+        output_format,
+        output_quality,
+        safety_tolerance,
+    ):
+        # Initialize Replicate client with the API key
+        client = replicate.Client(api_token=api_key)
+
+        # Run the model with additional parameters
+        output = client.run(
+            f"{model_name}",
+            input={
+                "prompt": prompt,
+                "seed": seed,
+                "steps": steps,
+                "guidance": guidance,
+                "interval": interval,
+                "aspect_ratio": aspect_ratio,
+                "output_format": output_format,
+                "output_quality": output_quality,
+                "safety_tolerance": safety_tolerance,
+            },
+        )
+
+        # Check if output is a list or a string and extract accordingly; otherwise, assign a default message
+        if isinstance(output, list) and len(output) > 0:
+            result_url = output[0]  # If output is a list, get the first element
+        elif isinstance(output, str):
+            result_url = output  # If output is a string, use it directly
+        else:
+            result_url = (
+                "No output received"  # Fallback message if output is not as expected
+            )
+
+        return result_url

autogpt_platform/backend/backend/blocks/rss.py

@@ -0,0 +1,116 @@
+import time
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+import feedparser
+import pydantic
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import SchemaField
+
+
+class RSSEntry(pydantic.BaseModel):
+    title: str
+    link: str
+    description: str
+    pub_date: datetime
+    author: str
+    categories: list[str]
+
+
+class ReadRSSFeedBlock(Block):
+    class Input(BlockSchema):
+        rss_url: str = SchemaField(
+            description="The URL of the RSS feed to read",
+            placeholder="https://example.com/rss",
+        )
+        time_period: int = SchemaField(
+            description="The time period to check in minutes relative to the run block runtime, e.g. 60 would check for new entries in the last hour.",
+            placeholder="1440",
+            default=1440,
+        )
+        polling_rate: int = SchemaField(
+            description="The number of seconds to wait between polling attempts.",
+            placeholder="300",
+        )
+        run_continuously: bool = SchemaField(
+            description="Whether to run the block continuously or just once.",
+            default=True,
+        )
+
+    class Output(BlockSchema):
+        entry: RSSEntry = SchemaField(description="The RSS item")
+
+    def __init__(self):
+        super().__init__(
+            id="c6731acb-4105-4zp1-bc9b-03d0036h370g",
+            input_schema=ReadRSSFeedBlock.Input,
+            output_schema=ReadRSSFeedBlock.Output,
+            description="Reads RSS feed entries from a given URL.",
+            categories={BlockCategory.INPUT},
+            test_input={
+                "rss_url": "https://example.com/rss",
+                "time_period": 10_000_000,
+                "polling_rate": 1,
+                "run_continuously": False,
+            },
+            test_output=[
+                (
+                    "entry",
+                    RSSEntry(
+                        title="Example RSS Item",
+                        link="https://example.com/article",
+                        description="This is an example RSS item description.",
+                        pub_date=datetime(2023, 6, 23, 12, 30, 0, tzinfo=timezone.utc),
+                        author="John Doe",
+                        categories=["Technology", "News"],
+                    ),
+                ),
+            ],
+            test_mock={
+                "parse_feed": lambda *args, **kwargs: {
+                    "entries": [
+                        {
+                            "title": "Example RSS Item",
+                            "link": "https://example.com/article",
+                            "summary": "This is an example RSS item description.",
+                            "published_parsed": (2023, 6, 23, 12, 30, 0, 4, 174, 0),
+                            "author": "John Doe",
+                            "tags": [{"term": "Technology"}, {"term": "News"}],
+                        }
+                    ]
+                }
+            },
+        )
+
+    @staticmethod
+    def parse_feed(url: str) -> dict[str, Any]:
+        return feedparser.parse(url)  # type: ignore
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        keep_going = True
+        start_time = datetime.now(timezone.utc) - timedelta(
+            minutes=input_data.time_period
+        )
+        while keep_going:
+            keep_going = input_data.run_continuously
+
+            feed = self.parse_feed(input_data.rss_url)
+
+            for entry in feed["entries"]:
+                pub_date = datetime(*entry["published_parsed"][:6], tzinfo=timezone.utc)
+
+                if pub_date > start_time:
+                    yield (
+                        "entry",
+                        RSSEntry(
+                            title=entry["title"],
+                            link=entry["link"],
+                            description=entry.get("summary", ""),
+                            pub_date=pub_date,
+                            author=entry.get("author", ""),
+                            categories=[tag["term"] for tag in entry.get("tags", [])],
+                        ),
+                    )
+
+            time.sleep(input_data.polling_rate)

autogpt_platform/backend/backend/blocks/sampling.py

@@ -0,0 +1,264 @@
+import random
+from collections import defaultdict
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import SchemaField
+
+
+class SamplingMethod(str, Enum):
+    RANDOM = "random"
+    SYSTEMATIC = "systematic"
+    TOP = "top"
+    BOTTOM = "bottom"
+    STRATIFIED = "stratified"
+    WEIGHTED = "weighted"
+    RESERVOIR = "reservoir"
+    CLUSTER = "cluster"
+
+
+class DataSamplingBlock(Block):
+    class Input(BlockSchema):
+        data: Union[Dict[str, Any], List[Union[dict, List[Any]]]] = SchemaField(
+            description="The dataset to sample from. Can be a single dictionary, a list of dictionaries, or a list of lists.",
+            placeholder="{'id': 1, 'value': 'a'} or [{'id': 1, 'value': 'a'}, {'id': 2, 'value': 'b'}, ...]",
+        )
+        sample_size: int = SchemaField(
+            description="The number of samples to take from the dataset.",
+            placeholder="10",
+            default=10,
+        )
+        sampling_method: SamplingMethod = SchemaField(
+            description="The method to use for sampling.",
+            default=SamplingMethod.RANDOM,
+        )
+        accumulate: bool = SchemaField(
+            description="Whether to accumulate data before sampling.",
+            default=False,
+        )
+        random_seed: Optional[int] = SchemaField(
+            description="Seed for random number generator (optional).",
+            default=None,
+        )
+        stratify_key: Optional[str] = SchemaField(
+            description="Key to use for stratified sampling (required for stratified sampling).",
+            default=None,
+        )
+        weight_key: Optional[str] = SchemaField(
+            description="Key to use for weighted sampling (required for weighted sampling).",
+            default=None,
+        )
+        cluster_key: Optional[str] = SchemaField(
+            description="Key to use for cluster sampling (required for cluster sampling).",
+            default=None,
+        )
+
+    class Output(BlockSchema):
+        sampled_data: List[Union[dict, List[Any]]] = SchemaField(
+            description="The sampled subset of the input data."
+        )
+        sample_indices: List[int] = SchemaField(
+            description="The indices of the sampled data in the original dataset."
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="4a448883-71fa-49cf-91cf-70d793bd7d87",
+            description="This block samples data from a given dataset using various sampling methods.",
+            categories={BlockCategory.LOGIC},
+            input_schema=DataSamplingBlock.Input,
+            output_schema=DataSamplingBlock.Output,
+            test_input={
+                "data": [
+                    {"id": i, "value": chr(97 + i), "group": i % 3} for i in range(10)
+                ],
+                "sample_size": 3,
+                "sampling_method": SamplingMethod.STRATIFIED,
+                "accumulate": False,
+                "random_seed": 42,
+                "stratify_key": "group",
+            },
+            test_output=[
+                (
+                    "sampled_data",
+                    [
+                        {"id": 0, "value": "a", "group": 0},
+                        {"id": 1, "value": "b", "group": 1},
+                        {"id": 8, "value": "i", "group": 2},
+                    ],
+                ),
+                ("sample_indices", [0, 1, 8]),
+            ],
+        )
+        self.accumulated_data = []
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        if input_data.accumulate:
+            if isinstance(input_data.data, dict):
+                self.accumulated_data.append(input_data.data)
+            elif isinstance(input_data.data, list):
+                self.accumulated_data.extend(input_data.data)
+            else:
+                raise ValueError(f"Unsupported data type: {type(input_data.data)}")
+
+            # If we don't have enough data yet, return without sampling
+            if len(self.accumulated_data) < input_data.sample_size:
+                return
+
+            data_to_sample = self.accumulated_data
+        else:
+            # If not accumulating, use the input data directly
+            data_to_sample = (
+                input_data.data
+                if isinstance(input_data.data, list)
+                else [input_data.data]
+            )
+
+        if input_data.random_seed is not None:
+            random.seed(input_data.random_seed)
+
+        data_size = len(data_to_sample)
+
+        if input_data.sample_size > data_size:
+            raise ValueError(
+                f"Sample size ({input_data.sample_size}) cannot be larger than the dataset size ({data_size})."
+            )
+
+        indices = []
+
+        if input_data.sampling_method == SamplingMethod.RANDOM:
+            indices = random.sample(range(data_size), input_data.sample_size)
+        elif input_data.sampling_method == SamplingMethod.SYSTEMATIC:
+            step = data_size // input_data.sample_size
+            start = random.randint(0, step - 1)
+            indices = list(range(start, data_size, step))[: input_data.sample_size]
+        elif input_data.sampling_method == SamplingMethod.TOP:
+            indices = list(range(input_data.sample_size))
+        elif input_data.sampling_method == SamplingMethod.BOTTOM:
+            indices = list(range(data_size - input_data.sample_size, data_size))
+        elif input_data.sampling_method == SamplingMethod.STRATIFIED:
+            if not input_data.stratify_key:
+                raise ValueError(
+                    "Stratify key must be provided for stratified sampling."
+                )
+            strata = defaultdict(list)
+            for i, item in enumerate(data_to_sample):
+                if isinstance(item, dict):
+                    strata_value = item.get(input_data.stratify_key)
+                elif hasattr(item, input_data.stratify_key):
+                    strata_value = getattr(item, input_data.stratify_key)
+                else:
+                    raise ValueError(
+                        f"Stratify key '{input_data.stratify_key}' not found in item {item}"
+                    )
+
+                if strata_value is None:
+                    raise ValueError(
+                        f"Stratify value for key '{input_data.stratify_key}' is None"
+                    )
+
+                strata[str(strata_value)].append(i)
+
+            # Calculate the number of samples to take from each stratum
+            stratum_sizes = {
+                k: max(1, int(len(v) / data_size * input_data.sample_size))
+                for k, v in strata.items()
+            }
+
+            # Adjust sizes to ensure we get exactly sample_size samples
+            while sum(stratum_sizes.values()) != input_data.sample_size:
+                if sum(stratum_sizes.values()) < input_data.sample_size:
+                    stratum_sizes[
+                        max(stratum_sizes, key=lambda k: stratum_sizes[k])
+                    ] += 1
+                else:
+                    stratum_sizes[
+                        max(stratum_sizes, key=lambda k: stratum_sizes[k])
+                    ] -= 1
+
+            for stratum, size in stratum_sizes.items():
+                indices.extend(random.sample(strata[stratum], size))
+        elif input_data.sampling_method == SamplingMethod.WEIGHTED:
+            if not input_data.weight_key:
+                raise ValueError("Weight key must be provided for weighted sampling.")
+            weights = []
+            for item in data_to_sample:
+                if isinstance(item, dict):
+                    weight = item.get(input_data.weight_key)
+                elif hasattr(item, input_data.weight_key):
+                    weight = getattr(item, input_data.weight_key)
+                else:
+                    raise ValueError(
+                        f"Weight key '{input_data.weight_key}' not found in item {item}"
+                    )
+
+                if weight is None:
+                    raise ValueError(
+                        f"Weight value for key '{input_data.weight_key}' is None"
+                    )
+                try:
+                    weights.append(float(weight))
+                except ValueError:
+                    raise ValueError(
+                        f"Weight value '{weight}' cannot be converted to a number"
+                    )
+
+            if not weights:
+                raise ValueError(
+                    f"No valid weights found using key '{input_data.weight_key}'"
+                )
+
+            indices = random.choices(
+                range(data_size), weights=weights, k=input_data.sample_size
+            )
+        elif input_data.sampling_method == SamplingMethod.RESERVOIR:
+            indices = list(range(input_data.sample_size))
+            for i in range(input_data.sample_size, data_size):
+                j = random.randint(0, i)
+                if j < input_data.sample_size:
+                    indices[j] = i
+        elif input_data.sampling_method == SamplingMethod.CLUSTER:
+            if not input_data.cluster_key:
+                raise ValueError("Cluster key must be provided for cluster sampling.")
+            clusters = defaultdict(list)
+            for i, item in enumerate(data_to_sample):
+                if isinstance(item, dict):
+                    cluster_value = item.get(input_data.cluster_key)
+                elif hasattr(item, input_data.cluster_key):
+                    cluster_value = getattr(item, input_data.cluster_key)
+                else:
+                    raise TypeError(
+                        f"Item {item} does not have the cluster key '{input_data.cluster_key}'"
+                    )
+
+                clusters[str(cluster_value)].append(i)
+
+            # Randomly select clusters until we have enough samples
+            selected_clusters = []
+            while (
+                sum(len(clusters[c]) for c in selected_clusters)
+                < input_data.sample_size
+            ):
+                available_clusters = [c for c in clusters if c not in selected_clusters]
+                if not available_clusters:
+                    break
+                selected_clusters.append(random.choice(available_clusters))
+
+            for cluster in selected_clusters:
+                indices.extend(clusters[cluster])
+
+            # If we have more samples than needed, randomly remove some
+            if len(indices) > input_data.sample_size:
+                indices = random.sample(indices, input_data.sample_size)
+        else:
+            raise ValueError(f"Unknown sampling method: {input_data.sampling_method}")
+
+        sampled_data = [data_to_sample[i] for i in indices]
+
+        # Clear accumulated data after sampling if accumulation is enabled
+        if input_data.accumulate:
+            self.accumulated_data = []
+
+        yield "sampled_data", sampled_data
+        yield "sample_indices", indices

autogpt_platform/backend/backend/blocks/search.py

@@ -0,0 +1,193 @@
+from typing import Any
+from urllib.parse import quote
+
+import requests
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import BlockSecret, SecretField
+
+
+class GetRequest:
+    @classmethod
+    def get_request(cls, url: str, json=False) -> Any:
+        response = requests.get(url)
+        response.raise_for_status()
+        return response.json() if json else response.text
+
+
+class GetWikipediaSummaryBlock(Block, GetRequest):
+    class Input(BlockSchema):
+        topic: str
+
+    class Output(BlockSchema):
+        summary: str
+        error: str
+
+    def __init__(self):
+        super().__init__(
+            id="h5e7f8g9-1b2c-3d4e-5f6g-7h8i9j0k1l2m",
+            description="This block fetches the summary of a given topic from Wikipedia.",
+            categories={BlockCategory.SEARCH},
+            input_schema=GetWikipediaSummaryBlock.Input,
+            output_schema=GetWikipediaSummaryBlock.Output,
+            test_input={"topic": "Artificial Intelligence"},
+            test_output=("summary", "summary content"),
+            test_mock={"get_request": lambda url, json: {"extract": "summary content"}},
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            topic = input_data.topic
+            url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{topic}"
+            response = self.get_request(url, json=True)
+            yield "summary", response["extract"]
+
+        except requests.exceptions.HTTPError as http_err:
+            yield "error", f"HTTP error occurred: {http_err}"
+
+        except requests.RequestException as e:
+            yield "error", f"Request to Wikipedia failed: {e}"
+
+        except KeyError as e:
+            yield "error", f"Error parsing Wikipedia response: {e}"
+
+
+class SearchTheWebBlock(Block, GetRequest):
+    class Input(BlockSchema):
+        query: str  # The search query
+
+    class Output(BlockSchema):
+        results: str  # The search results including content from top 5 URLs
+        error: str  # Error message if the search fails
+
+    def __init__(self):
+        super().__init__(
+            id="b2c3d4e5-6f7g-8h9i-0j1k-l2m3n4o5p6q7",
+            description="This block searches the internet for the given search query.",
+            categories={BlockCategory.SEARCH},
+            input_schema=SearchTheWebBlock.Input,
+            output_schema=SearchTheWebBlock.Output,
+            test_input={"query": "Artificial Intelligence"},
+            test_output=("results", "search content"),
+            test_mock={"get_request": lambda url, json: "search content"},
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            # Encode the search query
+            encoded_query = quote(input_data.query)
+
+            # Prepend the Jina Search URL to the encoded query
+            jina_search_url = f"https://s.jina.ai/{encoded_query}"
+
+            # Make the request to Jina Search
+            response = self.get_request(jina_search_url, json=False)
+
+            # Output the search results
+            yield "results", response
+
+        except requests.exceptions.HTTPError as http_err:
+            yield "error", f"HTTP error occurred: {http_err}"
+
+        except requests.RequestException as e:
+            yield "error", f"Request to Jina Search failed: {e}"
+
+
+class ExtractWebsiteContentBlock(Block, GetRequest):
+    class Input(BlockSchema):
+        url: str  # The URL to scrape
+
+    class Output(BlockSchema):
+        content: str  # The scraped content from the URL
+        error: str
+
+    def __init__(self):
+        super().__init__(
+            id="a1b2c3d4-5e6f-7g8h-9i0j-k1l2m3n4o5p6",  # Unique ID for the block
+            description="This block scrapes the content from the given web URL.",
+            categories={BlockCategory.SEARCH},
+            input_schema=ExtractWebsiteContentBlock.Input,
+            output_schema=ExtractWebsiteContentBlock.Output,
+            test_input={"url": "https://en.wikipedia.org/wiki/Artificial_intelligence"},
+            test_output=("content", "scraped content"),
+            test_mock={"get_request": lambda url, json: "scraped content"},
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            # Prepend the Jina-ai Reader URL to the input URL
+            jina_url = f"https://r.jina.ai/{input_data.url}"
+
+            # Make the request to Jina-ai Reader
+            response = self.get_request(jina_url, json=False)
+
+            # Output the scraped content
+            yield "content", response
+
+        except requests.exceptions.HTTPError as http_err:
+            yield "error", f"HTTP error occurred: {http_err}"
+
+        except requests.RequestException as e:
+            yield "error", f"Request to Jina-ai Reader failed: {e}"
+
+
+class GetWeatherInformationBlock(Block, GetRequest):
+    class Input(BlockSchema):
+        location: str
+        api_key: BlockSecret = SecretField(key="openweathermap_api_key")
+        use_celsius: bool = True
+
+    class Output(BlockSchema):
+        temperature: str
+        humidity: str
+        condition: str
+        error: str
+
+    def __init__(self):
+        super().__init__(
+            id="f7a8b2c3-6d4e-5f8b-9e7f-6d4e5f8b9e7f",
+            input_schema=GetWeatherInformationBlock.Input,
+            output_schema=GetWeatherInformationBlock.Output,
+            description="Retrieves weather information for a specified location using OpenWeatherMap API.",
+            test_input={
+                "location": "New York",
+                "api_key": "YOUR_API_KEY",
+                "use_celsius": True,
+            },
+            test_output=[
+                ("temperature", "21.66"),
+                ("humidity", "32"),
+                ("condition", "overcast clouds"),
+            ],
+            test_mock={
+                "get_request": lambda url, json: {
+                    "main": {"temp": 21.66, "humidity": 32},
+                    "weather": [{"description": "overcast clouds"}],
+                }
+            },
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            units = "metric" if input_data.use_celsius else "imperial"
+            api_key = input_data.api_key.get_secret_value()
+            location = input_data.location
+            url = f"http://api.openweathermap.org/data/2.5/weather?q={quote(location)}&appid={api_key}&units={units}"
+            weather_data = self.get_request(url, json=True)
+
+            if "main" in weather_data and "weather" in weather_data:
+                yield "temperature", str(weather_data["main"]["temp"])
+                yield "humidity", str(weather_data["main"]["humidity"])
+                yield "condition", weather_data["weather"][0]["description"]
+            else:
+                yield "error", f"Expected keys not found in response: {weather_data}"
+
+        except requests.exceptions.HTTPError as http_err:
+            if http_err.response.status_code == 403:
+                yield "error", "Request to weather API failed: 403 Forbidden. Check your API key and permissions."
+            else:
+                yield "error", f"HTTP error occurred: {http_err}"
+        except requests.RequestException as e:
+            yield "error", f"Request to weather API failed: {e}"
+        except KeyError as e:
+            yield "error", f"Error processing weather data: {e}"

autogpt_platform/backend/backend/blocks/talking_head.py

@@ -0,0 +1,146 @@
+import time
+from typing import Literal
+
+import requests
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import BlockSecret, SchemaField, SecretField
+
+
+class CreateTalkingAvatarVideoBlock(Block):
+    class Input(BlockSchema):
+        api_key: BlockSecret = SecretField(
+            key="did_api_key", description="D-ID API Key"
+        )
+        script_input: str = SchemaField(
+            description="The text input for the script", default="Welcome to AutoGPT"
+        )
+        provider: Literal["microsoft", "elevenlabs", "amazon"] = SchemaField(
+            description="The voice provider to use", default="microsoft"
+        )
+        voice_id: str = SchemaField(
+            description="The voice ID to use, get list of voices [here](https://docs.agpt.co/server/d_id)",
+            default="en-US-JennyNeural",
+        )
+        presenter_id: str = SchemaField(
+            description="The presenter ID to use", default="amy-Aq6OmGZnMt"
+        )
+        driver_id: str = SchemaField(
+            description="The driver ID to use", default="Vcq0R4a8F0"
+        )
+        result_format: Literal["mp4", "gif", "wav"] = SchemaField(
+            description="The desired result format", default="mp4"
+        )
+        crop_type: Literal["wide", "square", "vertical"] = SchemaField(
+            description="The crop type for the presenter", default="wide"
+        )
+        subtitles: bool = SchemaField(
+            description="Whether to include subtitles", default=False
+        )
+        ssml: bool = SchemaField(description="Whether the input is SSML", default=False)
+        max_polling_attempts: int = SchemaField(
+            description="Maximum number of polling attempts", default=30, ge=5
+        )
+        polling_interval: int = SchemaField(
+            description="Interval between polling attempts in seconds", default=10, ge=5
+        )
+
+    class Output(BlockSchema):
+        video_url: str = SchemaField(description="The URL of the created video")
+        error: str = SchemaField(description="Error message if the request failed")
+
+    def __init__(self):
+        super().__init__(
+            id="98c6f503-8c47-4b1c-a96d-351fc7c87dab",
+            description="This block integrates with D-ID to create video clips and retrieve their URLs.",
+            categories={BlockCategory.AI},
+            input_schema=CreateTalkingAvatarVideoBlock.Input,
+            output_schema=CreateTalkingAvatarVideoBlock.Output,
+            test_input={
+                "api_key": "your_test_api_key",
+                "script_input": "Welcome to AutoGPT",
+                "voice_id": "en-US-JennyNeural",
+                "presenter_id": "amy-Aq6OmGZnMt",
+                "driver_id": "Vcq0R4a8F0",
+                "result_format": "mp4",
+                "crop_type": "wide",
+                "subtitles": False,
+                "ssml": False,
+                "max_polling_attempts": 5,
+                "polling_interval": 5,
+            },
+            test_output=[
+                (
+                    "video_url",
+                    "https://d-id.com/api/clips/abcd1234-5678-efgh-ijkl-mnopqrstuvwx/video",
+                ),
+            ],
+            test_mock={
+                "create_clip": lambda *args, **kwargs: {
+                    "id": "abcd1234-5678-efgh-ijkl-mnopqrstuvwx",
+                    "status": "created",
+                },
+                "get_clip_status": lambda *args, **kwargs: {
+                    "status": "done",
+                    "result_url": "https://d-id.com/api/clips/abcd1234-5678-efgh-ijkl-mnopqrstuvwx/video",
+                },
+            },
+        )
+
+    def create_clip(self, api_key: str, payload: dict) -> dict:
+        url = "https://api.d-id.com/clips"
+        headers = {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "authorization": f"Basic {api_key}",
+        }
+        response = requests.post(url, json=payload, headers=headers)
+        response.raise_for_status()
+        return response.json()
+
+    def get_clip_status(self, api_key: str, clip_id: str) -> dict:
+        url = f"https://api.d-id.com/clips/{clip_id}"
+        headers = {"accept": "application/json", "authorization": f"Basic {api_key}"}
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+        return response.json()
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            # Create the clip
+            payload = {
+                "script": {
+                    "type": "text",
+                    "subtitles": str(input_data.subtitles).lower(),
+                    "provider": {
+                        "type": input_data.provider,
+                        "voice_id": input_data.voice_id,
+                    },
+                    "ssml": str(input_data.ssml).lower(),
+                    "input": input_data.script_input,
+                },
+                "config": {"result_format": input_data.result_format},
+                "presenter_config": {"crop": {"type": input_data.crop_type}},
+                "presenter_id": input_data.presenter_id,
+                "driver_id": input_data.driver_id,
+            }
+
+            response = self.create_clip(input_data.api_key.get_secret_value(), payload)
+            clip_id = response["id"]
+
+            # Poll for clip status
+            for _ in range(input_data.max_polling_attempts):
+                status_response = self.get_clip_status(
+                    input_data.api_key.get_secret_value(), clip_id
+                )
+                if status_response["status"] == "done":
+                    yield "video_url", status_response["result_url"]
+                    return
+                elif status_response["status"] == "error":
+                    yield "error", f"Clip creation failed: {status_response.get('error', 'Unknown error')}"
+                    return
+                time.sleep(input_data.polling_interval)
+
+            yield "error", "Clip creation timed out"
+        except Exception as e:
+            yield "error", str(e)

autogpt_platform/backend/backend/blocks/text.py

@@ -0,0 +1,183 @@
+import re
+from typing import Any
+
+from jinja2 import BaseLoader, Environment
+from pydantic import Field
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.util import json
+
+jinja = Environment(loader=BaseLoader())
+
+
+class MatchTextPatternBlock(Block):
+    class Input(BlockSchema):
+        text: Any = Field(description="Text to match")
+        match: str = Field(description="Pattern (Regex) to match")
+        data: Any = Field(description="Data to be forwarded to output")
+        case_sensitive: bool = Field(description="Case sensitive match", default=True)
+        dot_all: bool = Field(description="Dot matches all", default=True)
+
+    class Output(BlockSchema):
+        positive: Any = Field(description="Output data if match is found")
+        negative: Any = Field(description="Output data if match is not found")
+
+    def __init__(self):
+        super().__init__(
+            id="3060088f-6ed9-4928-9ba7-9c92823a7ccd",
+            description="Matches text against a regex pattern and forwards data to positive or negative output based on the match.",
+            categories={BlockCategory.TEXT},
+            input_schema=MatchTextPatternBlock.Input,
+            output_schema=MatchTextPatternBlock.Output,
+            test_input=[
+                {"text": "ABC", "match": "ab", "data": "X", "case_sensitive": False},
+                {"text": "ABC", "match": "ab", "data": "Y", "case_sensitive": True},
+                {"text": "Hello World!", "match": ".orld.+", "data": "Z"},
+                {"text": "Hello World!", "match": "World![a-z]+", "data": "Z"},
+            ],
+            test_output=[
+                ("positive", "X"),
+                ("negative", "Y"),
+                ("positive", "Z"),
+                ("negative", "Z"),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        output = input_data.data or input_data.text
+        flags = 0
+        if not input_data.case_sensitive:
+            flags = flags | re.IGNORECASE
+        if input_data.dot_all:
+            flags = flags | re.DOTALL
+
+        if isinstance(input_data.text, str):
+            text = input_data.text
+        else:
+            text = json.dumps(input_data.text)
+
+        if re.search(input_data.match, text, flags=flags):
+            yield "positive", output
+        else:
+            yield "negative", output
+
+
+class ExtractTextInformationBlock(Block):
+    class Input(BlockSchema):
+        text: Any = Field(description="Text to parse")
+        pattern: str = Field(description="Pattern (Regex) to parse")
+        group: int = Field(description="Group number to extract", default=0)
+        case_sensitive: bool = Field(description="Case sensitive match", default=True)
+        dot_all: bool = Field(description="Dot matches all", default=True)
+
+    class Output(BlockSchema):
+        positive: str = Field(description="Extracted text")
+        negative: str = Field(description="Original text")
+
+    def __init__(self):
+        super().__init__(
+            id="3146e4fe-2cdd-4f29-bd12-0c9d5bb4deb0",
+            description="This block extracts the text from the given text using the pattern (regex).",
+            categories={BlockCategory.TEXT},
+            input_schema=ExtractTextInformationBlock.Input,
+            output_schema=ExtractTextInformationBlock.Output,
+            test_input=[
+                {"text": "Hello, World!", "pattern": "Hello, (.+)", "group": 1},
+                {"text": "Hello, World!", "pattern": "Hello, (.+)", "group": 0},
+                {"text": "Hello, World!", "pattern": "Hello, (.+)", "group": 2},
+                {"text": "Hello, World!", "pattern": "hello,", "case_sensitive": False},
+            ],
+            test_output=[
+                ("positive", "World!"),
+                ("positive", "Hello, World!"),
+                ("negative", "Hello, World!"),
+                ("positive", "Hello,"),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        flags = 0
+        if not input_data.case_sensitive:
+            flags = flags | re.IGNORECASE
+        if input_data.dot_all:
+            flags = flags | re.DOTALL
+
+        if isinstance(input_data.text, str):
+            text = input_data.text
+        else:
+            text = json.dumps(input_data.text)
+
+        match = re.search(input_data.pattern, text, flags)
+        if match and input_data.group <= len(match.groups()):
+            yield "positive", match.group(input_data.group)
+        else:
+            yield "negative", text
+
+
+class FillTextTemplateBlock(Block):
+    class Input(BlockSchema):
+        values: dict[str, Any] = Field(description="Values (dict) to be used in format")
+        format: str = Field(description="Template to format the text using `values`")
+
+    class Output(BlockSchema):
+        output: str
+
+    def __init__(self):
+        super().__init__(
+            id="db7d8f02-2f44-4c55-ab7a-eae0941f0c30",
+            description="This block formats the given texts using the format template.",
+            categories={BlockCategory.TEXT},
+            input_schema=FillTextTemplateBlock.Input,
+            output_schema=FillTextTemplateBlock.Output,
+            test_input=[
+                {
+                    "values": {"name": "Alice", "hello": "Hello", "world": "World!"},
+                    "format": "{hello}, {world} {{name}}",
+                },
+                {
+                    "values": {"list": ["Hello", " World!"]},
+                    "format": "{% for item in list %}{{ item }}{% endfor %}",
+                },
+            ],
+            test_output=[
+                ("output", "Hello, World! Alice"),
+                ("output", "Hello World!"),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        # For python.format compatibility: replace all {...} with {{..}}.
+        # But avoid replacing {{...}} to {{{...}}}.
+        fmt = re.sub(r"(?<!{){[ a-zA-Z0-9_]+}", r"{\g<0>}", input_data.format)
+        template = jinja.from_string(fmt)
+        yield "output", template.render(**input_data.values)
+
+
+class CombineTextsBlock(Block):
+    class Input(BlockSchema):
+        input: list[str] = Field(description="text input to combine")
+        delimiter: str = Field(description="Delimiter to combine texts", default="")
+
+    class Output(BlockSchema):
+        output: str = Field(description="Combined text")
+
+    def __init__(self):
+        super().__init__(
+            id="e30a4d42-7b7d-4e6a-b36e-1f9b8e3b7d85",
+            description="This block combines multiple input texts into a single output text.",
+            categories={BlockCategory.TEXT},
+            input_schema=CombineTextsBlock.Input,
+            output_schema=CombineTextsBlock.Output,
+            test_input=[
+                {"input": ["Hello world I like ", "cake and to go for walks"]},
+                {"input": ["This is a test", "Hi!"], "delimiter": "! "},
+            ],
+            test_output=[
+                ("output", "Hello world I like cake and to go for walks"),
+                ("output", "This is a test! Hi!"),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        combined_text = input_data.delimiter.join(input_data.input)
+        yield "output", combined_text

autogpt_platform/backend/backend/blocks/time_blocks.py

@@ -0,0 +1,141 @@
+import time
+from datetime import datetime, timedelta
+from typing import Any, Union
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+
+
+class GetCurrentTimeBlock(Block):
+    class Input(BlockSchema):
+        trigger: str
+
+    class Output(BlockSchema):
+        time: str
+
+    def __init__(self):
+        super().__init__(
+            id="a892b8d9-3e4e-4e9c-9c1e-75f8efcf1bfa",
+            description="This block outputs the current time.",
+            categories={BlockCategory.TEXT},
+            input_schema=GetCurrentTimeBlock.Input,
+            output_schema=GetCurrentTimeBlock.Output,
+            test_input=[
+                {"trigger": "Hello", "format": "{time}"},
+            ],
+            test_output=[
+                ("time", lambda _: time.strftime("%H:%M:%S")),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        current_time = time.strftime("%H:%M:%S")
+        yield "time", current_time
+
+
+class GetCurrentDateBlock(Block):
+    class Input(BlockSchema):
+        trigger: str
+        offset: Union[int, str]
+
+    class Output(BlockSchema):
+        date: str
+
+    def __init__(self):
+        super().__init__(
+            id="b29c1b50-5d0e-4d9f-8f9d-1b0e6fcbf0b1",
+            description="This block outputs the current date with an optional offset.",
+            categories={BlockCategory.TEXT},
+            input_schema=GetCurrentDateBlock.Input,
+            output_schema=GetCurrentDateBlock.Output,
+            test_input=[
+                {"trigger": "Hello", "format": "{date}", "offset": "7"},
+            ],
+            test_output=[
+                (
+                    "date",
+                    lambda t: abs(datetime.now() - datetime.strptime(t, "%Y-%m-%d"))
+                    < timedelta(days=8),  # 7 days difference + 1 day error margin.
+                ),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            offset = int(input_data.offset)
+        except ValueError:
+            offset = 0
+        current_date = datetime.now() - timedelta(days=offset)
+        yield "date", current_date.strftime("%Y-%m-%d")
+
+
+class GetCurrentDateAndTimeBlock(Block):
+    class Input(BlockSchema):
+        trigger: str
+
+    class Output(BlockSchema):
+        date_time: str
+
+    def __init__(self):
+        super().__init__(
+            id="b29c1b50-5d0e-4d9f-8f9d-1b0e6fcbf0h2",
+            description="This block outputs the current date and time.",
+            categories={BlockCategory.TEXT},
+            input_schema=GetCurrentDateAndTimeBlock.Input,
+            output_schema=GetCurrentDateAndTimeBlock.Output,
+            test_input=[
+                {"trigger": "Hello", "format": "{date_time}"},
+            ],
+            test_output=[
+                (
+                    "date_time",
+                    lambda t: abs(
+                        datetime.now() - datetime.strptime(t, "%Y-%m-%d %H:%M:%S")
+                    )
+                    < timedelta(seconds=10),  # 10 seconds error margin.
+                ),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        current_date_time = time.strftime("%Y-%m-%d %H:%M:%S")
+        yield "date_time", current_date_time
+
+
+class CountdownTimerBlock(Block):
+    class Input(BlockSchema):
+        input_message: Any = "timer finished"
+        seconds: Union[int, str] = 0
+        minutes: Union[int, str] = 0
+        hours: Union[int, str] = 0
+        days: Union[int, str] = 0
+
+    class Output(BlockSchema):
+        output_message: str
+
+    def __init__(self):
+        super().__init__(
+            id="d67a9c52-5e4e-11e2-bcfd-0800200c9a71",
+            description="This block triggers after a specified duration.",
+            categories={BlockCategory.TEXT},
+            input_schema=CountdownTimerBlock.Input,
+            output_schema=CountdownTimerBlock.Output,
+            test_input=[
+                {"seconds": 1},
+                {"input_message": "Custom message"},
+            ],
+            test_output=[
+                ("output_message", "timer finished"),
+                ("output_message", "Custom message"),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        seconds = int(input_data.seconds)
+        minutes = int(input_data.minutes)
+        hours = int(input_data.hours)
+        days = int(input_data.days)
+
+        total_seconds = seconds + minutes * 60 + hours * 3600 + days * 86400
+
+        time.sleep(total_seconds)
+        yield "output_message", input_data.input_message

autogpt_platform/backend/backend/blocks/youtube.py

@@ -0,0 +1,77 @@
+from urllib.parse import parse_qs, urlparse
+
+from youtube_transcript_api import YouTubeTranscriptApi
+from youtube_transcript_api.formatters import TextFormatter
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import SchemaField
+
+
+class TranscribeYouTubeVideoBlock(Block):
+    class Input(BlockSchema):
+        youtube_url: str = SchemaField(
+            description="The URL of the YouTube video to transcribe",
+            placeholder="https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+        )
+
+    class Output(BlockSchema):
+        video_id: str = SchemaField(description="The extracted YouTube video ID")
+        transcript: str = SchemaField(description="The transcribed text of the video")
+        error: str = SchemaField(
+            description="Any error message if the transcription fails"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="f3a8f7e1-4b1d-4e5f-9f2a-7c3d5a2e6b4c",
+            input_schema=TranscribeYouTubeVideoBlock.Input,
+            output_schema=TranscribeYouTubeVideoBlock.Output,
+            description="Transcribes a YouTube video.",
+            categories={BlockCategory.SOCIAL},
+            test_input={"youtube_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"},
+            test_output=[
+                ("video_id", "dQw4w9WgXcQ"),
+                (
+                    "transcript",
+                    "Never gonna give you up\nNever gonna let you down",
+                ),
+            ],
+            test_mock={
+                "get_transcript": lambda video_id: [
+                    {"text": "Never gonna give you up"},
+                    {"text": "Never gonna let you down"},
+                ],
+            },
+        )
+
+    @staticmethod
+    def extract_video_id(url: str) -> str:
+        parsed_url = urlparse(url)
+        if parsed_url.netloc == "youtu.be":
+            return parsed_url.path[1:]
+        if parsed_url.netloc in ("www.youtube.com", "youtube.com"):
+            if parsed_url.path == "/watch":
+                p = parse_qs(parsed_url.query)
+                return p["v"][0]
+            if parsed_url.path[:7] == "/embed/":
+                return parsed_url.path.split("/")[2]
+            if parsed_url.path[:3] == "/v/":
+                return parsed_url.path.split("/")[2]
+        raise ValueError(f"Invalid YouTube URL: {url}")
+
+    @staticmethod
+    def get_transcript(video_id: str):
+        return YouTubeTranscriptApi.get_transcript(video_id)
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            video_id = self.extract_video_id(input_data.youtube_url)
+            yield "video_id", video_id
+
+            transcript = self.get_transcript(video_id)
+            formatter = TextFormatter()
+            transcript_text = formatter.format_transcript(transcript)
+
+            yield "transcript", transcript_text
+        except Exception as e:
+            yield "error", str(e)

autogpt_platform/backend/backend/cli.py

@@ -0,0 +1,247 @@
+"""
+The command line interface for the agent server
+"""
+
+import os
+import pathlib
+
+import click
+import psutil
+
+from backend import app
+from backend.util.process import AppProcess
+
+
+def get_pid_path() -> pathlib.Path:
+    home_dir = pathlib.Path.home()
+    new_dir = home_dir / ".config" / "agpt"
+    file_path = new_dir / "running.tmp"
+    return file_path
+
+
+def get_pid() -> int | None:
+    file_path = get_pid_path()
+    if not file_path.exists():
+        return None
+
+    os.makedirs(file_path.parent, exist_ok=True)
+    with open(file_path, "r", encoding="utf-8") as file:
+        pid = file.read()
+    try:
+        return int(pid)
+    except ValueError:
+        return None
+
+
+def write_pid(pid: int):
+    file_path = get_pid_path()
+    os.makedirs(file_path.parent, exist_ok=True)
+    with open(file_path, "w", encoding="utf-8") as file:
+        file.write(str(pid))
+
+
+class MainApp(AppProcess):
+    def run(self):
+        app.main(silent=True)
+
+
+@click.group()
+def main():
+    """AutoGPT Server CLI Tool"""
+    pass
+
+
+@main.command()
+def start():
+    """
+    Starts the server in the background and saves the PID
+    """
+    # Define the path for the new directory and file
+    pid = get_pid()
+    if pid and psutil.pid_exists(pid):
+        print("Server is already running")
+        exit(1)
+    elif pid:
+        print("PID does not exist deleting file")
+        os.remove(get_pid_path())
+
+    print("Starting server")
+    pid = MainApp().start(background=True, silent=True)
+    print(f"Server running in process: {pid}")
+
+    write_pid(pid)
+    print("done")
+    os._exit(status=0)
+
+
+@main.command()
+def stop():
+    """
+    Stops the server
+    """
+    pid = get_pid()
+    if not pid:
+        print("Server is not running")
+        return
+
+    os.remove(get_pid_path())
+    process = psutil.Process(int(pid))
+    for child in process.children(recursive=True):
+        child.terminate()
+    process.terminate()
+
+    print("Server Stopped")
+
+
+@click.group()
+def test():
+    """
+    Group for test commands
+    """
+    pass
+
+
+@test.command()
+@click.argument("server_address")
+def reddit(server_address: str):
+    """
+    Create an event graph
+    """
+    import requests
+
+    from backend.usecases.reddit_marketing import create_test_graph
+
+    test_graph = create_test_graph()
+    url = f"{server_address}/graphs"
+    headers = {"Content-Type": "application/json"}
+    data = test_graph.model_dump_json()
+
+    response = requests.post(url, headers=headers, data=data)
+
+    graph_id = response.json()["id"]
+    print(f"Graph created with ID: {graph_id}")
+
+
+@test.command()
+@click.argument("server_address")
+def populate_db(server_address: str):
+    """
+    Create an event graph
+    """
+    import requests
+
+    from backend.usecases.sample import create_test_graph
+
+    test_graph = create_test_graph()
+    url = f"{server_address}/graphs"
+    headers = {"Content-Type": "application/json"}
+    data = test_graph.model_dump_json()
+
+    response = requests.post(url, headers=headers, data=data)
+
+    graph_id = response.json()["id"]
+
+    if response.status_code == 200:
+        execute_url = f"{server_address}/graphs/{response.json()['id']}/execute"
+        text = "Hello, World!"
+        input_data = {"input": text}
+        response = requests.post(execute_url, headers=headers, json=input_data)
+
+        schedule_url = f"{server_address}/graphs/{graph_id}/schedules"
+        data = {
+            "graph_id": graph_id,
+            "cron": "*/5 * * * *",
+            "input_data": {"input": "Hello, World!"},
+        }
+        response = requests.post(schedule_url, headers=headers, json=data)
+
+    print("Database populated with: \n- graph\n- execution\n- schedule")
+
+
+@test.command()
+@click.argument("server_address")
+def graph(server_address: str):
+    """
+    Create an event graph
+    """
+    import requests
+
+    from backend.usecases.sample import create_test_graph
+
+    url = f"{server_address}/graphs"
+    headers = {"Content-Type": "application/json"}
+    data = create_test_graph().model_dump_json()
+    response = requests.post(url, headers=headers, data=data)
+
+    if response.status_code == 200:
+        print(response.json()["id"])
+        execute_url = f"{server_address}/graphs/{response.json()['id']}/execute"
+        text = "Hello, World!"
+        input_data = {"input": text}
+        response = requests.post(execute_url, headers=headers, json=input_data)
+
+    else:
+        print("Failed to send graph")
+        print(f"Response: {response.text}")
+
+
+@test.command()
+@click.argument("graph_id")
+@click.argument("content")
+def execute(graph_id: str, content: dict):
+    """
+    Create an event graph
+    """
+    import requests
+
+    headers = {"Content-Type": "application/json"}
+
+    execute_url = f"http://0.0.0.0:8000/graphs/{graph_id}/execute"
+    requests.post(execute_url, headers=headers, json=content)
+
+
+@test.command()
+def event():
+    """
+    Send an event to the running server
+    """
+    print("Event sent")
+
+
+@test.command()
+@click.argument("server_address")
+@click.argument("graph_id")
+def websocket(server_address: str, graph_id: str):
+    """
+    Tests the websocket connection.
+    """
+    import asyncio
+
+    import websockets
+
+    from backend.server.ws_api import ExecutionSubscription, Methods, WsMessage
+
+    async def send_message(server_address: str):
+        uri = f"ws://{server_address}"
+        async with websockets.connect(uri) as websocket:
+            try:
+                msg = WsMessage(
+                    method=Methods.SUBSCRIBE,
+                    data=ExecutionSubscription(graph_id=graph_id).model_dump(),
+                ).model_dump_json()
+                await websocket.send(msg)
+                print(f"Sending: {msg}")
+                while True:
+                    response = await websocket.recv()
+                    print(f"Response from server: {response}")
+            except InterruptedError:
+                exit(0)
+
+    asyncio.run(send_message(server_address))
+    print("Testing WS")
+
+
+main.add_command(test)
+
+if __name__ == "__main__":
+    main()