Feat(Fix) for the constraint violation's in prisma

.deepsource.toml

@@ -1,18 +0,0 @@
-version = 1
-
-test_patterns = ["**/*.spec.ts","**/*_test.py","**/*_tests.py","**/test_*.py"]
-
-exclude_patterns = ["classic/**"]
-
-[[analyzers]]
-name = "javascript"
-
-[analyzers.meta]
-plugins = ["react"]
-environment = ["nodejs"]
-
-[[analyzers]]
-name = "python"
-
-[analyzers.meta]
-runtime_version = "3.x.x"

.dockerignore

@@ -1,61 +1,40 @@
 # Ignore everything by default, selectively add things to context
-*
+classic/run
 
-# Platform - Libs
-!autogpt_platform/autogpt_libs/autogpt_libs/
-!autogpt_platform/autogpt_libs/pyproject.toml
-!autogpt_platform/autogpt_libs/poetry.lock
-!autogpt_platform/autogpt_libs/README.md
-
-# Platform - Backend
-!autogpt_platform/backend/backend/
-!autogpt_platform/backend/migrations/
-!autogpt_platform/backend/schema.prisma
-!autogpt_platform/backend/pyproject.toml
-!autogpt_platform/backend/poetry.lock
-!autogpt_platform/backend/README.md
-
-# Platform - Market
-!autogpt_platform/market/market/
-!autogpt_platform/market/scripts.py
-!autogpt_platform/market/schema.prisma
-!autogpt_platform/market/pyproject.toml
-!autogpt_platform/market/poetry.lock
-!autogpt_platform/market/README.md
-
-# Platform - Frontend
-!autogpt_platform/frontend/src/
-!autogpt_platform/frontend/public/
-!autogpt_platform/frontend/package.json
-!autogpt_platform/frontend/yarn.lock
-!autogpt_platform/frontend/tsconfig.json
-!autogpt_platform/frontend/README.md
-## config
-!autogpt_platform/frontend/*.config.*
-!autogpt_platform/frontend/.env.*
-
-# Classic - AutoGPT
+# AutoGPT
 !classic/original_autogpt/autogpt/
 !classic/original_autogpt/pyproject.toml
 !classic/original_autogpt/poetry.lock
 !classic/original_autogpt/README.md
 !classic/original_autogpt/tests/
 
-# Classic - Benchmark
+# Benchmark
 !classic/benchmark/agbenchmark/
 !classic/benchmark/pyproject.toml
 !classic/benchmark/poetry.lock
 !classic/benchmark/README.md
 
-# Classic - Forge
+# Forge
 !classic/forge/
 !classic/forge/pyproject.toml
 !classic/forge/poetry.lock
 !classic/forge/README.md
 
-# Classic - Frontend
+# 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

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,38 +1,23 @@
+### Background
+
 <!-- Clearly explain the need for these changes: -->
 
 ### Changes 🏗️
 
 <!-- Concisely describe all of the changes made in this pull request: -->
 
-### Checklist 📋
 
-#### For code changes:
-- [ ] I have clearly listed my changes in the PR description
-- [ ] I have made a test plan
-- [ ] I have tested my changes according to the test plan:
-  <!-- Put your test plan here: -->
-  - [ ] ...
+### Testing 🔍
+> [!NOTE] 
+Only for the new autogpt platform, currently in autogpt_platform/
 
-<details>
-  <summary>Example test plan</summary>
-  
-  - [ ] 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
-</details>
+<!--
+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:
+-->
 
-#### For configuration changes:
-- [ ] `.env.example` is updated or already compatible with my changes
-- [ ] `docker-compose.yml` is updated or already compatible with my changes
-- [ ] I have included a list of my configuration changes in the PR description (under **Changes**)
-
-<details>
-  <summary>Examples of configuration changes</summary>
-
-  - Changing ports
-  - Adding new services that need to communicate with each other
-  - Secrets or environment variable changes
-  - New or infrastructure changes such as databases
-</details>
+- 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/dependabot.yml

@@ -1,151 +0,0 @@
-version: 2
-updates:
-  # autogpt_libs (Poetry project)
-  - package-ecosystem: "pip"
-    directory: "autogpt_platform/autogpt_libs"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 10
-    target-branch: "dev"
-    commit-message:
-      prefix: "chore(libs/deps)"
-      prefix-development: "chore(libs/deps-dev)"
-    groups:
-      production-dependencies:
-        dependency-type: "production"
-        update-types:
-        - "minor"
-        - "patch"
-      development-dependencies:
-        dependency-type: "development"
-        update-types:
-        - "minor"
-        - "patch"
-
-  # backend (Poetry project)
-  - package-ecosystem: "pip"
-    directory: "autogpt_platform/backend"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 10
-    target-branch: "dev"
-    commit-message:
-      prefix: "chore(backend/deps)"
-      prefix-development: "chore(backend/deps-dev)"
-    groups:
-      production-dependencies:
-        dependency-type: "production"
-        update-types:
-        - "minor"
-        - "patch"
-      development-dependencies:
-        dependency-type: "development"
-        update-types:
-        - "minor"
-        - "patch"
-
-  # frontend (Next.js project)
-  - package-ecosystem: "npm"
-    directory: "autogpt_platform/frontend"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 10
-    target-branch: "dev"
-    commit-message:
-      prefix: "chore(frontend/deps)"
-      prefix-development: "chore(frontend/deps-dev)"
-    groups:
-      production-dependencies:
-        dependency-type: "production"
-        update-types:
-        - "minor"
-        - "patch"
-      development-dependencies:
-        dependency-type: "development"
-        update-types:
-        - "minor"
-        - "patch"
-
-  # infra (Terraform)
-  - package-ecosystem: "terraform"
-    directory: "autogpt_platform/infra"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 5
-    target-branch: "dev"
-    commit-message:
-      prefix: "chore(infra/deps)"
-      prefix-development: "chore(infra/deps-dev)"
-
-    groups:
-      production-dependencies:
-        dependency-type: "production"
-        update-types:
-        - "minor"
-        - "patch"
-      development-dependencies:
-        dependency-type: "development"
-        update-types:
-        - "minor"
-        - "patch"
-
-
-  # GitHub Actions
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 5
-    target-branch: "dev"
-    groups:
-      production-dependencies:
-        dependency-type: "production"
-        update-types:
-        - "minor"
-        - "patch"
-      development-dependencies:
-        dependency-type: "development"
-        update-types:
-        - "minor"
-        - "patch"
-
-
-  # Docker
-  - package-ecosystem: "docker"
-    directory: "autogpt_platform/"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 5
-    target-branch: "dev"
-    groups:
-      production-dependencies:
-        dependency-type: "production"
-        update-types:
-        - "minor"
-        - "patch"
-      development-dependencies:
-        dependency-type: "development"
-        update-types:
-        - "minor"
-        - "patch"
-
-  # Docs
-  - package-ecosystem: 'pip'
-    directory: "docs/"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 1
-    target-branch: "dev"
-    commit-message:
-      prefix: "chore(docs/deps)"
-    groups:
-      production-dependencies:
-        dependency-type: "production"
-        update-types:
-        - "minor"
-        - "patch"
-      development-dependencies:
-        dependency-type: "development"
-        update-types:
-        - "minor"
-        - "patch"

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

@@ -2,12 +2,12 @@ name: Classic - AutoGPT CI
 
 on:
   push:
-    branches: [ master, dev, ci-test* ]
+    branches: [ master, development, ci-test* ]
     paths:
       - '.github/workflows/classic-autogpt-ci.yml'
       - 'classic/original_autogpt/**'
   pull_request:
-    branches: [ master, dev, release-* ]
+    branches: [ master, development, release-* ]
     paths:
       - '.github/workflows/classic-autogpt-ci.yml'
       - 'classic/original_autogpt/**'
@@ -115,7 +115,6 @@ jobs:
           poetry run pytest -vv \
             --cov=autogpt --cov-branch --cov-report term-missing --cov-report xml \
             --numprocesses=logical --durations=10 \
-            --junitxml=junit.xml -o junit_family=legacy \
             tests/unit tests/integration
         env:
           CI: true
@@ -125,14 +124,8 @@ jobs:
           AWS_ACCESS_KEY_ID: minioadmin
           AWS_SECRET_ACCESS_KEY: minioadmin
 
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}  # Run even if tests fail
-        uses: codecov/test-results-action@v1
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           flags: autogpt-agent,${{ runner.os }}

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

@@ -5,7 +5,7 @@ on:
     - cron: 20 4 * * 1,4
 
 env:
-  BASE_BRANCH: dev
+  BASE_BRANCH: development
   IMAGE_NAME: auto-gpt
 
 jobs:
@@ -15,46 +15,46 @@ jobs:
       matrix:
         build-type: [release, dev]
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+    - name: Checkout repository
+      uses: actions/checkout@v4
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
 
-      - id: build
-        name: Build image
-        uses: docker/build-push-action@v6
-        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
+    - 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 }}
+    - name: Generate build report
+      env:
+        event_name: ${{ github.event_name }}
+        event_ref: ${{ github.event.schedule }}
 
-          build_type: ${{ matrix.build-type }}
+        build_type: ${{ matrix.build-type }}
 
-          prod_branch: master
-          dev_branch: dev
-          repository: ${{ github.repository }}
-          base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'dev' && 'dev' || 'master' }}
+        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:
+        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) }}
+        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) }}
+        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
+      run: .github/workflows/scripts/docker-ci-summary.sh >> $GITHUB_STEP_SUMMARY
+      continue-on-error: true

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

@@ -2,13 +2,13 @@ name: Classic - AutoGPT Docker CI
 
 on:
   push:
-    branches: [master, dev]
+    branches: [ master, development ]
     paths:
       - '.github/workflows/classic-autogpt-docker-ci.yml'
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
   pull_request:
-    branches: [ master, dev, release-* ]
+    branches: [ master, development, release-* ]
     paths:
       - '.github/workflows/classic-autogpt-docker-ci.yml'
       - 'classic/original_autogpt/**'
@@ -34,58 +34,58 @@ jobs:
       matrix:
         build-type: [release, dev]
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+    - name: Checkout repository
+      uses: actions/checkout@v4
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
 
-      - if: runner.debug
-        run: |
-          ls -al
-          du -hs *
+    - if: runner.debug
+      run: |
+        ls -al
+        du -hs *
 
-      - id: build
-        name: Build image
-        uses: docker/build-push-action@v6
-        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
+    - 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}}
+    - 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 }}
+        build_type: ${{ matrix.build-type }}
 
-          prod_branch: master
-          dev_branch: dev
-          repository: ${{ github.repository }}
-          base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'dev' && 'dev' || 'master' }}
+        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' || '' }}
+        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) }}
+        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) }}
+        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
+      run: .github/workflows/scripts/docker-ci-summary.sh >> $GITHUB_STEP_SUMMARY
+      continue-on-error: true
 
   test:
     runs-on: ubuntu-latest
@@ -117,16 +117,16 @@ jobs:
 
       - id: build
         name: Build image
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v5
         with:
           context: classic/
           file: classic/Dockerfile.autogpt
-          build-args: BUILD_TYPE=dev # include pytest
+          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
+          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

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

@@ -2,7 +2,7 @@ name: Classic - AutoGPT Docker Release
 
 on:
   release:
-    types: [published, edited]
+    types: [ published, edited ]
 
   workflow_dispatch:
     inputs:
@@ -19,69 +19,69 @@ jobs:
     if: startsWith(github.ref, 'refs/tags/autogpt-')
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+    - 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: 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
+    - 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 }}
+      # 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@v6
-        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 }}
+    - 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
+        # 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: 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 }}
+    - 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: dev
-          repository: ${{ github.repository }}
-          base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'dev' && 'dev' || 'master' }}
+        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) }}
+        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) }}
+        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
+      run: .github/workflows/scripts/docker-release-summary.sh >> $GITHUB_STEP_SUMMARY
+      continue-on-error: true

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

@@ -5,7 +5,7 @@ on:
   schedule:
     - cron: '0 8 * * *'
   push:
-    branches: [ master, dev, ci-test* ]
+    branches: [ master, development, ci-test* ]
     paths:
       - '.github/workflows/classic-autogpts-ci.yml'
       - 'classic/original_autogpt/**'
@@ -16,7 +16,7 @@ on:
       - 'classic/setup.py'
       - '!**/*.md'
   pull_request:
-    branches: [ master, dev, release-* ]
+    branches: [ master, development, release-* ]
     paths:
       - '.github/workflows/classic-autogpts-ci.yml'
       - 'classic/original_autogpt/**'

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

@@ -2,13 +2,13 @@ name: Classic - AGBenchmark CI
 
 on:
   push:
-    branches: [ master, dev, ci-test* ]
+    branches: [ master, development, ci-test* ]
     paths:
       - 'classic/benchmark/**'
       - '!classic/benchmark/reports/**'
       - .github/workflows/classic-benchmark-ci.yml
   pull_request:
-    branches: [ master, dev, release-* ]
+    branches: [ master, development, release-* ]
     paths:
       - 'classic/benchmark/**'
       - '!classic/benchmark/reports/**'
@@ -87,20 +87,13 @@ jobs:
           poetry run pytest -vv \
             --cov=agbenchmark --cov-branch --cov-report term-missing --cov-report xml \
             --durations=10 \
-            --junitxml=junit.xml -o junit_family=legacy \
             tests
         env:
           CI: true
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
 
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}  # Run even if tests fail
-        uses: codecov/test-results-action@v1
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           flags: agbenchmark,${{ runner.os }}
@@ -109,7 +102,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        agent-name: [forge]
+        agent-name: [ forge ]
       fail-fast: false
     timeout-minutes: 20
     steps:
@@ -153,23 +146,23 @@ jobs:
           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
+          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
+          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
+          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

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

@@ -2,13 +2,13 @@ name: Classic - Forge CI
 
 on:
   push:
-    branches: [ master, dev, ci-test* ]
+    branches: [ master, development, ci-test* ]
     paths:
       - '.github/workflows/classic-forge-ci.yml'
       - 'classic/forge/**'
       - '!classic/forge/tests/vcr_cassettes'
   pull_request:
-    branches: [ master, dev, release-* ]
+    branches: [ master, development, release-* ]
     paths:
       - '.github/workflows/classic-forge-ci.yml'
       - 'classic/forge/**'
@@ -139,7 +139,6 @@ jobs:
           poetry run pytest -vv \
             --cov=forge --cov-branch --cov-report term-missing --cov-report xml \
             --durations=10 \
-            --junitxml=junit.xml -o junit_family=legacy \
             forge
         env:
           CI: true
@@ -149,14 +148,8 @@ jobs:
           AWS_ACCESS_KEY_ID: minioadmin
           AWS_SECRET_ACCESS_KEY: minioadmin
 
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}  # Run even if tests fail
-        uses: codecov/test-results-action@v1
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           flags: forge,${{ runner.os }}

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

@@ -4,7 +4,7 @@ on:
   push:
     branches:
       - master
-      - dev
+      - development
       - 'ci-test*' # This will match any branch that starts with "ci-test"
     paths:
       - 'classic/frontend/**'
@@ -24,37 +24,37 @@ jobs:
       BUILD_BRANCH: ${{ format('classic-frontend-build/{0}', github.ref_name) }}
 
     steps:
-      - name: Checkout Repo
-        uses: actions/checkout@v4
+    - name: Checkout Repo
+      uses: actions/checkout@v4
 
-      - name: Setup Flutter
-        uses: subosito/flutter-action@v2
-        with:
-          flutter-version: '3.13.2'
+    - 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: 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: 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@v7
-        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 }}"
+    - 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

@@ -2,7 +2,7 @@ name: Classic - Python checks
 
 on:
   push:
-    branches: [ master, dev, ci-test* ]
+    branches: [ master, development, ci-test* ]
     paths:
       - '.github/workflows/classic-python-checks-ci.yml'
       - 'classic/original_autogpt/**'
@@ -11,7 +11,7 @@ on:
       - '**.py'
       - '!classic/forge/tests/vcr_cassettes'
   pull_request:
-    branches: [ master, dev, release-* ]
+    branches: [ master, development, release-* ]
     paths:
       - '.github/workflows/classic-python-checks-ci.yml'
       - 'classic/original_autogpt/**'

.github/workflows/codeql.yml

@@ -13,10 +13,9 @@ name: "CodeQL"
 
 on:
   push:
-    branches: [ "master", "release-*", "dev" ]
+    branches: [ "master", "release-*" ]
   pull_request:
-    branches: [ "master", "release-*", "dev" ]
-  merge_group:
+    branches: [ "master", "release-*" ]
   schedule:
     - cron: '15 4 * * 0'
 

.github/workflows/platform-autgpt-deploy-prod.yml

@@ -1,49 +0,0 @@
-name: AutoGPT Platform - Deploy Prod Environment
-
-on:
-  release:
-    types: [published]
-
-permissions:
-  contents: 'read'
-  id-token: 'write'
-
-jobs:
-  migrate:
-    environment: production
-    name: Run migrations for AutoGPT Platform
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-
-      - name: Install Python dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install prisma
-
-      - name: Run Backend Migrations
-        working-directory: ./autogpt_platform/backend
-        run: |
-          python -m prisma migrate deploy
-        env:
-          DATABASE_URL: ${{ secrets.BACKEND_DATABASE_URL }}
-
-          
-  trigger:
-    needs: migrate
-    runs-on: ubuntu-latest
-    steps:
-      - name: Trigger deploy workflow
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          token: ${{ secrets.DEPLOY_TOKEN }}
-          repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
-          event-type: build_deploy_prod
-          client-payload: '{"ref": "${{ github.ref }}", "sha": "${{ github.sha }}", "repository": "${{ github.repository }}"}'

.github/workflows/platform-autogpt-deploy-dev.yaml

@@ -1,50 +0,0 @@
-name: AutoGPT Platform - Deploy Dev Environment
-
-on:
-  push:
-    branches: [ dev ]
-    paths:
-      - 'autogpt_platform/**'
-
-permissions:
-  contents: 'read'
-  id-token: 'write'
-
-jobs:
-  migrate:
-    environment: develop
-    name: Run migrations for AutoGPT Platform
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-
-      - name: Install Python dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install prisma
-
-      - name: Run Backend Migrations
-        working-directory: ./autogpt_platform/backend
-        run: |
-          python -m prisma migrate deploy
-        env:
-          DATABASE_URL: ${{ secrets.BACKEND_DATABASE_URL }}
-
-  trigger:
-    needs: migrate
-    runs-on: ubuntu-latest
-    steps:
-      - name: Trigger deploy workflow
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          token: ${{ secrets.DEPLOY_TOKEN }}
-          repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
-          event-type: build_deploy_dev
-          client-payload: '{"ref": "${{ github.ref }}", "sha": "${{ github.sha }}", "repository": "${{ github.repository }}"}'

.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

@@ -2,18 +2,15 @@ name: AutoGPT Platform - Backend CI
 
 on:
   push:
-    branches: [master, dev, ci-test*]
+    branches: [master, development, ci-test*]
     paths:
       - ".github/workflows/platform-backend-ci.yml"
       - "autogpt_platform/backend/**"
-      - "autogpt_platform/autogpt_libs/**"
   pull_request:
-    branches: [master, dev, release-*]
+    branches: [master, development, release-*]
     paths:
       - ".github/workflows/platform-backend-ci.yml"
       - "autogpt_platform/backend/**"
-      - "autogpt_platform/autogpt_libs/**"
-  merge_group:
 
 concurrency:
   group: ${{ format('backend-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
@@ -35,22 +32,6 @@ jobs:
         python-version: ["3.10"]
     runs-on: ubuntu-latest
 
-    services:
-      redis:
-        image: bitnami/redis:6.2
-        env:
-          REDIS_PASSWORD: testpassword
-        ports:
-          - 6379:6379
-      rabbitmq:
-        image: rabbitmq:3.12-management
-        ports:
-          - 5672:5672
-          - 15672:15672
-        env:
-          RABBITMQ_DEFAULT_USER: ${{ env.RABBITMQ_DEFAULT_USER }}
-          RABBITMQ_DEFAULT_PASS: ${{ env.RABBITMQ_DEFAULT_PASS }}
-
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -66,7 +47,7 @@ jobs:
       - name: Setup Supabase
         uses: supabase/setup-cli@v1
         with:
-          version: 1.178.1
+          version: latest
 
       - id: get_date
         name: Get date
@@ -80,40 +61,12 @@ jobs:
 
       - name: Install Poetry (Unix)
         run: |
-          # Extract Poetry version from backend/poetry.lock
-          HEAD_POETRY_VERSION=$(head -n 1 poetry.lock | grep -oP '(?<=Poetry )[0-9]+\.[0-9]+\.[0-9]+')
-          echo "Found Poetry version ${HEAD_POETRY_VERSION} in backend/poetry.lock"
-
-          if [ -n "$BASE_REF" ]; then
-            BASE_BRANCH=${BASE_REF/refs\/heads\//}
-            BASE_POETRY_VERSION=$((git show "origin/$BASE_BRANCH":./poetry.lock; true) | head -n 1 | grep -oP '(?<=Poetry )[0-9]+\.[0-9]+\.[0-9]+')
-            echo "Found Poetry version ${BASE_POETRY_VERSION} in backend/poetry.lock on ${BASE_REF}"
-            POETRY_VERSION=$(printf '%s\n' "$HEAD_POETRY_VERSION" "$BASE_POETRY_VERSION" | sort -V | tail -n1)
-          else
-            POETRY_VERSION=$HEAD_POETRY_VERSION
-          fi
-          echo "Using Poetry version ${POETRY_VERSION}"
-
-          # Install Poetry
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$POETRY_VERSION python3 -
+          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
-        env:
-          BASE_REF: ${{ github.base_ref || github.event.merge_group.base_ref }}
-
-      - name: Check poetry.lock
-        run: |
-          poetry lock
-
-          if ! git diff --quiet --ignore-matching-lines="^# " poetry.lock; then
-            echo "Error: poetry.lock not up to date."
-            echo
-            git diff poetry.lock
-            exit 1
-          fi
 
       - name: Install Python dependencies
         run: poetry install
@@ -143,9 +96,9 @@ jobs:
       - name: Run pytest with coverage
         run: |
           if [[ "${{ runner.debug }}" == "1" ]]; then
-            poetry run pytest -s -vv -o log_cli=true -o log_cli_level=DEBUG test
+            poetry run pytest -vv -o log_cli=true -o log_cli_level=DEBUG test
           else
-            poetry run pytest -s -vv test
+            poetry run pytest -vv test
           fi
         if: success() || (failure() && steps.lint.outcome == 'failure')
         env:
@@ -154,23 +107,12 @@ jobs:
           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 }}
-          REDIS_HOST: 'localhost'
-          REDIS_PORT: '6379'
-          REDIS_PASSWORD: 'testpassword'
-
     env:
       CI: true
       PLAIN_OUTPUT: True
       RUN_ENV: local
       PORT: 8080
       OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-      # We know these are here, don't report this as a security vulnerability
-      # This is used as the default credential for the entire system's RabbitMQ instance
-      # If you want to replace this, you can do so by making our entire system generate
-      # new credentials for each local user and update the environment variables in
-      # the backend service, docker composes, and examples
-      RABBITMQ_DEFAULT_USER: 'rabbitmq_user_default'
-      RABBITMQ_DEFAULT_PASS: 'k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7'
 
       # - name: Upload coverage reports to Codecov
       #   uses: codecov/codecov-action@v4

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

@@ -2,7 +2,7 @@ name: AutoGPT Platform - Frontend CI
 
 on:
   push:
-    branches: [master, dev]
+    branches: [master]
     paths:
       - ".github/workflows/platform-frontend-ci.yml"
       - "autogpt_platform/frontend/**"
@@ -10,7 +10,6 @@ on:
     paths:
       - ".github/workflows/platform-frontend-ci.yml"
       - "autogpt_platform/frontend/**"
-  merge_group:
 
 defaults:
   run:
@@ -23,7 +22,6 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
-
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
@@ -31,62 +29,32 @@ jobs:
 
       - name: Install dependencies
         run: |
-          yarn install --frozen-lockfile
+          npm install
+
+      - name: Check formatting with Prettier
+        run: |
+          npx prettier --check .
 
       - name: Run lint
         run: |
-          yarn lint
-
-  type-check:
-    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: |
-          yarn install --frozen-lockfile
-
-      - name: Run tsc check
-        run: |
-          yarn type-check
+          npm run lint
 
   test:
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        browser: [chromium, webkit]
 
     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: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
-        with:
-          large-packages: false # slow
-          docker-images: false # limited benefit
-
       - name: Copy default supabase .env
         run: |
-          cp ../.env.example ../.env
-
-      - name: Copy backend .env
-        run: |
-          cp ../backend/.env.example ../backend/.env
+          cp ../supabase/docker/.env.example ../.env
 
       - name: Run docker compose
         run: |
@@ -94,28 +62,22 @@ jobs:
 
       - name: Install dependencies
         run: |
-          yarn install --frozen-lockfile
+          npm install
 
       - name: Setup Builder .env
         run: |
           cp .env.example .env
 
-      - name: Install Browser '${{ matrix.browser }}'
-        run: yarn playwright install --with-deps ${{ matrix.browser }}
+      - name: Install Playwright Browsers
+        run: npx playwright install --with-deps
 
       - name: Run tests
-        timeout-minutes: 20
         run: |
-          yarn test --project=${{ matrix.browser }}
-
-      - name: Print Final Docker Compose logs
-        if: always()
-        run: |
-          docker compose -f ../docker-compose.yml logs
+          npm run test
 
       - uses: actions/upload-artifact@v4
         if: ${{ !cancelled() }}
         with:
-          name: playwright-report-${{ matrix.browser }}
+          name: playwright-report
           path: playwright-report/
           retention-days: 30

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

@@ -25,7 +25,7 @@ jobs:
           close-issue-message: >
             This issue was closed automatically because it has been stale for 10 days
             with no activity.
-          days-before-stale: 100
+          days-before-stale: 50
           days-before-close: 10
           # Do not touch meta issues:
           exempt-issue-labels: meta,fridge,project management

.github/workflows/repo-pr-enforce-base-branch.yml

@@ -1,21 +0,0 @@
-name: Repo - Enforce dev as base branch
-on:
-  pull_request_target:
-    branches: [ master ]
-    types: [ opened ]
-
-jobs:
-  check_pr_target:
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-    steps:
-      - name: Check if PR is from dev or hotfix
-        if: ${{ !(startsWith(github.event.pull_request.head.ref, 'hotfix/') || github.event.pull_request.head.ref == 'dev') }}
-        run: |
-          gh pr comment ${{ github.event.number }} --repo "$REPO" \
-            --body $'This PR targets the `master` branch but does not come from `dev` or a `hotfix/*` branch.\n\nAutomatically setting the base branch to `dev`.'
-          gh pr edit ${{ github.event.number }} --base dev --repo "$REPO"
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-          REPO: ${{ github.repository }}

.github/workflows/repo-pr-label.yml

@@ -3,7 +3,7 @@ name: Repo - Pull Request auto-label
 on:
   # So that PRs touching the same files as the push are updated
   push:
-    branches: [ master, dev, release-* ]
+    branches: [ master, development, release-* ]
     paths-ignore:
       - 'classic/forge/tests/vcr_cassettes'
       - 'classic/benchmark/reports/**'

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

@@ -2,7 +2,6 @@ name: Repo - PR Status Checker
 on:
   pull_request:
     types: [opened, synchronize, reopened]
-  merge_group:
 
 jobs:
   status-check:

.github/workflows/scripts/check_actions_status.py

@@ -7,18 +7,13 @@ 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)
 
-        # Handle both PR and merge group events
-        if "pull_request" in event:
-            sha = event["pull_request"]["head"]["sha"]
-        else:
-            sha = os.environ["GITHUB_SHA"]
+        sha = event["pull_request"]["head"]["sha"]
 
         return (
             os.environ["GITHUB_API_URL"],

.gitignore

@@ -171,8 +171,3 @@ ig*
 .github_access_token
 LICENSE.rtf
 autogpt_platform/backend/settings.py
-/.auth
-/autogpt_platform/frontend/.auth
-
-*.ign.*
-.test-contents

.gitmodules

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

.pre-commit-config.yaml

@@ -10,142 +10,39 @@ repos:
       - id: check-symlinks
       - id: debug-statements
 
-  - repo: https://github.com/Yelp/detect-secrets
-    rev: v1.5.0
-    hooks:
-      - id: detect-secrets
-        name: Detect secrets
-        description: Detects high entropy strings that are likely to be passwords.
-        files: ^autogpt_platform/
-        stages: [push]
-
-  - repo: local
-    # For proper type checking, all dependencies need to be up-to-date.
-    # It's also a good idea to check that poetry.lock is consistent with pyproject.toml.
-    hooks:
-      - id: poetry-install
-        name: Check & Install dependencies - AutoGPT Platform - Backend
-        alias: poetry-install-platform-backend
-        entry: poetry -C autogpt_platform/backend install
-        # include autogpt_libs source (since it's a path dependency)
-        files: ^autogpt_platform/(backend|autogpt_libs)/poetry\.lock$
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: poetry-install
-        name: Check & Install dependencies - AutoGPT Platform - Libs
-        alias: poetry-install-platform-libs
-        entry: poetry -C autogpt_platform/autogpt_libs install
-        files: ^autogpt_platform/autogpt_libs/poetry\.lock$
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: poetry-install
-        name: Check & Install dependencies - Classic - AutoGPT
-        alias: poetry-install-classic-autogpt
-        entry: poetry -C classic/original_autogpt install
-        # include forge source (since it's a path dependency)
-        files: ^classic/(original_autogpt|forge)/poetry\.lock$
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: poetry-install
-        name: Check & Install dependencies - Classic - Forge
-        alias: poetry-install-classic-forge
-        entry: poetry -C classic/forge install
-        files: ^classic/forge/poetry\.lock$
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: poetry-install
-        name: Check & Install dependencies - Classic - Benchmark
-        alias: poetry-install-classic-benchmark
-        entry: poetry -C classic/benchmark install
-        files: ^classic/benchmark/poetry\.lock$
-        types: [file]
-        language: system
-        pass_filenames: false
-
-  - repo: local
-    # For proper type checking, Prisma client must be up-to-date.
-    hooks:
-      - id: prisma-generate
-        name: Prisma Generate - AutoGPT Platform - Backend
-        alias: prisma-generate-platform-backend
-        entry: bash -c 'cd autogpt_platform/backend && poetry run prisma generate'
-        # include everything that triggers poetry install + the prisma schema
-        files: ^autogpt_platform/((backend|autogpt_libs)/poetry\.lock|backend/schema.prisma)$
-        types: [file]
-        language: system
-        pass_filenames: false
-
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.2
-    hooks:
-      - id: ruff
-        name: Lint (Ruff) - AutoGPT Platform - Backend
-        alias: ruff-lint-platform-backend
-        files: ^autogpt_platform/backend/
-        args: [--fix]
-
-      - id: ruff
-        name: Lint (Ruff) - AutoGPT Platform - Libs
-        alias: ruff-lint-platform-libs
-        files: ^autogpt_platform/autogpt_libs/
-        args: [--fix]
-
-      - id: ruff-format
-        name: Format (Ruff) - AutoGPT Platform - Libs
-        alias: ruff-lint-platform-libs
-        files: ^autogpt_platform/autogpt_libs/
-
   - 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
-        name: Lint (isort) - AutoGPT Platform - Backend
-        alias: isort-platform-backend
-        entry: poetry -P autogpt_platform/backend run isort -p backend
-        files: ^autogpt_platform/backend/
-        types: [file, python]
-        language: system
-
-      - id: isort
-        name: Lint (isort) - Classic - AutoGPT
-        alias: isort-classic-autogpt
-        entry: poetry -P classic/original_autogpt run isort -p autogpt
+      - 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
-        name: Lint (isort) - Classic - Forge
-        alias: isort-classic-forge
-        entry: poetry -P classic/forge run isort -p forge
+      - id: isort-forge
+        name: Lint (isort) - Forge
+        entry: poetry -C classic/forge run isort
         files: ^classic/forge/
         types: [file, python]
         language: system
 
-      - id: isort
-        name: Lint (isort) - Classic - Benchmark
-        alias: isort-classic-benchmark
-        entry: poetry -P classic/benchmark run isort -p agbenchmark
+      - 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: 24.10.0
+    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: Format (Black)
+        name: Lint (Black)
+        language_version: python3.10
 
   - repo: https://github.com/PyCQA/flake8
     rev: 7.0.0
@@ -153,79 +50,53 @@ repos:
     # them separately.
     hooks:
       - id: flake8
-        name: Lint (Flake8) - Classic - AutoGPT
-        alias: flake8-classic-autogpt
+        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) - Classic - Forge
-        alias: flake8-classic-forge
+        name: Lint (Flake8) - Forge
+        alias: flake8-forge
         files: ^classic/forge/(forge|tests)/
         args: [--config=classic/forge/.flake8]
 
       - id: flake8
-        name: Lint (Flake8) - Classic - Benchmark
-        alias: flake8-classic-benchmark
+        name: Lint (Flake8) - Benchmark
+        alias: flake8-benchmark
         files: ^classic/benchmark/(agbenchmark|tests)/((?!reports).)*[/.]
         args: [--config=classic/benchmark/.flake8]
 
-  - repo: local
-    hooks:
-      - id: prettier
-        name: Format (Prettier) - AutoGPT Platform - Frontend
-        alias: format-platform-frontend
-        entry: bash -c 'cd autogpt_platform/frontend && npx prettier --write $(echo "$@" | sed "s|autogpt_platform/frontend/||g")' --
-        files: ^autogpt_platform/frontend/
-        types: [file]
-        language: system
-
   - 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 Platform - Backend
-        alias: pyright-platform-backend
-        entry: poetry -C autogpt_platform/backend run pyright
-        # include forge source (since it's a path dependency) but exclude *_test.py files:
-        files: ^autogpt_platform/(backend/((backend|test)/|(\w+\.py|poetry\.lock)$)|autogpt_libs/(autogpt_libs/.*(?<!_test)\.py|poetry\.lock)$)
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: pyright
-        name: Typecheck - AutoGPT Platform - Libs
-        alias: pyright-platform-libs
-        entry: poetry -C autogpt_platform/autogpt_libs run pyright
-        files: ^autogpt_platform/autogpt_libs/(autogpt_libs/|poetry\.lock$)
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: pyright
-        name: Typecheck - Classic - AutoGPT
-        alias: pyright-classic-autogpt
+        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/(forge/.*(?<!_test)\.py|poetry\.lock)$)
+        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 - Classic - Forge
-        alias: pyright-classic-forge
+        name: Typecheck - Forge
+        alias: pyright-forge
         entry: poetry -C classic/forge run pyright
-        files: ^classic/forge/(forge/|poetry\.lock$)
+        args: [-p, forge, forge]
+        files: ^classic/forge/(classic/forge/|poetry\.lock$)
         types: [file]
         language: system
         pass_filenames: false
 
       - id: pyright
-        name: Typecheck - Classic - Benchmark
-        alias: pyright-classic-benchmark
+        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
@@ -233,45 +104,23 @@ repos:
 
   - repo: local
     hooks:
-      - id: tsc
-        name: Typecheck - AutoGPT Platform - Frontend
-        entry: bash -c 'cd autogpt_platform/frontend && npm run type-check'
-        files: ^autogpt_platform/frontend/
-        types: [file]
-        language: system
-        pass_filenames: false
-
-  - repo: local
-    hooks:
-      - id: pytest
-        name: Run tests - AutoGPT Platform - Backend
-        alias: pytest-platform-backend
-        entry: bash -c 'cd autogpt_platform/backend && poetry run pytest'
-        # include autogpt_libs source (since it's a path dependency) but exclude *_test.py files:
-        files: ^autogpt_platform/(backend/((backend|test)/|poetry\.lock$)|autogpt_libs/(autogpt_libs/.*(?<!_test)\.py|poetry\.lock)$)
-        language: system
-        pass_filenames: false
-
-      - id: pytest
-        name: Run tests - Classic - AutoGPT (excl. slow tests)
-        alias: pytest-classic-autogpt
+      - 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/(forge/.*(?<!_test)\.py|poetry\.lock)$)
+        files: ^(classic/original_autogpt/((autogpt|tests)/|poetry\.lock$)|classic/forge/(classic/forge/.*(?<!_test)\.py|poetry\.lock)$)
         language: system
         pass_filenames: false
 
-      - id: pytest
-        name: Run tests - Classic - Forge (excl. slow tests)
-        alias: pytest-classic-forge
+      - 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/(forge/|tests/|poetry\.lock$)
+        files: ^classic/forge/(classic/forge/|tests/|poetry\.lock$)
         language: system
         pass_filenames: false
 
-      - id: pytest
-        name: Run tests - Classic - Benchmark
-        alias: pytest-classic-benchmark
+      - 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

.vscode/launch.json

@@ -1,67 +0,0 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "name": "Frontend: Server Side",
-      "type": "node-terminal",
-      "request": "launch",
-      "cwd": "${workspaceFolder}/autogpt_platform/frontend",
-      "command": "yarn dev"
-    },
-    {
-      "name": "Frontend: Client Side",
-      "type": "msedge",
-      "request": "launch",
-      "url": "http://localhost:3000"
-    },
-    {
-      "name": "Frontend: Full Stack",
-      "type": "node-terminal",
-
-      "request": "launch",
-      "command": "yarn dev",
-      "cwd": "${workspaceFolder}/autogpt_platform/frontend",
-      "serverReadyAction": {
-        "pattern": "- Local:.+(https?://.+)",
-        "uriFormat": "%s",
-        "action": "debugWithEdge"
-      }
-    },
-    {
-      "name": "Backend",
-      "type": "debugpy",
-      "request": "launch",
-      "module": "backend.app",
-      // "env": {
-      //   "ENV": "dev"
-      // },
-      "envFile": "${workspaceFolder}/backend/.env",
-      "justMyCode": false,
-      "cwd": "${workspaceFolder}/autogpt_platform/backend"
-    },
-    {
-      "name": "Marketplace",
-      "type": "debugpy",
-      "request": "launch",
-      "module": "autogpt_platform.market.main",
-      "env": {
-        "ENV": "dev"
-      },
-      "envFile": "${workspaceFolder}/market/.env",
-      "justMyCode": false,
-      "cwd": "${workspaceFolder}/market"
-    }
-  ],
-  "compounds": [
-    {
-      "name": "Everything",
-      "configurations": ["Backend", "Frontend: Full Stack"],
-      // "preLaunchTask": "${defaultBuildTask}",
-      "stopAll": true,
-      "presentation": {
-        "hidden": false,
-        "order": 0
-      }
-    }
-  ]
-}

CONTRIBUTING.md

@@ -2,13 +2,16 @@
 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. All contributions to other folders will be under the MIT license.
+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.

LICENSE

@@ -1,13 +1,7 @@
-All portions of this repository are under one of two licenses. The majority of the AutoGPT repository is under the MIT License below. The autogpt_platform folder is under the
-Polyform Shield License. 
-
-
 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
@@ -15,11 +9,9 @@ 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

README.md

@@ -15,11 +15,7 @@
 > 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.
 
-### Updated Setup Instructions:
-We’ve moved to a fully maintained and regularly updated documentation site.
-
-👉 [Follow the official self-hosting guide here](https://docs.agpt.co/platform/getting-started/)
-
+https://github.com/user-attachments/assets/d04273a5-b36a-4a37-818e-f631ce72d603
 
 This tutorial assumes you have Docker, VSCode, git and npm installed.
 
@@ -39,7 +35,7 @@ The AutoGPT frontend is where users interact with our powerful AI automation pla
 
    **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/platform/new_blocks/) to learn how to build your own custom blocks.
+[Read this guide](https://docs.agpt.co/server/new_blocks/) to learn how to build your own custom blocks.
 
 ### 💽 AutoGPT Server
 
@@ -69,7 +65,6 @@ Here are two examples of what you can do with AutoGPT:
 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.
 
 ---
-### Mission and Licencing
 Our mission is to provide the tools, so that you can focus on what matters:
 
 - 🏗️ **Building** - Lay the foundation for something amazing.
@@ -82,13 +77,6 @@ Be part of the revolution! **AutoGPT** is here to stay, at the forefront of AI i
  | 
 **🚀 [Contributing](CONTRIBUTING.md)**
 
-**Licensing:**
-
-MIT License: The majority of the AutoGPT repository is under the MIT License.
-
-Polyform Shield License: This license applies to the autogpt_platform folder. 
-
-For more information, see https://agpt.co/blog/introducing-the-autogpt-platform
 
 ---
 ## 🤖 AutoGPT Classic
@@ -113,7 +101,7 @@ This guide will walk you through the process of creating your own agent and usin
 
 📦 [`agbenchmark`](https://pypi.org/project/agbenchmark/) on Pypi
  | 
-📘 [Learn More](https://github.com/Significant-Gravitas/AutoGPT/tree/master/classic/benchmark) about the Benchmark
+📘 [Learn More](https://github.com/Significant-Gravitas/AutoGPT/blob/master/benchmark) about the Benchmark
 
 ### 💻 UI
 
@@ -162,8 +150,6 @@ To maintain a uniform standard and ensure seamless compatibility with many curre
 
 ---
 
-## Stars stats
-
 <p align="center">
 <a href="https://star-history.com/#Significant-Gravitas/AutoGPT">
   <picture>
@@ -173,10 +159,3 @@ To maintain a uniform standard and ensure seamless compatibility with many curre
   </picture>
 </a>
 </p>
-
-
-## ⚡ Contributors
-
-<a href="https://github.com/Significant-Gravitas/AutoGPT/graphs/contributors" alt="View Contributors">
-  <img src="https://contrib.rocks/image?repo=Significant-Gravitas/AutoGPT&max=1000&columns=10" alt="Contributors" />
-</a>

SECURITY.md

@@ -1,48 +0,0 @@
-# Security Policy
-
-## Reporting Security Issues
-
-We take the security of our project seriously. If you believe you have found a security vulnerability, please report it to us privately. **Please do not report security vulnerabilities through public GitHub issues, discussions, or pull requests.**
-
-> **Important Note**: Any code within the `classic/` folder is considered legacy, unsupported, and out of scope for security reports. We will not address security vulnerabilities in this deprecated code.
-
-Instead, please report them via:
-- [GitHub Security Advisory](https://github.com/Significant-Gravitas/AutoGPT/security/advisories/new)
-<!--- [Huntr.dev](https://huntr.com/repos/significant-gravitas/autogpt) - where you may be eligible for a bounty-->
-
-### Reporting Process
-1. **Submit Report**: Use one of the above channels to submit your report
-2. **Response Time**: Our team will acknowledge receipt of your report within 14 business days.
-3. **Collaboration**: We will collaborate with you to understand and validate the issue
-4. **Resolution**: We will work on a fix and coordinate the release process
-
-### Disclosure Policy
-- Please provide detailed reports with reproducible steps
-- Include the version/commit hash where you discovered the vulnerability
-- Allow us a 90-day security fix window before any public disclosure
-- After patch is released, allow 30 days for users to update before public disclosure (for a total of 120 days max between update time and fix time)
-- Share any potential mitigations or workarounds if known
-
-## Supported Versions
-Only the following versions are eligible for security updates:
-
-| Version | Supported |
-|---------|-----------|
-| Latest release on master branch | ✅ |
-| Development commits (pre-master) | ✅ |
-| Classic folder (deprecated) | ❌ |
-| All other versions | ❌ |
-
-## Security Best Practices
-When using this project:
-1. Always use the latest stable version
-2. Review security advisories before updating
-3. Follow our security documentation and guidelines
-4. Keep your dependencies up to date
-5. Do not use code from the `classic/` folder as it is deprecated and unsupported
-
-## Past Security Advisories
-For a list of past security advisories, please visit our [Security Advisory Page](https://github.com/Significant-Gravitas/AutoGPT/security/advisories) and [Huntr Disclosures Page](https://huntr.com/repos/significant-gravitas/autogpt).
-
----
-Last updated: November 2024

autogpt_platform/.env.example

@@ -1,123 +0,0 @@
-############
-# Secrets
-# YOU MUST CHANGE THESE BEFORE GOING INTO PRODUCTION
-############
-
-POSTGRES_PASSWORD=your-super-secret-and-long-postgres-password
-JWT_SECRET=your-super-secret-jwt-token-with-at-least-32-characters-long
-ANON_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJhbm9uIiwKICAgICJpc3MiOiAic3VwYWJhc2UtZGVtbyIsCiAgICAiaWF0IjogMTY0MTc2OTIwMCwKICAgICJleHAiOiAxNzk5NTM1NjAwCn0.dc_X5iR_VP_qT0zsiyj_I_OZ2T9FtRU2BBNWN8Bu4GE
-SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJzZXJ2aWNlX3JvbGUiLAogICAgImlzcyI6ICJzdXBhYmFzZS1kZW1vIiwKICAgICJpYXQiOiAxNjQxNzY5MjAwLAogICAgImV4cCI6IDE3OTk1MzU2MDAKfQ.DaYlNEoUrrEn2Ig7tqibS-PHK5vgusbcbo7X36XVt4Q
-DASHBOARD_USERNAME=supabase
-DASHBOARD_PASSWORD=this_password_is_insecure_and_should_be_updated
-SECRET_KEY_BASE=UpNVntn3cDxHJpq99YMc1T1AQgQpc8kfYTuRgBiYa15BLrx8etQoXz3gZv1/u2oq
-VAULT_ENC_KEY=your-encryption-key-32-chars-min
-
-
-############
-# Database - You can change these to any PostgreSQL database that has logical replication enabled.
-############
-
-POSTGRES_HOST=db
-POSTGRES_DB=postgres
-POSTGRES_PORT=5432
-# default user is postgres
-
-
-############
-# Supavisor -- Database pooler
-############
-POOLER_PROXY_PORT_TRANSACTION=6543
-POOLER_DEFAULT_POOL_SIZE=20
-POOLER_MAX_CLIENT_CONN=100
-POOLER_TENANT_ID=your-tenant-id
-
-
-############
-# API Proxy - Configuration for the Kong Reverse proxy.
-############
-
-KONG_HTTP_PORT=8000
-KONG_HTTPS_PORT=8443
-
-
-############
-# API - Configuration for PostgREST.
-############
-
-PGRST_DB_SCHEMAS=public,storage,graphql_public
-
-
-############
-# Auth - Configuration for the GoTrue authentication server.
-############
-
-## General
-SITE_URL=http://localhost:3000
-ADDITIONAL_REDIRECT_URLS=
-JWT_EXPIRY=3600
-DISABLE_SIGNUP=false
-API_EXTERNAL_URL=http://localhost:8000
-
-## Mailer Config
-MAILER_URLPATHS_CONFIRMATION="/auth/v1/verify"
-MAILER_URLPATHS_INVITE="/auth/v1/verify"
-MAILER_URLPATHS_RECOVERY="/auth/v1/verify"
-MAILER_URLPATHS_EMAIL_CHANGE="/auth/v1/verify"
-
-## Email auth
-ENABLE_EMAIL_SIGNUP=true
-ENABLE_EMAIL_AUTOCONFIRM=false
-SMTP_ADMIN_EMAIL=admin@example.com
-SMTP_HOST=supabase-mail
-SMTP_PORT=2500
-SMTP_USER=fake_mail_user
-SMTP_PASS=fake_mail_password
-SMTP_SENDER_NAME=fake_sender
-ENABLE_ANONYMOUS_USERS=false
-
-## Phone auth
-ENABLE_PHONE_SIGNUP=true
-ENABLE_PHONE_AUTOCONFIRM=true
-
-
-############
-# Studio - Configuration for the Dashboard
-############
-
-STUDIO_DEFAULT_ORGANIZATION=Default Organization
-STUDIO_DEFAULT_PROJECT=Default Project
-
-STUDIO_PORT=3000
-# replace if you intend to use Studio outside of localhost
-SUPABASE_PUBLIC_URL=http://localhost:8000
-
-# Enable webp support
-IMGPROXY_ENABLE_WEBP_DETECTION=true
-
-# Add your OpenAI API key to enable SQL Editor Assistant
-OPENAI_API_KEY=
-
-
-############
-# Functions - Configuration for Functions
-############
-# NOTE: VERIFY_JWT applies to all functions. Per-function VERIFY_JWT is not supported yet.
-FUNCTIONS_VERIFY_JWT=false
-
-
-############
-# Logs - Configuration for Logflare
-# Please refer to https://supabase.com/docs/reference/self-hosting-analytics/introduction
-############
-
-LOGFLARE_LOGGER_BACKEND_API_KEY=your-super-secret-and-long-logflare-key
-
-# Change vector.toml sinks to reflect this change
-LOGFLARE_API_KEY=your-super-secret-and-long-logflare-key
-
-# Docker socket location - this value will differ depending on your OS
-DOCKER_SOCKET_LOCATION=/var/run/docker.sock
-
-# Google Cloud Project details
-GOOGLE_PROJECT_ID=GOOGLE_PROJECT_ID
-GOOGLE_PROJECT_NUMBER=GOOGLE_PROJECT_NUMBER

autogpt_platform/.gitignore

@@ -1,2 +0,0 @@
-*.ignore.*
-*.ign.*

autogpt_platform/README.md

@@ -22,29 +22,35 @@ To run the AutoGPT Platform, follow these steps:
 
 2. Run the following command:
    ```
-   cp .env.example .env
+   git submodule update --init --recursive
    ```
-   This command will copy the `.env.example` file to `.env`. You can modify the `.env` file to add your own environment variables.
+   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.
 
-4. Navigate to `frontend` within the `autogpt_platform` directory:
+5. Navigate to `frontend` within the `autogpt_platform` directory:
    ```
    cd frontend
    ```
    You will need to run your frontend application separately on your local machine.
 
-5. Run the following command: 
+6. Run the following command: 
    ```
-   cp .env.example .env.local
+   cp .env.example .env
    ```
-   This command will copy the `.env.example` file to `.env.local` in the `frontend` directory. You can modify the `.env.local` within this folder to add your own environment variables for the frontend application.
+   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.
 
-6. Run the following command:
+7. Run the following command:
    ```
    npm install
    npm run dev
@@ -55,7 +61,7 @@ To run the AutoGPT Platform, follow these steps:
    yarn install && yarn dev
    ```
 
-7. Open your browser and navigate to `http://localhost:3000` to access the AutoGPT Platform frontend.
+8. Open your browser and navigate to `http://localhost:3000` to access the AutoGPT Platform frontend.
 
 ### Docker Compose Commands
 
@@ -143,3 +149,6 @@ To persist data for PostgreSQL and Redis, you can modify the `docker-compose.yml
 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/autogpt_libs/api_key/key_manager.py

@@ -1,34 +0,0 @@
-import hashlib
-import secrets
-from typing import NamedTuple
-
-
-class APIKeyContainer(NamedTuple):
-    """Container for API key parts."""
-
-    raw: str
-    prefix: str
-    postfix: str
-    hash: str
-
-
-class APIKeyManager:
-    PREFIX: str = "agpt_"
-    PREFIX_LENGTH: int = 8
-    POSTFIX_LENGTH: int = 8
-
-    def generate_api_key(self) -> APIKeyContainer:
-        """Generate a new API key with all its parts."""
-        raw_key = f"{self.PREFIX}{secrets.token_urlsafe(32)}"
-        return APIKeyContainer(
-            raw=raw_key,
-            prefix=raw_key[: self.PREFIX_LENGTH],
-            postfix=raw_key[-self.POSTFIX_LENGTH :],
-            hash=hashlib.sha256(raw_key.encode()).hexdigest(),
-        )
-
-    def verify_api_key(self, provided_key: str, stored_hash: str) -> bool:
-        """Verify if a provided API key matches the stored hash."""
-        if not provided_key.startswith(self.PREFIX):
-            return False
-        return hashlib.sha256(provided_key.encode()).hexdigest() == stored_hash

autogpt_platform/autogpt_libs/autogpt_libs/auth/__init__.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/config.py

@@ -1,11 +1,14 @@
 import os
 
+from dotenv import load_dotenv
+
+load_dotenv()
+
 
 class Settings:
-    def __init__(self):
-        self.JWT_SECRET_KEY: str = os.getenv("SUPABASE_JWT_SECRET", "")
-        self.ENABLE_AUTH: bool = os.getenv("ENABLE_AUTH", "false").lower() == "true"
-        self.JWT_ALGORITHM: str = "HS256"
+    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:

autogpt_platform/autogpt_libs/autogpt_libs/auth/depends.py

@@ -1,8 +1,7 @@
 import fastapi
 
-from .config import settings
 from .middleware import auth_middleware
-from .models import DEFAULT_USER_ID, User
+from .models import User
 
 
 def requires_user(payload: dict = fastapi.Depends(auth_middleware)) -> User:
@@ -17,12 +16,8 @@ def requires_admin_user(
 
 def verify_user(payload: dict | None, admin_only: bool) -> User:
     if not payload:
-        if settings.ENABLE_AUTH:
-            raise fastapi.HTTPException(
-                status_code=401, detail="Authorization header is missing"
-            )
         # This handles the case when authentication is disabled
-        payload = {"sub": DEFAULT_USER_ID, "role": "admin"}
+        payload = {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "admin"}
 
     user_id = payload.get("sub")
 
@@ -35,12 +30,3 @@ def verify_user(payload: dict | None, admin_only: bool) -> User:
         raise fastapi.HTTPException(status_code=403, detail="Admin access required")
 
     return User.from_payload(payload)
-
-
-def get_user_id(payload: dict = fastapi.Depends(auth_middleware)) -> str:
-    user_id = payload.get("sub")
-    if not user_id:
-        raise fastapi.HTTPException(
-            status_code=401, detail="User ID not found in token"
-        )
-    return user_id

autogpt_platform/autogpt_libs/autogpt_libs/auth/middleware.py

@@ -1,10 +1,7 @@
-import inspect
 import logging
-from typing import Any, Callable, Optional
 
-from fastapi import HTTPException, Request, Security
-from fastapi.security import APIKeyHeader, HTTPBearer
-from starlette.status import HTTP_401_UNAUTHORIZED
+from fastapi import HTTPException, Request
+from fastapi.security import HTTPBearer
 
 from .config import settings
 from .jwt_utils import parse_jwt_token
@@ -32,104 +29,3 @@ async def auth_middleware(request: Request):
     except ValueError as e:
         raise HTTPException(status_code=401, detail=str(e))
     return payload
-
-
-class APIKeyValidator:
-    """
-    Configurable API key validator that supports custom validation functions
-    for FastAPI applications.
-
-    This class provides a flexible way to implement API key authentication with optional
-    custom validation logic. It can be used for simple token matching
-    or more complex validation scenarios like database lookups.
-
-    Examples:
-        Simple token validation:
-        ```python
-        validator = APIKeyValidator(
-            header_name="X-API-Key",
-            expected_token="your-secret-token"
-        )
-
-        @app.get("/protected", dependencies=[Depends(validator.get_dependency())])
-        def protected_endpoint():
-            return {"message": "Access granted"}
-        ```
-
-        Custom validation with database lookup:
-        ```python
-        async def validate_with_db(api_key: str):
-            api_key_obj = await db.get_api_key(api_key)
-            return api_key_obj if api_key_obj and api_key_obj.is_active else None
-
-        validator = APIKeyValidator(
-            header_name="X-API-Key",
-            validate_fn=validate_with_db
-        )
-        ```
-
-    Args:
-        header_name (str): The name of the header containing the API key
-        expected_token (Optional[str]): The expected API key value for simple token matching
-        validate_fn (Optional[Callable]): Custom validation function that takes an API key
-            string and returns a boolean or object. Can be async.
-        error_status (int): HTTP status code to use for validation errors
-        error_message (str): Error message to return when validation fails
-    """
-
-    def __init__(
-        self,
-        header_name: str,
-        expected_token: Optional[str] = None,
-        validate_fn: Optional[Callable[[str], bool]] = None,
-        error_status: int = HTTP_401_UNAUTHORIZED,
-        error_message: str = "Invalid API key",
-    ):
-        # Create the APIKeyHeader as a class property
-        self.security_scheme = APIKeyHeader(name=header_name)
-        self.expected_token = expected_token
-        self.custom_validate_fn = validate_fn
-        self.error_status = error_status
-        self.error_message = error_message
-
-    async def default_validator(self, api_key: str) -> bool:
-        return api_key == self.expected_token
-
-    async def __call__(
-        self, request: Request, api_key: str = Security(APIKeyHeader)
-    ) -> Any:
-        if api_key is None:
-            raise HTTPException(status_code=self.error_status, detail="Missing API key")
-
-        # Use custom validation if provided, otherwise use default equality check
-        validator = self.custom_validate_fn or self.default_validator
-        result = (
-            await validator(api_key)
-            if inspect.iscoroutinefunction(validator)
-            else validator(api_key)
-        )
-
-        if not result:
-            raise HTTPException(
-                status_code=self.error_status, detail=self.error_message
-            )
-
-        # Store validation result in request state if it's not just a boolean
-        if result is not True:
-            request.state.api_key = result
-
-        return result
-
-    def get_dependency(self):
-        """
-        Returns a callable dependency that FastAPI will recognize as a security scheme
-        """
-
-        async def validate_api_key(
-            request: Request, api_key: str = Security(self.security_scheme)
-        ) -> Any:
-            return await self(request, api_key)
-
-        # This helps FastAPI recognize it as a security dependency
-        validate_api_key.__name__ = f"validate_{self.security_scheme.model.name}"
-        return validate_api_key

autogpt_platform/autogpt_libs/autogpt_libs/auth/models.py

@@ -1,8 +1,5 @@
 from dataclasses import dataclass
 
-DEFAULT_USER_ID = "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
-DEFAULT_EMAIL = "default@example.com"
-
 
 # Using dataclass here to avoid adding dependency on pydantic
 @dataclass(frozen=True)

autogpt_platform/autogpt_libs/autogpt_libs/feature_flag/client.py

@@ -1,166 +0,0 @@
-import asyncio
-import contextlib
-import logging
-from functools import wraps
-from typing import Any, Awaitable, Callable, Dict, Optional, TypeVar, Union, cast
-
-import ldclient
-from fastapi import HTTPException
-from ldclient import Context, LDClient
-from ldclient.config import Config
-from typing_extensions import ParamSpec
-
-from .config import SETTINGS
-
-logger = logging.getLogger(__name__)
-
-P = ParamSpec("P")
-T = TypeVar("T")
-
-
-def get_client() -> LDClient:
-    """Get the LaunchDarkly client singleton."""
-    return ldclient.get()
-
-
-def initialize_launchdarkly() -> None:
-    sdk_key = SETTINGS.launch_darkly_sdk_key
-    logger.debug(
-        f"Initializing LaunchDarkly with SDK key: {'present' if sdk_key else 'missing'}"
-    )
-
-    if not sdk_key:
-        logger.warning("LaunchDarkly SDK key not configured")
-        return
-
-    config = Config(sdk_key)
-    ldclient.set_config(config)
-
-    if ldclient.get().is_initialized():
-        logger.info("LaunchDarkly client initialized successfully")
-    else:
-        logger.error("LaunchDarkly client failed to initialize")
-
-
-def shutdown_launchdarkly() -> None:
-    """Shutdown the LaunchDarkly client."""
-    if ldclient.get().is_initialized():
-        ldclient.get().close()
-        logger.info("LaunchDarkly client closed successfully")
-
-
-def create_context(
-    user_id: str, additional_attributes: Optional[Dict[str, Any]] = None
-) -> Context:
-    """Create LaunchDarkly context with optional additional attributes."""
-    builder = Context.builder(str(user_id)).kind("user")
-    if additional_attributes:
-        for key, value in additional_attributes.items():
-            builder.set(key, value)
-    return builder.build()
-
-
-def feature_flag(
-    flag_key: str,
-    default: bool = False,
-) -> Callable[
-    [Callable[P, Union[T, Awaitable[T]]]], Callable[P, Union[T, Awaitable[T]]]
-]:
-    """
-    Decorator for feature flag protected endpoints.
-    """
-
-    def decorator(
-        func: Callable[P, Union[T, Awaitable[T]]],
-    ) -> Callable[P, Union[T, Awaitable[T]]]:
-        @wraps(func)
-        async def async_wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-            try:
-                user_id = kwargs.get("user_id")
-                if not user_id:
-                    raise ValueError("user_id is required")
-
-                if not get_client().is_initialized():
-                    logger.warning(
-                        f"LaunchDarkly not initialized, using default={default}"
-                    )
-                    is_enabled = default
-                else:
-                    context = create_context(str(user_id))
-                    is_enabled = get_client().variation(flag_key, context, default)
-
-                if not is_enabled:
-                    raise HTTPException(status_code=404, detail="Feature not available")
-
-                result = func(*args, **kwargs)
-                if asyncio.iscoroutine(result):
-                    return await result
-                return cast(T, result)
-            except Exception as e:
-                logger.error(f"Error evaluating feature flag {flag_key}: {e}")
-                raise
-
-        @wraps(func)
-        def sync_wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-            try:
-                user_id = kwargs.get("user_id")
-                if not user_id:
-                    raise ValueError("user_id is required")
-
-                if not get_client().is_initialized():
-                    logger.warning(
-                        f"LaunchDarkly not initialized, using default={default}"
-                    )
-                    is_enabled = default
-                else:
-                    context = create_context(str(user_id))
-                    is_enabled = get_client().variation(flag_key, context, default)
-
-                if not is_enabled:
-                    raise HTTPException(status_code=404, detail="Feature not available")
-
-                return cast(T, func(*args, **kwargs))
-            except Exception as e:
-                logger.error(f"Error evaluating feature flag {flag_key}: {e}")
-                raise
-
-        return cast(
-            Callable[P, Union[T, Awaitable[T]]],
-            async_wrapper if asyncio.iscoroutinefunction(func) else sync_wrapper,
-        )
-
-    return decorator
-
-
-def percentage_rollout(
-    flag_key: str,
-    default: bool = False,
-) -> Callable[
-    [Callable[P, Union[T, Awaitable[T]]]], Callable[P, Union[T, Awaitable[T]]]
-]:
-    """Decorator for percentage-based rollouts."""
-    return feature_flag(flag_key, default)
-
-
-def beta_feature(
-    flag_key: Optional[str] = None,
-    unauthorized_response: Any = {"message": "Not available in beta"},
-) -> Callable[
-    [Callable[P, Union[T, Awaitable[T]]]], Callable[P, Union[T, Awaitable[T]]]
-]:
-    """Decorator for beta features."""
-    actual_key = f"beta-{flag_key}" if flag_key else "beta"
-    return feature_flag(actual_key, False)
-
-
-@contextlib.contextmanager
-def mock_flag_variation(flag_key: str, return_value: Any):
-    """Context manager for testing feature flags."""
-    original_variation = get_client().variation
-    get_client().variation = lambda key, context, default: (
-        return_value if key == flag_key else original_variation(key, context, default)
-    )
-    try:
-        yield
-    finally:
-        get_client().variation = original_variation

autogpt_platform/autogpt_libs/autogpt_libs/feature_flag/client_test.py

@@ -1,45 +0,0 @@
-import pytest
-from ldclient import LDClient
-
-from autogpt_libs.feature_flag.client import feature_flag, mock_flag_variation
-
-
-@pytest.fixture
-def ld_client(mocker):
-    client = mocker.Mock(spec=LDClient)
-    mocker.patch("ldclient.get", return_value=client)
-    client.is_initialized.return_value = True
-    return client
-
-
-@pytest.mark.asyncio
-async def test_feature_flag_enabled(ld_client):
-    ld_client.variation.return_value = True
-
-    @feature_flag("test-flag")
-    async def test_function(user_id: str):
-        return "success"
-
-    result = test_function(user_id="test-user")
-    assert result == "success"
-    ld_client.variation.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_feature_flag_unauthorized_response(ld_client):
-    ld_client.variation.return_value = False
-
-    @feature_flag("test-flag")
-    async def test_function(user_id: str):
-        return "success"
-
-    result = test_function(user_id="test-user")
-    assert result == {"error": "disabled"}
-
-
-def test_mock_flag_variation(ld_client):
-    with mock_flag_variation("test-flag", True):
-        assert ld_client.variation("test-flag", None, False)
-
-    with mock_flag_variation("test-flag", False):
-        assert ld_client.variation("test-flag", None, False)

autogpt_platform/autogpt_libs/autogpt_libs/feature_flag/config.py

@@ -1,15 +0,0 @@
-from pydantic import Field
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class Settings(BaseSettings):
-    launch_darkly_sdk_key: str = Field(
-        default="",
-        description="The Launch Darkly SDK key",
-        validation_alias="LAUNCH_DARKLY_SDK_KEY",
-    )
-
-    model_config = SettingsConfigDict(case_sensitive=True, extra="ignore")
-
-
-SETTINGS = Settings()

autogpt_platform/autogpt_libs/autogpt_libs/logging/config.py

@@ -6,9 +6,8 @@ from pathlib import Path
 
 from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
-
 from .filters import BelowLevelFilter
-from .formatters import AGPTFormatter
+from .formatters import AGPTFormatter, StructuredLoggingFormatter
 
 LOG_DIR = Path(__file__).parent.parent.parent.parent / "logs"
 LOG_FILE = "activity.log"
@@ -18,11 +17,12 @@ 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"
+    "%(asctime)s %(levelname)s %(filename)s:%(lineno)d" "  %(title)s%(message)s"
 )
 
 
 class LoggingConfig(BaseSettings):
+
     level: str = Field(
         default="INFO",
         description="Logging level",
@@ -81,26 +81,9 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
     """
 
     config = LoggingConfig()
+
     log_handlers: list[logging.Handler] = []
 
-    # 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]
-
     # Cloud logging setup
     if config.enable_cloud_logging or force_cloud_logging:
         import google.cloud.logging
@@ -114,7 +97,28 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
             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:
@@ -152,6 +156,7 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
         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(

autogpt_platform/autogpt_libs/autogpt_libs/logging/formatters.py

@@ -1,6 +1,7 @@
 import logging
 
 from colorama import Fore, Style
+from google.cloud.logging_v2.handlers import CloudLoggingFilter, StructuredLogHandler
 
 from .utils import remove_color_codes
 
@@ -79,3 +80,16 @@ class AGPTFormatter(FancyConsoleFormatter):
             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/test_utils.py

@@ -24,10 +24,10 @@ from .utils import remove_color_codes
         ),
         ("", ""),
         ("hello", "hello"),
-        ("hello\x1b[31m world", "hello world"),
-        ("\x1b[36mHello,\x1b[32m World!", "Hello, World!"),
+        ("hello\x1B[31m world", "hello world"),
+        ("\x1B[36mHello,\x1B[32m World!", "Hello, World!"),
         (
-            "\x1b[1m\x1b[31mError:\x1b[0m\x1b[31m file not found",
+            "\x1B[1m\x1B[31mError:\x1B[0m\x1B[31m file not found",
             "Error: file not found",
         ),
     ],

autogpt_platform/autogpt_libs/autogpt_libs/logging/utils.py

@@ -2,7 +2,6 @@ import logging
 import re
 from typing import Any
 
-import uvicorn.config
 from colorama import Fore
 
 
@@ -26,14 +25,3 @@ def print_attribute(
             "color": value_color,
         },
     )
-
-
-def generate_uvicorn_config():
-    """
-    Generates a uvicorn logging config that silences uvicorn's default logging and tells it to use the native logging module.
-    """
-    log_config = dict(uvicorn.config.LOGGING_CONFIG)
-    log_config["loggers"]["uvicorn"] = {"handlers": []}
-    log_config["loggers"]["uvicorn.error"] = {"handlers": []}
-    log_config["loggers"]["uvicorn.access"] = {"handlers": []}
-    return log_config

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/config.py

@@ -1,31 +0,0 @@
-from pydantic import Field
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class RateLimitSettings(BaseSettings):
-    redis_host: str = Field(
-        default="redis://localhost:6379",
-        description="Redis host",
-        validation_alias="REDIS_HOST",
-    )
-
-    redis_port: str = Field(
-        default="6379", description="Redis port", validation_alias="REDIS_PORT"
-    )
-
-    redis_password: str = Field(
-        default="password",
-        description="Redis password",
-        validation_alias="REDIS_PASSWORD",
-    )
-
-    requests_per_minute: int = Field(
-        default=60,
-        description="Maximum number of requests allowed per minute per API key",
-        validation_alias="RATE_LIMIT_REQUESTS_PER_MINUTE",
-    )
-
-    model_config = SettingsConfigDict(case_sensitive=True, extra="ignore")
-
-
-RATE_LIMIT_SETTINGS = RateLimitSettings()

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/limiter.py

@@ -1,51 +0,0 @@
-import time
-from typing import Tuple
-
-from redis import Redis
-
-from .config import RATE_LIMIT_SETTINGS
-
-
-class RateLimiter:
-    def __init__(
-        self,
-        redis_host: str = RATE_LIMIT_SETTINGS.redis_host,
-        redis_port: str = RATE_LIMIT_SETTINGS.redis_port,
-        redis_password: str = RATE_LIMIT_SETTINGS.redis_password,
-        requests_per_minute: int = RATE_LIMIT_SETTINGS.requests_per_minute,
-    ):
-        self.redis = Redis(
-            host=redis_host,
-            port=int(redis_port),
-            password=redis_password,
-            decode_responses=True,
-        )
-        self.window = 60
-        self.max_requests = requests_per_minute
-
-    async def check_rate_limit(self, api_key_id: str) -> Tuple[bool, int, int]:
-        """
-        Check if request is within rate limits.
-
-        Args:
-            api_key_id: The API key identifier to check
-
-        Returns:
-            Tuple of (is_allowed, remaining_requests, reset_time)
-        """
-        now = time.time()
-        window_start = now - self.window
-        key = f"ratelimit:{api_key_id}:1min"
-
-        pipe = self.redis.pipeline()
-        pipe.zremrangebyscore(key, 0, window_start)
-        pipe.zadd(key, {str(now): now})
-        pipe.zcount(key, window_start, now)
-        pipe.expire(key, self.window)
-
-        _, _, request_count, _ = pipe.execute()
-
-        remaining = max(0, self.max_requests - request_count)
-        reset_time = int(now + self.window)
-
-        return request_count <= self.max_requests, remaining, reset_time

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/middleware.py

@@ -1,32 +0,0 @@
-from fastapi import HTTPException, Request
-from starlette.middleware.base import RequestResponseEndpoint
-
-from .limiter import RateLimiter
-
-
-async def rate_limit_middleware(request: Request, call_next: RequestResponseEndpoint):
-    """FastAPI middleware for rate limiting API requests."""
-    limiter = RateLimiter()
-
-    if not request.url.path.startswith("/api"):
-        return await call_next(request)
-
-    api_key = request.headers.get("Authorization")
-    if not api_key:
-        return await call_next(request)
-
-    api_key = api_key.replace("Bearer ", "")
-
-    is_allowed, remaining, reset_time = await limiter.check_rate_limit(api_key)
-
-    if not is_allowed:
-        raise HTTPException(
-            status_code=429, detail="Rate limit exceeded. Please try again later."
-        )
-
-    response = await call_next(request)
-    response.headers["X-RateLimit-Limit"] = str(limiter.max_requests)
-    response.headers["X-RateLimit-Remaining"] = str(remaining)
-    response.headers["X-RateLimit-Reset"] = str(reset_time)
-
-    return response

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

@@ -56,8 +56,6 @@ class OAuthState(BaseModel):
     token: str
     provider: str
     expires_at: int
-    code_verifier: Optional[str] = None
-    scopes: list[str]
     """Unix timestamp (seconds) indicating when this OAuth state expires"""
 
 
@@ -69,8 +67,3 @@ class UserMetadata(BaseModel):
 class UserMetadataRaw(TypedDict, total=False):
     integration_credentials: list[dict]
     integration_oauth_states: list[dict]
-
-
-class UserIntegrations(BaseModel):
-    credentials: list[Credentials] = Field(default_factory=list)
-    oauth_states: list[OAuthState] = Field(default_factory=list)

autogpt_platform/autogpt_libs/autogpt_libs/utils/cache.py

@@ -1,20 +0,0 @@
-import threading
-from typing import Callable, ParamSpec, TypeVar
-
-P = ParamSpec("P")
-R = TypeVar("R")
-
-
-def thread_cached(func: Callable[P, R]) -> Callable[P, R]:
-    thread_local = threading.local()
-
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-        cache = getattr(thread_local, "cache", None)
-        if cache is None:
-            cache = thread_local.cache = {}
-        key = (args, tuple(sorted(kwargs.items())))
-        if key not in cache:
-            cache[key] = func(*args, **kwargs)
-        return cache[key]
-
-    return wrapper

autogpt_platform/autogpt_libs/autogpt_libs/utils/synchronize.py

@@ -1,57 +0,0 @@
-from contextlib import contextmanager
-from threading import Lock
-from typing import TYPE_CHECKING, Any
-
-from expiringdict import ExpiringDict
-
-if TYPE_CHECKING:
-    from redis import Redis
-    from redis.lock import Lock as RedisLock
-
-
-class RedisKeyedMutex:
-    """
-    This class provides a mutex that can be locked and unlocked by a specific key,
-    using Redis as a distributed locking provider.
-    It uses an ExpiringDict to automatically clear the mutex after a specified timeout,
-    in case the key is not unlocked for a specified duration, to prevent memory leaks.
-    """
-
-    def __init__(self, redis: "Redis", timeout: int | None = 60):
-        self.redis = redis
-        self.timeout = timeout
-        self.locks: dict[Any, "RedisLock"] = ExpiringDict(
-            max_len=6000, max_age_seconds=self.timeout
-        )
-        self.locks_lock = Lock()
-
-    @contextmanager
-    def locked(self, key: Any):
-        lock = self.acquire(key)
-        try:
-            yield
-        finally:
-            if lock.locked():
-                lock.release()
-
-    def acquire(self, key: Any) -> "RedisLock":
-        """Acquires and returns a lock with the given key"""
-        with self.locks_lock:
-            if key not in self.locks:
-                self.locks[key] = self.redis.lock(
-                    str(key), self.timeout, thread_local=False
-                )
-            lock = self.locks[key]
-        lock.acquire()
-        return lock
-
-    def release(self, key: Any):
-        if (lock := self.locks.get(key)) and lock.locked() and lock.owned():
-            lock.release()
-
-    def release_all_locks(self):
-        """Call this on process termination to ensure all locks are released"""
-        self.locks_lock.acquire(blocking=False)
-        for lock in self.locks.values():
-            if lock.locked() and lock.owned():
-                lock.release()

autogpt_platform/autogpt_libs/pyproject.toml

@@ -8,26 +8,14 @@ packages = [{ include = "autogpt_libs" }]
 
 [tool.poetry.dependencies]
 colorama = "^0.4.6"
-expiringdict = "^1.2.2"
-google-cloud-logging = "^3.11.4"
-pydantic = "^2.11.1"
-pydantic-settings = "^2.8.1"
-pyjwt = "^2.10.1"
-pytest-asyncio = "^0.26.0"
-pytest-mock = "^3.14.0"
+google-cloud-logging = "^3.8.0"
+pydantic = "^2.8.2"
+pydantic-settings = "^2.5.2"
+pyjwt = "^2.8.0"
 python = ">=3.10,<4.0"
-supabase = "^2.15.0"
-
-[tool.poetry.group.dev.dependencies]
-redis = "^5.2.1"
-ruff = "^0.11.0"
+python-dotenv = "^1.0.1"
+supabase = "^2.7.2"
 
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
-
-[tool.ruff]
-line-length = 88
-
-[tool.ruff.lint]
-extend-select = ["I"]  # sort dependencies

autogpt_platform/backend/.env.example

@@ -2,69 +2,29 @@ DB_USER=postgres
 DB_PASS=your-super-secret-and-long-postgres-password
 DB_NAME=postgres
 DB_PORT=5432
-DB_HOST=localhost
-DB_CONNECTION_LIMIT=12
-DB_CONNECT_TIMEOUT=60
-DB_POOL_TIMEOUT=300
-DB_SCHEMA=platform
-DATABASE_URL="postgresql://${DB_USER}:${DB_PASS}@${DB_HOST}:${DB_PORT}/${DB_NAME}?schema=${DB_SCHEMA}&connect_timeout=${DB_CONNECT_TIMEOUT}"
+DATABASE_URL="postgresql://${DB_USER}:${DB_PASS}@localhost:${DB_PORT}/${DB_NAME}?connect_timeout=60&schema=platform"
 PRISMA_SCHEMA="postgres/schema.prisma"
 
-# EXECUTOR
-NUM_GRAPH_WORKERS=10
-NUM_NODE_WORKERS=3
-
 BACKEND_CORS_ALLOW_ORIGINS=["http://localhost:3000"]
 
-# generate using `from cryptography.fernet import Fernet;Fernet.generate_key().decode()`
-ENCRYPTION_KEY='dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw='
-UNSUBSCRIBE_SECRET_KEY = 'HlP8ivStJjmbf6NKi78m_3FnOogut0t5ckzjsIqeaio='
-
 REDIS_HOST=localhost
 REDIS_PORT=6379
 REDIS_PASSWORD=password
 
 ENABLE_CREDIT=false
-STRIPE_API_KEY=
-STRIPE_WEBHOOK_SECRET=
-
-# What environment things should be logged under: local dev or prod
-APP_ENV=local
-# What environment to behave as: "local" or "cloud"
-BEHAVE_AS=local
+APP_ENV="local"
 PYRO_HOST=localhost
 SENTRY_DSN=
 
-# Email For Postmark so we can send emails
-POSTMARK_SERVER_API_TOKEN=
-POSTMARK_SENDER_EMAIL=invalid@invalid.com
-POSTMARK_WEBHOOK_TOKEN=
-
 ## User auth with Supabase is required for any of the 3rd party integrations with auth to work.
-ENABLE_AUTH=true
+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
 
-# RabbitMQ credentials -- Used for communication between services
-RABBITMQ_HOST=localhost
-RABBITMQ_PORT=5672
-RABBITMQ_DEFAULT_USER=rabbitmq_user_default
-RABBITMQ_DEFAULT_PASS=k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7
-
-## GCS bucket is required for marketplace and library functionality
-MEDIA_GCS_BUCKET_NAME=
-
-## For local development, you may need to set FRONTEND_BASE_URL for the OAuth flow
-## for integrations to work. Defaults to the value of PLATFORM_BASE_URL if not set.
+# 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
 
-## PLATFORM_BASE_URL must be set to a *publicly accessible* URL pointing to your backend
-## to use the platform's webhook-related functionality.
-## If you are developing locally, you can use something like ngrok to get a publc URL
-## and tunnel it to your locally running backend.
-PLATFORM_BASE_URL=http://localhost:3000
-
 ## == INTEGRATION CREDENTIALS == ##
 # Each set of server side credentials is required for the corresponding 3rd party
 # integration to work.
@@ -76,59 +36,18 @@ PLATFORM_BASE_URL=http://localhost:3000
 GITHUB_CLIENT_ID=
 GITHUB_CLIENT_SECRET=
 
-# Google OAuth App server credentials - https://console.cloud.google.com/apis/credentials, and enable gmail api and set scopes
-# https://console.cloud.google.com/apis/credentials/consent ?project=<your_project_id>
-
-# You'll need to add/enable the following scopes (minimum):
-# https://console.developers.google.com/apis/api/gmail.googleapis.com/overview ?project=<your_project_id>
-# https://console.cloud.google.com/apis/library/sheets.googleapis.com/ ?project=<your_project_id>
-GOOGLE_CLIENT_ID=
-GOOGLE_CLIENT_SECRET=
-
-# Twitter (X) OAuth 2.0 with PKCE Configuration
-# 1. Create a Twitter Developer Account:
-#    - Visit https://developer.x.com/en and sign up
-# 2. Set up your application:
-#    - Navigate to Developer Portal > Projects > Create Project
-#    - Add a new app to your project
-# 3. Configure app settings:
-#    - App Permissions: Read + Write + Direct Messages
-#    - App Type: Web App, Automated App or Bot
-#    - OAuth 2.0 Callback URL: http://localhost:3000/auth/integrations/oauth_callback
-#    - Save your Client ID and Client Secret below
-TWITTER_CLIENT_ID=
-TWITTER_CLIENT_SECRET=
-
-# Linear App
-# Make a new workspace for your OAuth APP -- trust me
-# https://linear.app/settings/api/applications/new
-# Callback URL: http://localhost:3000/auth/integrations/oauth_callback
-LINEAR_CLIENT_ID=
-LINEAR_CLIENT_SECRET=
-
-# To obtain Todoist API credentials:
-# 1. Create a Todoist account at todoist.com
-# 2. Visit the Developer Console: https://developer.todoist.com/appconsole.html
-# 3. Click "Create new app"
-# 4. Once created, copy your Client ID and Client Secret below
-TODOIST_CLIENT_ID=
-TODOIST_CLIENT_SECRET=
-
 ## ===== OPTIONAL API KEYS ===== ##
 
 # LLM
 OPENAI_API_KEY=
 ANTHROPIC_API_KEY=
 GROQ_API_KEY=
-OPEN_ROUTER_API_KEY=
 
 # Reddit
-# Go to https://www.reddit.com/prefs/apps and create a new app
-# Choose "script" for the type
-# Fill in the redirect uri as <your_frontend_url>/auth/integrations/oauth_callback, e.g. http://localhost:3000/auth/integrations/oauth_callback
 REDDIT_CLIENT_ID=
 REDDIT_CLIENT_SECRET=
-REDDIT_USER_AGENT="AutoGPT:1.0 (by /u/autogpt)"
+REDDIT_USERNAME=
+REDDIT_PASSWORD=
 
 # Discord
 DISCORD_BOT_TOKEN=
@@ -161,35 +80,6 @@ GOOGLE_MAPS_API_KEY=
 # Replicate
 REPLICATE_API_KEY=
 
-# Ideogram
-IDEOGRAM_API_KEY=
-
-# Fal
-FAL_API_KEY=
-
-# Exa
-EXA_API_KEY=
-
-# E2B
-E2B_API_KEY=
-
-# Mem0
-MEM0_API_KEY=
-
-# Nvidia
-NVIDIA_API_KEY=
-
-# Apollo
-APOLLO_API_KEY=
-
-# SmartLead
-SMARTLEAD_API_KEY=
-
-# ZeroBounce
-ZEROBOUNCE_API_KEY=
-
-## ===== OPTIONAL API KEYS END ===== ##
-
 # Logging Configuration
 LOG_LEVEL=INFO
 ENABLE_CLOUD_LOGGING=false

autogpt_platform/backend/.gitignore

@@ -5,7 +5,4 @@ dev.db-journal
 build/
 config.json
 secrets/*
-!secrets/.gitkeep
-
-*.ignore.*
-*.ign.*
+!secrets/.gitkeep

autogpt_platform/backend/Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.11.10-slim-bookworm AS builder
+FROM python:3.11-slim-buster AS builder
 
 # Set environment variables
 ENV PYTHONDONTWRITEBYTECODE 1
@@ -6,21 +6,17 @@ ENV PYTHONUNBUFFERED 1
 
 WORKDIR /app
 
-RUN echo 'Acquire::http::Pipeline-Depth 0;\nAcquire::http::No-Cache true;\nAcquire::BrokenProxy true;\n' > /etc/apt/apt.conf.d/99fixbadproxy
-
-RUN apt-get update --allow-releaseinfo-change --fix-missing
-
 # Install build dependencies
-RUN apt-get install -y build-essential 
-RUN apt-get install -y libpq5
-RUN apt-get install -y libz-dev
-RUN apt-get install -y libssl-dev
-RUN apt-get install -y postgresql-client
+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_HOME=/opt/poetry
-ENV POETRY_NO_INTERACTION=1
-ENV POETRY_VIRTUALENVS_CREATE=false
-ENV PATH=/opt/poetry/bin:$PATH
+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
@@ -31,20 +27,24 @@ RUN pip3 install poetry
 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 install --no-ansi --no-root
+RUN poetry config virtualenvs.create false \
+    && poetry install --no-interaction --no-ansi
 
 # Generate Prisma client
 COPY autogpt_platform/backend/schema.prisma ./
-RUN poetry run prisma generate
+RUN poetry config virtualenvs.create false \
+    && poetry run prisma generate
 
-FROM python:3.11.10-slim-bookworm AS server_dependencies
+FROM python:3.11-slim-buster AS server_dependencies
 
 WORKDIR /app
 
-ENV POETRY_HOME=/opt/poetry \
+ENV POETRY_VERSION=1.8.3 \
+    POETRY_HOME="/opt/poetry" \
     POETRY_NO_INTERACTION=1 \
-    POETRY_VIRTUALENVS_CREATE=false
-ENV PATH=/opt/poetry/bin:$PATH
+    POETRY_VIRTUALENVS_CREATE=false \
+    PATH="$POETRY_HOME/bin:$PATH"
+
 
 # Upgrade pip and setuptools to fix security vulnerabilities
 RUN pip3 install --upgrade pip setuptools
@@ -71,7 +71,6 @@ WORKDIR /app/autogpt_platform/backend
 FROM server_dependencies AS server
 
 COPY autogpt_platform/backend /app/autogpt_platform/backend
-RUN poetry install --no-ansi --only-root
 
 ENV DATABASE_URL=""
 ENV PORT=8000

autogpt_platform/backend/README.advanced.md

@@ -1 +1,75 @@
-[Advanced Setup (Dev Branch)](https://dev-docs.agpt.co/platform/advanced_setup/#autogpt_agent_server_advanced_set_up)
+# 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

@@ -1 +1,202 @@
-[Getting Started (Released)](https://docs.agpt.co/platform/getting-started/#autogpt_agent_server)
+# 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

@@ -1,30 +1,22 @@
-import logging
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from backend.util.process import AppProcess
 
-logger = logging.getLogger(__name__)
-
 
 def run_processes(*processes: "AppProcess", **kwargs):
     """
     Execute all processes in the app. The last process is run in the foreground.
-    Includes enhanced error handling and process lifecycle management.
     """
     try:
-        # Run all processes except the last one in the background.
         for process in processes[:-1]:
             process.start(background=True, **kwargs)
 
-        # Run the last process in the foreground.
+        # Run the last process in the foreground
         processes[-1].start(background=False, **kwargs)
     finally:
         for process in processes:
-            try:
-                process.stop()
-            except Exception as e:
-                logger.exception(f"[{process.service_name}] unable to stop: {e}")
+            process.stop()
 
 
 def main(**kwargs):
@@ -32,16 +24,12 @@ def main(**kwargs):
     Run all the processes required for the AutoGPT-server (REST and WebSocket APIs).
     """
 
-    from backend.executor import DatabaseManager, ExecutionManager, Scheduler
-    from backend.notifications import NotificationManager
-    from backend.server.rest_api import AgentServer
-    from backend.server.ws_api import WebsocketServer
+    from backend.executor import ExecutionManager, ExecutionScheduler
+    from backend.server import AgentServer, WebsocketServer
 
     run_processes(
-        DatabaseManager(),
         ExecutionManager(),
-        Scheduler(),
-        NotificationManager(),
+        ExecutionScheduler(),
         WebsocketServer(),
         AgentServer(),
         **kwargs,

autogpt_platform/backend/backend/blocks/__init__.py

@@ -2,103 +2,73 @@ import importlib
 import os
 import re
 from pathlib import Path
-from typing import TYPE_CHECKING, TypeVar
 
-if TYPE_CHECKING:
-    from backend.data.block import Block
+from backend.data.block import Block
 
-T = TypeVar("T")
+# 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 = {}
 
 
-_AVAILABLE_BLOCKS: dict[str, type["Block"]] = {}
-
-
-def load_all_blocks() -> dict[str, type["Block"]]:
-    from backend.data.block import Block
-
-    if _AVAILABLE_BLOCKS:
-        return _AVAILABLE_BLOCKS
-
-    # 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-z0-9_.]+$", module):
-            raise ValueError(
-                f"Block module {module} error: module name must be lowercase, "
-                "and contain only alphanumeric characters and underscores."
-            )
-
-        importlib.import_module(f".{module}", package=__name__)
-        AVAILABLE_MODULES.append(module)
-
-    # Load all Block instances from the available modules
-    for block_cls in all_subclasses(Block):
-        class_name = block_cls.__name__
-
-        if class_name.endswith("Base"):
-            continue
-
-        if not class_name.endswith("Block"):
-            raise ValueError(
-                f"Block class {class_name} does not end with 'Block'. "
-                "If you are creating an abstract class, "
-                "please name the class with 'Base' at the end"
-            )
-
-        block = block_cls.create()
-
-        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"
-            )
-
-        input_schema = block.input_schema.model_fields
-        output_schema = block.output_schema.model_fields
-
-        # Make sure `error` field is a string in the output schema
-        if "error" in output_schema and output_schema["error"].annotation is not str:
-            raise ValueError(
-                f"{block.name} `error` field in output_schema must be a string"
-            )
-
-        # Ensure all fields in input_schema and output_schema are annotated SchemaFields
-        for field_name, field in [*input_schema.items(), *output_schema.items()]:
-            if field.annotation is None:
-                raise ValueError(
-                    f"{block.name} has a field {field_name} that is not annotated"
-                )
-            if field.json_schema_extra is None:
-                raise ValueError(
-                    f"{block.name} has a field {field_name} not defined as SchemaField"
-                )
-
-        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"
-                )
-
-        _AVAILABLE_BLOCKS[block.id] = block_cls
-
-    return _AVAILABLE_BLOCKS
-
-
-__all__ = ["load_all_blocks"]
-
-
-def all_subclasses(cls: type[T]) -> list[type[T]]:
-    subclasses = cls.__subclasses__()
+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/agent.py

@@ -1,127 +0,0 @@
-import logging
-from typing import Any
-
-from autogpt_libs.utils.cache import thread_cached
-
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockInput,
-    BlockOutput,
-    BlockSchema,
-    BlockType,
-    get_block,
-)
-from backend.data.execution import ExecutionStatus
-from backend.data.model import SchemaField
-from backend.util import json
-
-logger = logging.getLogger(__name__)
-
-
-@thread_cached
-def get_executor_manager_client():
-    from backend.executor import ExecutionManager
-    from backend.util.service import get_service_client
-
-    return get_service_client(ExecutionManager)
-
-
-@thread_cached
-def get_event_bus():
-    from backend.data.execution import RedisExecutionEventBus
-
-    return RedisExecutionEventBus()
-
-
-class AgentExecutorBlock(Block):
-    class Input(BlockSchema):
-        user_id: str = SchemaField(description="User ID")
-        graph_id: str = SchemaField(description="Graph ID")
-        graph_version: int = SchemaField(description="Graph Version")
-
-        data: BlockInput = SchemaField(description="Input data for the graph")
-        input_schema: dict = SchemaField(description="Input schema for the graph")
-        output_schema: dict = SchemaField(description="Output schema for the graph")
-
-        @classmethod
-        def get_input_schema(cls, data: BlockInput) -> dict[str, Any]:
-            return data.get("input_schema", {})
-
-        @classmethod
-        def get_input_defaults(cls, data: BlockInput) -> BlockInput:
-            return data.get("data", {})
-
-        @classmethod
-        def get_missing_input(cls, data: BlockInput) -> set[str]:
-            required_fields = cls.get_input_schema(data).get("required", [])
-            return set(required_fields) - set(data)
-
-        @classmethod
-        def get_mismatch_error(cls, data: BlockInput) -> str | None:
-            return json.validate_with_jsonschema(cls.get_input_schema(data), data)
-
-    class Output(BlockSchema):
-        pass
-
-    def __init__(self):
-        super().__init__(
-            id="e189baac-8c20-45a1-94a7-55177ea42565",
-            description="Executes an existing agent inside your agent",
-            input_schema=AgentExecutorBlock.Input,
-            output_schema=AgentExecutorBlock.Output,
-            block_type=BlockType.AGENT,
-            categories={BlockCategory.AGENT},
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        from backend.data.execution import ExecutionEventType
-
-        executor_manager = get_executor_manager_client()
-        event_bus = get_event_bus()
-
-        graph_exec = executor_manager.add_execution(
-            graph_id=input_data.graph_id,
-            graph_version=input_data.graph_version,
-            user_id=input_data.user_id,
-            data=input_data.data,
-        )
-        log_id = f"Graph #{input_data.graph_id}-V{input_data.graph_version}, exec-id: {graph_exec.graph_exec_id}"
-        logger.info(f"Starting execution of {log_id}")
-
-        for event in event_bus.listen(
-            user_id=graph_exec.user_id,
-            graph_id=graph_exec.graph_id,
-            graph_exec_id=graph_exec.graph_exec_id,
-        ):
-            if event.event_type == ExecutionEventType.GRAPH_EXEC_UPDATE:
-                if event.status in [
-                    ExecutionStatus.COMPLETED,
-                    ExecutionStatus.TERMINATED,
-                    ExecutionStatus.FAILED,
-                ]:
-                    logger.info(f"Execution {log_id} ended with status {event.status}")
-                    break
-                else:
-                    continue
-
-            logger.info(
-                f"Execution {log_id} produced input {event.input_data} output {event.output_data}"
-            )
-
-            if not event.block_id:
-                logger.warning(f"{log_id} received event without block_id {event}")
-                continue
-
-            block = get_block(event.block_id)
-            if not block or block.block_type != BlockType.OUTPUT:
-                continue
-
-            output_name = event.input_data.get("name")
-            if not output_name:
-                logger.warning(f"{log_id} produced an output with no name {event}")
-                continue
-
-            for output_data in event.output_data.get("output", []):
-                logger.info(f"Execution {log_id} produced {output_name}: {output_data}")
-                yield output_name, output_data

autogpt_platform/backend/backend/blocks/ai_image_generator_block.py

@@ -1,325 +0,0 @@
-from enum import Enum
-from typing import Literal
-
-import replicate
-from pydantic import SecretStr
-from replicate.helpers import FileOutput
-
-from backend.data.block import Block, BlockCategory, BlockSchema
-from backend.data.model import (
-    APIKeyCredentials,
-    CredentialsField,
-    CredentialsMetaInput,
-    SchemaField,
-)
-from backend.integrations.providers import ProviderName
-
-
-class ImageSize(str, Enum):
-    """
-    Semantic sizes that map reliably across all models
-    """
-
-    SQUARE = "square"  # For profile pictures, icons, etc.
-    LANDSCAPE = "landscape"  # For traditional photos, scenes
-    PORTRAIT = "portrait"  # For vertical photos, portraits
-    WIDE = "wide"  # For cinematic, desktop wallpapers
-    TALL = "tall"  # For mobile wallpapers, stories
-
-
-# Mapping semantic sizes to model-specific formats
-SIZE_TO_SD_RATIO = {
-    ImageSize.SQUARE: "1:1",
-    ImageSize.LANDSCAPE: "4:3",
-    ImageSize.PORTRAIT: "3:4",
-    ImageSize.WIDE: "16:9",
-    ImageSize.TALL: "9:16",
-}
-
-SIZE_TO_FLUX_RATIO = {
-    ImageSize.SQUARE: "1:1",
-    ImageSize.LANDSCAPE: "4:3",
-    ImageSize.PORTRAIT: "3:4",
-    ImageSize.WIDE: "16:9",
-    ImageSize.TALL: "9:16",
-}
-
-SIZE_TO_FLUX_DIMENSIONS = {
-    ImageSize.SQUARE: (1024, 1024),
-    ImageSize.LANDSCAPE: (1365, 1024),
-    ImageSize.PORTRAIT: (1024, 1365),
-    ImageSize.WIDE: (1440, 810),  # Adjusted to maintain 16:9 within 1440 limit
-    ImageSize.TALL: (810, 1440),  # Adjusted to maintain 9:16 within 1440 limit
-}
-
-SIZE_TO_RECRAFT_DIMENSIONS = {
-    ImageSize.SQUARE: "1024x1024",
-    ImageSize.LANDSCAPE: "1365x1024",
-    ImageSize.PORTRAIT: "1024x1365",
-    ImageSize.WIDE: "1536x1024",
-    ImageSize.TALL: "1024x1536",
-}
-
-
-class ImageStyle(str, Enum):
-    """
-    Complete set of supported styles
-    """
-
-    ANY = "any"
-    # Realistic image styles
-    REALISTIC = "realistic_image"
-    REALISTIC_BW = "realistic_image/b_and_w"
-    REALISTIC_HDR = "realistic_image/hdr"
-    REALISTIC_NATURAL = "realistic_image/natural_light"
-    REALISTIC_STUDIO = "realistic_image/studio_portrait"
-    REALISTIC_ENTERPRISE = "realistic_image/enterprise"
-    REALISTIC_HARD_FLASH = "realistic_image/hard_flash"
-    REALISTIC_MOTION_BLUR = "realistic_image/motion_blur"
-    # Digital illustration styles
-    DIGITAL_ART = "digital_illustration"
-    PIXEL_ART = "digital_illustration/pixel_art"
-    HAND_DRAWN = "digital_illustration/hand_drawn"
-    GRAIN = "digital_illustration/grain"
-    SKETCH = "digital_illustration/infantile_sketch"
-    POSTER = "digital_illustration/2d_art_poster"
-    POSTER_2 = "digital_illustration/2d_art_poster_2"
-    HANDMADE_3D = "digital_illustration/handmade_3d"
-    HAND_DRAWN_OUTLINE = "digital_illustration/hand_drawn_outline"
-    ENGRAVING_COLOR = "digital_illustration/engraving_color"
-
-
-class ImageGenModel(str, Enum):
-    """
-    Available model providers
-    """
-
-    FLUX = "Flux 1.1 Pro"
-    FLUX_ULTRA = "Flux 1.1 Pro Ultra"
-    RECRAFT = "Recraft v3"
-    SD3_5 = "Stable Diffusion 3.5 Medium"
-
-
-class AIImageGeneratorBlock(Block):
-    class Input(BlockSchema):
-        credentials: CredentialsMetaInput[
-            Literal[ProviderName.REPLICATE], Literal["api_key"]
-        ] = CredentialsField(
-            description="Enter your Replicate API key to access the image generation API. You can obtain an API key from https://replicate.com/account/api-tokens.",
-        )
-        prompt: str = SchemaField(
-            description="Text prompt for image generation",
-            placeholder="e.g., 'A red panda using a laptop in a snowy forest'",
-            title="Prompt",
-        )
-        model: ImageGenModel = SchemaField(
-            description="The AI model to use for image generation",
-            default=ImageGenModel.SD3_5,
-            title="Model",
-        )
-        size: ImageSize = SchemaField(
-            description=(
-                "Format of the generated image:\n"
-                "- Square: Perfect for profile pictures, icons\n"
-                "- Landscape: Traditional photo format\n"
-                "- Portrait: Vertical photos, portraits\n"
-                "- Wide: Cinematic format, desktop wallpapers\n"
-                "- Tall: Mobile wallpapers, social media stories"
-            ),
-            default=ImageSize.SQUARE,
-            title="Image Format",
-        )
-        style: ImageStyle = SchemaField(
-            description="Visual style for the generated image",
-            default=ImageStyle.ANY,
-            title="Image Style",
-        )
-
-    class Output(BlockSchema):
-        image_url: str = SchemaField(description="URL of the generated image")
-        error: str = SchemaField(description="Error message if generation failed")
-
-    def __init__(self):
-        super().__init__(
-            id="ed1ae7a0-b770-4089-b520-1f0005fad19a",
-            description="Generate images using various AI models through a unified interface",
-            categories={BlockCategory.AI},
-            input_schema=AIImageGeneratorBlock.Input,
-            output_schema=AIImageGeneratorBlock.Output,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "prompt": "An octopus using a laptop in a snowy forest with 'AutoGPT' clearly visible on the screen",
-                "model": ImageGenModel.RECRAFT,
-                "size": ImageSize.SQUARE,
-                "style": ImageStyle.REALISTIC,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "image_url",
-                    "https://replicate.delivery/generated-image.webp",
-                ),
-            ],
-            test_mock={
-                "_run_client": lambda *args, **kwargs: "https://replicate.delivery/generated-image.webp"
-            },
-        )
-
-    def _run_client(
-        self, credentials: APIKeyCredentials, model_name: str, input_params: dict
-    ):
-        try:
-            # Initialize Replicate client
-            client = replicate.Client(api_token=credentials.api_key.get_secret_value())
-
-            # Run the model with input parameters
-            output = client.run(model_name, input=input_params, wait=False)
-
-            # Process output
-            if isinstance(output, list) and len(output) > 0:
-                if isinstance(output[0], FileOutput):
-                    result_url = output[0].url
-                else:
-                    result_url = output[0]
-            elif isinstance(output, FileOutput):
-                result_url = output.url
-            elif isinstance(output, str):
-                result_url = output
-            else:
-                result_url = None
-
-            return result_url
-
-        except TypeError as e:
-            raise TypeError(f"Error during model execution: {e}")
-        except Exception as e:
-            raise RuntimeError(f"Unexpected error during model execution: {e}")
-
-    def generate_image(self, input_data: Input, credentials: APIKeyCredentials):
-        try:
-            # Handle style-based prompt modification for models without native style support
-            modified_prompt = input_data.prompt
-            if input_data.model not in [ImageGenModel.RECRAFT]:
-                style_prefix = self._style_to_prompt_prefix(input_data.style)
-                modified_prompt = f"{style_prefix} {modified_prompt}".strip()
-
-            if input_data.model == ImageGenModel.SD3_5:
-                # Use Stable Diffusion 3.5 with aspect ratio
-                input_params = {
-                    "prompt": modified_prompt,
-                    "aspect_ratio": SIZE_TO_SD_RATIO[input_data.size],
-                    "output_format": "webp",
-                    "output_quality": 90,
-                    "steps": 40,
-                    "cfg_scale": 7.0,
-                }
-                output = self._run_client(
-                    credentials,
-                    "stability-ai/stable-diffusion-3.5-medium",
-                    input_params,
-                )
-                return output
-
-            elif input_data.model == ImageGenModel.FLUX:
-                # Use Flux-specific dimensions with 'jpg' format to avoid ReplicateError
-                width, height = SIZE_TO_FLUX_DIMENSIONS[input_data.size]
-                input_params = {
-                    "prompt": modified_prompt,
-                    "width": width,
-                    "height": height,
-                    "aspect_ratio": SIZE_TO_FLUX_RATIO[input_data.size],
-                    "output_format": "jpg",  # Set to jpg for Flux models
-                    "output_quality": 90,
-                }
-                output = self._run_client(
-                    credentials, "black-forest-labs/flux-1.1-pro", input_params
-                )
-                return output
-
-            elif input_data.model == ImageGenModel.FLUX_ULTRA:
-                width, height = SIZE_TO_FLUX_DIMENSIONS[input_data.size]
-                input_params = {
-                    "prompt": modified_prompt,
-                    "width": width,
-                    "height": height,
-                    "aspect_ratio": SIZE_TO_FLUX_RATIO[input_data.size],
-                    "output_format": "jpg",
-                    "output_quality": 90,
-                }
-                output = self._run_client(
-                    credentials, "black-forest-labs/flux-1.1-pro-ultra", input_params
-                )
-                return output
-
-            elif input_data.model == ImageGenModel.RECRAFT:
-                input_params = {
-                    "prompt": input_data.prompt,
-                    "size": SIZE_TO_RECRAFT_DIMENSIONS[input_data.size],
-                    "style": input_data.style.value,
-                }
-                output = self._run_client(
-                    credentials, "recraft-ai/recraft-v3", input_params
-                )
-                return output
-
-        except Exception as e:
-            raise RuntimeError(f"Failed to generate image: {str(e)}")
-
-    def _style_to_prompt_prefix(self, style: ImageStyle) -> str:
-        """
-        Convert a style enum to a prompt prefix for models without native style support.
-        """
-        if style == ImageStyle.ANY:
-            return ""
-
-        style_map = {
-            ImageStyle.REALISTIC: "photorealistic",
-            ImageStyle.REALISTIC_BW: "black and white photograph",
-            ImageStyle.REALISTIC_HDR: "HDR photograph",
-            ImageStyle.REALISTIC_NATURAL: "natural light photograph",
-            ImageStyle.REALISTIC_STUDIO: "studio portrait photograph",
-            ImageStyle.REALISTIC_ENTERPRISE: "enterprise photograph",
-            ImageStyle.REALISTIC_HARD_FLASH: "hard flash photograph",
-            ImageStyle.REALISTIC_MOTION_BLUR: "motion blur photograph",
-            ImageStyle.DIGITAL_ART: "digital art",
-            ImageStyle.PIXEL_ART: "pixel art",
-            ImageStyle.HAND_DRAWN: "hand drawn illustration",
-            ImageStyle.GRAIN: "grainy digital illustration",
-            ImageStyle.SKETCH: "sketchy illustration",
-            ImageStyle.POSTER: "2D art poster",
-            ImageStyle.POSTER_2: "alternate 2D art poster",
-            ImageStyle.HANDMADE_3D: "handmade 3D illustration",
-            ImageStyle.HAND_DRAWN_OUTLINE: "hand drawn outline illustration",
-            ImageStyle.ENGRAVING_COLOR: "color engraving illustration",
-        }
-
-        style_text = style_map.get(style, "")
-        return f"{style_text} of" if style_text else ""
-
-    def run(self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs):
-        try:
-            url = self.generate_image(input_data, credentials)
-            if url:
-                yield "image_url", url
-            else:
-                yield "error", "Image generation returned an empty result."
-        except Exception as e:
-            # Capture and return only the message of the exception, avoiding serialization of non-serializable objects
-            yield "error", str(e)
-
-
-# Test credentials stay the same
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="replicate",
-    api_key=SecretStr("mock-replicate-api-key"),
-    title="Mock Replicate API key",
-    expires_at=None,
-)
-
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.title,
-}

autogpt_platform/backend/backend/blocks/ai_music_generator.py

@@ -1,227 +0,0 @@
-import logging
-import time
-from enum import Enum
-from typing import Literal
-
-import replicate
-from pydantic import SecretStr
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import (
-    APIKeyCredentials,
-    CredentialsField,
-    CredentialsMetaInput,
-    SchemaField,
-)
-from backend.integrations.providers import ProviderName
-
-logger = logging.getLogger(__name__)
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="replicate",
-    api_key=SecretStr("mock-replicate-api-key"),
-    title="Mock Replicate API key",
-    expires_at=None,
-)
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.type,
-}
-
-
-# Model version enum
-class MusicGenModelVersion(str, Enum):
-    STEREO_LARGE = "stereo-large"
-    MELODY_LARGE = "melody-large"
-    LARGE = "large"
-
-
-# Audio format enum
-class AudioFormat(str, Enum):
-    WAV = "wav"
-    MP3 = "mp3"
-
-
-# Normalization strategy enum
-class NormalizationStrategy(str, Enum):
-    LOUDNESS = "loudness"
-    CLIP = "clip"
-    PEAK = "peak"
-    RMS = "rms"
-
-
-class AIMusicGeneratorBlock(Block):
-    class Input(BlockSchema):
-        credentials: CredentialsMetaInput[
-            Literal[ProviderName.REPLICATE], Literal["api_key"]
-        ] = CredentialsField(
-            description="The Replicate integration can be used with "
-            "any API key with sufficient permissions for the blocks it is used on.",
-        )
-        prompt: str = SchemaField(
-            description="A description of the music you want to generate",
-            placeholder="e.g., 'An upbeat electronic dance track with heavy bass'",
-            title="Prompt",
-        )
-        music_gen_model_version: MusicGenModelVersion = SchemaField(
-            description="Model to use for generation",
-            default=MusicGenModelVersion.STEREO_LARGE,
-            title="Model Version",
-        )
-        duration: int = SchemaField(
-            description="Duration of the generated audio in seconds",
-            default=8,
-            title="Duration",
-        )
-        temperature: float = SchemaField(
-            description="Controls the 'conservativeness' of the sampling process. Higher temperature means more diversity",
-            default=1.0,
-            title="Temperature",
-        )
-        top_k: int = SchemaField(
-            description="Reduces sampling to the k most likely tokens",
-            default=250,
-            title="Top K",
-        )
-        top_p: float = SchemaField(
-            description="Reduces sampling to tokens with cumulative probability of p. When set to 0 (default), top_k sampling is used",
-            default=0.0,
-            title="Top P",
-        )
-        classifier_free_guidance: int = SchemaField(
-            description="Increases the influence of inputs on the output. Higher values produce lower-variance outputs that adhere more closely to inputs",
-            default=3,
-            title="Classifier Free Guidance",
-        )
-        output_format: AudioFormat = SchemaField(
-            description="Output format for generated audio",
-            default=AudioFormat.WAV,
-            title="Output Format",
-        )
-        normalization_strategy: NormalizationStrategy = SchemaField(
-            description="Strategy for normalizing audio",
-            default=NormalizationStrategy.LOUDNESS,
-            title="Normalization Strategy",
-        )
-
-    class Output(BlockSchema):
-        result: str = SchemaField(description="URL of the generated audio file")
-        error: str = SchemaField(description="Error message if the model run failed")
-
-    def __init__(self):
-        super().__init__(
-            id="44f6c8ad-d75c-4ae1-8209-aad1c0326928",
-            description="This block generates music using Meta's MusicGen model on Replicate.",
-            categories={BlockCategory.AI},
-            input_schema=AIMusicGeneratorBlock.Input,
-            output_schema=AIMusicGeneratorBlock.Output,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "prompt": "An upbeat electronic dance track with heavy bass",
-                "music_gen_model_version": MusicGenModelVersion.STEREO_LARGE,
-                "duration": 8,
-                "temperature": 1.0,
-                "top_k": 250,
-                "top_p": 0.0,
-                "classifier_free_guidance": 3,
-                "output_format": AudioFormat.WAV,
-                "normalization_strategy": NormalizationStrategy.LOUDNESS,
-            },
-            test_output=[
-                (
-                    "result",
-                    "https://replicate.com/output/generated-audio-url.wav",
-                ),
-            ],
-            test_mock={
-                "run_model": lambda api_key, music_gen_model_version, prompt, duration, temperature, top_k, top_p, classifier_free_guidance, output_format, normalization_strategy: "https://replicate.com/output/generated-audio-url.wav",
-            },
-            test_credentials=TEST_CREDENTIALS,
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        max_retries = 3
-        retry_delay = 5  # seconds
-        last_error = None
-
-        for attempt in range(max_retries):
-            try:
-                logger.debug(
-                    f"[AIMusicGeneratorBlock] - Running model (attempt {attempt + 1})"
-                )
-                result = self.run_model(
-                    api_key=credentials.api_key,
-                    music_gen_model_version=input_data.music_gen_model_version,
-                    prompt=input_data.prompt,
-                    duration=input_data.duration,
-                    temperature=input_data.temperature,
-                    top_k=input_data.top_k,
-                    top_p=input_data.top_p,
-                    classifier_free_guidance=input_data.classifier_free_guidance,
-                    output_format=input_data.output_format,
-                    normalization_strategy=input_data.normalization_strategy,
-                )
-                if result and result != "No output received":
-                    yield "result", result
-                    return
-                else:
-                    last_error = "Model returned empty or invalid response"
-                    raise ValueError(last_error)
-            except Exception as e:
-                last_error = f"Unexpected error: {str(e)}"
-                logger.error(f"[AIMusicGeneratorBlock] - Error: {last_error}")
-                if attempt < max_retries - 1:
-                    time.sleep(retry_delay)
-                    continue
-
-        # If we've exhausted all retries, yield the error
-        yield "error", f"Failed after {max_retries} attempts. Last error: {last_error}"
-
-    def run_model(
-        self,
-        api_key: SecretStr,
-        music_gen_model_version: MusicGenModelVersion,
-        prompt: str,
-        duration: int,
-        temperature: float,
-        top_k: int,
-        top_p: float,
-        classifier_free_guidance: int,
-        output_format: AudioFormat,
-        normalization_strategy: NormalizationStrategy,
-    ):
-        # Initialize Replicate client with the API key
-        client = replicate.Client(api_token=api_key.get_secret_value())
-
-        # Run the model with parameters
-        output = client.run(
-            "meta/musicgen:671ac645ce5e552cc63a54a2bbff63fcf798043055d2dac5fc9e36a837eedcfb",
-            input={
-                "prompt": prompt,
-                "music_gen_model_version": music_gen_model_version,
-                "duration": duration,
-                "temperature": temperature,
-                "top_k": top_k,
-                "top_p": top_p,
-                "classifier_free_guidance": classifier_free_guidance,
-                "output_format": output_format,
-                "normalization_strategy": normalization_strategy,
-            },
-        )
-
-        # Handle the output
-        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/ai_shortform_video_block.py

@@ -1,33 +1,13 @@
 import logging
 import time
 from enum import Enum
-from typing import Literal
+from typing import Optional
 
-from pydantic import SecretStr
+import requests
+from pydantic import Field
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import (
-    APIKeyCredentials,
-    CredentialsField,
-    CredentialsMetaInput,
-    SchemaField,
-)
-from backend.integrations.providers import ProviderName
-from backend.util.request import requests
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="revid",
-    api_key=SecretStr("mock-revid-api-key"),
-    title="Mock Revid API key",
-    expires_at=None,
-)
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.type,
-}
+from backend.data.model import BlockSecret, SchemaField, SecretField
 
 
 class AudioTrack(str, Enum):
@@ -141,23 +121,18 @@ logger = logging.getLogger(__name__)
 
 class AIShortformVideoCreatorBlock(Block):
     class Input(BlockSchema):
-        credentials: CredentialsMetaInput[
-            Literal[ProviderName.REVID], Literal["api_key"]
-        ] = CredentialsField(
-            description="The revid.ai integration can be used with "
-            "any API key with sufficient permissions for the blocks it is used on.",
+        api_key: BlockSecret = SecretField(
+            key="revid_api_key",
+            description="Your revid.ai API key",
+            placeholder="Enter your revid.ai API key",
         )
         script: str = SchemaField(
             description="""1. Use short and punctuated sentences\n\n2. Use linebreaks to create a new clip\n\n3. Text outside of brackets is spoken by the AI, and [text between brackets] will be used to guide the visual generation. For example, [close-up of a cat] will show a close-up of a cat.""",
             placeholder="[close-up of a cat] Meow!",
         )
-        ratio: str = SchemaField(
-            description="Aspect ratio of the video", default="9 / 16"
-        )
-        resolution: str = SchemaField(
-            description="Resolution of the video", default="720p"
-        )
-        frame_rate: int = SchemaField(description="Frame rate of the video", default=60)
+        ratio: str = Field(description="Aspect ratio of the video", default="9 / 16")
+        resolution: str = Field(description="Resolution of the video", default="720p")
+        frame_rate: int = Field(description="Frame rate of the video", default=60)
         generation_preset: GenerationPreset = SchemaField(
             description="Generation preset for visual style - only effects AI generated visuals",
             default=GenerationPreset.LEONARDO,
@@ -180,8 +155,8 @@ class AIShortformVideoCreatorBlock(Block):
         )
 
     class Output(BlockSchema):
-        video_url: str = SchemaField(description="The URL of the created video")
-        error: str = SchemaField(description="Error message if the request failed")
+        video_url: str = Field(description="The URL of the created video")
+        error: Optional[str] = Field(description="Error message if the request failed")
 
     def __init__(self):
         super().__init__(
@@ -191,7 +166,7 @@ class AIShortformVideoCreatorBlock(Block):
             input_schema=AIShortformVideoCreatorBlock.Input,
             output_schema=AIShortformVideoCreatorBlock.Output,
             test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
+                "api_key": "test_api_key",
                 "script": "[close-up of a cat] Meow!",
                 "ratio": "9 / 16",
                 "resolution": "720p",
@@ -213,37 +188,35 @@ class AIShortformVideoCreatorBlock(Block):
                 "create_video": lambda api_key, payload: {"pid": "test_pid"},
                 "wait_for_video": lambda api_key, pid, webhook_token, max_wait_time=1000: "https://example.com/video.mp4",
             },
-            test_credentials=TEST_CREDENTIALS,
         )
 
     def create_webhook(self):
         url = "https://webhook.site/token"
         headers = {"Accept": "application/json", "Content-Type": "application/json"}
         response = requests.post(url, headers=headers)
+        response.raise_for_status()
         webhook_data = response.json()
         return webhook_data["uuid"], f"https://webhook.site/{webhook_data['uuid']}"
 
-    def create_video(self, api_key: SecretStr, payload: dict) -> dict:
+    def create_video(self, api_key: str, payload: dict) -> dict:
         url = "https://www.revid.ai/api/public/v2/render"
-        headers = {"key": api_key.get_secret_value()}
+        headers = {"key": api_key}
         response = requests.post(url, json=payload, headers=headers)
         logger.debug(
             f"API Response Status Code: {response.status_code}, Content: {response.text}"
         )
+        response.raise_for_status()
         return response.json()
 
-    def check_video_status(self, api_key: SecretStr, pid: str) -> dict:
+    def check_video_status(self, api_key: str, pid: str) -> dict:
         url = f"https://www.revid.ai/api/public/v2/status?pid={pid}"
-        headers = {"key": api_key.get_secret_value()}
+        headers = {"key": api_key}
         response = requests.get(url, headers=headers)
+        response.raise_for_status()
         return response.json()
 
     def wait_for_video(
-        self,
-        api_key: SecretStr,
-        pid: str,
-        webhook_token: str,
-        max_wait_time: int = 1000,
+        self, api_key: str, pid: str, webhook_token: str, max_wait_time: int = 1000
     ) -> str:
         start_time = time.time()
         while time.time() - start_time < max_wait_time:
@@ -265,59 +238,70 @@ class AIShortformVideoCreatorBlock(Block):
         logger.error("Video creation timed out")
         raise TimeoutError("Video creation timed out")
 
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        # Create a new Webhook.site URL
-        webhook_token, webhook_url = self.create_webhook()
-        logger.debug(f"Webhook URL: {webhook_url}")
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        try:
+            # Create a new Webhook.site URL
+            webhook_token, webhook_url = self.create_webhook()
+            logger.debug(f"Webhook URL: {webhook_url}")
 
-        audio_url = input_data.background_music.audio_url
+            audio_url = input_data.background_music.audio_url
 
-        payload = {
-            "frameRate": input_data.frame_rate,
-            "resolution": input_data.resolution,
-            "frameDurationMultiplier": 18,
-            "webhook": webhook_url,
-            "creationParams": {
-                "mediaType": input_data.video_style,
-                "captionPresetName": "Wrap 1",
-                "selectedVoice": input_data.voice.voice_id,
-                "hasEnhancedGeneration": True,
-                "generationPreset": input_data.generation_preset.name,
-                "selectedAudio": input_data.background_music,
-                "origin": "/create",
-                "inputText": input_data.script,
-                "flowType": "text-to-video",
-                "slug": "create-tiktok-video",
-                "hasToGenerateVoice": True,
-                "hasToTranscript": False,
-                "hasToSearchMedia": True,
-                "hasAvatar": False,
-                "hasWebsiteRecorder": False,
-                "hasTextSmallAtBottom": False,
-                "ratio": input_data.ratio,
-                "sourceType": "contentScraping",
-                "selectedStoryStyle": {"value": "custom", "label": "Custom"},
-                "hasToGenerateVideos": input_data.video_style
-                != VisualMediaType.STOCK_VIDEOS,
-                "audioUrl": audio_url,
-            },
-        }
+            payload = {
+                "frameRate": input_data.frame_rate,
+                "resolution": input_data.resolution,
+                "frameDurationMultiplier": 18,
+                "webhook": webhook_url,
+                "creationParams": {
+                    "mediaType": input_data.video_style,
+                    "captionPresetName": "Wrap 1",
+                    "selectedVoice": input_data.voice.voice_id,
+                    "hasEnhancedGeneration": True,
+                    "generationPreset": input_data.generation_preset.name,
+                    "selectedAudio": input_data.background_music,
+                    "origin": "/create",
+                    "inputText": input_data.script,
+                    "flowType": "text-to-video",
+                    "slug": "create-tiktok-video",
+                    "hasToGenerateVoice": True,
+                    "hasToTranscript": False,
+                    "hasToSearchMedia": True,
+                    "hasAvatar": False,
+                    "hasWebsiteRecorder": False,
+                    "hasTextSmallAtBottom": False,
+                    "ratio": input_data.ratio,
+                    "sourceType": "contentScraping",
+                    "selectedStoryStyle": {"value": "custom", "label": "Custom"},
+                    "hasToGenerateVideos": input_data.video_style
+                    != VisualMediaType.STOCK_VIDEOS,
+                    "audioUrl": audio_url,
+                },
+            }
 
-        logger.debug("Creating video...")
-        response = self.create_video(credentials.api_key, payload)
-        pid = response.get("pid")
+            logger.debug("Creating video...")
+            response = self.create_video(input_data.api_key.get_secret_value(), payload)
+            pid = response.get("pid")
 
-        if not pid:
-            logger.error(
-                f"Failed to create video: No project ID returned. API Response: {response}"
-            )
-            raise RuntimeError("Failed to create video: No project ID returned")
-        else:
-            logger.debug(
-                f"Video created with project ID: {pid}. Waiting for completion..."
-            )
-            video_url = self.wait_for_video(credentials.api_key, pid, webhook_token)
-            logger.debug(f"Video ready: {video_url}")
-            yield "video_url", video_url
+            if not pid:
+                logger.error(
+                    f"Failed to create video: No project ID returned. API Response: {response}"
+                )
+                yield "error", "Failed to create video: No project ID returned"
+            else:
+                logger.debug(
+                    f"Video created with project ID: {pid}. Waiting for completion..."
+                )
+                video_url = self.wait_for_video(
+                    input_data.api_key.get_secret_value(), pid, webhook_token
+                )
+                logger.debug(f"Video ready: {video_url}")
+                yield "video_url", video_url
+
+        except requests.RequestException as e:
+            logger.exception("Error creating video")
+            yield "error", f"Error creating video: {str(e)}"
+        except ValueError as e:
+            logger.exception("Error in video creation process")
+            yield "error", str(e)
+        except TimeoutError as e:
+            logger.exception("Video creation timed out")
+            yield "error", str(e)

autogpt_platform/backend/backend/blocks/apollo/_api.py

@@ -1,108 +0,0 @@
-import logging
-from typing import List
-
-from backend.blocks.apollo._auth import ApolloCredentials
-from backend.blocks.apollo.models import (
-    Contact,
-    Organization,
-    SearchOrganizationsRequest,
-    SearchOrganizationsResponse,
-    SearchPeopleRequest,
-    SearchPeopleResponse,
-)
-from backend.util.request import Requests
-
-logger = logging.getLogger(name=__name__)
-
-
-class ApolloClient:
-    """Client for the Apollo API"""
-
-    API_URL = "https://api.apollo.io/api/v1"
-
-    def __init__(self, credentials: ApolloCredentials):
-        self.credentials = credentials
-        self.requests = Requests()
-
-    def _get_headers(self) -> dict[str, str]:
-        return {"x-api-key": self.credentials.api_key.get_secret_value()}
-
-    def search_people(self, query: SearchPeopleRequest) -> List[Contact]:
-        """Search for people in Apollo"""
-        response = self.requests.get(
-            f"{self.API_URL}/mixed_people/search",
-            headers=self._get_headers(),
-            params=query.model_dump(exclude={"credentials", "max_results"}),
-        )
-        parsed_response = SearchPeopleResponse(**response.json())
-        if parsed_response.pagination.total_entries == 0:
-            return []
-
-        people = parsed_response.people
-
-        # handle pagination
-        if (
-            query.max_results is not None
-            and query.max_results < parsed_response.pagination.total_entries
-            and len(people) < query.max_results
-        ):
-            while (
-                len(people) < query.max_results
-                and query.page < parsed_response.pagination.total_pages
-                and len(parsed_response.people) > 0
-            ):
-                query.page += 1
-                response = self.requests.get(
-                    f"{self.API_URL}/mixed_people/search",
-                    headers=self._get_headers(),
-                    params=query.model_dump(exclude={"credentials", "max_results"}),
-                )
-                parsed_response = SearchPeopleResponse(**response.json())
-                people.extend(parsed_response.people[: query.max_results - len(people)])
-
-        logger.info(f"Found {len(people)} people")
-        return people[: query.max_results] if query.max_results else people
-
-    def search_organizations(
-        self, query: SearchOrganizationsRequest
-    ) -> List[Organization]:
-        """Search for organizations in Apollo"""
-        response = self.requests.get(
-            f"{self.API_URL}/mixed_companies/search",
-            headers=self._get_headers(),
-            params=query.model_dump(exclude={"credentials", "max_results"}),
-        )
-        parsed_response = SearchOrganizationsResponse(**response.json())
-        if parsed_response.pagination.total_entries == 0:
-            return []
-
-        organizations = parsed_response.organizations
-
-        # handle pagination
-        if (
-            query.max_results is not None
-            and query.max_results < parsed_response.pagination.total_entries
-            and len(organizations) < query.max_results
-        ):
-            while (
-                len(organizations) < query.max_results
-                and query.page < parsed_response.pagination.total_pages
-                and len(parsed_response.organizations) > 0
-            ):
-                query.page += 1
-                response = self.requests.get(
-                    f"{self.API_URL}/mixed_companies/search",
-                    headers=self._get_headers(),
-                    params=query.model_dump(exclude={"credentials", "max_results"}),
-                )
-                parsed_response = SearchOrganizationsResponse(**response.json())
-                organizations.extend(
-                    parsed_response.organizations[
-                        : query.max_results - len(organizations)
-                    ]
-                )
-
-        logger.info(f"Found {len(organizations)} organizations")
-        return (
-            organizations[: query.max_results] if query.max_results else organizations
-        )

autogpt_platform/backend/backend/blocks/apollo/_auth.py

@@ -1,35 +0,0 @@
-from typing import Literal
-
-from pydantic import SecretStr
-
-from backend.data.model import APIKeyCredentials, CredentialsField, CredentialsMetaInput
-from backend.integrations.providers import ProviderName
-
-ApolloCredentials = APIKeyCredentials
-ApolloCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.APOLLO],
-    Literal["api_key"],
-]
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="apollo",
-    api_key=SecretStr("mock-apollo-api-key"),
-    title="Mock Apollo API key",
-    expires_at=None,
-)
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.title,
-}
-
-
-def ApolloCredentialsField() -> ApolloCredentialsInput:
-    """
-    Creates a Apollo credentials input on a block.
-    """
-    return CredentialsField(
-        description="The Apollo integration can be used with an API Key.",
-    )

autogpt_platform/backend/backend/blocks/apollo/models.py

@@ -1,548 +0,0 @@
-from enum import Enum
-from typing import Any, Optional
-
-from pydantic import BaseModel, ConfigDict
-
-from backend.data.model import SchemaField
-
-
-class PrimaryPhone(BaseModel):
-    """A primary phone in Apollo"""
-
-    number: str
-    source: str
-    sanitized_number: str
-
-
-class SenorityLevels(str, Enum):
-    """Seniority levels in Apollo"""
-
-    OWNER = "owner"
-    FOUNDER = "founder"
-    C_SUITE = "c_suite"
-    PARTNER = "partner"
-    VP = "vp"
-    HEAD = "head"
-    DIRECTOR = "director"
-    MANAGER = "manager"
-    SENIOR = "senior"
-    ENTRY = "entry"
-    INTERN = "intern"
-
-
-class ContactEmailStatuses(str, Enum):
-    """Contact email statuses in Apollo"""
-
-    VERIFIED = "verified"
-    UNVERIFIED = "unverified"
-    LIKELY_TO_ENGAGE = "likely_to_engage"
-    UNAVAILABLE = "unavailable"
-
-
-class RuleConfigStatus(BaseModel):
-    """A rule config status in Apollo"""
-
-    _id: str
-    created_at: str
-    rule_action_config_id: str
-    rule_config_id: str
-    status_cd: str
-    updated_at: str
-    id: str
-    key: str
-
-
-class ContactCampaignStatus(BaseModel):
-    """A contact campaign status in Apollo"""
-
-    id: str
-    emailer_campaign_id: str
-    send_email_from_user_id: str
-    inactive_reason: str
-    status: str
-    added_at: str
-    added_by_user_id: str
-    finished_at: str
-    paused_at: str
-    auto_unpause_at: str
-    send_email_from_email_address: str
-    send_email_from_email_account_id: str
-    manually_set_unpause: str
-    failure_reason: str
-    current_step_id: str
-    in_response_to_emailer_message_id: str
-    cc_emails: str
-    bcc_emails: str
-    to_emails: str
-
-
-class Account(BaseModel):
-    """An account in Apollo"""
-
-    id: str
-    name: str
-    website_url: str
-    blog_url: str
-    angellist_url: str
-    linkedin_url: str
-    twitter_url: str
-    facebook_url: str
-    primary_phone: PrimaryPhone
-    languages: list[str]
-    alexa_ranking: int
-    phone: str
-    linkedin_uid: str
-    founded_year: int
-    publicly_traded_symbol: str
-    publicly_traded_exchange: str
-    logo_url: str
-    chrunchbase_url: str
-    primary_domain: str
-    domain: str
-    team_id: str
-    organization_id: str
-    account_stage_id: str
-    source: str
-    original_source: str
-    creator_id: str
-    owner_id: str
-    created_at: str
-    phone_status: str
-    hubspot_id: str
-    salesforce_id: str
-    crm_owner_id: str
-    parent_account_id: str
-    sanitized_phone: str
-    # no listed type on the API docs
-    account_playbook_statues: list[Any]
-    account_rule_config_statuses: list[RuleConfigStatus]
-    existence_level: str
-    label_ids: list[str]
-    typed_custom_fields: Any
-    custom_field_errors: Any
-    modality: str
-    source_display_name: str
-    salesforce_record_id: str
-    crm_record_url: str
-
-
-class ContactEmail(BaseModel):
-    """A contact email in Apollo"""
-
-    email: str = ""
-    email_md5: str = ""
-    email_sha256: str = ""
-    email_status: str = ""
-    email_source: str = ""
-    extrapolated_email_confidence: str = ""
-    position: int = 0
-    email_from_customer: str = ""
-    free_domain: bool = True
-
-
-class EmploymentHistory(BaseModel):
-    """An employment history in Apollo"""
-
-    model_config = ConfigDict(
-        extra="allow",
-        arbitrary_types_allowed=True,
-        from_attributes=True,
-        populate_by_name=True,
-    )
-
-    _id: Optional[str] = None
-    created_at: Optional[str] = None
-    current: Optional[bool] = None
-    degree: Optional[str] = None
-    description: Optional[str] = None
-    emails: Optional[str] = None
-    end_date: Optional[str] = None
-    grade_level: Optional[str] = None
-    kind: Optional[str] = None
-    major: Optional[str] = None
-    organization_id: Optional[str] = None
-    organization_name: Optional[str] = None
-    raw_address: Optional[str] = None
-    start_date: Optional[str] = None
-    title: Optional[str] = None
-    updated_at: Optional[str] = None
-    id: Optional[str] = None
-    key: Optional[str] = None
-
-
-class Breadcrumb(BaseModel):
-    """A breadcrumb in Apollo"""
-
-    label: Optional[str] = "N/A"
-    signal_field_name: Optional[str] = "N/A"
-    value: str | list | None = "N/A"
-    display_name: Optional[str] = "N/A"
-
-
-class TypedCustomField(BaseModel):
-    """A typed custom field in Apollo"""
-
-    id: Optional[str] = "N/A"
-    value: Optional[str] = "N/A"
-
-
-class Pagination(BaseModel):
-    """Pagination in Apollo"""
-
-    model_config = ConfigDict(
-        extra="allow",
-        arbitrary_types_allowed=True,
-        from_attributes=True,
-        populate_by_name=True,
-    )
-
-    page: int = 0
-    per_page: int = 0
-    total_entries: int = 0
-    total_pages: int = 0
-
-
-class DialerFlags(BaseModel):
-    """A dialer flags in Apollo"""
-
-    country_name: str
-    country_enabled: bool
-    high_risk_calling_enabled: bool
-    potential_high_risk_number: bool
-
-
-class PhoneNumber(BaseModel):
-    """A phone number in Apollo"""
-
-    raw_number: str = ""
-    sanitized_number: str = ""
-    type: str = ""
-    position: int = 0
-    status: str = ""
-    dnc_status: str = ""
-    dnc_other_info: str = ""
-    dailer_flags: DialerFlags = DialerFlags(
-        country_name="",
-        country_enabled=True,
-        high_risk_calling_enabled=True,
-        potential_high_risk_number=True,
-    )
-
-
-class Organization(BaseModel):
-    """An organization in Apollo"""
-
-    model_config = ConfigDict(
-        extra="allow",
-        arbitrary_types_allowed=True,
-        from_attributes=True,
-        populate_by_name=True,
-    )
-
-    id: Optional[str] = "N/A"
-    name: Optional[str] = "N/A"
-    website_url: Optional[str] = "N/A"
-    blog_url: Optional[str] = "N/A"
-    angellist_url: Optional[str] = "N/A"
-    linkedin_url: Optional[str] = "N/A"
-    twitter_url: Optional[str] = "N/A"
-    facebook_url: Optional[str] = "N/A"
-    primary_phone: Optional[PrimaryPhone] = PrimaryPhone(
-        number="N/A", source="N/A", sanitized_number="N/A"
-    )
-    languages: list[str] = []
-    alexa_ranking: Optional[int] = 0
-    phone: Optional[str] = "N/A"
-    linkedin_uid: Optional[str] = "N/A"
-    founded_year: Optional[int] = 0
-    publicly_traded_symbol: Optional[str] = "N/A"
-    publicly_traded_exchange: Optional[str] = "N/A"
-    logo_url: Optional[str] = "N/A"
-    chrunchbase_url: Optional[str] = "N/A"
-    primary_domain: Optional[str] = "N/A"
-    sanitized_phone: Optional[str] = "N/A"
-    owned_by_organization_id: Optional[str] = "N/A"
-    intent_strength: Optional[str] = "N/A"
-    show_intent: bool = True
-    has_intent_signal_account: Optional[bool] = True
-    intent_signal_account: Optional[str] = "N/A"
-
-
-class Contact(BaseModel):
-    """A contact in Apollo"""
-
-    model_config = ConfigDict(
-        extra="allow",
-        arbitrary_types_allowed=True,
-        from_attributes=True,
-        populate_by_name=True,
-    )
-
-    contact_roles: list[Any] = []
-    id: Optional[str] = None
-    first_name: Optional[str] = None
-    last_name: Optional[str] = None
-    name: Optional[str] = None
-    linkedin_url: Optional[str] = None
-    title: Optional[str] = None
-    contact_stage_id: Optional[str] = None
-    owner_id: Optional[str] = None
-    creator_id: Optional[str] = None
-    person_id: Optional[str] = None
-    email_needs_tickling: bool = True
-    organization_name: Optional[str] = None
-    source: Optional[str] = None
-    original_source: Optional[str] = None
-    organization_id: Optional[str] = None
-    headline: Optional[str] = None
-    photo_url: Optional[str] = None
-    present_raw_address: Optional[str] = None
-    linkededin_uid: Optional[str] = None
-    extrapolated_email_confidence: Optional[float] = None
-    salesforce_id: Optional[str] = None
-    salesforce_lead_id: Optional[str] = None
-    salesforce_contact_id: Optional[str] = None
-    saleforce_account_id: Optional[str] = None
-    crm_owner_id: Optional[str] = None
-    created_at: Optional[str] = None
-    emailer_campaign_ids: list[str] = []
-    direct_dial_status: Optional[str] = None
-    direct_dial_enrichment_failed_at: Optional[str] = None
-    email_status: Optional[str] = None
-    email_source: Optional[str] = None
-    account_id: Optional[str] = None
-    last_activity_date: Optional[str] = None
-    hubspot_vid: Optional[str] = None
-    hubspot_company_id: Optional[str] = None
-    crm_id: Optional[str] = None
-    sanitized_phone: Optional[str] = None
-    merged_crm_ids: Optional[str] = None
-    updated_at: Optional[str] = None
-    queued_for_crm_push: bool = True
-    suggested_from_rule_engine_config_id: Optional[str] = None
-    email_unsubscribed: Optional[str] = None
-    label_ids: list[Any] = []
-    has_pending_email_arcgate_request: bool = True
-    has_email_arcgate_request: bool = True
-    existence_level: Optional[str] = None
-    email: Optional[str] = None
-    email_from_customer: Optional[str] = None
-    typed_custom_fields: list[TypedCustomField] = []
-    custom_field_errors: Any = None
-    salesforce_record_id: Optional[str] = None
-    crm_record_url: Optional[str] = None
-    email_status_unavailable_reason: Optional[str] = None
-    email_true_status: Optional[str] = None
-    updated_email_true_status: bool = True
-    contact_rule_config_statuses: list[RuleConfigStatus] = []
-    source_display_name: Optional[str] = None
-    twitter_url: Optional[str] = None
-    contact_campaign_statuses: list[ContactCampaignStatus] = []
-    state: Optional[str] = None
-    city: Optional[str] = None
-    country: Optional[str] = None
-    account: Optional[Account] = None
-    contact_emails: list[ContactEmail] = []
-    organization: Optional[Organization] = None
-    employment_history: list[EmploymentHistory] = []
-    time_zone: Optional[str] = None
-    intent_strength: Optional[str] = None
-    show_intent: bool = True
-    phone_numbers: list[PhoneNumber] = []
-    account_phone_note: Optional[str] = None
-    free_domain: bool = True
-    is_likely_to_engage: bool = True
-    email_domain_catchall: bool = True
-    contact_job_change_event: Optional[str] = None
-
-
-class SearchOrganizationsRequest(BaseModel):
-    """Request for Apollo's search organizations API"""
-
-    organization_num_empoloyees_range: list[int] = SchemaField(
-        description="""The number range of employees working for the company. This enables you to find companies based on headcount. You can add multiple ranges to expand your search results.
-
-Each range you add needs to be a string, with the upper and lower numbers of the range separated only by a comma.""",
-        default=[0, 1000000],
-    )
-
-    organization_locations: list[str] = SchemaField(
-        description="""The location of the company headquarters. You can search across cities, US states, and countries.
-
-If a company has several office locations, results are still based on the headquarters location. For example, if you search chicago but a company's HQ location is in boston, any Boston-based companies will not appearch in your search results, even if they match other parameters.
-
-To exclude companies based on location, use the organization_not_locations parameter.
-""",
-        default_factory=list,
-    )
-    organizations_not_locations: list[str] = SchemaField(
-        description="""Exclude companies from search results based on the location of the company headquarters. You can use cities, US states, and countries as locations to exclude.
-
-This parameter is useful for ensuring you do not prospect in an undesirable territory. For example, if you use ireland as a value, no Ireland-based companies will appear in your search results.
-""",
-        default_factory=list,
-    )
-    q_organization_keyword_tags: list[str] = SchemaField(
-        description="""Filter search results based on keywords associated with companies. For example, you can enter mining as a value to return only companies that have an association with the mining industry."""
-    )
-    q_organization_name: str = SchemaField(
-        description="""Filter search results to include a specific company name.
-
-If the value you enter for this parameter does not match with a company's name, the company will not appear in search results, even if it matches other parameters. Partial matches are accepted. For example, if you filter by the value marketing, a company called NY Marketing Unlimited would still be eligible as a search result, but NY Market Analysis would not be eligible."""
-    )
-    organization_ids: list[str] = SchemaField(
-        description="""The Apollo IDs for the companies you want to include in your search results. Each company in the Apollo database is assigned a unique ID.
-
-To find IDs, identify the values for organization_id when you call this endpoint.""",
-        default_factory=list,
-    )
-    max_results: int = SchemaField(
-        description="""The maximum number of results to return. If you don't specify this parameter, the default is 100.""",
-        default=100,
-        ge=1,
-        le=50000,
-        advanced=True,
-    )
-
-    page: int = SchemaField(
-        description="""The page number of the Apollo data that you want to retrieve.
-
-Use this parameter in combination with the per_page parameter to make search results for navigable and improve the performance of the endpoint.""",
-        default=1,
-    )
-    per_page: int = SchemaField(
-        description="""The number of search results that should be returned for each page. Limited the number of results per page improves the endpoint's performance.
-
-Use the page parameter to search the different pages of data.""",
-        default=100,
-    )
-
-
-class SearchOrganizationsResponse(BaseModel):
-    """Response from Apollo's search organizations API"""
-
-    breadcrumbs: list[Breadcrumb] = []
-    partial_results_only: bool = True
-    has_join: bool = True
-    disable_eu_prospecting: bool = True
-    partial_results_limit: int = 0
-    pagination: Pagination = Pagination(
-        page=0, per_page=0, total_entries=0, total_pages=0
-    )
-    # no listed type on the API docs
-    accounts: list[Any] = []
-    organizations: list[Organization] = []
-    models_ids: list[str] = []
-    num_fetch_result: Optional[str] = "N/A"
-    derived_params: Optional[str] = "N/A"
-
-
-class SearchPeopleRequest(BaseModel):
-    """Request for Apollo's search people API"""
-
-    person_titles: list[str] = SchemaField(
-        description="""Job titles held by the people you want to find. For a person to be included in search results, they only need to match 1 of the job titles you add. Adding more job titles expands your search results.
-
-Results also include job titles with the same terms, even if they are not exact matches. For example, searching for marketing manager might return people with the job title content marketing manager.
-
-Use this parameter in combination with the person_seniorities[] parameter to find people based on specific job functions and seniority levels.
-""",
-        default_factory=list,
-        placeholder="marketing manager",
-    )
-    person_locations: list[str] = SchemaField(
-        description="""The location where people live. You can search across cities, US states, and countries.
-
-To find people based on the headquarters locations of their current employer, use the organization_locations parameter.""",
-        default_factory=list,
-    )
-    person_seniorities: list[SenorityLevels] = SchemaField(
-        description="""The job seniority that people hold within their current employer. This enables you to find people that currently hold positions at certain reporting levels, such as Director level or senior IC level.
-
-For a person to be included in search results, they only need to match 1 of the seniorities you add. Adding more seniorities expands your search results.
-
-Searches only return results based on their current job title, so searching for Director-level employees only returns people that currently hold a Director-level title. If someone was previously a Director, but is currently a VP, they would not be included in your search results.
-
-Use this parameter in combination with the person_titles[] parameter to find people based on specific job functions and seniority levels.""",
-        default_factory=list,
-    )
-    organization_locations: list[str] = SchemaField(
-        description="""The location of the company headquarters for a person's current employer. You can search across cities, US states, and countries.
-
-If a company has several office locations, results are still based on the headquarters location. For example, if you search chicago but a company's HQ location is in boston, people that work for the Boston-based company will not appear in your results, even if they match other parameters.
-
-To find people based on their personal location, use the person_locations parameter.""",
-        default_factory=list,
-    )
-    q_organization_domains: list[str] = SchemaField(
-        description="""The domain name for the person's employer. This can be the current employer or a previous employer. Do not include www., the @ symbol, or similar.
-
-You can add multiple domains to search across companies.
-
-  Examples: apollo.io and microsoft.com""",
-        default_factory=list,
-    )
-    contact_email_statuses: list[ContactEmailStatuses] = SchemaField(
-        description="""The email statuses for the people you want to find. You can add multiple statuses to expand your search.""",
-        default_factory=list,
-    )
-    organization_ids: list[str] = SchemaField(
-        description="""The Apollo IDs for the companies (employers) you want to include in your search results. Each company in the Apollo database is assigned a unique ID.
-
-To find IDs, call the Organization Search endpoint and identify the values for organization_id.""",
-        default_factory=list,
-    )
-    organization_num_empoloyees_range: list[int] = SchemaField(
-        description="""The number range of employees working for the company. This enables you to find companies based on headcount. You can add multiple ranges to expand your search results.
-
-Each range you add needs to be a string, with the upper and lower numbers of the range separated only by a comma.""",
-        default_factory=list,
-    )
-    q_keywords: str = SchemaField(
-        description="""A string of words over which we want to filter the results""",
-        default="",
-    )
-    page: int = SchemaField(
-        description="""The page number of the Apollo data that you want to retrieve.
-
-Use this parameter in combination with the per_page parameter to make search results for navigable and improve the performance of the endpoint.""",
-        default=1,
-    )
-    per_page: int = SchemaField(
-        description="""The number of search results that should be returned for each page. Limited the number of results per page improves the endpoint's performance.
-
-Use the page parameter to search the different pages of data.""",
-        default=100,
-    )
-    max_results: int = SchemaField(
-        description="""The maximum number of results to return. If you don't specify this parameter, the default is 100.""",
-        default=100,
-        ge=1,
-        le=50000,
-        advanced=True,
-    )
-
-
-class SearchPeopleResponse(BaseModel):
-    """Response from Apollo's search people API"""
-
-    model_config = ConfigDict(
-        extra="allow",
-        arbitrary_types_allowed=True,
-        from_attributes=True,
-        populate_by_name=True,
-    )
-
-    breadcrumbs: list[Breadcrumb] = []
-    partial_results_only: bool = True
-    has_join: bool = True
-    disable_eu_prospecting: bool = True
-    partial_results_limit: int = 0
-    pagination: Pagination = Pagination(
-        page=0, per_page=0, total_entries=0, total_pages=0
-    )
-    contacts: list[Contact] = []
-    people: list[Contact] = []
-    model_ids: list[str] = []
-    num_fetch_result: Optional[str] = "N/A"
-    derived_params: Optional[str] = "N/A"

autogpt_platform/backend/backend/blocks/apollo/organization.py

@@ -1,219 +0,0 @@
-from backend.blocks.apollo._api import ApolloClient
-from backend.blocks.apollo._auth import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    ApolloCredentials,
-    ApolloCredentialsInput,
-)
-from backend.blocks.apollo.models import (
-    Organization,
-    PrimaryPhone,
-    SearchOrganizationsRequest,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-
-class SearchOrganizationsBlock(Block):
-    """Search for organizations in Apollo"""
-
-    class Input(BlockSchema):
-        organization_num_empoloyees_range: list[int] = SchemaField(
-            description="""The number range of employees working for the company. This enables you to find companies based on headcount. You can add multiple ranges to expand your search results.
-
-Each range you add needs to be a string, with the upper and lower numbers of the range separated only by a comma.""",
-            default=[0, 1000000],
-        )
-
-        organization_locations: list[str] = SchemaField(
-            description="""The location of the company headquarters. You can search across cities, US states, and countries.
-
-If a company has several office locations, results are still based on the headquarters location. For example, if you search chicago but a company's HQ location is in boston, any Boston-based companies will not appearch in your search results, even if they match other parameters.
-
-To exclude companies based on location, use the organization_not_locations parameter.
-""",
-            default_factory=list,
-        )
-        organizations_not_locations: list[str] = SchemaField(
-            description="""Exclude companies from search results based on the location of the company headquarters. You can use cities, US states, and countries as locations to exclude.
-
-This parameter is useful for ensuring you do not prospect in an undesirable territory. For example, if you use ireland as a value, no Ireland-based companies will appear in your search results.
-""",
-            default_factory=list,
-        )
-        q_organization_keyword_tags: list[str] = SchemaField(
-            description="""Filter search results based on keywords associated with companies. For example, you can enter mining as a value to return only companies that have an association with the mining industry.""",
-            default_factory=list,
-        )
-        q_organization_name: str = SchemaField(
-            description="""Filter search results to include a specific company name.
-
-If the value you enter for this parameter does not match with a company's name, the company will not appear in search results, even if it matches other parameters. Partial matches are accepted. For example, if you filter by the value marketing, a company called NY Marketing Unlimited would still be eligible as a search result, but NY Market Analysis would not be eligible.""",
-            default="",
-            advanced=False,
-        )
-        organization_ids: list[str] = SchemaField(
-            description="""The Apollo IDs for the companies you want to include in your search results. Each company in the Apollo database is assigned a unique ID.
-
-To find IDs, identify the values for organization_id when you call this endpoint.""",
-            default_factory=list,
-        )
-        max_results: int = SchemaField(
-            description="""The maximum number of results to return. If you don't specify this parameter, the default is 100.""",
-            default=100,
-            ge=1,
-            le=50000,
-            advanced=True,
-        )
-        credentials: ApolloCredentialsInput = SchemaField(
-            description="Apollo credentials",
-        )
-
-    class Output(BlockSchema):
-        organizations: list[Organization] = SchemaField(
-            description="List of organizations found",
-            default_factory=list,
-        )
-        organization: Organization = SchemaField(
-            description="Each found organization, one at a time",
-        )
-        error: str = SchemaField(
-            description="Error message if the search failed",
-            default="",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="3d71270d-599e-4148-9b95-71b35d2f44f0",
-            description="Search for organizations in Apollo",
-            categories={BlockCategory.SEARCH},
-            input_schema=SearchOrganizationsBlock.Input,
-            output_schema=SearchOrganizationsBlock.Output,
-            test_credentials=TEST_CREDENTIALS,
-            test_input={"query": "Google", "credentials": TEST_CREDENTIALS_INPUT},
-            test_output=[
-                (
-                    "organization",
-                    Organization(
-                        id="1",
-                        name="Google",
-                        website_url="https://google.com",
-                        blog_url="https://google.com/blog",
-                        angellist_url="https://angel.co/google",
-                        linkedin_url="https://linkedin.com/company/google",
-                        twitter_url="https://twitter.com/google",
-                        facebook_url="https://facebook.com/google",
-                        primary_phone=PrimaryPhone(
-                            source="google",
-                            number="1234567890",
-                            sanitized_number="1234567890",
-                        ),
-                        languages=["en"],
-                        alexa_ranking=1000,
-                        phone="1234567890",
-                        linkedin_uid="1234567890",
-                        founded_year=2000,
-                        publicly_traded_symbol="GOOGL",
-                        publicly_traded_exchange="NASDAQ",
-                        logo_url="https://google.com/logo.png",
-                        chrunchbase_url="https://chrunchbase.com/google",
-                        primary_domain="google.com",
-                        sanitized_phone="1234567890",
-                        owned_by_organization_id="1",
-                        intent_strength="strong",
-                        show_intent=True,
-                        has_intent_signal_account=True,
-                        intent_signal_account="1",
-                    ),
-                ),
-                (
-                    "organizations",
-                    [
-                        Organization(
-                            id="1",
-                            name="Google",
-                            website_url="https://google.com",
-                            blog_url="https://google.com/blog",
-                            angellist_url="https://angel.co/google",
-                            linkedin_url="https://linkedin.com/company/google",
-                            twitter_url="https://twitter.com/google",
-                            facebook_url="https://facebook.com/google",
-                            primary_phone=PrimaryPhone(
-                                source="google",
-                                number="1234567890",
-                                sanitized_number="1234567890",
-                            ),
-                            languages=["en"],
-                            alexa_ranking=1000,
-                            phone="1234567890",
-                            linkedin_uid="1234567890",
-                            founded_year=2000,
-                            publicly_traded_symbol="GOOGL",
-                            publicly_traded_exchange="NASDAQ",
-                            logo_url="https://google.com/logo.png",
-                            chrunchbase_url="https://chrunchbase.com/google",
-                            primary_domain="google.com",
-                            sanitized_phone="1234567890",
-                            owned_by_organization_id="1",
-                            intent_strength="strong",
-                            show_intent=True,
-                            has_intent_signal_account=True,
-                            intent_signal_account="1",
-                        ),
-                    ],
-                ),
-            ],
-            test_mock={
-                "search_organizations": lambda *args, **kwargs: [
-                    Organization(
-                        id="1",
-                        name="Google",
-                        website_url="https://google.com",
-                        blog_url="https://google.com/blog",
-                        angellist_url="https://angel.co/google",
-                        linkedin_url="https://linkedin.com/company/google",
-                        twitter_url="https://twitter.com/google",
-                        facebook_url="https://facebook.com/google",
-                        primary_phone=PrimaryPhone(
-                            source="google",
-                            number="1234567890",
-                            sanitized_number="1234567890",
-                        ),
-                        languages=["en"],
-                        alexa_ranking=1000,
-                        phone="1234567890",
-                        linkedin_uid="1234567890",
-                        founded_year=2000,
-                        publicly_traded_symbol="GOOGL",
-                        publicly_traded_exchange="NASDAQ",
-                        logo_url="https://google.com/logo.png",
-                        chrunchbase_url="https://chrunchbase.com/google",
-                        primary_domain="google.com",
-                        sanitized_phone="1234567890",
-                        owned_by_organization_id="1",
-                        intent_strength="strong",
-                        show_intent=True,
-                        has_intent_signal_account=True,
-                        intent_signal_account="1",
-                    )
-                ]
-            },
-        )
-
-    @staticmethod
-    def search_organizations(
-        query: SearchOrganizationsRequest, credentials: ApolloCredentials
-    ) -> list[Organization]:
-        client = ApolloClient(credentials)
-        return client.search_organizations(query)
-
-    def run(
-        self, input_data: Input, *, credentials: ApolloCredentials, **kwargs
-    ) -> BlockOutput:
-        query = SearchOrganizationsRequest(
-            **input_data.model_dump(exclude={"credentials"})
-        )
-        organizations = self.search_organizations(query, credentials)
-        for organization in organizations:
-            yield "organization", organization
-        yield "organizations", organizations

autogpt_platform/backend/backend/blocks/apollo/people.py

@@ -1,394 +0,0 @@
-from backend.blocks.apollo._api import ApolloClient
-from backend.blocks.apollo._auth import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    ApolloCredentials,
-    ApolloCredentialsInput,
-)
-from backend.blocks.apollo.models import (
-    Contact,
-    ContactEmailStatuses,
-    SearchPeopleRequest,
-    SenorityLevels,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-
-class SearchPeopleBlock(Block):
-    """Search for people in Apollo"""
-
-    class Input(BlockSchema):
-        person_titles: list[str] = SchemaField(
-            description="""Job titles held by the people you want to find. For a person to be included in search results, they only need to match 1 of the job titles you add. Adding more job titles expands your search results.
-
-        Results also include job titles with the same terms, even if they are not exact matches. For example, searching for marketing manager might return people with the job title content marketing manager.
-
-        Use this parameter in combination with the person_seniorities[] parameter to find people based on specific job functions and seniority levels.
-        """,
-            default_factory=list,
-            advanced=False,
-        )
-        person_locations: list[str] = SchemaField(
-            description="""The location where people live. You can search across cities, US states, and countries.
-
-        To find people based on the headquarters locations of their current employer, use the organization_locations parameter.""",
-            default_factory=list,
-            advanced=False,
-        )
-        person_seniorities: list[SenorityLevels] = SchemaField(
-            description="""The job seniority that people hold within their current employer. This enables you to find people that currently hold positions at certain reporting levels, such as Director level or senior IC level.
-
-        For a person to be included in search results, they only need to match 1 of the seniorities you add. Adding more seniorities expands your search results.
-
-        Searches only return results based on their current job title, so searching for Director-level employees only returns people that currently hold a Director-level title. If someone was previously a Director, but is currently a VP, they would not be included in your search results.
-
-        Use this parameter in combination with the person_titles[] parameter to find people based on specific job functions and seniority levels.""",
-            default_factory=list,
-            advanced=False,
-        )
-        organization_locations: list[str] = SchemaField(
-            description="""The location of the company headquarters for a person's current employer. You can search across cities, US states, and countries.
-
-        If a company has several office locations, results are still based on the headquarters location. For example, if you search chicago but a company's HQ location is in boston, people that work for the Boston-based company will not appear in your results, even if they match other parameters.
-
-        To find people based on their personal location, use the person_locations parameter.""",
-            default_factory=list,
-            advanced=False,
-        )
-        q_organization_domains: list[str] = SchemaField(
-            description="""The domain name for the person's employer. This can be the current employer or a previous employer. Do not include www., the @ symbol, or similar.
-
-        You can add multiple domains to search across companies.
-
-          Examples: apollo.io and microsoft.com""",
-            default_factory=list,
-            advanced=False,
-        )
-        contact_email_statuses: list[ContactEmailStatuses] = SchemaField(
-            description="""The email statuses for the people you want to find. You can add multiple statuses to expand your search.""",
-            default_factory=list,
-            advanced=False,
-        )
-        organization_ids: list[str] = SchemaField(
-            description="""The Apollo IDs for the companies (employers) you want to include in your search results. Each company in the Apollo database is assigned a unique ID.
-
-        To find IDs, call the Organization Search endpoint and identify the values for organization_id.""",
-            default_factory=list,
-            advanced=False,
-        )
-        organization_num_empoloyees_range: list[int] = SchemaField(
-            description="""The number range of employees working for the company. This enables you to find companies based on headcount. You can add multiple ranges to expand your search results.
-
-        Each range you add needs to be a string, with the upper and lower numbers of the range separated only by a comma.""",
-            default_factory=list,
-            advanced=False,
-        )
-        q_keywords: str = SchemaField(
-            description="""A string of words over which we want to filter the results""",
-            default="",
-            advanced=False,
-        )
-        max_results: int = SchemaField(
-            description="""The maximum number of results to return. If you don't specify this parameter, the default is 100.""",
-            default=100,
-            ge=1,
-            le=50000,
-            advanced=True,
-        )
-
-        credentials: ApolloCredentialsInput = SchemaField(
-            description="Apollo credentials",
-        )
-
-    class Output(BlockSchema):
-        people: list[Contact] = SchemaField(
-            description="List of people found",
-            default_factory=list,
-        )
-        person: Contact = SchemaField(
-            description="Each found person, one at a time",
-        )
-        error: str = SchemaField(
-            description="Error message if the search failed",
-            default="",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="c2adb3aa-5aae-488d-8a6e-4eb8c23e2ed6",
-            description="Search for people in Apollo",
-            categories={BlockCategory.SEARCH},
-            input_schema=SearchPeopleBlock.Input,
-            output_schema=SearchPeopleBlock.Output,
-            test_credentials=TEST_CREDENTIALS,
-            test_input={"credentials": TEST_CREDENTIALS_INPUT},
-            test_output=[
-                (
-                    "person",
-                    Contact(
-                        contact_roles=[],
-                        id="1",
-                        name="John Doe",
-                        first_name="John",
-                        last_name="Doe",
-                        linkedin_url="https://www.linkedin.com/in/johndoe",
-                        title="Software Engineer",
-                        organization_name="Google",
-                        organization_id="123456",
-                        contact_stage_id="1",
-                        owner_id="1",
-                        creator_id="1",
-                        person_id="1",
-                        email_needs_tickling=True,
-                        source="apollo",
-                        original_source="apollo",
-                        headline="Software Engineer",
-                        photo_url="https://www.linkedin.com/in/johndoe",
-                        present_raw_address="123 Main St, Anytown, USA",
-                        linkededin_uid="123456",
-                        extrapolated_email_confidence=0.8,
-                        salesforce_id="123456",
-                        salesforce_lead_id="123456",
-                        salesforce_contact_id="123456",
-                        saleforce_account_id="123456",
-                        crm_owner_id="123456",
-                        created_at="2021-01-01",
-                        emailer_campaign_ids=[],
-                        direct_dial_status="active",
-                        direct_dial_enrichment_failed_at="2021-01-01",
-                        email_status="active",
-                        email_source="apollo",
-                        account_id="123456",
-                        last_activity_date="2021-01-01",
-                        hubspot_vid="123456",
-                        hubspot_company_id="123456",
-                        crm_id="123456",
-                        sanitized_phone="123456",
-                        merged_crm_ids="123456",
-                        updated_at="2021-01-01",
-                        queued_for_crm_push=True,
-                        suggested_from_rule_engine_config_id="123456",
-                        email_unsubscribed=None,
-                        label_ids=[],
-                        has_pending_email_arcgate_request=True,
-                        has_email_arcgate_request=True,
-                        existence_level=None,
-                        email=None,
-                        email_from_customer=None,
-                        typed_custom_fields=[],
-                        custom_field_errors=None,
-                        salesforce_record_id=None,
-                        crm_record_url=None,
-                        email_status_unavailable_reason=None,
-                        email_true_status=None,
-                        updated_email_true_status=True,
-                        contact_rule_config_statuses=[],
-                        source_display_name=None,
-                        twitter_url=None,
-                        contact_campaign_statuses=[],
-                        state=None,
-                        city=None,
-                        country=None,
-                        account=None,
-                        contact_emails=[],
-                        organization=None,
-                        employment_history=[],
-                        time_zone=None,
-                        intent_strength=None,
-                        show_intent=True,
-                        phone_numbers=[],
-                        account_phone_note=None,
-                        free_domain=True,
-                        is_likely_to_engage=True,
-                        email_domain_catchall=True,
-                        contact_job_change_event=None,
-                    ),
-                ),
-                (
-                    "people",
-                    [
-                        Contact(
-                            contact_roles=[],
-                            id="1",
-                            name="John Doe",
-                            first_name="John",
-                            last_name="Doe",
-                            linkedin_url="https://www.linkedin.com/in/johndoe",
-                            title="Software Engineer",
-                            organization_name="Google",
-                            organization_id="123456",
-                            contact_stage_id="1",
-                            owner_id="1",
-                            creator_id="1",
-                            person_id="1",
-                            email_needs_tickling=True,
-                            source="apollo",
-                            original_source="apollo",
-                            headline="Software Engineer",
-                            photo_url="https://www.linkedin.com/in/johndoe",
-                            present_raw_address="123 Main St, Anytown, USA",
-                            linkededin_uid="123456",
-                            extrapolated_email_confidence=0.8,
-                            salesforce_id="123456",
-                            salesforce_lead_id="123456",
-                            salesforce_contact_id="123456",
-                            saleforce_account_id="123456",
-                            crm_owner_id="123456",
-                            created_at="2021-01-01",
-                            emailer_campaign_ids=[],
-                            direct_dial_status="active",
-                            direct_dial_enrichment_failed_at="2021-01-01",
-                            email_status="active",
-                            email_source="apollo",
-                            account_id="123456",
-                            last_activity_date="2021-01-01",
-                            hubspot_vid="123456",
-                            hubspot_company_id="123456",
-                            crm_id="123456",
-                            sanitized_phone="123456",
-                            merged_crm_ids="123456",
-                            updated_at="2021-01-01",
-                            queued_for_crm_push=True,
-                            suggested_from_rule_engine_config_id="123456",
-                            email_unsubscribed=None,
-                            label_ids=[],
-                            has_pending_email_arcgate_request=True,
-                            has_email_arcgate_request=True,
-                            existence_level=None,
-                            email=None,
-                            email_from_customer=None,
-                            typed_custom_fields=[],
-                            custom_field_errors=None,
-                            salesforce_record_id=None,
-                            crm_record_url=None,
-                            email_status_unavailable_reason=None,
-                            email_true_status=None,
-                            updated_email_true_status=True,
-                            contact_rule_config_statuses=[],
-                            source_display_name=None,
-                            twitter_url=None,
-                            contact_campaign_statuses=[],
-                            state=None,
-                            city=None,
-                            country=None,
-                            account=None,
-                            contact_emails=[],
-                            organization=None,
-                            employment_history=[],
-                            time_zone=None,
-                            intent_strength=None,
-                            show_intent=True,
-                            phone_numbers=[],
-                            account_phone_note=None,
-                            free_domain=True,
-                            is_likely_to_engage=True,
-                            email_domain_catchall=True,
-                            contact_job_change_event=None,
-                        ),
-                    ],
-                ),
-            ],
-            test_mock={
-                "search_people": lambda query, credentials: [
-                    Contact(
-                        id="1",
-                        name="John Doe",
-                        first_name="John",
-                        last_name="Doe",
-                        linkedin_url="https://www.linkedin.com/in/johndoe",
-                        title="Software Engineer",
-                        organization_name="Google",
-                        organization_id="123456",
-                        contact_stage_id="1",
-                        owner_id="1",
-                        creator_id="1",
-                        person_id="1",
-                        email_needs_tickling=True,
-                        source="apollo",
-                        original_source="apollo",
-                        headline="Software Engineer",
-                        photo_url="https://www.linkedin.com/in/johndoe",
-                        present_raw_address="123 Main St, Anytown, USA",
-                        linkededin_uid="123456",
-                        extrapolated_email_confidence=0.8,
-                        salesforce_id="123456",
-                        salesforce_lead_id="123456",
-                        salesforce_contact_id="123456",
-                        saleforce_account_id="123456",
-                        crm_owner_id="123456",
-                        created_at="2021-01-01",
-                        emailer_campaign_ids=[],
-                        direct_dial_status="active",
-                        direct_dial_enrichment_failed_at="2021-01-01",
-                        email_status="active",
-                        email_source="apollo",
-                        account_id="123456",
-                        last_activity_date="2021-01-01",
-                        hubspot_vid="123456",
-                        hubspot_company_id="123456",
-                        crm_id="123456",
-                        sanitized_phone="123456",
-                        merged_crm_ids="123456",
-                        updated_at="2021-01-01",
-                        queued_for_crm_push=True,
-                        suggested_from_rule_engine_config_id="123456",
-                        email_unsubscribed=None,
-                        label_ids=[],
-                        has_pending_email_arcgate_request=True,
-                        has_email_arcgate_request=True,
-                        existence_level=None,
-                        email=None,
-                        email_from_customer=None,
-                        typed_custom_fields=[],
-                        custom_field_errors=None,
-                        salesforce_record_id=None,
-                        crm_record_url=None,
-                        email_status_unavailable_reason=None,
-                        email_true_status=None,
-                        updated_email_true_status=True,
-                        contact_rule_config_statuses=[],
-                        source_display_name=None,
-                        twitter_url=None,
-                        contact_campaign_statuses=[],
-                        state=None,
-                        city=None,
-                        country=None,
-                        account=None,
-                        contact_emails=[],
-                        organization=None,
-                        employment_history=[],
-                        time_zone=None,
-                        intent_strength=None,
-                        show_intent=True,
-                        phone_numbers=[],
-                        account_phone_note=None,
-                        free_domain=True,
-                        is_likely_to_engage=True,
-                        email_domain_catchall=True,
-                        contact_job_change_event=None,
-                    ),
-                ]
-            },
-        )
-
-    @staticmethod
-    def search_people(
-        query: SearchPeopleRequest, credentials: ApolloCredentials
-    ) -> list[Contact]:
-        client = ApolloClient(credentials)
-        return client.search_people(query)
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: ApolloCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-
-        query = SearchPeopleRequest(**input_data.model_dump(exclude={"credentials"}))
-        people = self.search_people(query, credentials)
-        for person in people:
-            yield "person", person
-        yield "people", people

autogpt_platform/backend/backend/blocks/basic.py

@@ -1,48 +1,14 @@
-import enum
+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 import json
-from backend.util.file import store_media_file
 from backend.util.mock import MockObject
-from backend.util.type import MediaFileType, convert
 
-
-class FileStoreBlock(Block):
-    class Input(BlockSchema):
-        file_in: MediaFileType = SchemaField(
-            description="The file to store in the temporary directory, it can be a URL, data URI, or local path."
-        )
-
-    class Output(BlockSchema):
-        file_out: MediaFileType = SchemaField(
-            description="The relative path to the stored file in the temporary directory."
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="cbb50872-625b-42f0-8203-a2ae78242d8a",
-            description="Stores the input file in the temporary directory.",
-            categories={BlockCategory.BASIC, BlockCategory.MULTIMEDIA},
-            input_schema=FileStoreBlock.Input,
-            output_schema=FileStoreBlock.Output,
-            static_output=True,
-        )
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        graph_exec_id: str,
-        **kwargs,
-    ) -> BlockOutput:
-        file_path = store_media_file(
-            graph_exec_id=graph_exec_id,
-            file=input_data.file_in,
-            return_content=False,
-        )
-        yield "file_out", file_path
+jinja = Environment(loader=BaseLoader())
 
 
 class StoreValueBlock(Block):
@@ -53,18 +19,18 @@ class StoreValueBlock(Block):
     """
 
     class Input(BlockSchema):
-        input: Any = SchemaField(
+        input: Any = Field(
             description="Trigger the block to produce the output. "
             "The value is only used when `data` is None."
         )
-        data: Any = SchemaField(
+        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 = SchemaField(description="The stored data retained in the block.")
+        output: Any
 
     def __init__(self):
         super().__init__(
@@ -88,17 +54,38 @@ class StoreValueBlock(Block):
         yield "output", input_data.data or input_data.input
 
 
-class FindInDictionaryBlock(Block):
+class PrintToConsoleBlock(Block):
     class Input(BlockSchema):
-        input: Any = SchemaField(description="Dictionary to lookup from")
-        key: str | int = SchemaField(description="Key to lookup in the dictionary")
+        text: str
 
     class Output(BlockSchema):
-        output: Any = SchemaField(description="Value found for the given key")
-        missing: Any = SchemaField(
-            description="Value of the input that missing the key"
+        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="0e50422c-6dee-4145-83d6-3a5a392f65de",
@@ -128,9 +115,6 @@ class FindInDictionaryBlock(Block):
         obj = input_data.input
         key = input_data.key
 
-        if isinstance(obj, str):
-            obj = json.loads(obj)
-
         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):
@@ -148,28 +132,171 @@ class FindInDictionaryBlock(Block):
             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[Any, Any] = SchemaField(
-            default_factory=dict,
+        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(
-            default="",
-            description="The key for the new entry.",
-            placeholder="new_key",
-            advanced=False,
+            description="The key for the new entry.", placeholder="new_key"
         )
         value: Any = SchemaField(
-            default=None,
-            description="The value for the new entry.",
-            placeholder="new_value",
-            advanced=False,
-        )
-        entries: dict[Any, Any] = SchemaField(
-            default_factory=dict,
-            description="The entries to add to the dictionary. This is the batch version of the `key` and `value` fields.",
-            advanced=True,
+            description="The value for the new entry.", placeholder="new_value"
         )
 
     class Output(BlockSchema):
@@ -192,10 +319,6 @@ class AddToDictionaryBlock(Block):
                     "value": "new_value",
                 },
                 {"key": "first_key", "value": "first_value"},
-                {
-                    "dictionary": {"existing_key": "existing_value"},
-                    "entries": {"new_key": "new_value", "first_key": "first_value"},
-                },
             ],
             test_output=[
                 (
@@ -203,49 +326,41 @@ class AddToDictionaryBlock(Block):
                     {"existing_key": "existing_value", "new_key": "new_value"},
                 ),
                 ("updated_dictionary", {"first_key": "first_value"}),
-                (
-                    "updated_dictionary",
-                    {
-                        "existing_key": "existing_value",
-                        "new_key": "new_value",
-                        "first_key": "first_value",
-                    },
-                ),
             ],
         )
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        updated_dict = input_data.dictionary.copy()
+        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()
 
-        if input_data.value is not None and input_data.key:
+            # Add the new key-value pair
             updated_dict[input_data.key] = input_data.value
 
-        for key, value in input_data.entries.items():
-            updated_dict[key] = value
-
-        yield "updated_dictionary", updated_dict
+            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] = SchemaField(
-            default_factory=list,
-            advanced=False,
+        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.).",
-            advanced=False,
-            default=None,
-        )
-        entries: List[Any] = SchemaField(
-            default_factory=lambda: list(),
-            description="The entries to add to the list. This is the batch version of the `entry` field.",
-            advanced=True,
+            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):
@@ -269,12 +384,6 @@ class AddToListBlock(Block):
                 },
                 {"entry": "first_entry"},
                 {"list": ["a", "b", "c"], "entry": "d"},
-                {
-                    "entry": "e",
-                    "entries": ["f", "g"],
-                    "list": ["a", "b"],
-                    "position": 1,
-                },
             ],
             test_output=[
                 (
@@ -288,64 +397,27 @@ class AddToListBlock(Block):
                 ),
                 ("updated_list", ["first_entry"]),
                 ("updated_list", ["a", "b", "c", "d"]),
-                ("updated_list", ["a", "f", "g", "e", "b"]),
-            ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        entries_added = input_data.entries.copy()
-        if input_data.entry:
-            entries_added.append(input_data.entry)
-
-        updated_list = input_data.list.copy()
-        if (pos := input_data.position) is not None:
-            updated_list = updated_list[:pos] + entries_added + updated_list[pos:]
-        else:
-            updated_list += entries_added
-
-        yield "updated_list", updated_list
-
-
-class FindInListBlock(Block):
-    class Input(BlockSchema):
-        list: List[Any] = SchemaField(description="The list to search in.")
-        value: Any = SchemaField(description="The value to search for.")
-
-    class Output(BlockSchema):
-        index: int = SchemaField(description="The index of the value in the list.")
-        found: bool = SchemaField(
-            description="Whether the value was found in the list."
-        )
-        not_found_value: Any = SchemaField(
-            description="The value that was not found in the list."
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="5e2c6d0a-1e37-489f-b1d0-8e1812b23333",
-            description="Finds the index of the value in the list.",
-            categories={BlockCategory.BASIC},
-            input_schema=FindInListBlock.Input,
-            output_schema=FindInListBlock.Output,
-            test_input=[
-                {"list": [1, 2, 3, 4, 5], "value": 3},
-                {"list": [1, 2, 3, 4, 5], "value": 6},
-            ],
-            test_output=[
-                ("index", 2),
-                ("found", True),
-                ("found", False),
-                ("not_found_value", 6),
             ],
         )
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
         try:
-            yield "index", input_data.list.index(input_data.value)
-            yield "found", True
-        except ValueError:
-            yield "found", False
-            yield "not_found_value", input_data.value
+            # 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):
@@ -371,145 +443,3 @@ class NoteBlock(Block):
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
         yield "output", input_data.text
-
-
-class CreateDictionaryBlock(Block):
-    class Input(BlockSchema):
-        values: dict[str, Any] = SchemaField(
-            description="Key-value pairs to create the dictionary with",
-            placeholder="e.g., {'name': 'Alice', 'age': 25}",
-        )
-
-    class Output(BlockSchema):
-        dictionary: dict[str, Any] = SchemaField(
-            description="The created dictionary containing the specified key-value pairs"
-        )
-        error: str = SchemaField(
-            description="Error message if dictionary creation failed"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="b924ddf4-de4f-4b56-9a85-358930dcbc91",
-            description="Creates a dictionary with the specified key-value pairs. Use this when you know all the values you want to add upfront.",
-            categories={BlockCategory.DATA},
-            input_schema=CreateDictionaryBlock.Input,
-            output_schema=CreateDictionaryBlock.Output,
-            test_input=[
-                {
-                    "values": {"name": "Alice", "age": 25, "city": "New York"},
-                },
-                {
-                    "values": {"numbers": [1, 2, 3], "active": True, "score": 95.5},
-                },
-            ],
-            test_output=[
-                (
-                    "dictionary",
-                    {"name": "Alice", "age": 25, "city": "New York"},
-                ),
-                (
-                    "dictionary",
-                    {"numbers": [1, 2, 3], "active": True, "score": 95.5},
-                ),
-            ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        try:
-            # The values are already validated by Pydantic schema
-            yield "dictionary", input_data.values
-        except Exception as e:
-            yield "error", f"Failed to create dictionary: {str(e)}"
-
-
-class CreateListBlock(Block):
-    class Input(BlockSchema):
-        values: List[Any] = SchemaField(
-            description="A list of values to be combined into a new list.",
-            placeholder="e.g., ['Alice', 25, True]",
-        )
-
-    class Output(BlockSchema):
-        list: List[Any] = SchemaField(
-            description="The created list containing the specified values."
-        )
-        error: str = SchemaField(description="Error message if list creation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="a912d5c7-6e00-4542-b2a9-8034136930e4",
-            description="Creates a list with the specified values. Use this when you know all the values you want to add upfront.",
-            categories={BlockCategory.DATA},
-            input_schema=CreateListBlock.Input,
-            output_schema=CreateListBlock.Output,
-            test_input=[
-                {
-                    "values": ["Alice", 25, True],
-                },
-                {
-                    "values": [1, 2, 3, "four", {"key": "value"}],
-                },
-            ],
-            test_output=[
-                (
-                    "list",
-                    ["Alice", 25, True],
-                ),
-                (
-                    "list",
-                    [1, 2, 3, "four", {"key": "value"}],
-                ),
-            ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        try:
-            # The values are already validated by Pydantic schema
-            yield "list", input_data.values
-        except Exception as e:
-            yield "error", f"Failed to create list: {str(e)}"
-
-
-class TypeOptions(enum.Enum):
-    STRING = "string"
-    NUMBER = "number"
-    BOOLEAN = "boolean"
-    LIST = "list"
-    DICTIONARY = "dictionary"
-
-
-class UniversalTypeConverterBlock(Block):
-    class Input(BlockSchema):
-        value: Any = SchemaField(
-            description="The value to convert to a universal type."
-        )
-        type: TypeOptions = SchemaField(description="The type to convert the value to.")
-
-    class Output(BlockSchema):
-        value: Any = SchemaField(description="The converted value.")
-
-    def __init__(self):
-        super().__init__(
-            id="95d1b990-ce13-4d88-9737-ba5c2070c97b",
-            description="This block is used to convert a value to a universal type.",
-            categories={BlockCategory.BASIC},
-            input_schema=UniversalTypeConverterBlock.Input,
-            output_schema=UniversalTypeConverterBlock.Output,
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        try:
-            converted_value = convert(
-                input_data.value,
-                {
-                    TypeOptions.STRING: str,
-                    TypeOptions.NUMBER: float,
-                    TypeOptions.BOOLEAN: bool,
-                    TypeOptions.LIST: list,
-                    TypeOptions.DICTIONARY: dict,
-                }[input_data.type],
-            )
-            yield "value", converted_value
-        except Exception as e:
-            yield "error", f"Failed to convert value: {str(e)}"

autogpt_platform/backend/backend/blocks/block.py

@@ -3,7 +3,6 @@ import re
 from typing import Type
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
 
 
 class BlockInstallationBlock(Block):
@@ -16,17 +15,11 @@ class BlockInstallationBlock(Block):
     """
 
     class Input(BlockSchema):
-        code: str = SchemaField(
-            description="Python code of the block to be installed",
-        )
+        code: str
 
     class Output(BlockSchema):
-        success: str = SchemaField(
-            description="Success message if the block is installed successfully",
-        )
-        error: str = SchemaField(
-            description="Error message if the block installation fails",
-        )
+        success: str
+        error: str
 
     def __init__(self):
         super().__init__(
@@ -44,12 +37,14 @@ class BlockInstallationBlock(Block):
         if search := re.search(r"class (\w+)\(Block\):", code):
             class_name = search.group(1)
         else:
-            raise RuntimeError("No class found in the code.")
+            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:
-            raise RuntimeError("No UUID found in the code.")
+            yield "error", "No UUID found in the code."
+            return
 
         block_dir = os.path.dirname(__file__)
         file_path = f"{block_dir}/{file_name}.py"
@@ -68,4 +63,4 @@ class BlockInstallationBlock(Block):
             yield "success", "Block installed successfully."
         except Exception as e:
             os.remove(file_path)
-            raise RuntimeError(f"[Code]\n{code}\n\n[Error]\n{str(e)}")
+            yield "error", f"[Code]\n{code}\n\n[Error]\n{str(e)}"

autogpt_platform/backend/backend/blocks/branching.py

@@ -71,24 +71,11 @@ class ConditionBlock(Block):
         )
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        operator = input_data.operator
-
         value1 = input_data.value1
-        if isinstance(value1, str):
-            try:
-                value1 = float(value1.strip())
-            except ValueError:
-                value1 = value1.strip()
-
+        operator = input_data.operator
         value2 = input_data.value2
-        if isinstance(value2, str):
-            try:
-                value2 = float(value2.strip())
-            except ValueError:
-                value2 = value2.strip()
-
         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 value2
+        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,
@@ -99,91 +86,17 @@ class ConditionBlock(Block):
             ComparisonOperator.LESS_THAN_OR_EQUAL: lambda a, b: a <= b,
         }
 
-        result = comparison_funcs[operator](value1, value2)
+        try:
+            result = comparison_funcs[operator](value1, value2)
 
-        yield "result", result
+            yield "result", result
 
-        if result:
-            yield "yes_output", yes_value
-        else:
-            yield "no_output", no_value
+            if result:
+                yield "yes_output", yes_value
+            else:
+                yield "no_output", no_value
 
-
-class IfInputMatchesBlock(Block):
-    class Input(BlockSchema):
-        input: Any = SchemaField(
-            description="The input to match against",
-            placeholder="For example: 10 or 'hello' or True",
-        )
-        value: Any = SchemaField(
-            description="The value to output if the input matches",
-            placeholder="For example: 'Greater' or 20 or False",
-        )
-        yes_value: Any = SchemaField(
-            description="The value to output if the input matches",
-            placeholder="For example: 'Greater' or 20 or False",
-            default=None,
-        )
-        no_value: Any = SchemaField(
-            description="The value to output if the input does not match",
-            placeholder="For example: 'Greater' or 20 or False",
-            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="6dbbc4b3-ca6c-42b6-b508-da52d23e13f2",
-            input_schema=IfInputMatchesBlock.Input,
-            output_schema=IfInputMatchesBlock.Output,
-            description="Handles conditional logic based on comparison operators",
-            categories={BlockCategory.LOGIC},
-            test_input=[
-                {
-                    "input": 10,
-                    "value": 10,
-                    "yes_value": "Greater",
-                    "no_value": "Not greater",
-                },
-                {
-                    "input": 10,
-                    "value": 20,
-                    "yes_value": "Greater",
-                    "no_value": "Not greater",
-                },
-                {
-                    "input": 10,
-                    "value": None,
-                    "yes_value": "Yes",
-                    "no_value": "No",
-                },
-            ],
-            test_output=[
-                ("result", True),
-                ("yes_output", "Greater"),
-                ("result", False),
-                ("no_output", "Not greater"),
-                ("result", False),
-                ("no_output", "No"),
-                # ("result", True),
-                # ("yes_output", "Yes"),
-            ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        if input_data.input == input_data.value or input_data.input is input_data.value:
-            yield "result", True
-            yield "yes_output", input_data.yes_value
-        else:
-            yield "result", False
-            yield "no_output", input_data.no_value
+        except Exception:
+            yield "result", None
+            yield "yes_output", None
+            yield "no_output", None

autogpt_platform/backend/backend/blocks/code_executor.py

@@ -1,457 +0,0 @@
-from enum import Enum
-from typing import Literal
-
-from e2b_code_interpreter import Sandbox
-from pydantic import SecretStr
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import (
-    APIKeyCredentials,
-    CredentialsField,
-    CredentialsMetaInput,
-    SchemaField,
-)
-from backend.integrations.providers import ProviderName
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="e2b",
-    api_key=SecretStr("mock-e2b-api-key"),
-    title="Mock E2B API key",
-    expires_at=None,
-)
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.type,
-}
-
-
-class ProgrammingLanguage(Enum):
-    PYTHON = "python"
-    JAVASCRIPT = "js"
-    BASH = "bash"
-    R = "r"
-    JAVA = "java"
-
-
-class CodeExecutionBlock(Block):
-    # TODO : Add support to upload and download files
-    # Currently, You can customized the CPU and Memory, only by creating a pre customized sandbox template
-    class Input(BlockSchema):
-        credentials: CredentialsMetaInput[
-            Literal[ProviderName.E2B], Literal["api_key"]
-        ] = CredentialsField(
-            description="Enter your api key for the E2B Sandbox. You can get it in here - https://e2b.dev/docs",
-        )
-
-        # Todo : Option to run commond in background
-        setup_commands: list[str] = SchemaField(
-            description=(
-                "Shell commands to set up the sandbox before running the code. "
-                "You can use `curl` or `git` to install your desired Debian based "
-                "package manager. `pip` and `npm` are pre-installed.\n\n"
-                "These commands are executed with `sh`, in the foreground."
-            ),
-            placeholder="pip install cowsay",
-            default_factory=list,
-            advanced=False,
-        )
-
-        code: str = SchemaField(
-            description="Code to execute in the sandbox",
-            placeholder="print('Hello, World!')",
-            default="",
-            advanced=False,
-        )
-
-        language: ProgrammingLanguage = SchemaField(
-            description="Programming language to execute",
-            default=ProgrammingLanguage.PYTHON,
-            advanced=False,
-        )
-
-        timeout: int = SchemaField(
-            description="Execution timeout in seconds", default=300
-        )
-
-        template_id: str = SchemaField(
-            description=(
-                "You can use an E2B sandbox template by entering its ID here. "
-                "Check out the E2B docs for more details: "
-                "[E2B - Sandbox template](https://e2b.dev/docs/sandbox-template)"
-            ),
-            default="",
-            advanced=True,
-        )
-
-    class Output(BlockSchema):
-        response: str = SchemaField(description="Response from code execution")
-        stdout_logs: str = SchemaField(
-            description="Standard output logs from execution"
-        )
-        stderr_logs: str = SchemaField(description="Standard error logs from execution")
-        error: str = SchemaField(description="Error message if execution failed")
-
-    def __init__(self):
-        super().__init__(
-            id="0b02b072-abe7-11ef-8372-fb5d162dd712",
-            description="Executes code in an isolated sandbox environment with internet access.",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=CodeExecutionBlock.Input,
-            output_schema=CodeExecutionBlock.Output,
-            test_credentials=TEST_CREDENTIALS,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "code": "print('Hello World')",
-                "language": ProgrammingLanguage.PYTHON.value,
-                "setup_commands": [],
-                "timeout": 300,
-                "template_id": "",
-            },
-            test_output=[
-                ("response", "Hello World"),
-                ("stdout_logs", "Hello World\n"),
-            ],
-            test_mock={
-                "execute_code": lambda code, language, setup_commands, timeout, api_key, template_id: (
-                    "Hello World",
-                    "Hello World\n",
-                    "",
-                ),
-            },
-        )
-
-    def execute_code(
-        self,
-        code: str,
-        language: ProgrammingLanguage,
-        setup_commands: list[str],
-        timeout: int,
-        api_key: str,
-        template_id: str,
-    ):
-        try:
-            sandbox = None
-            if template_id:
-                sandbox = Sandbox(
-                    template=template_id, api_key=api_key, timeout=timeout
-                )
-            else:
-                sandbox = Sandbox(api_key=api_key, timeout=timeout)
-
-            if not sandbox:
-                raise Exception("Sandbox not created")
-
-            # Running setup commands
-            for cmd in setup_commands:
-                sandbox.commands.run(cmd)
-
-            # Executing the code
-            execution = sandbox.run_code(
-                code,
-                language=language.value,
-                on_error=lambda e: sandbox.kill(),  # Kill the sandbox if there is an error
-            )
-
-            if execution.error:
-                raise Exception(execution.error)
-
-            response = execution.text
-            stdout_logs = "".join(execution.logs.stdout)
-            stderr_logs = "".join(execution.logs.stderr)
-
-            return response, stdout_logs, stderr_logs
-
-        except Exception as e:
-            raise e
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            response, stdout_logs, stderr_logs = self.execute_code(
-                input_data.code,
-                input_data.language,
-                input_data.setup_commands,
-                input_data.timeout,
-                credentials.api_key.get_secret_value(),
-                input_data.template_id,
-            )
-
-            if response:
-                yield "response", response
-            if stdout_logs:
-                yield "stdout_logs", stdout_logs
-            if stderr_logs:
-                yield "stderr_logs", stderr_logs
-        except Exception as e:
-            yield "error", str(e)
-
-
-class InstantiationBlock(Block):
-    class Input(BlockSchema):
-        credentials: CredentialsMetaInput[
-            Literal[ProviderName.E2B], Literal["api_key"]
-        ] = CredentialsField(
-            description="Enter your api key for the E2B Sandbox. You can get it in here - https://e2b.dev/docs",
-        )
-
-        # Todo : Option to run commond in background
-        setup_commands: list[str] = SchemaField(
-            description=(
-                "Shell commands to set up the sandbox before running the code. "
-                "You can use `curl` or `git` to install your desired Debian based "
-                "package manager. `pip` and `npm` are pre-installed.\n\n"
-                "These commands are executed with `sh`, in the foreground."
-            ),
-            placeholder="pip install cowsay",
-            default_factory=list,
-            advanced=False,
-        )
-
-        setup_code: str = SchemaField(
-            description="Code to execute in the sandbox",
-            placeholder="print('Hello, World!')",
-            default="",
-            advanced=False,
-        )
-
-        language: ProgrammingLanguage = SchemaField(
-            description="Programming language to execute",
-            default=ProgrammingLanguage.PYTHON,
-            advanced=False,
-        )
-
-        timeout: int = SchemaField(
-            description="Execution timeout in seconds", default=300
-        )
-
-        template_id: str = SchemaField(
-            description=(
-                "You can use an E2B sandbox template by entering its ID here. "
-                "Check out the E2B docs for more details: "
-                "[E2B - Sandbox template](https://e2b.dev/docs/sandbox-template)"
-            ),
-            default="",
-            advanced=True,
-        )
-
-    class Output(BlockSchema):
-        sandbox_id: str = SchemaField(description="ID of the sandbox instance")
-        response: str = SchemaField(description="Response from code execution")
-        stdout_logs: str = SchemaField(
-            description="Standard output logs from execution"
-        )
-        stderr_logs: str = SchemaField(description="Standard error logs from execution")
-        error: str = SchemaField(description="Error message if execution failed")
-
-    def __init__(self):
-        super().__init__(
-            id="ff0861c9-1726-4aec-9e5b-bf53f3622112",
-            description="Instantiate an isolated sandbox environment with internet access where to execute code in.",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=InstantiationBlock.Input,
-            output_schema=InstantiationBlock.Output,
-            test_credentials=TEST_CREDENTIALS,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "setup_code": "print('Hello World')",
-                "language": ProgrammingLanguage.PYTHON.value,
-                "setup_commands": [],
-                "timeout": 300,
-                "template_id": "",
-            },
-            test_output=[
-                ("sandbox_id", str),
-                ("response", "Hello World"),
-                ("stdout_logs", "Hello World\n"),
-            ],
-            test_mock={
-                "execute_code": lambda setup_code, language, setup_commands, timeout, api_key, template_id: (
-                    "sandbox_id",
-                    "Hello World",
-                    "Hello World\n",
-                    "",
-                ),
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            sandbox_id, response, stdout_logs, stderr_logs = self.execute_code(
-                input_data.setup_code,
-                input_data.language,
-                input_data.setup_commands,
-                input_data.timeout,
-                credentials.api_key.get_secret_value(),
-                input_data.template_id,
-            )
-            if sandbox_id:
-                yield "sandbox_id", sandbox_id
-            else:
-                yield "error", "Sandbox ID not found"
-            if response:
-                yield "response", response
-            if stdout_logs:
-                yield "stdout_logs", stdout_logs
-            if stderr_logs:
-                yield "stderr_logs", stderr_logs
-        except Exception as e:
-            yield "error", str(e)
-
-    def execute_code(
-        self,
-        code: str,
-        language: ProgrammingLanguage,
-        setup_commands: list[str],
-        timeout: int,
-        api_key: str,
-        template_id: str,
-    ):
-        try:
-            sandbox = None
-            if template_id:
-                sandbox = Sandbox(
-                    template=template_id, api_key=api_key, timeout=timeout
-                )
-            else:
-                sandbox = Sandbox(api_key=api_key, timeout=timeout)
-
-            if not sandbox:
-                raise Exception("Sandbox not created")
-
-            # Running setup commands
-            for cmd in setup_commands:
-                sandbox.commands.run(cmd)
-
-            # Executing the code
-            execution = sandbox.run_code(
-                code,
-                language=language.value,
-                on_error=lambda e: sandbox.kill(),  # Kill the sandbox if there is an error
-            )
-
-            if execution.error:
-                raise Exception(execution.error)
-
-            response = execution.text
-            stdout_logs = "".join(execution.logs.stdout)
-            stderr_logs = "".join(execution.logs.stderr)
-
-            return sandbox.sandbox_id, response, stdout_logs, stderr_logs
-
-        except Exception as e:
-            raise e
-
-
-class StepExecutionBlock(Block):
-    class Input(BlockSchema):
-        credentials: CredentialsMetaInput[
-            Literal[ProviderName.E2B], Literal["api_key"]
-        ] = CredentialsField(
-            description="Enter your api key for the E2B Sandbox. You can get it in here - https://e2b.dev/docs",
-        )
-
-        sandbox_id: str = SchemaField(
-            description="ID of the sandbox instance to execute the code in",
-            advanced=False,
-        )
-
-        step_code: str = SchemaField(
-            description="Code to execute in the sandbox",
-            placeholder="print('Hello, World!')",
-            default="",
-            advanced=False,
-        )
-
-        language: ProgrammingLanguage = SchemaField(
-            description="Programming language to execute",
-            default=ProgrammingLanguage.PYTHON,
-            advanced=False,
-        )
-
-    class Output(BlockSchema):
-        response: str = SchemaField(description="Response from code execution")
-        stdout_logs: str = SchemaField(
-            description="Standard output logs from execution"
-        )
-        stderr_logs: str = SchemaField(description="Standard error logs from execution")
-        error: str = SchemaField(description="Error message if execution failed")
-
-    def __init__(self):
-        super().__init__(
-            id="82b59b8e-ea10-4d57-9161-8b169b0adba6",
-            description="Execute code in a previously instantiated sandbox environment.",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=StepExecutionBlock.Input,
-            output_schema=StepExecutionBlock.Output,
-            test_credentials=TEST_CREDENTIALS,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "sandbox_id": "sandbox_id",
-                "step_code": "print('Hello World')",
-                "language": ProgrammingLanguage.PYTHON.value,
-            },
-            test_output=[
-                ("response", "Hello World"),
-                ("stdout_logs", "Hello World\n"),
-            ],
-            test_mock={
-                "execute_step_code": lambda sandbox_id, step_code, language, api_key: (
-                    "Hello World",
-                    "Hello World\n",
-                    "",
-                ),
-            },
-        )
-
-    def execute_step_code(
-        self,
-        sandbox_id: str,
-        code: str,
-        language: ProgrammingLanguage,
-        api_key: str,
-    ):
-        try:
-            sandbox = Sandbox.connect(sandbox_id=sandbox_id, api_key=api_key)
-            if not sandbox:
-                raise Exception("Sandbox not found")
-
-            # Executing the code
-            execution = sandbox.run_code(code, language=language.value)
-
-            if execution.error:
-                raise Exception(execution.error)
-
-            response = execution.text
-            stdout_logs = "".join(execution.logs.stdout)
-            stderr_logs = "".join(execution.logs.stderr)
-
-            return response, stdout_logs, stderr_logs
-
-        except Exception as e:
-            raise e
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            response, stdout_logs, stderr_logs = self.execute_step_code(
-                input_data.sandbox_id,
-                input_data.step_code,
-                input_data.language,
-                credentials.api_key.get_secret_value(),
-            )
-
-            if response:
-                yield "response", response
-            if stdout_logs:
-                yield "stdout_logs", stdout_logs
-            if stderr_logs:
-                yield "stderr_logs", stderr_logs
-        except Exception as e:
-            yield "error", str(e)

autogpt_platform/backend/backend/blocks/code_extraction_block.py

@@ -1,110 +0,0 @@
-import re
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-
-class CodeExtractionBlock(Block):
-    class Input(BlockSchema):
-        text: str = SchemaField(
-            description="Text containing code blocks to extract (e.g., AI response)",
-            placeholder="Enter text containing code blocks",
-        )
-
-    class Output(BlockSchema):
-        html: str = SchemaField(description="Extracted HTML code")
-        css: str = SchemaField(description="Extracted CSS code")
-        javascript: str = SchemaField(description="Extracted JavaScript code")
-        python: str = SchemaField(description="Extracted Python code")
-        sql: str = SchemaField(description="Extracted SQL code")
-        java: str = SchemaField(description="Extracted Java code")
-        cpp: str = SchemaField(description="Extracted C++ code")
-        csharp: str = SchemaField(description="Extracted C# code")
-        json_code: str = SchemaField(description="Extracted JSON code")
-        bash: str = SchemaField(description="Extracted Bash code")
-        php: str = SchemaField(description="Extracted PHP code")
-        ruby: str = SchemaField(description="Extracted Ruby code")
-        yaml: str = SchemaField(description="Extracted YAML code")
-        markdown: str = SchemaField(description="Extracted Markdown code")
-        typescript: str = SchemaField(description="Extracted TypeScript code")
-        xml: str = SchemaField(description="Extracted XML code")
-        remaining_text: str = SchemaField(
-            description="Remaining text after code extraction"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="d3a7d896-3b78-4f44-8b4b-48fbf4f0bcd8",
-            description="Extracts code blocks from text and identifies their programming languages",
-            categories={BlockCategory.TEXT},
-            input_schema=CodeExtractionBlock.Input,
-            output_schema=CodeExtractionBlock.Output,
-            test_input={
-                "text": "Here's a Python example:\n```python\nprint('Hello World')\n```\nAnd some HTML:\n```html\n<h1>Title</h1>\n```"
-            },
-            test_output=[
-                ("html", "<h1>Title</h1>"),
-                ("python", "print('Hello World')"),
-                ("remaining_text", "Here's a Python example:\nAnd some HTML:"),
-            ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        # List of supported programming languages with mapped aliases
-        language_aliases = {
-            "html": ["html", "htm"],
-            "css": ["css"],
-            "javascript": ["javascript", "js"],
-            "python": ["python", "py"],
-            "sql": ["sql"],
-            "java": ["java"],
-            "cpp": ["cpp", "c++"],
-            "csharp": ["csharp", "c#", "cs"],
-            "json_code": ["json"],
-            "bash": ["bash", "shell", "sh"],
-            "php": ["php"],
-            "ruby": ["ruby", "rb"],
-            "yaml": ["yaml", "yml"],
-            "markdown": ["markdown", "md"],
-            "typescript": ["typescript", "ts"],
-            "xml": ["xml"],
-        }
-
-        # Extract code for each language
-        for canonical_name, aliases in language_aliases.items():
-            code = ""
-            # Try each alias for the language
-            for alias in aliases:
-                code_for_alias = self.extract_code(input_data.text, alias)
-                if code_for_alias:
-                    code = code + "\n\n" + code_for_alias if code else code_for_alias
-
-            if code:  # Only yield if there's actual code content
-                yield canonical_name, code
-
-        # Remove all code blocks from the text to get remaining text
-        pattern = (
-            r"```(?:"
-            + "|".join(
-                re.escape(alias)
-                for aliases in language_aliases.values()
-                for alias in aliases
-            )
-            + r")\s+[\s\S]*?```"
-        )
-
-        remaining_text = re.sub(pattern, "", input_data.text).strip()
-        remaining_text = re.sub(r"\n\s*\n", "\n", remaining_text)
-
-        if remaining_text:  # Only yield if there's remaining text
-            yield "remaining_text", remaining_text
-
-    def extract_code(self, text: str, language: str) -> str:
-        # Escape special regex characters in the language string
-        language = re.escape(language)
-        # Extract all code blocks enclosed in ```language``` blocks
-        pattern = re.compile(rf"```{language}\s+(.*?)```", re.DOTALL | re.IGNORECASE)
-        matches = pattern.finditer(text)
-        # Combine all code blocks for this language with newlines between them
-        code_blocks = [match.group(1).strip() for match in matches]
-        return "\n\n".join(code_blocks) if code_blocks else ""

autogpt_platform/backend/backend/blocks/compass/triggers.py

@@ -1,60 +0,0 @@
-from pydantic import BaseModel
-
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockManualWebhookConfig,
-    BlockOutput,
-    BlockSchema,
-)
-from backend.data.model import SchemaField
-from backend.integrations.providers import ProviderName
-from backend.integrations.webhooks.compass import CompassWebhookType
-
-
-class Transcription(BaseModel):
-    text: str
-    speaker: str
-    end: float
-    start: float
-    duration: float
-
-
-class TranscriptionDataModel(BaseModel):
-    date: str
-    transcription: str
-    transcriptions: list[Transcription]
-
-
-class CompassAITriggerBlock(Block):
-    class Input(BlockSchema):
-        payload: TranscriptionDataModel = SchemaField(hidden=True)
-
-    class Output(BlockSchema):
-        transcription: str = SchemaField(
-            description="The contents of the compass transcription."
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="9464a020-ed1d-49e1-990f-7f2ac924a2b7",
-            description="This block will output the contents of the compass transcription.",
-            categories={BlockCategory.HARDWARE},
-            input_schema=CompassAITriggerBlock.Input,
-            output_schema=CompassAITriggerBlock.Output,
-            webhook_config=BlockManualWebhookConfig(
-                provider=ProviderName.COMPASS,
-                webhook_type=CompassWebhookType.TRANSCRIPTION,
-            ),
-            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.
-            # ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        yield "transcription", input_data.payload.transcription

autogpt_platform/backend/backend/blocks/count_words_and_char_block.py

@@ -1,43 +0,0 @@
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-
-class WordCharacterCountBlock(Block):
-    class Input(BlockSchema):
-        text: str = SchemaField(
-            description="Input text to count words and characters",
-            placeholder="Enter your text here",
-            advanced=False,
-        )
-
-    class Output(BlockSchema):
-        word_count: int = SchemaField(description="Number of words in the input text")
-        character_count: int = SchemaField(
-            description="Number of characters in the input text"
-        )
-        error: str = SchemaField(
-            description="Error message if the counting operation failed"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="ab2a782d-22cf-4587-8a70-55b59b3f9f90",
-            description="Counts the number of words and characters in a given text.",
-            categories={BlockCategory.TEXT},
-            input_schema=WordCharacterCountBlock.Input,
-            output_schema=WordCharacterCountBlock.Output,
-            test_input={"text": "Hello, how are you?"},
-            test_output=[("word_count", 4), ("character_count", 19)],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        try:
-            text = input_data.text
-            word_count = len(text.split())
-            character_count = len(text)
-
-            yield "word_count", word_count
-            yield "character_count", character_count
-
-        except Exception as e:
-            yield "error", str(e)

autogpt_platform/backend/backend/blocks/csv.py

@@ -1,49 +1,21 @@
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import ContributorDetails, SchemaField
+from backend.data.model import ContributorDetails
 
 
 class ReadCsvBlock(Block):
     class Input(BlockSchema):
-        contents: str = SchemaField(
-            description="The contents of the CSV file to read",
-            placeholder="a, b, c\n1,2,3\n4,5,6",
-        )
-        delimiter: str = SchemaField(
-            description="The delimiter used in the CSV file",
-            default=",",
-        )
-        quotechar: str = SchemaField(
-            description="The character used to quote fields",
-            default='"',
-        )
-        escapechar: str = SchemaField(
-            description="The character used to escape the delimiter",
-            default="\\",
-        )
-        has_header: bool = SchemaField(
-            description="Whether the CSV file has a header row",
-            default=True,
-        )
-        skip_rows: int = SchemaField(
-            description="The number of rows to skip from the start of the file",
-            default=0,
-        )
-        strip: bool = SchemaField(
-            description="Whether to strip whitespace from the values",
-            default=True,
-        )
-        skip_columns: list[str] = SchemaField(
-            description="The columns to skip from the start of the row",
-            default_factory=list,
-        )
+        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] = SchemaField(
-            description="The data produced from each row in the CSV file"
-        )
-        all_data: list[dict[str, str]] = SchemaField(
-            description="All the data in the CSV file as a list of rows"
-        )
+        row: dict[str, str]
+        all_data: list[dict[str, str]]
 
     def __init__(self):
         super().__init__(
@@ -52,7 +24,7 @@ class ReadCsvBlock(Block):
             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, BlockCategory.DATA},
+            categories={BlockCategory.TEXT},
             test_input={
                 "contents": "a, b, c\n1,2,3\n4,5,6",
             },

autogpt_platform/backend/backend/blocks/decoder_block.py

@@ -35,5 +35,8 @@ This is a "quoted" string.""",
         )
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        decoded_text = codecs.decode(input_data.text, "unicode_escape")
-        yield "decoded_text", decoded_text
+        try:
+            decoded_text = codecs.decode(input_data.text, "unicode_escape")
+            yield "decoded_text", decoded_text
+        except Exception as e:
+            yield "error", f"Error decoding text: {str(e)}"

autogpt_platform/backend/backend/blocks/discord.py

@@ -1,55 +1,28 @@
 import asyncio
-from typing import Literal
 
 import aiohttp
 import discord
-from pydantic import SecretStr
+from pydantic import Field
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import (
-    APIKeyCredentials,
-    CredentialsField,
-    CredentialsMetaInput,
-    SchemaField,
-)
-from backend.integrations.providers import ProviderName
-
-DiscordCredentials = CredentialsMetaInput[
-    Literal[ProviderName.DISCORD], Literal["api_key"]
-]
-
-
-def DiscordCredentialsField() -> DiscordCredentials:
-    return CredentialsField(description="Discord bot token")
-
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="discord",
-    api_key=SecretStr("test_api_key"),
-    title="Mock Discord API key",
-    expires_at=None,
-)
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.type,
-}
+from backend.data.model import BlockSecret, SecretField
 
 
 class ReadDiscordMessagesBlock(Block):
     class Input(BlockSchema):
-        credentials: DiscordCredentials = DiscordCredentialsField()
+        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 = SchemaField(
-            description="The content of the message received"
-        )
-        channel_name: str = SchemaField(
+        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 = SchemaField(
+        username: str = Field(
             description="The username of the user who sent the message"
         )
 
@@ -60,11 +33,7 @@ class ReadDiscordMessagesBlock(Block):
             output_schema=ReadDiscordMessagesBlock.Output,  # Assign output schema
             description="Reads messages from a Discord channel using a bot token.",
             categories={BlockCategory.SOCIAL},
-            test_input={
-                "continuous_read": False,
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
+            test_input={"discord_bot_token": "test_token", "continuous_read": False},
             test_output=[
                 (
                     "message_content",
@@ -78,7 +47,7 @@ class ReadDiscordMessagesBlock(Block):
             },
         )
 
-    async def run_bot(self, token: SecretStr):
+    async def run_bot(self, token: str):
         intents = discord.Intents.default()
         intents.message_content = True
 
@@ -111,20 +80,19 @@ class ReadDiscordMessagesBlock(Block):
 
             await client.close()
 
-        await client.start(token.get_secret_value())
+        await client.start(token)
 
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
         while True:
-            for output_name, output_value in self.__run(input_data, credentials):
+            for output_name, output_value in self.__run(input_data):
                 yield output_name, output_value
-            break
+            if not input_data.continuous_read:
+                break
 
-    def __run(self, input_data: Input, credentials: APIKeyCredentials) -> BlockOutput:
+    def __run(self, input_data: Input) -> BlockOutput:
         try:
             loop = asyncio.get_event_loop()
-            future = self.run_bot(credentials.api_key)
+            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):
@@ -163,16 +131,16 @@ class ReadDiscordMessagesBlock(Block):
 
 class SendDiscordMessageBlock(Block):
     class Input(BlockSchema):
-        credentials: DiscordCredentials = DiscordCredentialsField()
-        message_content: str = SchemaField(
-            description="The content of the message received"
+        discord_bot_token: BlockSecret = SecretField(
+            key="discord_bot_token", description="Discord bot token"
         )
-        channel_name: str = SchemaField(
+        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 = SchemaField(
+        status: str = Field(
             description="The status of the operation (e.g., 'Message sent', 'Error')"
         )
 
@@ -184,15 +152,14 @@ class SendDiscordMessageBlock(Block):
             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!",
-                "credentials": TEST_CREDENTIALS_INPUT,
             },
             test_output=[("status", "Message sent")],
             test_mock={
                 "send_message": lambda token, channel_name, message_content: asyncio.Future()
             },
-            test_credentials=TEST_CREDENTIALS,
         )
 
     async def send_message(self, token: str, channel_name: str, message_content: str):
@@ -222,13 +189,11 @@ class SendDiscordMessageBlock(Block):
         """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, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
         try:
             loop = asyncio.get_event_loop()
             future = self.send_message(
-                credentials.api_key.get_secret_value(),
+                input_data.discord_bot_token.get_secret_value(),
                 input_data.channel_name,
                 input_data.message_content,
             )

autogpt_platform/backend/backend/blocks/email_block.py

@@ -1,53 +1,22 @@
 import smtplib
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
-from typing import Literal
 
-from pydantic import BaseModel, ConfigDict, SecretStr
+from pydantic import BaseModel, ConfigDict, Field
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import (
-    CredentialsField,
-    CredentialsMetaInput,
-    SchemaField,
-    UserPasswordCredentials,
-)
-from backend.integrations.providers import ProviderName
-
-TEST_CREDENTIALS = UserPasswordCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="smtp",
-    username=SecretStr("mock-smtp-username"),
-    password=SecretStr("mock-smtp-password"),
-    title="Mock SMTP credentials",
-)
-
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.title,
-}
-SMTPCredentials = UserPasswordCredentials
-SMTPCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.SMTP],
-    Literal["user_password"],
-]
+from backend.data.model import BlockSecret, SchemaField, SecretField
 
 
-def SMTPCredentialsField() -> SMTPCredentialsInput:
-    return CredentialsField(
-        description="The SMTP integration requires a username and password.",
+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")
 
-
-class SMTPConfig(BaseModel):
-    smtp_server: str = SchemaField(
-        default="smtp.example.com", description="SMTP server address"
-    )
-    smtp_port: int = SchemaField(default=25, description="SMTP port number")
-
-    model_config = ConfigDict(title="SMTP Config")
+    model_config = ConfigDict(title="Email Credentials")
 
 
 class SendEmailBlock(Block):
@@ -61,11 +30,10 @@ class SendEmailBlock(Block):
         body: str = SchemaField(
             description="Body of the email", placeholder="Enter the email body"
         )
-        config: SMTPConfig = SchemaField(
-            description="SMTP Config",
-            default=SMTPConfig(),
+        creds: EmailCredentials = Field(
+            description="SMTP credentials",
+            default=EmailCredentials(),
         )
-        credentials: SMTPCredentialsInput = SMTPCredentialsField()
 
     class Output(BlockSchema):
         status: str = SchemaField(description="Status of the email sending operation")
@@ -84,50 +52,50 @@ class SendEmailBlock(Block):
                 "to_email": "recipient@example.com",
                 "subject": "Test Email",
                 "body": "This is a test email.",
-                "config": {
+                "creds": {
                     "smtp_server": "smtp.gmail.com",
                     "smtp_port": 25,
+                    "smtp_username": "your-email@gmail.com",
+                    "smtp_password": "your-gmail-password",
                 },
-                "credentials": TEST_CREDENTIALS_INPUT,
             },
-            test_credentials=TEST_CREDENTIALS,
             test_output=[("status", "Email sent successfully")],
             test_mock={"send_email": lambda *args, **kwargs: "Email sent successfully"},
         )
 
     @staticmethod
     def send_email(
-        config: SMTPConfig,
-        to_email: str,
-        subject: str,
-        body: str,
-        credentials: SMTPCredentials,
+        creds: EmailCredentials, to_email: str, subject: str, body: str
     ) -> str:
-        smtp_server = config.smtp_server
-        smtp_port = config.smtp_port
-        smtp_username = credentials.username.get_secret_value()
-        smtp_password = credentials.password.get_secret_value()
+        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"))
+            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())
+            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"
+            return "Email sent successfully"
+        except Exception as e:
+            return f"Failed to send email: {str(e)}"
 
-    def run(
-        self, input_data: Input, *, credentials: SMTPCredentials, **kwargs
-    ) -> BlockOutput:
-        yield "status", self.send_email(
-            config=input_data.config,
-            to_email=input_data.to_email,
-            subject=input_data.subject,
-            body=input_data.body,
-            credentials=credentials,
+    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/exa/_auth.py

@@ -1,32 +0,0 @@
-from typing import Literal
-
-from pydantic import SecretStr
-
-from backend.data.model import APIKeyCredentials, CredentialsField, CredentialsMetaInput
-from backend.integrations.providers import ProviderName
-
-ExaCredentials = APIKeyCredentials
-ExaCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.EXA],
-    Literal["api_key"],
-]
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="exa",
-    api_key=SecretStr("mock-exa-api-key"),
-    title="Mock Exa API key",
-    expires_at=None,
-)
-
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.title,
-}
-
-
-def ExaCredentialsField() -> ExaCredentialsInput:
-    """Creates an Exa credentials input on a block."""
-    return CredentialsField(description="The Exa integration requires an API Key.")

autogpt_platform/backend/backend/blocks/exa/contents.py

@@ -1,88 +0,0 @@
-from typing import List
-
-from pydantic import BaseModel
-
-from backend.blocks.exa._auth import (
-    ExaCredentials,
-    ExaCredentialsField,
-    ExaCredentialsInput,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-from backend.util.request import requests
-
-
-class ContentRetrievalSettings(BaseModel):
-    text: dict = SchemaField(
-        description="Text content settings",
-        default={"maxCharacters": 1000, "includeHtmlTags": False},
-        advanced=True,
-    )
-    highlights: dict = SchemaField(
-        description="Highlight settings",
-        default={
-            "numSentences": 3,
-            "highlightsPerUrl": 3,
-            "query": "",
-        },
-        advanced=True,
-    )
-    summary: dict = SchemaField(
-        description="Summary settings",
-        default={"query": ""},
-        advanced=True,
-    )
-
-
-class ExaContentsBlock(Block):
-    class Input(BlockSchema):
-        credentials: ExaCredentialsInput = ExaCredentialsField()
-        ids: List[str] = SchemaField(
-            description="Array of document IDs obtained from searches",
-        )
-        contents: ContentRetrievalSettings = SchemaField(
-            description="Content retrieval settings",
-            default=ContentRetrievalSettings(),
-            advanced=True,
-        )
-
-    class Output(BlockSchema):
-        results: list = SchemaField(
-            description="List of document contents",
-            default_factory=list,
-        )
-        error: str = SchemaField(description="Error message if the request failed")
-
-    def __init__(self):
-        super().__init__(
-            id="c52be83f-f8cd-4180-b243-af35f986b461",
-            description="Retrieves document contents using Exa's contents API",
-            categories={BlockCategory.SEARCH},
-            input_schema=ExaContentsBlock.Input,
-            output_schema=ExaContentsBlock.Output,
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: ExaCredentials, **kwargs
-    ) -> BlockOutput:
-        url = "https://api.exa.ai/contents"
-        headers = {
-            "Content-Type": "application/json",
-            "x-api-key": credentials.api_key.get_secret_value(),
-        }
-
-        payload = {
-            "ids": input_data.ids,
-            "text": input_data.contents.text,
-            "highlights": input_data.contents.highlights,
-            "summary": input_data.contents.summary,
-        }
-
-        try:
-            response = requests.post(url, headers=headers, json=payload)
-            response.raise_for_status()
-            data = response.json()
-            yield "results", data.get("results", [])
-        except Exception as e:
-            yield "error", str(e)
-            yield "results", []

autogpt_platform/backend/backend/blocks/exa/helpers.py

@@ -1,54 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel
-
-from backend.data.model import SchemaField
-
-
-class TextSettings(BaseModel):
-    max_characters: int = SchemaField(
-        default=1000,
-        description="Maximum number of characters to return",
-        placeholder="1000",
-    )
-    include_html_tags: bool = SchemaField(
-        default=False,
-        description="Whether to include HTML tags in the text",
-        placeholder="False",
-    )
-
-
-class HighlightSettings(BaseModel):
-    num_sentences: int = SchemaField(
-        default=3,
-        description="Number of sentences per highlight",
-        placeholder="3",
-    )
-    highlights_per_url: int = SchemaField(
-        default=3,
-        description="Number of highlights per URL",
-        placeholder="3",
-    )
-
-
-class SummarySettings(BaseModel):
-    query: Optional[str] = SchemaField(
-        default="",
-        description="Query string for summarization",
-        placeholder="Enter query",
-    )
-
-
-class ContentSettings(BaseModel):
-    text: TextSettings = SchemaField(
-        default=TextSettings(),
-        description="Text content settings",
-    )
-    highlights: HighlightSettings = SchemaField(
-        default=HighlightSettings(),
-        description="Highlight settings",
-    )
-    summary: SummarySettings = SchemaField(
-        default=SummarySettings(),
-        description="Summary settings",
-    )

autogpt_platform/backend/backend/blocks/exa/search.py

@@ -1,143 +0,0 @@
-from datetime import datetime
-from typing import List
-
-from backend.blocks.exa._auth import (
-    ExaCredentials,
-    ExaCredentialsField,
-    ExaCredentialsInput,
-)
-from backend.blocks.exa.helpers import ContentSettings
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-from backend.util.request import requests
-
-
-class ExaSearchBlock(Block):
-    class Input(BlockSchema):
-        credentials: ExaCredentialsInput = ExaCredentialsField()
-        query: str = SchemaField(description="The search query")
-        use_auto_prompt: bool = SchemaField(
-            description="Whether to use autoprompt",
-            default=True,
-            advanced=True,
-        )
-        type: str = SchemaField(
-            description="Type of search",
-            default="",
-            advanced=True,
-        )
-        category: str = SchemaField(
-            description="Category to search within",
-            default="",
-            advanced=True,
-        )
-        number_of_results: int = SchemaField(
-            description="Number of results to return",
-            default=10,
-            advanced=True,
-        )
-        include_domains: List[str] = SchemaField(
-            description="Domains to include in search",
-            default_factory=list,
-        )
-        exclude_domains: List[str] = SchemaField(
-            description="Domains to exclude from search",
-            default_factory=list,
-            advanced=True,
-        )
-        start_crawl_date: datetime = SchemaField(
-            description="Start date for crawled content",
-        )
-        end_crawl_date: datetime = SchemaField(
-            description="End date for crawled content",
-        )
-        start_published_date: datetime = SchemaField(
-            description="Start date for published content",
-        )
-        end_published_date: datetime = SchemaField(
-            description="End date for published content",
-        )
-        include_text: List[str] = SchemaField(
-            description="Text patterns to include",
-            default_factory=list,
-            advanced=True,
-        )
-        exclude_text: List[str] = SchemaField(
-            description="Text patterns to exclude",
-            default_factory=list,
-            advanced=True,
-        )
-        contents: ContentSettings = SchemaField(
-            description="Content retrieval settings",
-            default=ContentSettings(),
-            advanced=True,
-        )
-
-    class Output(BlockSchema):
-        results: list = SchemaField(
-            description="List of search results",
-            default_factory=list,
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="996cec64-ac40-4dde-982f-b0dc60a5824d",
-            description="Searches the web using Exa's advanced search API",
-            categories={BlockCategory.SEARCH},
-            input_schema=ExaSearchBlock.Input,
-            output_schema=ExaSearchBlock.Output,
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: ExaCredentials, **kwargs
-    ) -> BlockOutput:
-        url = "https://api.exa.ai/search"
-        headers = {
-            "Content-Type": "application/json",
-            "x-api-key": credentials.api_key.get_secret_value(),
-        }
-
-        payload = {
-            "query": input_data.query,
-            "useAutoprompt": input_data.use_auto_prompt,
-            "numResults": input_data.number_of_results,
-            "contents": input_data.contents.dict(),
-        }
-
-        date_field_mapping = {
-            "start_crawl_date": "startCrawlDate",
-            "end_crawl_date": "endCrawlDate",
-            "start_published_date": "startPublishedDate",
-            "end_published_date": "endPublishedDate",
-        }
-
-        # Add dates if they exist
-        for input_field, api_field in date_field_mapping.items():
-            value = getattr(input_data, input_field, None)
-            if value:
-                payload[api_field] = value.strftime("%Y-%m-%dT%H:%M:%S.000Z")
-
-        optional_field_mapping = {
-            "type": "type",
-            "category": "category",
-            "include_domains": "includeDomains",
-            "exclude_domains": "excludeDomains",
-            "include_text": "includeText",
-            "exclude_text": "excludeText",
-        }
-
-        # Add other fields
-        for input_field, api_field in optional_field_mapping.items():
-            value = getattr(input_data, input_field)
-            if value:  # Only add non-empty values
-                payload[api_field] = value
-
-        try:
-            response = requests.post(url, headers=headers, json=payload)
-            response.raise_for_status()
-            data = response.json()
-            # Extract just the results array from the response
-            yield "results", data.get("results", [])
-        except Exception as e:
-            yield "error", str(e)
-            yield "results", []

autogpt_platform/backend/backend/blocks/exa/similar.py

@@ -1,128 +0,0 @@
-from datetime import datetime
-from typing import Any, List
-
-from backend.blocks.exa._auth import (
-    ExaCredentials,
-    ExaCredentialsField,
-    ExaCredentialsInput,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-from backend.util.request import requests
-
-from .helpers import ContentSettings
-
-
-class ExaFindSimilarBlock(Block):
-    class Input(BlockSchema):
-        credentials: ExaCredentialsInput = ExaCredentialsField()
-        url: str = SchemaField(
-            description="The url for which you would like to find similar links"
-        )
-        number_of_results: int = SchemaField(
-            description="Number of results to return",
-            default=10,
-            advanced=True,
-        )
-        include_domains: List[str] = SchemaField(
-            description="Domains to include in search",
-            default_factory=list,
-            advanced=True,
-        )
-        exclude_domains: List[str] = SchemaField(
-            description="Domains to exclude from search",
-            default_factory=list,
-            advanced=True,
-        )
-        start_crawl_date: datetime = SchemaField(
-            description="Start date for crawled content",
-        )
-        end_crawl_date: datetime = SchemaField(
-            description="End date for crawled content",
-        )
-        start_published_date: datetime = SchemaField(
-            description="Start date for published content",
-        )
-        end_published_date: datetime = SchemaField(
-            description="End date for published content",
-        )
-        include_text: List[str] = SchemaField(
-            description="Text patterns to include (max 1 string, up to 5 words)",
-            default_factory=list,
-            advanced=True,
-        )
-        exclude_text: List[str] = SchemaField(
-            description="Text patterns to exclude (max 1 string, up to 5 words)",
-            default_factory=list,
-            advanced=True,
-        )
-        contents: ContentSettings = SchemaField(
-            description="Content retrieval settings",
-            default=ContentSettings(),
-            advanced=True,
-        )
-
-    class Output(BlockSchema):
-        results: List[Any] = SchemaField(
-            description="List of similar documents with title, URL, published date, author, and score",
-            default_factory=list,
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="5e7315d1-af61-4a0c-9350-7c868fa7438a",
-            description="Finds similar links using Exa's findSimilar API",
-            categories={BlockCategory.SEARCH},
-            input_schema=ExaFindSimilarBlock.Input,
-            output_schema=ExaFindSimilarBlock.Output,
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: ExaCredentials, **kwargs
-    ) -> BlockOutput:
-        url = "https://api.exa.ai/findSimilar"
-        headers = {
-            "Content-Type": "application/json",
-            "x-api-key": credentials.api_key.get_secret_value(),
-        }
-
-        payload = {
-            "url": input_data.url,
-            "numResults": input_data.number_of_results,
-            "contents": input_data.contents.dict(),
-        }
-
-        optional_field_mapping = {
-            "include_domains": "includeDomains",
-            "exclude_domains": "excludeDomains",
-            "include_text": "includeText",
-            "exclude_text": "excludeText",
-        }
-
-        # Add optional fields if they have values
-        for input_field, api_field in optional_field_mapping.items():
-            value = getattr(input_data, input_field)
-            if value:  # Only add non-empty values
-                payload[api_field] = value
-
-        date_field_mapping = {
-            "start_crawl_date": "startCrawlDate",
-            "end_crawl_date": "endCrawlDate",
-            "start_published_date": "startPublishedDate",
-            "end_published_date": "endPublishedDate",
-        }
-
-        # Add dates if they exist
-        for input_field, api_field in date_field_mapping.items():
-            value = getattr(input_data, input_field, None)
-            if value:
-                payload[api_field] = value.strftime("%Y-%m-%dT%H:%M:%S.000Z")
-
-        try:
-            response = requests.post(url, headers=headers, json=payload)
-            response.raise_for_status()
-            data = response.json()
-            yield "results", data.get("results", [])
-        except Exception as e:
-            yield "error", str(e)
-            yield "results", []

autogpt_platform/backend/backend/blocks/fal/_auth.py

@@ -1,35 +0,0 @@
-from typing import Literal
-
-from pydantic import SecretStr
-
-from backend.data.model import APIKeyCredentials, CredentialsField, CredentialsMetaInput
-from backend.integrations.providers import ProviderName
-
-FalCredentials = APIKeyCredentials
-FalCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.FAL],
-    Literal["api_key"],
-]
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="fal",
-    api_key=SecretStr("mock-fal-api-key"),
-    title="Mock FAL API key",
-    expires_at=None,
-)
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.title,
-}
-
-
-def FalCredentialsField() -> FalCredentialsInput:
-    """
-    Creates a FAL credentials input on a block.
-    """
-    return CredentialsField(
-        description="The FAL integration can be used with an API Key.",
-    )

autogpt_platform/backend/backend/blocks/fal/ai_video_generator.py

@@ -1,199 +0,0 @@
-import logging
-import time
-from enum import Enum
-from typing import Any
-
-import httpx
-
-from backend.blocks.fal._auth import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    FalCredentials,
-    FalCredentialsField,
-    FalCredentialsInput,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-logger = logging.getLogger(__name__)
-
-
-class FalModel(str, Enum):
-    MOCHI = "fal-ai/mochi-v1"
-    LUMA = "fal-ai/luma-dream-machine"
-
-
-class AIVideoGeneratorBlock(Block):
-    class Input(BlockSchema):
-        prompt: str = SchemaField(
-            description="Description of the video to generate.",
-            placeholder="A dog running in a field.",
-        )
-        model: FalModel = SchemaField(
-            title="FAL Model",
-            default=FalModel.MOCHI,
-            description="The FAL model to use for video generation.",
-        )
-        credentials: FalCredentialsInput = FalCredentialsField()
-
-    class Output(BlockSchema):
-        video_url: str = SchemaField(description="The URL of the generated video.")
-        error: str = SchemaField(
-            description="Error message if video generation failed."
-        )
-        logs: list[str] = SchemaField(
-            description="Generation progress logs.",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="530cf046-2ce0-4854-ae2c-659db17c7a46",
-            description="Generate videos using FAL AI models.",
-            categories={BlockCategory.AI},
-            input_schema=self.Input,
-            output_schema=self.Output,
-            test_input={
-                "prompt": "A dog running in a field.",
-                "model": FalModel.MOCHI,
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[("video_url", "https://fal.media/files/example/video.mp4")],
-            test_mock={
-                "generate_video": lambda *args, **kwargs: "https://fal.media/files/example/video.mp4"
-            },
-        )
-
-    def _get_headers(self, api_key: str) -> dict[str, str]:
-        """Get headers for FAL API requests."""
-        return {
-            "Authorization": f"Key {api_key}",
-            "Content-Type": "application/json",
-        }
-
-    def _submit_request(
-        self, url: str, headers: dict[str, str], data: dict[str, Any]
-    ) -> dict[str, Any]:
-        """Submit a request to the FAL API."""
-        try:
-            response = httpx.post(url, headers=headers, json=data)
-            response.raise_for_status()
-            return response.json()
-        except httpx.HTTPError as e:
-            logger.error(f"FAL API request failed: {str(e)}")
-            raise RuntimeError(f"Failed to submit request: {str(e)}")
-
-    def _poll_status(self, status_url: str, headers: dict[str, str]) -> dict[str, Any]:
-        """Poll the status endpoint until completion or failure."""
-        try:
-            response = httpx.get(status_url, headers=headers)
-            response.raise_for_status()
-            return response.json()
-        except httpx.HTTPError as e:
-            logger.error(f"Failed to get status: {str(e)}")
-            raise RuntimeError(f"Failed to get status: {str(e)}")
-
-    def generate_video(self, input_data: Input, credentials: FalCredentials) -> str:
-        """Generate video using the specified FAL model."""
-        base_url = "https://queue.fal.run"
-        api_key = credentials.api_key.get_secret_value()
-        headers = self._get_headers(api_key)
-
-        # Submit generation request
-        submit_url = f"{base_url}/{input_data.model.value}"
-        submit_data = {"prompt": input_data.prompt}
-
-        seen_logs = set()
-
-        try:
-            # Submit request to queue
-            submit_response = httpx.post(submit_url, headers=headers, json=submit_data)
-            submit_response.raise_for_status()
-            request_data = submit_response.json()
-
-            # Get request_id and urls from initial response
-            request_id = request_data.get("request_id")
-            status_url = request_data.get("status_url")
-            result_url = request_data.get("response_url")
-
-            if not all([request_id, status_url, result_url]):
-                raise ValueError("Missing required data in submission response")
-
-            # Poll for status with exponential backoff
-            max_attempts = 30
-            attempt = 0
-            base_wait_time = 5
-
-            while attempt < max_attempts:
-                status_response = httpx.get(f"{status_url}?logs=1", headers=headers)
-                status_response.raise_for_status()
-                status_data = status_response.json()
-
-                # Process new logs only
-                logs = status_data.get("logs", [])
-                if logs and isinstance(logs, list):
-                    for log in logs:
-                        if isinstance(log, dict):
-                            # Create a unique key for this log entry
-                            log_key = (
-                                f"{log.get('timestamp', '')}-{log.get('message', '')}"
-                            )
-                            if log_key not in seen_logs:
-                                seen_logs.add(log_key)
-                                message = log.get("message", "")
-                                if message:
-                                    logger.debug(
-                                        f"[FAL Generation] [{log.get('level', 'INFO')}] [{log.get('source', '')}] [{log.get('timestamp', '')}] {message}"
-                                    )
-
-                status = status_data.get("status")
-                if status == "COMPLETED":
-                    # Get the final result
-                    result_response = httpx.get(result_url, headers=headers)
-                    result_response.raise_for_status()
-                    result_data = result_response.json()
-
-                    if "video" not in result_data or not isinstance(
-                        result_data["video"], dict
-                    ):
-                        raise ValueError("Invalid response format - missing video data")
-
-                    video_url = result_data["video"].get("url")
-                    if not video_url:
-                        raise ValueError("No video URL in response")
-
-                    return video_url
-
-                elif status == "FAILED":
-                    error_msg = status_data.get("error", "No error details provided")
-                    raise RuntimeError(f"Video generation failed: {error_msg}")
-                elif status == "IN_QUEUE":
-                    position = status_data.get("queue_position", "unknown")
-                    logger.debug(
-                        f"[FAL Generation] Status: In queue, position: {position}"
-                    )
-                elif status == "IN_PROGRESS":
-                    logger.debug(
-                        "[FAL Generation] Status: Request is being processed..."
-                    )
-                else:
-                    logger.info(f"[FAL Generation] Status: Unknown status: {status}")
-
-                wait_time = min(base_wait_time * (2**attempt), 60)  # Cap at 60 seconds
-                time.sleep(wait_time)
-                attempt += 1
-
-            raise RuntimeError("Maximum polling attempts reached")
-
-        except httpx.HTTPError as e:
-            raise RuntimeError(f"API request failed: {str(e)}")
-
-    def run(
-        self, input_data: Input, *, credentials: FalCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            video_url = self.generate_video(input_data, credentials)
-            yield "video_url", video_url
-        except Exception as e:
-            error_message = str(e)
-            yield "error", error_message

autogpt_platform/backend/backend/blocks/generic_webhook/triggers.py

@@ -1,51 +0,0 @@
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockManualWebhookConfig,
-    BlockOutput,
-    BlockSchema,
-)
-from backend.data.model import SchemaField
-from backend.integrations.providers import ProviderName
-from backend.integrations.webhooks.generic import GenericWebhookType
-
-
-class GenericWebhookTriggerBlock(Block):
-    class Input(BlockSchema):
-        payload: dict = SchemaField(hidden=True, default_factory=dict)
-        constants: dict = SchemaField(
-            description="The constants to be set when the block is put on the graph",
-            default_factory=dict,
-        )
-
-    class Output(BlockSchema):
-        payload: dict = SchemaField(
-            description="The complete webhook payload that was received from the generic webhook."
-        )
-        constants: dict = SchemaField(
-            description="The constants to be set when the block is put on the graph"
-        )
-
-    example_payload = {"message": "Hello, World!"}
-
-    def __init__(self):
-        super().__init__(
-            id="8fa8c167-2002-47ce-aba8-97572fc5d387",
-            description="This block will output the contents of the generic input for the webhook.",
-            categories={BlockCategory.INPUT},
-            input_schema=GenericWebhookTriggerBlock.Input,
-            output_schema=GenericWebhookTriggerBlock.Output,
-            webhook_config=BlockManualWebhookConfig(
-                provider=ProviderName.GENERIC_WEBHOOK,
-                webhook_type=GenericWebhookType.PLAIN,
-            ),
-            test_input={"constants": {"key": "value"}, "payload": self.example_payload},
-            test_output=[
-                ("constants", {"key": "value"}),
-                ("payload", self.example_payload),
-            ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        yield "constants", input_data.constants
-        yield "payload", input_data.payload

autogpt_platform/backend/backend/blocks/github/_api.py

@@ -1,102 +0,0 @@
-from urllib.parse import urlparse
-
-from backend.blocks.github._auth import (
-    GithubCredentials,
-    GithubFineGrainedAPICredentials,
-)
-from backend.util.request import Requests
-
-
-def _convert_to_api_url(url: str) -> str:
-    """
-    Converts a standard GitHub URL to the corresponding GitHub API URL.
-    Handles repository URLs, issue URLs, pull request URLs, and more.
-    """
-    parsed_url = urlparse(url)
-    path_parts = parsed_url.path.strip("/").split("/")
-
-    if len(path_parts) >= 2:
-        owner, repo = path_parts[0], path_parts[1]
-        api_base = f"https://api.github.com/repos/{owner}/{repo}"
-
-        if len(path_parts) > 2:
-            additional_path = "/".join(path_parts[2:])
-            api_url = f"{api_base}/{additional_path}"
-        else:
-            # Repository base URL
-            api_url = api_base
-    else:
-        raise ValueError("Invalid GitHub URL format.")
-
-    return api_url
-
-
-def _get_headers(credentials: GithubCredentials) -> dict[str, str]:
-    return {
-        "Authorization": credentials.auth_header(),
-        "Accept": "application/vnd.github.v3+json",
-    }
-
-
-def convert_comment_url_to_api_endpoint(comment_url: str) -> str:
-    """
-    Converts a GitHub comment URL (web interface) to the appropriate API endpoint URL.
-
-    Handles:
-    1. Issue/PR comments: #issuecomment-{id}
-    2. PR review comments: #discussion_r{id}
-
-    Returns the appropriate API endpoint path for the comment.
-    """
-    # First, check if this is already an API URL
-    parsed_url = urlparse(comment_url)
-    if parsed_url.hostname == "api.github.com":
-        return comment_url
-
-    # Replace pull with issues for comment endpoints
-    if "/pull/" in comment_url:
-        comment_url = comment_url.replace("/pull/", "/issues/")
-
-    # Handle issue/PR comments (#issuecomment-xxx)
-    if "#issuecomment-" in comment_url:
-        base_url, comment_part = comment_url.split("#issuecomment-")
-        comment_id = comment_part
-
-        # Extract repo information from base URL
-        parsed_url = urlparse(base_url)
-        path_parts = parsed_url.path.strip("/").split("/")
-        owner, repo = path_parts[0], path_parts[1]
-
-        # Construct API URL for issue comments
-        return (
-            f"https://api.github.com/repos/{owner}/{repo}/issues/comments/{comment_id}"
-        )
-
-    # Handle PR review comments (#discussion_r)
-    elif "#discussion_r" in comment_url:
-        base_url, comment_part = comment_url.split("#discussion_r")
-        comment_id = comment_part
-
-        # Extract repo information from base URL
-        parsed_url = urlparse(base_url)
-        path_parts = parsed_url.path.strip("/").split("/")
-        owner, repo = path_parts[0], path_parts[1]
-
-        # Construct API URL for PR review comments
-        return (
-            f"https://api.github.com/repos/{owner}/{repo}/pulls/comments/{comment_id}"
-        )
-
-    # If no specific comment identifiers are found, use the general URL conversion
-    return _convert_to_api_url(comment_url)
-
-
-def get_api(
-    credentials: GithubCredentials | GithubFineGrainedAPICredentials,
-    convert_urls: bool = True,
-) -> Requests:
-    return Requests(
-        trusted_origins=["https://api.github.com", "https://github.com"],
-        extra_url_validator=_convert_to_api_url if convert_urls else None,
-        extra_headers=_get_headers(credentials),
-    )

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

@@ -1,14 +1,12 @@
 from typing import Literal
 
-from pydantic import SecretStr
-
-from backend.data.model import (
+from autogpt_libs.supabase_integration_credentials_store.types import (
     APIKeyCredentials,
-    CredentialsField,
-    CredentialsMetaInput,
     OAuth2Credentials,
 )
-from backend.integrations.providers import ProviderName
+from pydantic import SecretStr
+
+from backend.data.model import CredentialsField, CredentialsMetaInput
 from backend.util.settings import Secrets
 
 secrets = Secrets()
@@ -18,15 +16,10 @@ GITHUB_OAUTH_IS_CONFIGURED = bool(
 
 GithubCredentials = APIKeyCredentials | OAuth2Credentials
 GithubCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.GITHUB],
+    Literal["github"],
     Literal["api_key", "oauth2"] if GITHUB_OAUTH_IS_CONFIGURED else Literal["api_key"],
 ]
 
-GithubFineGrainedAPICredentials = APIKeyCredentials
-GithubFineGrainedAPICredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.GITHUB], Literal["api_key"]
-]
-
 
 def GithubCredentialsField(scope: str) -> GithubCredentialsInput:
     """
@@ -36,16 +29,10 @@ def GithubCredentialsField(scope: str) -> GithubCredentialsInput:
         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(
-        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.",
-    )
-
-
-def GithubFineGrainedAPICredentialsField(
-    scope: str,
-) -> GithubFineGrainedAPICredentialsInput:
-    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.",
@@ -65,18 +52,3 @@ TEST_CREDENTIALS_INPUT = {
     "type": TEST_CREDENTIALS.type,
     "title": TEST_CREDENTIALS.type,
 }
-
-TEST_FINE_GRAINED_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_FINE_GRAINED_CREDENTIALS_INPUT = {
-    "provider": TEST_FINE_GRAINED_CREDENTIALS.provider,
-    "id": TEST_FINE_GRAINED_CREDENTIALS.id,
-    "type": TEST_FINE_GRAINED_CREDENTIALS.type,
-    "title": TEST_FINE_GRAINED_CREDENTIALS.type,
-}

autogpt_platform/backend/backend/blocks/github/checks.py

@@ -1,360 +0,0 @@
-from enum import Enum
-from typing import Optional
-
-from pydantic import BaseModel
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-from ._api import get_api
-from ._auth import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    GithubCredentials,
-    GithubCredentialsField,
-    GithubCredentialsInput,
-)
-
-
-# queued, in_progress, completed, waiting, requested, pending
-class ChecksStatus(Enum):
-    QUEUED = "queued"
-    IN_PROGRESS = "in_progress"
-    COMPLETED = "completed"
-    WAITING = "waiting"
-    REQUESTED = "requested"
-    PENDING = "pending"
-
-
-class ChecksConclusion(Enum):
-    SUCCESS = "success"
-    FAILURE = "failure"
-    NEUTRAL = "neutral"
-    CANCELLED = "cancelled"
-    TIMED_OUT = "timed_out"
-    ACTION_REQUIRED = "action_required"
-    SKIPPED = "skipped"
-
-
-class GithubCreateCheckRunBlock(Block):
-    """Block for creating a new check run on a GitHub repository."""
-
-    class Input(BlockSchema):
-        credentials: GithubCredentialsInput = GithubCredentialsField("repo:status")
-        repo_url: str = SchemaField(
-            description="URL of the GitHub repository",
-            placeholder="https://github.com/owner/repo",
-        )
-        name: str = SchemaField(
-            description="The name of the check run (e.g., 'code-coverage')",
-        )
-        head_sha: str = SchemaField(
-            description="The SHA of the commit to check",
-        )
-        status: ChecksStatus = SchemaField(
-            description="Current status of the check run",
-            default=ChecksStatus.QUEUED,
-        )
-        conclusion: Optional[ChecksConclusion] = SchemaField(
-            description="The final conclusion of the check (required if status is completed)",
-            default=None,
-        )
-        details_url: str = SchemaField(
-            description="The URL for the full details of the check",
-            default="",
-        )
-        output_title: str = SchemaField(
-            description="Title of the check run output",
-            default="",
-        )
-        output_summary: str = SchemaField(
-            description="Summary of the check run output",
-            default="",
-        )
-        output_text: str = SchemaField(
-            description="Detailed text of the check run output",
-            default="",
-        )
-
-    class Output(BlockSchema):
-        class CheckRunResult(BaseModel):
-            id: int
-            html_url: str
-            status: str
-
-        check_run: CheckRunResult = SchemaField(
-            description="Details of the created check run"
-        )
-        error: str = SchemaField(
-            description="Error message if check run creation failed"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="2f45e89a-3b7d-4f22-b89e-6c4f5c7e1234",
-            description="Creates a new check run for a specific commit in a GitHub repository",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=GithubCreateCheckRunBlock.Input,
-            output_schema=GithubCreateCheckRunBlock.Output,
-            test_input={
-                "repo_url": "https://github.com/owner/repo",
-                "name": "test-check",
-                "head_sha": "ce587453ced02b1526dfb4cb910479d431683101",
-                "status": ChecksStatus.COMPLETED.value,
-                "conclusion": ChecksConclusion.SUCCESS.value,
-                "output_title": "Test Results",
-                "output_summary": "All tests passed",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            # requires a github app not available to oauth in our current system
-            disabled=True,
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "check_run",
-                    {
-                        "id": 4,
-                        "html_url": "https://github.com/owner/repo/runs/4",
-                        "status": "completed",
-                    },
-                ),
-            ],
-            test_mock={
-                "create_check_run": lambda *args, **kwargs: {
-                    "id": 4,
-                    "html_url": "https://github.com/owner/repo/runs/4",
-                    "status": "completed",
-                }
-            },
-        )
-
-    @staticmethod
-    def create_check_run(
-        credentials: GithubCredentials,
-        repo_url: str,
-        name: str,
-        head_sha: str,
-        status: ChecksStatus,
-        conclusion: Optional[ChecksConclusion] = None,
-        details_url: Optional[str] = None,
-        output_title: Optional[str] = None,
-        output_summary: Optional[str] = None,
-        output_text: Optional[str] = None,
-    ) -> dict:
-        api = get_api(credentials)
-
-        class CheckRunData(BaseModel):
-            name: str
-            head_sha: str
-            status: str
-            conclusion: Optional[str] = None
-            details_url: Optional[str] = None
-            output: Optional[dict[str, str]] = None
-
-        data = CheckRunData(
-            name=name,
-            head_sha=head_sha,
-            status=status.value,
-        )
-
-        if conclusion:
-            data.conclusion = conclusion.value
-
-        if details_url:
-            data.details_url = details_url
-
-        if output_title or output_summary or output_text:
-            output_data = {
-                "title": output_title or "",
-                "summary": output_summary or "",
-                "text": output_text or "",
-            }
-            data.output = output_data
-
-        check_runs_url = f"{repo_url}/check-runs"
-        response = api.post(
-            check_runs_url, data=data.model_dump_json(exclude_none=True)
-        )
-        result = response.json()
-
-        return {
-            "id": result["id"],
-            "html_url": result["html_url"],
-            "status": result["status"],
-        }
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: GithubCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            result = self.create_check_run(
-                credentials=credentials,
-                repo_url=input_data.repo_url,
-                name=input_data.name,
-                head_sha=input_data.head_sha,
-                status=input_data.status,
-                conclusion=input_data.conclusion,
-                details_url=input_data.details_url,
-                output_title=input_data.output_title,
-                output_summary=input_data.output_summary,
-                output_text=input_data.output_text,
-            )
-            yield "check_run", result
-        except Exception as e:
-            yield "error", str(e)
-
-
-class GithubUpdateCheckRunBlock(Block):
-    """Block for updating an existing check run on a GitHub repository."""
-
-    class Input(BlockSchema):
-        credentials: GithubCredentialsInput = GithubCredentialsField("repo:status")
-        repo_url: str = SchemaField(
-            description="URL of the GitHub repository",
-            placeholder="https://github.com/owner/repo",
-        )
-        check_run_id: int = SchemaField(
-            description="The ID of the check run to update",
-        )
-        status: ChecksStatus = SchemaField(
-            description="New status of the check run",
-        )
-        conclusion: ChecksConclusion = SchemaField(
-            description="The final conclusion of the check (required if status is completed)",
-        )
-        output_title: Optional[str] = SchemaField(
-            description="New title of the check run output",
-            default=None,
-        )
-        output_summary: Optional[str] = SchemaField(
-            description="New summary of the check run output",
-            default=None,
-        )
-        output_text: Optional[str] = SchemaField(
-            description="New detailed text of the check run output",
-            default=None,
-        )
-
-    class Output(BlockSchema):
-        class CheckRunResult(BaseModel):
-            id: int
-            html_url: str
-            status: str
-            conclusion: Optional[str]
-
-        check_run: CheckRunResult = SchemaField(
-            description="Details of the updated check run"
-        )
-        error: str = SchemaField(description="Error message if check run update failed")
-
-    def __init__(self):
-        super().__init__(
-            id="8a23c567-9d01-4e56-b789-0c12d3e45678",  # Generated UUID
-            description="Updates an existing check run in a GitHub repository",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=GithubUpdateCheckRunBlock.Input,
-            output_schema=GithubUpdateCheckRunBlock.Output,
-            # requires a github app not available to oauth in our current system
-            disabled=True,
-            test_input={
-                "repo_url": "https://github.com/owner/repo",
-                "check_run_id": 4,
-                "status": ChecksStatus.COMPLETED.value,
-                "conclusion": ChecksConclusion.SUCCESS.value,
-                "output_title": "Updated Results",
-                "output_summary": "All tests passed after retry",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "check_run",
-                    {
-                        "id": 4,
-                        "html_url": "https://github.com/owner/repo/runs/4",
-                        "status": "completed",
-                        "conclusion": "success",
-                    },
-                ),
-            ],
-            test_mock={
-                "update_check_run": lambda *args, **kwargs: {
-                    "id": 4,
-                    "html_url": "https://github.com/owner/repo/runs/4",
-                    "status": "completed",
-                    "conclusion": "success",
-                }
-            },
-        )
-
-    @staticmethod
-    def update_check_run(
-        credentials: GithubCredentials,
-        repo_url: str,
-        check_run_id: int,
-        status: ChecksStatus,
-        conclusion: Optional[ChecksConclusion] = None,
-        output_title: Optional[str] = None,
-        output_summary: Optional[str] = None,
-        output_text: Optional[str] = None,
-    ) -> dict:
-        api = get_api(credentials)
-
-        class UpdateCheckRunData(BaseModel):
-            status: str
-            conclusion: Optional[str] = None
-            output: Optional[dict[str, str]] = None
-
-        data = UpdateCheckRunData(
-            status=status.value,
-        )
-
-        if conclusion:
-            data.conclusion = conclusion.value
-
-        if output_title or output_summary or output_text:
-            output_data = {
-                "title": output_title or "",
-                "summary": output_summary or "",
-                "text": output_text or "",
-            }
-            data.output = output_data
-
-        check_run_url = f"{repo_url}/check-runs/{check_run_id}"
-        response = api.patch(
-            check_run_url, data=data.model_dump_json(exclude_none=True)
-        )
-        result = response.json()
-
-        return {
-            "id": result["id"],
-            "html_url": result["html_url"],
-            "status": result["status"],
-            "conclusion": result.get("conclusion"),
-        }
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: GithubCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            result = self.update_check_run(
-                credentials=credentials,
-                repo_url=input_data.repo_url,
-                check_run_id=input_data.check_run_id,
-                status=input_data.status,
-                conclusion=input_data.conclusion,
-                output_title=input_data.output_title,
-                output_summary=input_data.output_summary,
-                output_text=input_data.output_text,
-            )
-            yield "check_run", result
-        except Exception as e:
-            yield "error", str(e)

autogpt_platform/backend/backend/blocks/github/example_payloads/pull_request.synchronize.json

@@ -1,700 +0,0 @@
-{
-  "action": "synchronize",
-  "number": 8358,
-  "pull_request": {
-    "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/pulls/8358",
-    "id": 2128918491,
-    "node_id": "PR_kwDOJKSTjM5-5Lfb",
-    "html_url": "https://github.com/Significant-Gravitas/AutoGPT/pull/8358",
-    "diff_url": "https://github.com/Significant-Gravitas/AutoGPT/pull/8358.diff",
-    "patch_url": "https://github.com/Significant-Gravitas/AutoGPT/pull/8358.patch",
-    "issue_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/8358",
-    "number": 8358,
-    "state": "open",
-    "locked": false,
-    "title": "feat(platform, blocks): Webhook-triggered blocks",
-    "user": {
-      "login": "Pwuts",
-      "id": 12185583,
-      "node_id": "MDQ6VXNlcjEyMTg1NTgz",
-      "avatar_url": "https://avatars.githubusercontent.com/u/12185583?v=4",
-      "gravatar_id": "",
-      "url": "https://api.github.com/users/Pwuts",
-      "html_url": "https://github.com/Pwuts",
-      "followers_url": "https://api.github.com/users/Pwuts/followers",
-      "following_url": "https://api.github.com/users/Pwuts/following{/other_user}",
-      "gists_url": "https://api.github.com/users/Pwuts/gists{/gist_id}",
-      "starred_url": "https://api.github.com/users/Pwuts/starred{/owner}{/repo}",
-      "subscriptions_url": "https://api.github.com/users/Pwuts/subscriptions",
-      "organizations_url": "https://api.github.com/users/Pwuts/orgs",
-      "repos_url": "https://api.github.com/users/Pwuts/repos",
-      "events_url": "https://api.github.com/users/Pwuts/events{/privacy}",
-      "received_events_url": "https://api.github.com/users/Pwuts/received_events",
-      "type": "User",
-      "user_view_type": "public",
-      "site_admin": false
-    },
-    "body": "- Resolves #8352\r\n\r\n## Changes 🏗️\r\n\r\n- feat(blocks): Add GitHub Pull Request Trigger block\r\n\r\n### feat(platform): Add support for Webhook-triggered blocks\r\n- ⚠️ Add `PLATFORM_BASE_URL` setting\r\n\r\n- Add webhook config option and `BlockType.WEBHOOK` to `Block`\r\n  - Add check to `Block.__init__` to enforce type and shape of webhook event filter\r\n  - Add check to `Block.__init__` to enforce `payload` input on webhook blocks\r\n\r\n- Add `Webhook` model + CRUD functions in `backend.data.integrations` to represent webhooks created by our system\r\n  - Add `IntegrationWebhook` to DB schema + reference `AgentGraphNode.webhook_id`\r\n    - Add `set_node_webhook(..)` in `backend.data.graph`\r\n\r\n- Add webhook-related endpoints:\r\n  - `POST /integrations/{provider}/webhooks/{webhook_id}/ingress` endpoint, to receive webhook payloads, and for all associated nodes create graph executions\r\n    - Add `Node.is_triggered_by_event_type(..)` helper method\r\n  - `POST /integrations/{provider}/webhooks/{webhook_id}/ping` endpoint, to allow testing a webhook\r\n  - Add `WebhookEvent` + pub/sub functions in `backend.data.integrations`\r\n\r\n- Add `backend.integrations.webhooks` module, including:\r\n  - `graph_lifecycle_hooks`, e.g. `on_graph_activate(..)`, to handle corresponding webhook creation etc.\r\n    - Add calls to these hooks in the graph create/update endpoints\r\n  - `BaseWebhooksManager` + `GithubWebhooksManager` to handle creating + registering, removing + deregistering, and retrieving existing webhooks, and validating incoming payloads\r\n\r\n### Other improvements\r\n- fix(blocks): Allow having an input and output pin with the same name\r\n- feat(blocks): Allow hiding inputs (e.g. `payload`) with `SchemaField(hidden=True)`\r\n- feat(backend/data): Add `graph_id`, `graph_version` to `Node`; `user_id` to `GraphMeta`\r\n  - Add `Creatable` versions of `Node`, `GraphMeta` and `Graph` without these properties\r\n  - Add `graph_from_creatable(..)` helper function in `backend.data.graph`\r\n- refactor(backend/data): Make `RedisEventQueue` generic\r\n- refactor(frontend): Deduplicate & clean up code for different block types in `generateInputHandles(..)` in `CustomNode`\r\n- refactor(backend): Remove unused subgraph functionality\r\n\r\n## How it works\r\n- When a graph is created, the `on_graph_activate` and `on_node_activate` hooks are called on the graph and its nodes\r\n- If a webhook-triggered node has presets for all the relevant inputs, `on_node_activate` will get/create a suitable webhook and link it by setting `AgentGraphNode.webhook_id`\r\n  - `on_node_activate` uses `webhook_manager.get_suitable_webhook(..)`, which tries to find a suitable webhook (with matching requirements) or creates it if none exists yet\r\n- When a graph is deactivated (in favor of a newer/other version) or deleted, `on_graph_deactivate` and `on_node_deactivate` are called on the graph and its nodes to clean up webhooks that are no longer in use\r\n- When a valid webhook payload is received, two things happen:\r\n  1. It is broadcast on the Redis channel `webhooks/{webhook_id}/{event_type}`\r\n  2. Graph executions are initiated for all nodes triggered by this webhook\r\n\r\n## TODO\r\n- [ ] #8537\r\n- [x] #8538\r\n- [ ] #8357\r\n- [ ] ~~#8554~~ can be done in a follow-up PR\r\n- [ ] Test test test!\r\n- [ ] Add note on `repo` input of webhook blocks that the credentials used must have the right permissions for the given organization/repo\r\n- [x] Implement proper detection and graceful handling of webhook creation failing due to insufficient permissions. This should give a clear message to the user to e.g. \"give the app access to this organization in your settings\".\r\n- [ ] Nice-to-have: make a button on webhook blocks to trigger a ping and check its result. The API endpoints for this is already implemented.",
-    "created_at": "2024-10-16T22:13:47Z",
-    "updated_at": "2024-11-11T18:34:54Z",
-    "closed_at": null,
-    "merged_at": null,
-    "merge_commit_sha": "cbfd0cdd8db52cdd5a3b7ce088fc0ab4617a652e",
-    "assignee": {
-      "login": "Pwuts",
-      "id": 12185583,
-      "node_id": "MDQ6VXNlcjEyMTg1NTgz",
-      "avatar_url": "https://avatars.githubusercontent.com/u/12185583?v=4",
-      "gravatar_id": "",
-      "url": "https://api.github.com/users/Pwuts",
-      "html_url": "https://github.com/Pwuts",
-      "followers_url": "https://api.github.com/users/Pwuts/followers",
-      "following_url": "https://api.github.com/users/Pwuts/following{/other_user}",
-      "gists_url": "https://api.github.com/users/Pwuts/gists{/gist_id}",
-      "starred_url": "https://api.github.com/users/Pwuts/starred{/owner}{/repo}",
-      "subscriptions_url": "https://api.github.com/users/Pwuts/subscriptions",
-      "organizations_url": "https://api.github.com/users/Pwuts/orgs",
-      "repos_url": "https://api.github.com/users/Pwuts/repos",
-      "events_url": "https://api.github.com/users/Pwuts/events{/privacy}",
-      "received_events_url": "https://api.github.com/users/Pwuts/received_events",
-      "type": "User",
-      "user_view_type": "public",
-      "site_admin": false
-    },
-    "assignees": [
-      {
-        "login": "Pwuts",
-        "id": 12185583,
-        "node_id": "MDQ6VXNlcjEyMTg1NTgz",
-        "avatar_url": "https://avatars.githubusercontent.com/u/12185583?v=4",
-        "gravatar_id": "",
-        "url": "https://api.github.com/users/Pwuts",
-        "html_url": "https://github.com/Pwuts",
-        "followers_url": "https://api.github.com/users/Pwuts/followers",
-        "following_url": "https://api.github.com/users/Pwuts/following{/other_user}",
-        "gists_url": "https://api.github.com/users/Pwuts/gists{/gist_id}",
-        "starred_url": "https://api.github.com/users/Pwuts/starred{/owner}{/repo}",
-        "subscriptions_url": "https://api.github.com/users/Pwuts/subscriptions",
-        "organizations_url": "https://api.github.com/users/Pwuts/orgs",
-        "repos_url": "https://api.github.com/users/Pwuts/repos",
-        "events_url": "https://api.github.com/users/Pwuts/events{/privacy}",
-        "received_events_url": "https://api.github.com/users/Pwuts/received_events",
-        "type": "User",
-        "user_view_type": "public",
-        "site_admin": false
-      }
-    ],
-    "requested_reviewers": [
-      {
-        "login": "kcze",
-        "id": 34861343,
-        "node_id": "MDQ6VXNlcjM0ODYxMzQz",
-        "avatar_url": "https://avatars.githubusercontent.com/u/34861343?v=4",
-        "gravatar_id": "",
-        "url": "https://api.github.com/users/kcze",
-        "html_url": "https://github.com/kcze",
-        "followers_url": "https://api.github.com/users/kcze/followers",
-        "following_url": "https://api.github.com/users/kcze/following{/other_user}",
-        "gists_url": "https://api.github.com/users/kcze/gists{/gist_id}",
-        "starred_url": "https://api.github.com/users/kcze/starred{/owner}{/repo}",
-        "subscriptions_url": "https://api.github.com/users/kcze/subscriptions",
-        "organizations_url": "https://api.github.com/users/kcze/orgs",
-        "repos_url": "https://api.github.com/users/kcze/repos",
-        "events_url": "https://api.github.com/users/kcze/events{/privacy}",
-        "received_events_url": "https://api.github.com/users/kcze/received_events",
-        "type": "User",
-        "user_view_type": "public",
-        "site_admin": false
-      }
-    ],
-    "requested_teams": [
-      {
-        "name": "DevOps",
-        "id": 9547361,
-        "node_id": "T_kwDOB8roIc4Aka5h",
-        "slug": "devops",
-        "description": "",
-        "privacy": "closed",
-        "notification_setting": "notifications_enabled",
-        "url": "https://api.github.com/organizations/130738209/team/9547361",
-        "html_url": "https://github.com/orgs/Significant-Gravitas/teams/devops",
-        "members_url": "https://api.github.com/organizations/130738209/team/9547361/members{/member}",
-        "repositories_url": "https://api.github.com/organizations/130738209/team/9547361/repos",
-        "permission": "pull",
-        "parent": null
-      }
-    ],
-    "labels": [
-      {
-        "id": 5272676214,
-        "node_id": "LA_kwDOJKSTjM8AAAABOkandg",
-        "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/labels/documentation",
-        "name": "documentation",
-        "color": "0075ca",
-        "default": true,
-        "description": "Improvements or additions to documentation"
-      },
-      {
-        "id": 5410633769,
-        "node_id": "LA_kwDOJKSTjM8AAAABQn-4KQ",
-        "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/labels/size/xl",
-        "name": "size/xl",
-        "color": "E751DD",
-        "default": false,
-        "description": ""
-      },
-      {
-        "id": 6892322271,
-        "node_id": "LA_kwDOJKSTjM8AAAABmtB93w",
-        "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/labels/Review%20effort%20[1-5]:%204",
-        "name": "Review effort [1-5]: 4",
-        "color": "d1bcf9",
-        "default": false,
-        "description": null
-      },
-      {
-        "id": 7218433025,
-        "node_id": "LA_kwDOJKSTjM8AAAABrkCMAQ",
-        "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/labels/platform/frontend",
-        "name": "platform/frontend",
-        "color": "033C07",
-        "default": false,
-        "description": "AutoGPT Platform - Front end"
-      },
-      {
-        "id": 7219356193,
-        "node_id": "LA_kwDOJKSTjM8AAAABrk6iIQ",
-        "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/labels/platform/backend",
-        "name": "platform/backend",
-        "color": "ededed",
-        "default": false,
-        "description": "AutoGPT Platform - Back end"
-      },
-      {
-        "id": 7515330106,
-        "node_id": "LA_kwDOJKSTjM8AAAABv_LWOg",
-        "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/labels/platform/blocks",
-        "name": "platform/blocks",
-        "color": "eb5757",
-        "default": false,
-        "description": null
-      }
-    ],
-    "milestone": null,
-    "draft": false,
-    "commits_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/pulls/8358/commits",
-    "review_comments_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/pulls/8358/comments",
-    "review_comment_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/pulls/comments{/number}",
-    "comments_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/8358/comments",
-    "statuses_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/statuses/8f708a2b60463eec10747d8f45dead35b5a45bd0",
-    "head": {
-      "label": "Significant-Gravitas:reinier/open-1961-implement-github-on-pull-request-block",
-      "ref": "reinier/open-1961-implement-github-on-pull-request-block",
-      "sha": "8f708a2b60463eec10747d8f45dead35b5a45bd0",
-      "user": {
-        "login": "Significant-Gravitas",
-        "id": 130738209,
-        "node_id": "O_kgDOB8roIQ",
-        "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-        "gravatar_id": "",
-        "url": "https://api.github.com/users/Significant-Gravitas",
-        "html_url": "https://github.com/Significant-Gravitas",
-        "followers_url": "https://api.github.com/users/Significant-Gravitas/followers",
-        "following_url": "https://api.github.com/users/Significant-Gravitas/following{/other_user}",
-        "gists_url": "https://api.github.com/users/Significant-Gravitas/gists{/gist_id}",
-        "starred_url": "https://api.github.com/users/Significant-Gravitas/starred{/owner}{/repo}",
-        "subscriptions_url": "https://api.github.com/users/Significant-Gravitas/subscriptions",
-        "organizations_url": "https://api.github.com/users/Significant-Gravitas/orgs",
-        "repos_url": "https://api.github.com/users/Significant-Gravitas/repos",
-        "events_url": "https://api.github.com/users/Significant-Gravitas/events{/privacy}",
-        "received_events_url": "https://api.github.com/users/Significant-Gravitas/received_events",
-        "type": "Organization",
-        "user_view_type": "public",
-        "site_admin": false
-      },
-      "repo": {
-        "id": 614765452,
-        "node_id": "R_kgDOJKSTjA",
-        "name": "AutoGPT",
-        "full_name": "Significant-Gravitas/AutoGPT",
-        "private": false,
-        "owner": {
-          "login": "Significant-Gravitas",
-          "id": 130738209,
-          "node_id": "O_kgDOB8roIQ",
-          "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-          "gravatar_id": "",
-          "url": "https://api.github.com/users/Significant-Gravitas",
-          "html_url": "https://github.com/Significant-Gravitas",
-          "followers_url": "https://api.github.com/users/Significant-Gravitas/followers",
-          "following_url": "https://api.github.com/users/Significant-Gravitas/following{/other_user}",
-          "gists_url": "https://api.github.com/users/Significant-Gravitas/gists{/gist_id}",
-          "starred_url": "https://api.github.com/users/Significant-Gravitas/starred{/owner}{/repo}",
-          "subscriptions_url": "https://api.github.com/users/Significant-Gravitas/subscriptions",
-          "organizations_url": "https://api.github.com/users/Significant-Gravitas/orgs",
-          "repos_url": "https://api.github.com/users/Significant-Gravitas/repos",
-          "events_url": "https://api.github.com/users/Significant-Gravitas/events{/privacy}",
-          "received_events_url": "https://api.github.com/users/Significant-Gravitas/received_events",
-          "type": "Organization",
-          "user_view_type": "public",
-          "site_admin": false
-        },
-        "html_url": "https://github.com/Significant-Gravitas/AutoGPT",
-        "description": "AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.",
-        "fork": false,
-        "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT",
-        "forks_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/forks",
-        "keys_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/keys{/key_id}",
-        "collaborators_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/collaborators{/collaborator}",
-        "teams_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/teams",
-        "hooks_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/hooks",
-        "issue_events_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/events{/number}",
-        "events_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/events",
-        "assignees_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/assignees{/user}",
-        "branches_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/branches{/branch}",
-        "tags_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/tags",
-        "blobs_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/blobs{/sha}",
-        "git_tags_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/tags{/sha}",
-        "git_refs_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/refs{/sha}",
-        "trees_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/trees{/sha}",
-        "statuses_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/statuses/{sha}",
-        "languages_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/languages",
-        "stargazers_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/stargazers",
-        "contributors_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/contributors",
-        "subscribers_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/subscribers",
-        "subscription_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/subscription",
-        "commits_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/commits{/sha}",
-        "git_commits_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/commits{/sha}",
-        "comments_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/comments{/number}",
-        "issue_comment_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/comments{/number}",
-        "contents_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/contents/{+path}",
-        "compare_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/compare/{base}...{head}",
-        "merges_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/merges",
-        "archive_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/{archive_format}{/ref}",
-        "downloads_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/downloads",
-        "issues_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues{/number}",
-        "pulls_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/pulls{/number}",
-        "milestones_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/milestones{/number}",
-        "notifications_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/notifications{?since,all,participating}",
-        "labels_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/labels{/name}",
-        "releases_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/releases{/id}",
-        "deployments_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/deployments",
-        "created_at": "2023-03-16T09:21:07Z",
-        "updated_at": "2024-11-11T18:16:29Z",
-        "pushed_at": "2024-11-11T18:34:52Z",
-        "git_url": "git://github.com/Significant-Gravitas/AutoGPT.git",
-        "ssh_url": "git@github.com:Significant-Gravitas/AutoGPT.git",
-        "clone_url": "https://github.com/Significant-Gravitas/AutoGPT.git",
-        "svn_url": "https://github.com/Significant-Gravitas/AutoGPT",
-        "homepage": "https://agpt.co",
-        "size": 181894,
-        "stargazers_count": 168203,
-        "watchers_count": 168203,
-        "language": "Python",
-        "has_issues": true,
-        "has_projects": true,
-        "has_downloads": true,
-        "has_wiki": true,
-        "has_pages": false,
-        "has_discussions": true,
-        "forks_count": 44376,
-        "mirror_url": null,
-        "archived": false,
-        "disabled": false,
-        "open_issues_count": 189,
-        "license": {
-          "key": "other",
-          "name": "Other",
-          "spdx_id": "NOASSERTION",
-          "url": null,
-          "node_id": "MDc6TGljZW5zZTA="
-        },
-        "allow_forking": true,
-        "is_template": false,
-        "web_commit_signoff_required": false,
-        "topics": [
-          "ai",
-          "artificial-intelligence",
-          "autonomous-agents",
-          "gpt-4",
-          "openai",
-          "python"
-        ],
-        "visibility": "public",
-        "forks": 44376,
-        "open_issues": 189,
-        "watchers": 168203,
-        "default_branch": "master",
-        "allow_squash_merge": true,
-        "allow_merge_commit": false,
-        "allow_rebase_merge": false,
-        "allow_auto_merge": true,
-        "delete_branch_on_merge": true,
-        "allow_update_branch": true,
-        "use_squash_pr_title_as_default": true,
-        "squash_merge_commit_message": "COMMIT_MESSAGES",
-        "squash_merge_commit_title": "PR_TITLE",
-        "merge_commit_message": "BLANK",
-        "merge_commit_title": "PR_TITLE"
-      }
-    },
-    "base": {
-      "label": "Significant-Gravitas:dev",
-      "ref": "dev",
-      "sha": "0b5b95eff5e18c1e162d2b30b66a7be2bed1cbc2",
-      "user": {
-        "login": "Significant-Gravitas",
-        "id": 130738209,
-        "node_id": "O_kgDOB8roIQ",
-        "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-        "gravatar_id": "",
-        "url": "https://api.github.com/users/Significant-Gravitas",
-        "html_url": "https://github.com/Significant-Gravitas",
-        "followers_url": "https://api.github.com/users/Significant-Gravitas/followers",
-        "following_url": "https://api.github.com/users/Significant-Gravitas/following{/other_user}",
-        "gists_url": "https://api.github.com/users/Significant-Gravitas/gists{/gist_id}",
-        "starred_url": "https://api.github.com/users/Significant-Gravitas/starred{/owner}{/repo}",
-        "subscriptions_url": "https://api.github.com/users/Significant-Gravitas/subscriptions",
-        "organizations_url": "https://api.github.com/users/Significant-Gravitas/orgs",
-        "repos_url": "https://api.github.com/users/Significant-Gravitas/repos",
-        "events_url": "https://api.github.com/users/Significant-Gravitas/events{/privacy}",
-        "received_events_url": "https://api.github.com/users/Significant-Gravitas/received_events",
-        "type": "Organization",
-        "user_view_type": "public",
-        "site_admin": false
-      },
-      "repo": {
-        "id": 614765452,
-        "node_id": "R_kgDOJKSTjA",
-        "name": "AutoGPT",
-        "full_name": "Significant-Gravitas/AutoGPT",
-        "private": false,
-        "owner": {
-          "login": "Significant-Gravitas",
-          "id": 130738209,
-          "node_id": "O_kgDOB8roIQ",
-          "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-          "gravatar_id": "",
-          "url": "https://api.github.com/users/Significant-Gravitas",
-          "html_url": "https://github.com/Significant-Gravitas",
-          "followers_url": "https://api.github.com/users/Significant-Gravitas/followers",
-          "following_url": "https://api.github.com/users/Significant-Gravitas/following{/other_user}",
-          "gists_url": "https://api.github.com/users/Significant-Gravitas/gists{/gist_id}",
-          "starred_url": "https://api.github.com/users/Significant-Gravitas/starred{/owner}{/repo}",
-          "subscriptions_url": "https://api.github.com/users/Significant-Gravitas/subscriptions",
-          "organizations_url": "https://api.github.com/users/Significant-Gravitas/orgs",
-          "repos_url": "https://api.github.com/users/Significant-Gravitas/repos",
-          "events_url": "https://api.github.com/users/Significant-Gravitas/events{/privacy}",
-          "received_events_url": "https://api.github.com/users/Significant-Gravitas/received_events",
-          "type": "Organization",
-          "user_view_type": "public",
-          "site_admin": false
-        },
-        "html_url": "https://github.com/Significant-Gravitas/AutoGPT",
-        "description": "AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.",
-        "fork": false,
-        "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT",
-        "forks_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/forks",
-        "keys_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/keys{/key_id}",
-        "collaborators_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/collaborators{/collaborator}",
-        "teams_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/teams",
-        "hooks_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/hooks",
-        "issue_events_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/events{/number}",
-        "events_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/events",
-        "assignees_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/assignees{/user}",
-        "branches_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/branches{/branch}",
-        "tags_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/tags",
-        "blobs_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/blobs{/sha}",
-        "git_tags_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/tags{/sha}",
-        "git_refs_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/refs{/sha}",
-        "trees_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/trees{/sha}",
-        "statuses_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/statuses/{sha}",
-        "languages_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/languages",
-        "stargazers_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/stargazers",
-        "contributors_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/contributors",
-        "subscribers_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/subscribers",
-        "subscription_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/subscription",
-        "commits_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/commits{/sha}",
-        "git_commits_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/commits{/sha}",
-        "comments_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/comments{/number}",
-        "issue_comment_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/comments{/number}",
-        "contents_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/contents/{+path}",
-        "compare_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/compare/{base}...{head}",
-        "merges_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/merges",
-        "archive_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/{archive_format}{/ref}",
-        "downloads_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/downloads",
-        "issues_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues{/number}",
-        "pulls_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/pulls{/number}",
-        "milestones_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/milestones{/number}",
-        "notifications_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/notifications{?since,all,participating}",
-        "labels_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/labels{/name}",
-        "releases_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/releases{/id}",
-        "deployments_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/deployments",
-        "created_at": "2023-03-16T09:21:07Z",
-        "updated_at": "2024-11-11T18:16:29Z",
-        "pushed_at": "2024-11-11T18:34:52Z",
-        "git_url": "git://github.com/Significant-Gravitas/AutoGPT.git",
-        "ssh_url": "git@github.com:Significant-Gravitas/AutoGPT.git",
-        "clone_url": "https://github.com/Significant-Gravitas/AutoGPT.git",
-        "svn_url": "https://github.com/Significant-Gravitas/AutoGPT",
-        "homepage": "https://agpt.co",
-        "size": 181894,
-        "stargazers_count": 168203,
-        "watchers_count": 168203,
-        "language": "Python",
-        "has_issues": true,
-        "has_projects": true,
-        "has_downloads": true,
-        "has_wiki": true,
-        "has_pages": false,
-        "has_discussions": true,
-        "forks_count": 44376,
-        "mirror_url": null,
-        "archived": false,
-        "disabled": false,
-        "open_issues_count": 189,
-        "license": {
-          "key": "other",
-          "name": "Other",
-          "spdx_id": "NOASSERTION",
-          "url": null,
-          "node_id": "MDc6TGljZW5zZTA="
-        },
-        "allow_forking": true,
-        "is_template": false,
-        "web_commit_signoff_required": false,
-        "topics": [
-          "ai",
-          "artificial-intelligence",
-          "autonomous-agents",
-          "gpt-4",
-          "openai",
-          "python"
-        ],
-        "visibility": "public",
-        "forks": 44376,
-        "open_issues": 189,
-        "watchers": 168203,
-        "default_branch": "master",
-        "allow_squash_merge": true,
-        "allow_merge_commit": false,
-        "allow_rebase_merge": false,
-        "allow_auto_merge": true,
-        "delete_branch_on_merge": true,
-        "allow_update_branch": true,
-        "use_squash_pr_title_as_default": true,
-        "squash_merge_commit_message": "COMMIT_MESSAGES",
-        "squash_merge_commit_title": "PR_TITLE",
-        "merge_commit_message": "BLANK",
-        "merge_commit_title": "PR_TITLE"
-      }
-    },
-    "_links": {
-      "self": {
-        "href": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/pulls/8358"
-      },
-      "html": {
-        "href": "https://github.com/Significant-Gravitas/AutoGPT/pull/8358"
-      },
-      "issue": {
-        "href": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/8358"
-      },
-      "comments": {
-        "href": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/8358/comments"
-      },
-      "review_comments": {
-        "href": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/pulls/8358/comments"
-      },
-      "review_comment": {
-        "href": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/pulls/comments{/number}"
-      },
-      "commits": {
-        "href": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/pulls/8358/commits"
-      },
-      "statuses": {
-        "href": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/statuses/8f708a2b60463eec10747d8f45dead35b5a45bd0"
-      }
-    },
-    "author_association": "MEMBER",
-    "auto_merge": null,
-    "active_lock_reason": null,
-    "merged": false,
-    "mergeable": null,
-    "rebaseable": null,
-    "mergeable_state": "unknown",
-    "merged_by": null,
-    "comments": 12,
-    "review_comments": 29,
-    "maintainer_can_modify": false,
-    "commits": 62,
-    "additions": 1674,
-    "deletions": 331,
-    "changed_files": 36
-  },
-  "before": "f40aef87672203f47bbbd53f83fae0964c5624da",
-  "after": "8f708a2b60463eec10747d8f45dead35b5a45bd0",
-  "repository": {
-    "id": 614765452,
-    "node_id": "R_kgDOJKSTjA",
-    "name": "AutoGPT",
-    "full_name": "Significant-Gravitas/AutoGPT",
-    "private": false,
-    "owner": {
-      "login": "Significant-Gravitas",
-      "id": 130738209,
-      "node_id": "O_kgDOB8roIQ",
-      "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-      "gravatar_id": "",
-      "url": "https://api.github.com/users/Significant-Gravitas",
-      "html_url": "https://github.com/Significant-Gravitas",
-      "followers_url": "https://api.github.com/users/Significant-Gravitas/followers",
-      "following_url": "https://api.github.com/users/Significant-Gravitas/following{/other_user}",
-      "gists_url": "https://api.github.com/users/Significant-Gravitas/gists{/gist_id}",
-      "starred_url": "https://api.github.com/users/Significant-Gravitas/starred{/owner}{/repo}",
-      "subscriptions_url": "https://api.github.com/users/Significant-Gravitas/subscriptions",
-      "organizations_url": "https://api.github.com/users/Significant-Gravitas/orgs",
-      "repos_url": "https://api.github.com/users/Significant-Gravitas/repos",
-      "events_url": "https://api.github.com/users/Significant-Gravitas/events{/privacy}",
-      "received_events_url": "https://api.github.com/users/Significant-Gravitas/received_events",
-      "type": "Organization",
-      "user_view_type": "public",
-      "site_admin": false
-    },
-    "html_url": "https://github.com/Significant-Gravitas/AutoGPT",
-    "description": "AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.",
-    "fork": false,
-    "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT",
-    "forks_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/forks",
-    "keys_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/keys{/key_id}",
-    "collaborators_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/collaborators{/collaborator}",
-    "teams_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/teams",
-    "hooks_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/hooks",
-    "issue_events_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/events{/number}",
-    "events_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/events",
-    "assignees_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/assignees{/user}",
-    "branches_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/branches{/branch}",
-    "tags_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/tags",
-    "blobs_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/blobs{/sha}",
-    "git_tags_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/tags{/sha}",
-    "git_refs_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/refs{/sha}",
-    "trees_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/trees{/sha}",
-    "statuses_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/statuses/{sha}",
-    "languages_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/languages",
-    "stargazers_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/stargazers",
-    "contributors_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/contributors",
-    "subscribers_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/subscribers",
-    "subscription_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/subscription",
-    "commits_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/commits{/sha}",
-    "git_commits_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/git/commits{/sha}",
-    "comments_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/comments{/number}",
-    "issue_comment_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/comments{/number}",
-    "contents_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/contents/{+path}",
-    "compare_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/compare/{base}...{head}",
-    "merges_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/merges",
-    "archive_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/{archive_format}{/ref}",
-    "downloads_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/downloads",
-    "issues_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues{/number}",
-    "pulls_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/pulls{/number}",
-    "milestones_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/milestones{/number}",
-    "notifications_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/notifications{?since,all,participating}",
-    "labels_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/labels{/name}",
-    "releases_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/releases{/id}",
-    "deployments_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/deployments",
-    "created_at": "2023-03-16T09:21:07Z",
-    "updated_at": "2024-11-11T18:16:29Z",
-    "pushed_at": "2024-11-11T18:34:52Z",
-    "git_url": "git://github.com/Significant-Gravitas/AutoGPT.git",
-    "ssh_url": "git@github.com:Significant-Gravitas/AutoGPT.git",
-    "clone_url": "https://github.com/Significant-Gravitas/AutoGPT.git",
-    "svn_url": "https://github.com/Significant-Gravitas/AutoGPT",
-    "homepage": "https://agpt.co",
-    "size": 181894,
-    "stargazers_count": 168203,
-    "watchers_count": 168203,
-    "language": "Python",
-    "has_issues": true,
-    "has_projects": true,
-    "has_downloads": true,
-    "has_wiki": true,
-    "has_pages": false,
-    "has_discussions": true,
-    "forks_count": 44376,
-    "mirror_url": null,
-    "archived": false,
-    "disabled": false,
-    "open_issues_count": 189,
-    "license": {
-      "key": "other",
-      "name": "Other",
-      "spdx_id": "NOASSERTION",
-      "url": null,
-      "node_id": "MDc6TGljZW5zZTA="
-    },
-    "allow_forking": true,
-    "is_template": false,
-    "web_commit_signoff_required": false,
-    "topics": [
-      "ai",
-      "artificial-intelligence",
-      "autonomous-agents",
-      "gpt-4",
-      "openai",
-      "python"
-    ],
-    "visibility": "public",
-    "forks": 44376,
-    "open_issues": 189,
-    "watchers": 168203,
-    "default_branch": "master",
-    "custom_properties": {
-
-    }
-  },
-  "organization": {
-    "login": "Significant-Gravitas",
-    "id": 130738209,
-    "node_id": "O_kgDOB8roIQ",
-    "url": "https://api.github.com/orgs/Significant-Gravitas",
-    "repos_url": "https://api.github.com/orgs/Significant-Gravitas/repos",
-    "events_url": "https://api.github.com/orgs/Significant-Gravitas/events",
-    "hooks_url": "https://api.github.com/orgs/Significant-Gravitas/hooks",
-    "issues_url": "https://api.github.com/orgs/Significant-Gravitas/issues",
-    "members_url": "https://api.github.com/orgs/Significant-Gravitas/members{/member}",
-    "public_members_url": "https://api.github.com/orgs/Significant-Gravitas/public_members{/member}",
-    "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-    "description": ""
-  },
-  "enterprise": {
-    "id": 149607,
-    "slug": "significant-gravitas",
-    "name": "Significant Gravitas",
-    "node_id": "E_kgDOAAJIZw",
-    "avatar_url": "https://avatars.githubusercontent.com/b/149607?v=4",
-    "description": "The creators of AutoGPT",
-    "website_url": "discord.gg/autogpt",
-    "html_url": "https://github.com/enterprises/significant-gravitas",
-    "created_at": "2024-04-18T17:43:53Z",
-    "updated_at": "2024-10-23T16:59:55Z"
-  },
-  "sender": {
-    "login": "Pwuts",
-    "id": 12185583,
-    "node_id": "MDQ6VXNlcjEyMTg1NTgz",
-    "avatar_url": "https://avatars.githubusercontent.com/u/12185583?v=4",
-    "gravatar_id": "",
-    "url": "https://api.github.com/users/Pwuts",
-    "html_url": "https://github.com/Pwuts",
-    "followers_url": "https://api.github.com/users/Pwuts/followers",
-    "following_url": "https://api.github.com/users/Pwuts/following{/other_user}",
-    "gists_url": "https://api.github.com/users/Pwuts/gists{/gist_id}",
-    "starred_url": "https://api.github.com/users/Pwuts/starred{/owner}{/repo}",
-    "subscriptions_url": "https://api.github.com/users/Pwuts/subscriptions",
-    "organizations_url": "https://api.github.com/users/Pwuts/orgs",
-    "repos_url": "https://api.github.com/users/Pwuts/repos",
-    "events_url": "https://api.github.com/users/Pwuts/events{/privacy}",
-    "received_events_url": "https://api.github.com/users/Pwuts/received_events",
-    "type": "User",
-    "user_view_type": "public",
-    "site_admin": false
-  }
-}

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

@@ -1,12 +1,9 @@
-import logging
-from urllib.parse import urlparse
-
+import requests
 from typing_extensions import TypedDict
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
-from ._api import convert_comment_url_to_api_endpoint, get_api
 from ._auth import (
     TEST_CREDENTIALS,
     TEST_CREDENTIALS_INPUT,
@@ -15,14 +12,7 @@ from ._auth import (
     GithubCredentialsInput,
 )
 
-logger = logging.getLogger(__name__)
 
-
-def is_github_url(url: str) -> bool:
-    return urlparse(url).netloc == "github.com"
-
-
-# --8<-- [start:GithubCommentBlockExample]
 class GithubCommentBlock(Block):
     class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
@@ -49,27 +39,15 @@ class GithubCommentBlock(Block):
             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,
-                },
-                {
-                    "issue_url": "https://github.com/owner/repo/pull/1",
-                    "comment": "This is a test comment.",
-                    "credentials": TEST_CREDENTIALS_INPUT,
-                },
-            ],
+            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"),
-                ("id", 1337),
-                (
-                    "url",
-                    "https://github.com/owner/repo/issues/1#issuecomment-1337",
-                ),
             ],
             test_mock={
                 "post_comment": lambda *args, **kwargs: (
@@ -83,103 +61,27 @@ class GithubCommentBlock(Block):
     def post_comment(
         credentials: GithubCredentials, issue_url: str, body_text: str
     ) -> tuple[int, str]:
-        api = get_api(credentials)
-        data = {"body": body_text}
-        if "pull" in issue_url:
-            issue_url = issue_url.replace("pull", "issues")
-        comments_url = issue_url + "/comments"
-        response = api.post(comments_url, json=data)
-        comment = response.json()
-        return comment["id"], comment["html_url"]
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: GithubCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        id, url = self.post_comment(
-            credentials,
-            input_data.issue_url,
-            input_data.comment,
-        )
-        yield "id", id
-        yield "url", url
-
-
-# --8<-- [end:GithubCommentBlockExample]
-
-
-class GithubUpdateCommentBlock(Block):
-    class Input(BlockSchema):
-        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
-        comment_url: str = SchemaField(
-            description="URL of the GitHub comment",
-            placeholder="https://github.com/owner/repo/issues/1#issuecomment-123456789",
-            default="",
-            advanced=False,
-        )
-        issue_url: str = SchemaField(
-            description="URL of the GitHub issue or pull request",
-            placeholder="https://github.com/owner/repo/issues/1",
-            default="",
-        )
-        comment_id: str = SchemaField(
-            description="ID of the GitHub comment",
-            placeholder="123456789",
-            default="",
-        )
-        comment: str = SchemaField(
-            description="Comment to update",
-            placeholder="Enter your comment",
-        )
-
-    class Output(BlockSchema):
-        id: int = SchemaField(description="ID of the updated comment")
-        url: str = SchemaField(description="URL to the comment on GitHub")
-        error: str = SchemaField(
-            description="Error message if the comment update failed"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="b3f4d747-10e3-4e69-8c51-f2be1d99c9a7",
-            description="This block updates a comment on a specified GitHub issue or pull request.",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=GithubUpdateCommentBlock.Input,
-            output_schema=GithubUpdateCommentBlock.Output,
-            test_input={
-                "comment_url": "https://github.com/owner/repo/issues/1#issuecomment-123456789",
-                "comment": "This is an updated comment.",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                ("id", 123456789),
-                (
-                    "url",
-                    "https://github.com/owner/repo/issues/1#issuecomment-123456789",
-                ),
-            ],
-            test_mock={
-                "update_comment": lambda *args, **kwargs: (
-                    123456789,
-                    "https://github.com/owner/repo/issues/1#issuecomment-123456789",
+        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"
+            )
 
-    @staticmethod
-    def update_comment(
-        credentials: GithubCredentials, comment_url: str, body_text: str
-    ) -> tuple[int, str]:
-        api = get_api(credentials, convert_urls=False)
+        headers = {
+            "Authorization": credentials.bearer(),
+            "Accept": "application/vnd.github.v3+json",
+        }
         data = {"body": body_text}
-        url = convert_comment_url_to_api_endpoint(comment_url)
 
-        logger.info(url)
-        response = api.patch(url, json=data)
+        response = requests.post(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
         comment = response.json()
         return comment["id"], comment["html_url"]
 
@@ -190,147 +92,16 @@ class GithubUpdateCommentBlock(Block):
         credentials: GithubCredentials,
         **kwargs,
     ) -> BlockOutput:
-        if (
-            not input_data.comment_url
-            and input_data.comment_id
-            and input_data.issue_url
-        ):
-            parsed_url = urlparse(input_data.issue_url)
-            path_parts = parsed_url.path.strip("/").split("/")
-            owner, repo = path_parts[0], path_parts[1]
-
-            input_data.comment_url = f"https://api.github.com/repos/{owner}/{repo}/issues/comments/{input_data.comment_id}"
-
-        elif (
-            not input_data.comment_url
-            and not input_data.comment_id
-            and input_data.issue_url
-        ):
-            raise ValueError(
-                "Must provide either comment_url or comment_id and issue_url"
+        try:
+            id, url = self.post_comment(
+                credentials,
+                input_data.issue_url,
+                input_data.comment,
             )
-        id, url = self.update_comment(
-            credentials,
-            input_data.comment_url,
-            input_data.comment,
-        )
-        yield "id", id
-        yield "url", url
-
-
-class GithubListCommentsBlock(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",
-        )
-
-    class Output(BlockSchema):
-        class CommentItem(TypedDict):
-            id: int
-            body: str
-            user: str
-            url: str
-
-        comment: CommentItem = SchemaField(
-            title="Comment", description="Comments with their ID, body, user, and URL"
-        )
-        comments: list[CommentItem] = SchemaField(
-            description="List of comments with their ID, body, user, and URL"
-        )
-        error: str = SchemaField(description="Error message if listing comments failed")
-
-    def __init__(self):
-        super().__init__(
-            id="c4b5fb63-0005-4a11-b35a-0c2467bd6b59",
-            description="This block lists all comments for a specified GitHub issue or pull request.",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=GithubListCommentsBlock.Input,
-            output_schema=GithubListCommentsBlock.Output,
-            test_input={
-                "issue_url": "https://github.com/owner/repo/issues/1",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "comment",
-                    {
-                        "id": 123456789,
-                        "body": "This is a test comment.",
-                        "user": "test_user",
-                        "url": "https://github.com/owner/repo/issues/1#issuecomment-123456789",
-                    },
-                ),
-                (
-                    "comments",
-                    [
-                        {
-                            "id": 123456789,
-                            "body": "This is a test comment.",
-                            "user": "test_user",
-                            "url": "https://github.com/owner/repo/issues/1#issuecomment-123456789",
-                        }
-                    ],
-                ),
-            ],
-            test_mock={
-                "list_comments": lambda *args, **kwargs: [
-                    {
-                        "id": 123456789,
-                        "body": "This is a test comment.",
-                        "user": "test_user",
-                        "url": "https://github.com/owner/repo/issues/1#issuecomment-123456789",
-                    }
-                ]
-            },
-        )
-
-    @staticmethod
-    def list_comments(
-        credentials: GithubCredentials, issue_url: str
-    ) -> list[Output.CommentItem]:
-        parsed_url = urlparse(issue_url)
-        path_parts = parsed_url.path.strip("/").split("/")
-
-        owner = path_parts[0]
-        repo = path_parts[1]
-
-        # GitHub API uses 'issues' for both issues and pull requests when it comes to comments
-        issue_number = path_parts[3]  # Whether 'issues/123' or 'pull/123'
-
-        # Construct the proper API URL directly
-        api_url = f"https://api.github.com/repos/{owner}/{repo}/issues/{issue_number}/comments"
-
-        # Set convert_urls=False since we're already providing an API URL
-        api = get_api(credentials, convert_urls=False)
-        response = api.get(api_url)
-        comments = response.json()
-        parsed_comments: list[GithubListCommentsBlock.Output.CommentItem] = [
-            {
-                "id": comment["id"],
-                "body": comment["body"],
-                "user": comment["user"]["login"],
-                "url": comment["html_url"],
-            }
-            for comment in comments
-        ]
-        return parsed_comments
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: GithubCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        comments = self.list_comments(
-            credentials,
-            input_data.issue_url,
-        )
-        yield from (("comment", comment) for comment in comments)
-        yield "comments", comments
+            yield "id", id
+            yield "url", url
+        except Exception as e:
+            yield "error", f"Failed to post comment: {str(e)}"
 
 
 class GithubMakeIssueBlock(Block):
@@ -384,10 +155,16 @@ class GithubMakeIssueBlock(Block):
     def create_issue(
         credentials: GithubCredentials, repo_url: str, title: str, body: str
     ) -> tuple[int, str]:
-        api = get_api(credentials)
+        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}
-        issues_url = repo_url + "/issues"
-        response = api.post(issues_url, json=data)
+
+        response = requests.post(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
         issue = response.json()
         return issue["number"], issue["html_url"]
 
@@ -398,14 +175,17 @@ class GithubMakeIssueBlock(Block):
         credentials: GithubCredentials,
         **kwargs,
     ) -> BlockOutput:
-        number, url = self.create_issue(
-            credentials,
-            input_data.repo_url,
-            input_data.title,
-            input_data.body,
-        )
-        yield "number", number
-        yield "url", url
+        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):
@@ -454,12 +234,21 @@ class GithubReadIssueBlock(Block):
     def read_issue(
         credentials: GithubCredentials, issue_url: str
     ) -> tuple[str, str, str]:
-        api = get_api(credentials)
-        response = api.get(issue_url)
+        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(
@@ -469,16 +258,16 @@ class GithubReadIssueBlock(Block):
         credentials: GithubCredentials,
         **kwargs,
     ) -> BlockOutput:
-        title, body, user = self.read_issue(
-            credentials,
-            input_data.issue_url,
-        )
-        if title:
+        try:
+            title, body, user = self.read_issue(
+                credentials,
+                input_data.issue_url,
+            )
             yield "title", title
-        if body:
             yield "body", body
-        if user:
             yield "user", user
+        except Exception as e:
+            yield "error", f"Failed to read issue: {str(e)}"
 
 
 class GithubListIssuesBlock(Block):
@@ -534,13 +323,20 @@ class GithubListIssuesBlock(Block):
     def list_issues(
         credentials: GithubCredentials, repo_url: str
     ) -> list[Output.IssueItem]:
-        api = get_api(credentials)
-        issues_url = repo_url + "/issues"
-        response = api.get(issues_url)
+        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(
@@ -550,11 +346,14 @@ class GithubListIssuesBlock(Block):
         credentials: GithubCredentials,
         **kwargs,
     ) -> BlockOutput:
-        issues = self.list_issues(
-            credentials,
-            input_data.repo_url,
-        )
-        yield from (("issue", issue) for issue in issues)
+        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):
@@ -594,10 +393,28 @@ class GithubAddLabelBlock(Block):
 
     @staticmethod
     def add_label(credentials: GithubCredentials, issue_url: str, label: str) -> str:
-        api = get_api(credentials)
+        # 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]}
-        labels_url = issue_url + "/labels"
-        api.post(labels_url, json=data)
+
+        response = requests.post(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
         return "Label added successfully"
 
     def run(
@@ -607,12 +424,15 @@ class GithubAddLabelBlock(Block):
         credentials: GithubCredentials,
         **kwargs,
     ) -> BlockOutput:
-        status = self.add_label(
-            credentials,
-            input_data.issue_url,
-            input_data.label,
-        )
-        yield "status", status
+        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):
@@ -654,9 +474,31 @@ class GithubRemoveLabelBlock(Block):
 
     @staticmethod
     def remove_label(credentials: GithubCredentials, issue_url: str, label: str) -> str:
-        api = get_api(credentials)
-        label_url = issue_url + f"/labels/{label}"
-        api.delete(label_url)
+        # 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(
@@ -666,12 +508,15 @@ class GithubRemoveLabelBlock(Block):
         credentials: GithubCredentials,
         **kwargs,
     ) -> BlockOutput:
-        status = self.remove_label(
-            credentials,
-            input_data.issue_url,
-            input_data.label,
-        )
-        yield "status", status
+        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):
@@ -719,10 +564,23 @@ class GithubAssignIssueBlock(Block):
         issue_url: str,
         assignee: str,
     ) -> str:
-        api = get_api(credentials)
-        assignees_url = issue_url + "/assignees"
+        # 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]}
-        api.post(assignees_url, json=data)
+
+        response = requests.post(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
         return "Issue assigned successfully"
 
     def run(
@@ -732,12 +590,15 @@ class GithubAssignIssueBlock(Block):
         credentials: GithubCredentials,
         **kwargs,
     ) -> BlockOutput:
-        status = self.assign_issue(
-            credentials,
-            input_data.issue_url,
-            input_data.assignee,
-        )
-        yield "status", status
+        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):
@@ -785,10 +646,23 @@ class GithubUnassignIssueBlock(Block):
         issue_url: str,
         assignee: str,
     ) -> str:
-        api = get_api(credentials)
-        assignees_url = issue_url + "/assignees"
+        # 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]}
-        api.delete(assignees_url, json=data)
+
+        response = requests.delete(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
         return "Issue unassigned successfully"
 
     def run(
@@ -798,9 +672,12 @@ class GithubUnassignIssueBlock(Block):
         credentials: GithubCredentials,
         **kwargs,
     ) -> BlockOutput:
-        status = self.unassign_issue(
-            credentials,
-            input_data.issue_url,
-            input_data.assignee,
-        )
-        yield "status", status
+        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

@@ -1,11 +1,9 @@
-import re
-
+import requests
 from typing_extensions import TypedDict
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
-from ._api import get_api
 from ._auth import (
     TEST_CREDENTIALS,
     TEST_CREDENTIALS_INPUT,
@@ -66,13 +64,20 @@ class GithubListPullRequestsBlock(Block):
 
     @staticmethod
     def list_prs(credentials: GithubCredentials, repo_url: str) -> list[Output.PRItem]:
-        api = get_api(credentials)
-        pulls_url = repo_url + "/pulls"
-        response = api.get(pulls_url)
+        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(
@@ -82,11 +87,14 @@ class GithubListPullRequestsBlock(Block):
         credentials: GithubCredentials,
         **kwargs,
     ) -> BlockOutput:
-        pull_requests = self.list_prs(
-            credentials,
-            input_data.repo_url,
-        )
-        yield from (("pull_request", pr) for pr in pull_requests)
+        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):
@@ -105,11 +113,7 @@ class GithubMakePullRequestBlock(Block):
             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."
-            ),
+            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(
@@ -161,10 +165,17 @@ class GithubMakePullRequestBlock(Block):
         head: str,
         base: str,
     ) -> tuple[int, str]:
-        api = get_api(credentials)
-        pulls_url = repo_url + "/pulls"
+        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 = api.post(pulls_url, json=data)
+
+        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"]
 
@@ -186,8 +197,15 @@ class GithubMakePullRequestBlock(Block):
             )
             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", str(e)
+            yield "error", f"Failed to create pull request: {str(e)}"
 
 
 class GithubReadPullRequestBlock(Block):
@@ -200,7 +218,6 @@ class GithubReadPullRequestBlock(Block):
         include_pr_changes: bool = SchemaField(
             description="Whether to include the changes made in the pull request",
             default=False,
-            advanced=False,
         )
 
     class Output(BlockSchema):
@@ -243,21 +260,42 @@ class GithubReadPullRequestBlock(Block):
 
     @staticmethod
     def read_pr(credentials: GithubCredentials, pr_url: str) -> tuple[str, str, str]:
-        api = get_api(credentials)
-        # Adjust the URL to access the issue endpoint for PR metadata
-        issue_url = pr_url.replace("/pull/", "/issues/")
-        response = api.get(issue_url)
+        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 = get_api(credentials)
-        files_url = prepare_pr_api_url(pr_url=pr_url, path="files")
-        response = api.get(files_url)
+        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:
@@ -265,6 +303,7 @@ class GithubReadPullRequestBlock(Block):
             patch = file.get("patch")
             if filename and patch:
                 changes.append(f"File: {filename}\n{patch}")
+
         return "\n\n".join(changes)
 
     def run(
@@ -274,20 +313,23 @@ class GithubReadPullRequestBlock(Block):
         credentials: GithubCredentials,
         **kwargs,
     ) -> BlockOutput:
-        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(
+        try:
+            title, body, author = self.read_pr(
                 credentials,
                 input_data.pr_url,
             )
-            yield "changes", changes
+            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):
@@ -333,10 +375,23 @@ class GithubAssignPRReviewerBlock(Block):
     def assign_reviewer(
         credentials: GithubCredentials, pr_url: str, reviewer: str
     ) -> str:
-        api = get_api(credentials)
-        reviewers_url = prepare_pr_api_url(pr_url=pr_url, path="requested_reviewers")
+        # 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]}
-        api.post(reviewers_url, json=data)
+
+        response = requests.post(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
         return "Reviewer assigned successfully"
 
     def run(
@@ -353,8 +408,19 @@ class GithubAssignPRReviewerBlock(Block):
                 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", str(e)
+            yield "error", f"Failed to assign reviewer: {str(e)}"
 
 
 class GithubUnassignPRReviewerBlock(Block):
@@ -400,10 +466,21 @@ class GithubUnassignPRReviewerBlock(Block):
     def unassign_reviewer(
         credentials: GithubCredentials, pr_url: str, reviewer: str
     ) -> str:
-        api = get_api(credentials)
-        reviewers_url = prepare_pr_api_url(pr_url=pr_url, path="requested_reviewers")
+        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]}
-        api.delete(reviewers_url, json=data)
+
+        response = requests.delete(api_url, headers=headers, json=data)
+        response.raise_for_status()
+
         return "Reviewer unassigned successfully"
 
     def run(
@@ -421,7 +498,7 @@ class GithubUnassignPRReviewerBlock(Block):
             )
             yield "status", status
         except Exception as e:
-            yield "error", str(e)
+            yield "error", f"Failed to unassign reviewer: {str(e)}"
 
 
 class GithubListPRReviewersBlock(Block):
@@ -480,14 +557,26 @@ class GithubListPRReviewersBlock(Block):
     def list_reviewers(
         credentials: GithubCredentials, pr_url: str
     ) -> list[Output.ReviewerItem]:
-        api = get_api(credentials)
-        reviewers_url = prepare_pr_api_url(pr_url=pr_url, path="requested_reviewers")
-        response = api.get(reviewers_url)
+        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(
@@ -497,19 +586,11 @@ class GithubListPRReviewersBlock(Block):
         credentials: GithubCredentials,
         **kwargs,
     ) -> BlockOutput:
-        reviewers = self.list_reviewers(
-            credentials,
-            input_data.pr_url,
-        )
-        yield from (("reviewer", reviewer) for reviewer in reviewers)
-
-
-def prepare_pr_api_url(pr_url: str, path: str) -> str:
-    # Pattern to capture the base repository URL and the pull request number
-    pattern = r"^(?:https?://)?([^/]+/[^/]+/[^/]+)/pull/(\d+)"
-    match = re.match(pattern, pr_url)
-    if not match:
-        return pr_url
-
-    base_url, pr_number = match.groups()
-    return f"{base_url}/pulls/{pr_number}/{path}"
+        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)}"