remove work dir

.dockerignore

@@ -1,61 +0,0 @@
-# Ignore everything by default, selectively add things to context
-*
-
-# 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
-!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
-!classic/benchmark/agbenchmark/
-!classic/benchmark/pyproject.toml
-!classic/benchmark/poetry.lock
-!classic/benchmark/README.md
-
-# Classic - Forge
-!classic/forge/
-!classic/forge/pyproject.toml
-!classic/forge/poetry.lock
-!classic/forge/README.md
-
-# Classic - Frontend
-!classic/frontend/build/web/
-
-# Explicitly re-ignore some folders
-.*
-**/__pycache__

.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,175 +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"
-
-
-  # Submodules
-  - package-ecosystem: "gitsubmodule"
-    directory: "autogpt_platform/supabase"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 1
-    target-branch: "dev"
-    commit-message:
-      prefix: "chore(platform/deps)"
-      prefix-development: "chore(platform/deps-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/labeler.yml

@@ -25,8 +25,3 @@ platform/frontend:
 platform/backend:
 - changed-files:
   - any-glob-to-any-file: autogpt_platform/backend/**
-  - all-globs-to-all-files: '!autogpt_platform/backend/backend/blocks/**'
-
-platform/blocks:
-- changed-files:
-  - any-glob-to-any-file: autogpt_platform/backend/backend/blocks/**

.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/**'

.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/**'
@@ -102,7 +102,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        agent-name: [forge]
+        agent-name: [ forge ]
       fail-fast: false
     timeout-minutes: 20
     steps:
@@ -146,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/**'

.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

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

.github/workflows/platform-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-docker-ci.yml

@@ -0,0 +1,40 @@
+name: AutoGPT Server Docker Build & Push
+
+on:
+  push:
+    branches: [ update-docker-ci ]
+    paths:
+      - '**'
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  PROJECT_ID: agpt-dev
+  IMAGE_NAME: agpt-server-dev
+  REGION: us-central1
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up Cloud SDK
+        uses: google-github-actions/setup-gcloud@v0.2.1
+        with:
+          project_id: ${{ env.PROJECT_ID }}
+          service_account_key: ${{ secrets.GCP_SA_KEY }}
+          export_default_credentials: true
+
+      - name: Configure Docker
+        run: gcloud auth configure-docker ${{ env.REGION }}-docker.pkg.dev
+
+      - name: Build Docker image
+        run: docker build -t ${{ env.REGION }}-docker.pkg.dev/${{ env.PROJECT_ID }}/${{ env.IMAGE_NAME }}:${{ github.sha }} -f autogpt_platform/backend/Dockerfile .
+
+      - name: Push Docker image
+        run: docker push ${{ env.REGION }}-docker.pkg.dev/${{ env.PROJECT_ID }}/${{ env.IMAGE_NAME }}:${{ github.sha }}

.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) }}
@@ -33,17 +30,45 @@ jobs:
       fail-fast: false
       matrix:
         python-version: ["3.10"]
-    runs-on: ubuntu-latest
-
-    services:
-      redis:
-        image: bitnami/redis:6.2
-        env:
-          REDIS_PASSWORD: testpassword
-        ports:
-          - 6379:6379
+        platform-os: [ubuntu, macos, macos-arm64, windows]
+    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
 
     steps:
+      - name: Setup PostgreSQL
+        uses: ikalnytskyi/action-setup-postgres@v6
+        with:
+          username: ${{ secrets.DB_USER || 'postgres' }}
+          password: ${{ secrets.DB_PASS || 'postgres' }}
+          database: postgres
+          port: 5432
+        id: postgres
+
+      # Quite slow on macOS (2~4 minutes to set up Docker)
+      # - name: Set up Docker (macOS)
+      #   if: runner.os == 'macOS'
+      #   uses: crazy-max/ghaction-setup-docker@v3
+
+      - name: Start MinIO service (Linux)
+        if: runner.os == 'Linux'
+        working-directory: "."
+        run: |
+          docker pull minio/minio:edge-cicd
+          docker run -d -p 9000:9000 minio/minio:edge-cicd
+
+      - name: Start MinIO service (macOS)
+        if: runner.os == 'macOS'
+        working-directory: ${{ runner.temp }}
+        run: |
+          brew install minio/stable/minio
+          mkdir data
+          minio server ./data &
+
+      # No MinIO on Windows:
+      # - Windows doesn't support running Linux Docker containers
+      # - It doesn't seem possible to start background processes on Windows. They are
+      #   killed after the step returns.
+      #   See: https://github.com/actions/runner/issues/598#issuecomment-2011890429
+
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
@@ -55,22 +80,20 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
-      - name: Setup Supabase
-        uses: supabase/setup-cli@v1
-        with:
-          version: latest
-
       - id: get_date
         name: Get date
         run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
 
       - name: Set up Python dependency cache
+        # On Windows, unpacking cached dependencies takes longer than just installing them
+        if: runner.os != 'Windows'
         uses: actions/cache@v4
         with:
-          path: ~/.cache/pypoetry
+          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
           key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
 
       - name: Install Poetry (Unix)
+        if: runner.os != 'Windows'
         run: |
           curl -sSL https://install.python-poetry.org | python3 -
 
@@ -79,16 +102,14 @@ jobs:
             echo "$HOME/.local/bin" >> $GITHUB_PATH
           fi
 
-      - name: Check poetry.lock
+      - name: Install Poetry (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
         run: |
-          poetry lock
+          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
 
-          if ! git diff --quiet poetry.lock; then
-            echo "Error: poetry.lock not up to date."
-            echo
-            git diff poetry.lock
-            exit 1
-          fi
+          $env:PATH += ";$env:APPDATA\Python\Scripts"
+          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
 
       - name: Install Python dependencies
         run: poetry install
@@ -96,20 +117,10 @@ jobs:
       - name: Generate Prisma Client
         run: poetry run prisma generate
 
-      - id: supabase
-        name: Start Supabase
-        working-directory: .
-        run: |
-          supabase init
-          supabase start --exclude postgres-meta,realtime,storage-api,imgproxy,inbucket,studio,edge-runtime,logflare,vector,supavisor
-          supabase status -o env | sed 's/="/=/; s/"$//' >> $GITHUB_OUTPUT
-        # outputs:
-        # DB_URL, API_URL, GRAPHQL_URL, ANON_KEY, SERVICE_ROLE_KEY, JWT_SECRET
-
       - name: Run Database Migrations
         run: poetry run prisma migrate dev --name updates
         env:
-          DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
+          CONNECTION_STR: ${{ steps.postgres.outputs.connection-uri }}
 
       - id: lint
         name: Run Linter
@@ -118,27 +129,24 @@ 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:
           LOG_LEVEL: ${{ runner.debug && 'DEBUG' || 'INFO' }}
-          DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
-          SUPABASE_URL: ${{ steps.supabase.outputs.API_URL }}
-          SUPABASE_SERVICE_ROLE_KEY: ${{ steps.supabase.outputs.SERVICE_ROLE_KEY }}
-          SUPABASE_JWT_SECRET: ${{ steps.supabase.outputs.JWT_SECRET }}
-          REDIS_HOST: 'localhost'
-          REDIS_PORT: '6379'
-          REDIS_PASSWORD: 'testpassword'
-
     env:
       CI: true
       PLAIN_OUTPUT: True
+      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+      DB_USER: ${{ secrets.DB_USER || 'postgres' }}
+      DB_PASS: ${{ secrets.DB_PASS || 'postgres' }}
+      DB_NAME: postgres
+      DB_PORT: 5432
       RUN_ENV: local
       PORT: 8080
-      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+      DATABASE_URL: postgresql://${{ secrets.DB_USER || 'postgres' }}:${{ secrets.DB_PASS || 'postgres' }}@localhost:5432/${{ secrets.DB_NAME || 'postgres'}}
 
       # - name: Upload coverage reports to Codecov
       #   uses: codecov/codecov-action@v4

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

@@ -2,15 +2,14 @@ name: AutoGPT Platform - Frontend CI
 
 on:
   push:
-    branches: [master, dev]
+    branches: [ master ]
     paths:
-      - ".github/workflows/platform-frontend-ci.yml"
-      - "autogpt_platform/frontend/**"
+      - '.github/workflows/platform-frontend-ci.yml'
+      - 'autogpt_platform/frontend/**'
   pull_request:
     paths:
-      - ".github/workflows/platform-frontend-ci.yml"
-      - "autogpt_platform/frontend/**"
-  merge_group:
+      - '.github/workflows/platform-frontend-ci.yml'
+      - 'autogpt_platform/frontend/**'
 
 defaults:
   run:
@@ -18,84 +17,25 @@ defaults:
     working-directory: autogpt_platform/frontend
 
 jobs:
+
   lint:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v4
+    - uses: actions/checkout@v4
+    - name: Set up Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '21'
 
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "21"
+    - name: Install dependencies
+      run: |
+        npm install
 
-      - name: Install dependencies
-        run: |
-          yarn install --frozen-lockfile
+    - name: Check formatting with Prettier
+      run: |
+        npx prettier --check .
 
-      - name: Run lint
-        run: |
-          yarn 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 ../supabase/docker/.env.example ../.env
-
-      - name: Copy backend .env
-        run: |
-          cp ../backend/.env.example ../backend/.env
-
-      - name: Run docker compose
-        run: |
-          docker compose -f ../docker-compose.yml up -d
-
-      - name: Install dependencies
-        run: |
-          yarn install --frozen-lockfile
-
-      - name: Setup Builder .env
-        run: |
-          cp .env.example .env
-
-      - name: Install Browser '${{ matrix.browser }}'
-        run: yarn playwright install --with-deps ${{ matrix.browser }}
-
-      - name: Run tests
-        run: |
-          yarn test --project=${{ matrix.browser }}
-
-      - name: Print Docker Compose logs in debug mode
-        if: runner.debug
-        run: |
-          docker compose -f ../docker-compose.yml logs
-
-      - uses: actions/upload-artifact@v4
-        if: ${{ !cancelled() }}
-        with:
-          name: playwright-report-${{ matrix.browser }}
-          path: playwright-report/
-          retention-days: 30
+    - name: Run lint
+      run: |
+        npm run lint

.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

@@ -5,8 +5,6 @@ import sys
 import time
 from typing import Dict, List, Tuple
 
-CHECK_INTERVAL = 30
-
 
 def get_environment_variables() -> Tuple[str, str, str, str, str]:
     """Retrieve and return necessary environment variables."""
@@ -14,11 +12,7 @@ def get_environment_variables() -> Tuple[str, str, str, str, str]:
         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"],
@@ -99,10 +93,9 @@ def main():
             break
 
         print(
-            "Some check runs are still in progress. "
-            f"Waiting {CHECK_INTERVAL} seconds before checking again..."
+            "Some check runs are still in progress. Waiting 3 minutes before checking again..."
         )
-        time.sleep(CHECK_INTERVAL)
+        time.sleep(180)
 
     if all_others_passed:
         print("All other completed check runs have passed. This check passes.")

.gitignore

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

.pre-commit-config.yaml

@@ -10,131 +10,27 @@ 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
@@ -145,7 +41,8 @@ repos:
     # 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,20 +50,20 @@ 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]
 
@@ -175,47 +72,31 @@ repos:
     # 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
@@ -223,35 +104,23 @@ repos:
 
   - 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/all-projects.code-workspace

@@ -1,12 +1,12 @@
 {
   "folders": [
     {
-      "name": "frontend",
-      "path": "../autogpt_platform/frontend"
+      "name": "autogpt_server",
+      "path": "../autogpt_platform/autogpt_server"
     },
     {
-      "name": "backend",
-      "path": "../autogpt_platform/backend"
+      "name": "autogpt_builder",
+      "path": "../autogpt_platform/autogpt_builder"
     },
     {
       "name": "market",
@@ -24,7 +24,10 @@
       "name": "docs",
       "path": "../docs"
     },
-
+    {
+      "name": "[root]",
+      "path": ".."
+    },
     {
       "name": "classic - autogpt",
       "path": "../classic/original_autogpt"
@@ -41,10 +44,6 @@
       "name": "classic - frontend",
       "path": "../classic/frontend"
     },
-    {
-      "name": "[root]",
-      "path": ".."
-    }
   ],
   "settings": {
     "python.analysis.typeCheckingMode": "basic"

.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

@@ -10,9 +10,6 @@ Also check out our [🚀 Roadmap][roadmap] for information about our priorities
 [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.
-
 ## In short
 1. Avoid duplicate work, issues, PRs etc.
 2. We encourage you to collaborate with fellow community members on some of our bigger

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

@@ -1,71 +1,43 @@
-# AutoGPT: Build, Deploy, and Run AI Agents
+# AutoGPT: Build & Use AI Agents
 
 [![Discord Follow](https://dcbadge.vercel.app/api/server/autogpt?style=flat)](https://discord.gg/autogpt)  
 [![Twitter Follow](https://img.shields.io/twitter/follow/Auto_GPT?style=social)](https://twitter.com/Auto_GPT)  
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-**AutoGPT** is a powerful platform that allows you to create, deploy, and manage continuous AI agents that automate complex workflows. 
+**AutoGPT** is a powerful tool that lets you create and run intelligent agents. These agents can perform various tasks automatically, making your life easier.
 
-## Hosting Options 
-   - Download to self-host
-   - [Join the Waitlist](https://bit.ly/3ZDijAI) for the cloud-hosted beta  
+## How to Get Started
 
-## How to Setup for Self-Hosting
-> [!NOTE]
-> Setting up and hosting the AutoGPT Platform yourself is a technical process. 
-> If you'd rather something that just works, we recommend [joining the waitlist](https://bit.ly/3ZDijAI) for the cloud-hosted beta.
+https://github.com/user-attachments/assets/8508f4dc-b362-4cab-900f-644964a96cdf
 
-https://github.com/user-attachments/assets/d04273a5-b36a-4a37-818e-f631ce72d603
+### 🧱 AutoGPT Builder 
 
-This tutorial assumes you have Docker, VSCode, git and npm installed.
+The AutoGPT Builder is the frontend. It allows you to design agents using an easy flowchart style. You build your agent by connecting blocks, where each block performs a single action. It's simple and intuitive!
 
-### 🧱 AutoGPT Frontend
-
-The AutoGPT frontend is where users interact with our powerful AI automation platform. It offers multiple ways to engage with and leverage our AI agents. This is the interface where you'll bring your AI automation ideas to life:
-
-   **Agent Builder:** For those who want to customize, our intuitive, low-code interface allows you to design and configure your own AI agents. 
-   
-   **Workflow Management:** Build, modify, and optimize your automation workflows with ease. You build your agent by connecting blocks, where each block     performs a single action.
-   
-   **Deployment Controls:** Manage the lifecycle of your agents, from testing to production.
-   
-   **Ready-to-Use Agents:** Don't want to build? Simply select from our library of pre-configured agents and put them to work immediately.
-   
-   **Agent Interaction:** Whether you've built your own or are using pre-configured agents, easily run and interact with them through our user-friendly      interface.
-
-   **Monitoring and Analytics:** Keep track of your agents' performance and gain insights to continually improve your automation processes.
-
-[Read this guide](https://docs.agpt.co/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
 
-The AutoGPT Server is the powerhouse of our platform This is where your agents run. Once deployed, agents can be triggered by external sources and can operate continuously. It contains all the essential components that make AutoGPT run smoothly.
-
-   **Source Code:** The core logic that drives our agents and automation processes.
-   
-   **Infrastructure:** Robust systems that ensure reliable and scalable performance.
-   
-   **Marketplace:** A comprehensive marketplace where you can find and deploy a wide range of pre-built agents.
+The AutoGPT Server is the backend. This is where your agents run. Once deployed, agents can be triggered by external sources and can operate continuously.
 
 ### 🐙 Example Agents
 
 Here are two examples of what you can do with AutoGPT:
 
-1. **Generate Viral Videos from Trending Topics**
-   - This agent reads topics on Reddit.
-   - It identifies trending topics.
-   - It then automatically creates a short-form video based on the content. 
+1. **Reddit Marketing Agent**
+   - This agent reads comments on Reddit.
+   - It looks for people asking about your product.
+   - It then automatically responds to them.
 
-2. **Identify Top Quotes from Videos for Social Media**
+2. **YouTube Content Repurposing Agent**
    - This agent subscribes to your YouTube channel.
    - When you post a new video, it transcribes it.
-   - It uses AI to identify the most impactful quotes to generate a summary.
-   - Then, it writes a post to automatically publish to your social media. 
+   - It uses AI to write a search engine optimized blog post.
+   - Then, it publishes this blog post to your Medium account.
 
-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.
+These examples show just a glimpse of what you can achieve with AutoGPT!
 
 ---
-### 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.
@@ -78,13 +50,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
@@ -109,7 +74,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
 
@@ -158,8 +123,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>
@@ -169,10 +132,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,47 +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
-- 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/.gitignore

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

autogpt_platform/Contributor License Agreement (CLA).md

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

autogpt_platform/LICENCE.txt

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

autogpt_platform/README.md

@@ -8,67 +8,46 @@ Welcome to the AutoGPT Platform - a powerful system for creating and running AI
 
 - Docker
 - Docker Compose V2 (comes with Docker Desktop, or can be installed separately)
-- Node.js & NPM (for running the frontend application)
 
 ### Running the System
 
 To run the AutoGPT Platform, follow these steps:
 
-1. Clone this repository to your local machine and navigate to the `autogpt_platform` directory within the repository:
-   ```
-   git clone <https://github.com/Significant-Gravitas/AutoGPT.git | git@github.com:Significant-Gravitas/AutoGPT.git>
-   cd AutoGPT/autogpt_platform
-   ```
-
-2. Run the following command:
-   ```
-   git submodule update --init --recursive
-   ```
-   This command will initialize and update the submodules in the repository. The `supabase` folder will be cloned to the root directory.
-
+1. Clone this repository to your local machine.
+2. Navigate to autogpt_platform/supabase
 3. Run the following command:
    ```
-   cp supabase/docker/.env.example .env
+      git submodule update --init --recursive
    ```
-   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. Navigate back to autogpt_platform (cd ..)
+5. Run the following command:
+   ```
+      cp supabase/docker/.env.example .env
+   ```
+6. Run the following command:
 
-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.
+   docker compose -f docker-compose.combined.yml up -d
 
-5. Navigate to `frontend` within the `autogpt_platform` directory:
-   ```
-   cd frontend
-   ```
-   You will need to run your frontend application separately on your local machine.
-
-6. Run the following command: 
-   ```
-   cp .env.example .env.local
-   ```
-   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.
-
-7. Run the following command:
-   ```
-   npm install
-   npm run dev
-   ```
-   This command will install the necessary dependencies and start the frontend application in development mode.
-   If you are using Yarn, you can run the following commands instead:
-   ```
-   yarn install && yarn dev
    ```
 
-8. Open your browser and navigate to `http://localhost:3000` to access the AutoGPT Platform frontend.
+   This command will start all the necessary backend services defined in the `docker-compose.combined.yml` file in detached mode.
+7. Navigate to autogpt_platform/frontend.
+8. Run the following command: 
+   ```
+      cp .env.example .env.local
+   ```
+9. Run the following command: 
+   ```
+      yarn dev
+   ```
 
 ### Docker Compose Commands
 
 Here are some useful Docker Compose commands for managing your AutoGPT Platform:
 
-- `docker compose up -d`: Start the services in detached mode.
-- `docker compose stop`: Stop the running services without removing them.
+- `docker compose -f docker-compose.combined.yml up -d`: Start the services in detached mode.
+- `docker compose -f docker-compose.combined.yml stop`: Stop the running services without removing them.
 - `docker compose rm`: Remove stopped service containers.
 - `docker compose build`: Build or rebuild services.
 - `docker compose down`: Stop and remove containers, networks, and volumes.
@@ -149,3 +128,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/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

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/models.py

@@ -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,167 +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__)
-logging.basicConfig(level=logging.DEBUG)
-
-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,7 +6,6 @@ from pathlib import Path
 
 from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
-
 from .filters import BelowLevelFilter
 from .formatters import AGPTFormatter, StructuredLoggingFormatter
 
@@ -23,6 +22,7 @@ DEBUG_LOG_FORMAT = (
 
 
 class LoggingConfig(BaseSettings):
+
     level: str = Field(
         default="INFO",
         description="Logging level",

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/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

@@ -29,9 +29,6 @@ class OAuth2Credentials(_BaseCredentials):
     scopes: list[str]
     metadata: dict[str, Any] = Field(default_factory=dict)
 
-    def bearer(self) -> str:
-        return f"Bearer {self.access_token.get_secret_value()}"
-
 
 class APIKeyCredentials(_BaseCredentials):
     type: Literal["api_key"] = "api_key"
@@ -39,9 +36,6 @@ class APIKeyCredentials(_BaseCredentials):
     expires_at: Optional[int]
     """Unix timestamp (seconds) indicating when the API key expires (if at all)"""
 
-    def bearer(self) -> str:
-        return f"Bearer {self.api_key.get_secret_value()}"
-
 
 Credentials = Annotated[
     OAuth2Credentials | APIKeyCredentials,
@@ -49,15 +43,10 @@ Credentials = Annotated[
 ]
 
 
-CredentialsType = Literal["api_key", "oauth2"]
-
-
 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 +58,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/poetry.lock

@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 1.8.5 and should not be changed by hand.
+# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand.
 
 [[package]]
 name = "aiohappyeyeballs"
@@ -377,20 +377,6 @@ files = [
 [package.extras]
 test = ["pytest (>=6)"]
 
-[[package]]
-name = "expiringdict"
-version = "1.2.2"
-description = "Dictionary with auto-expiring values for caching purposes"
-optional = false
-python-versions = "*"
-files = [
-    {file = "expiringdict-1.2.2-py3-none-any.whl", hash = "sha256:09a5d20bc361163e6432a874edd3179676e935eb81b925eccef48d409a8a45e8"},
-    {file = "expiringdict-1.2.2.tar.gz", hash = "sha256:300fb92a7e98f15b05cf9a856c1415b3bc4f2e132be07daa326da6414c23ee09"},
-]
-
-[package.extras]
-tests = ["coverage", "coveralls", "dill", "mock", "nose"]
-
 [[package]]
 name = "frozenlist"
 version = "1.4.1"
@@ -583,13 +569,13 @@ grpc = ["grpcio (>=1.38.0,<2.0dev)", "grpcio-status (>=1.38.0,<2.0.dev0)"]
 
 [[package]]
 name = "google-cloud-logging"
-version = "3.11.3"
+version = "3.11.2"
 description = "Stackdriver Logging API client library"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "google_cloud_logging-3.11.3-py2.py3-none-any.whl", hash = "sha256:b8ec23f2998f76a58f8492db26a0f4151dd500425c3f08448586b85972f3c494"},
-    {file = "google_cloud_logging-3.11.3.tar.gz", hash = "sha256:0a73cd94118875387d4535371d9e9426861edef8e44fba1261e86782d5b8d54f"},
+    {file = "google_cloud_logging-3.11.2-py2.py3-none-any.whl", hash = "sha256:0a755f04f184fbe77ad608258dc283a032485ebb4d0e2b2501964059ee9c898f"},
+    {file = "google_cloud_logging-3.11.2.tar.gz", hash = "sha256:4897441c2b74f6eda9181c23a8817223b6145943314a821d64b729d30766cb2b"},
 ]
 
 [package.dependencies]
@@ -626,17 +612,17 @@ grpc = ["grpcio (>=1.44.0,<2.0.0.dev0)"]
 
 [[package]]
 name = "gotrue"
-version = "2.10.0"
+version = "2.8.1"
 description = "Python Client Library for Supabase Auth"
 optional = false
-python-versions = "<4.0,>=3.9"
+python-versions = "<4.0,>=3.8"
 files = [
-    {file = "gotrue-2.10.0-py3-none-any.whl", hash = "sha256:768e58207488e5184ffbdc4351b7280d913daf97962f4e9f2cca05c80004b042"},
-    {file = "gotrue-2.10.0.tar.gz", hash = "sha256:4edf4c251da3535f2b044e23deba221e848ca1210c17d0c7a9b19f79a1e3f3c0"},
+    {file = "gotrue-2.8.1-py3-none-any.whl", hash = "sha256:97dff077d71cca629f046c35ba34fae132b69c55fe271651766ddcf6d8132468"},
+    {file = "gotrue-2.8.1.tar.gz", hash = "sha256:644d0096c4c390f7e36d9cb05271a7091c01e7dc6d506eb117b8fe8fc48eb8d9"},
 ]
 
 [package.dependencies]
-httpx = {version = ">=0.26,<0.28", extras = ["http2"]}
+httpx = {version = ">=0.24,<0.28", extras = ["http2"]}
 pydantic = ">=1.10,<3"
 
 [[package]]
@@ -854,17 +840,6 @@ doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linke
 perf = ["ipython"]
 test = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-perf (>=0.9.2)", "pytest-ruff (>=0.2.1)"]
 
-[[package]]
-name = "iniconfig"
-version = "2.0.0"
-description = "brain-dead simple config-ini parsing"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"},
-    {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},
-]
-
 [[package]]
 name = "multidict"
 version = "6.1.0"
@@ -995,37 +970,22 @@ files = [
     {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"},
 ]
 
-[[package]]
-name = "pluggy"
-version = "1.5.0"
-description = "plugin and hook calling mechanisms for python"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
-    {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
-]
-
-[package.extras]
-dev = ["pre-commit", "tox"]
-testing = ["pytest", "pytest-benchmark"]
-
 [[package]]
 name = "postgrest"
-version = "0.18.0"
+version = "0.16.11"
 description = "PostgREST client for Python. This library provides an ORM interface to PostgREST."
 optional = false
-python-versions = "<4.0,>=3.9"
+python-versions = "<4.0,>=3.8"
 files = [
-    {file = "postgrest-0.18.0-py3-none-any.whl", hash = "sha256:200baad0d23fee986b3a0ffd3e07bfe0cdd40e09760f11e8e13a6c0c2376d5fa"},
-    {file = "postgrest-0.18.0.tar.gz", hash = "sha256:29c1a94801a17eb9ad590189993fe5a7a6d8c1bfc11a3c9d0ce7ba146454ebb3"},
+    {file = "postgrest-0.16.11-py3-none-any.whl", hash = "sha256:22fb6b817ace1f68aa648fd4ce0f56d2786c9260fa4ed2cb9046191231a682b8"},
+    {file = "postgrest-0.16.11.tar.gz", hash = "sha256:10af51b4c39e288ad7df2db92d6a61fb3c4683131b40561f473e3de116e83fa5"},
 ]
 
 [package.dependencies]
 deprecation = ">=2.1.0,<3.0.0"
-httpx = {version = ">=0.26,<0.28", extras = ["http2"]}
+httpx = {version = ">=0.24,<0.28", extras = ["http2"]}
 pydantic = ">=1.9,<3.0"
-strenum = {version = ">=0.4.9,<0.5.0", markers = "python_version < \"3.11\""}
+strenum = ">=0.4.9,<0.5.0"
 
 [[package]]
 name = "proto-plus"
@@ -1071,7 +1031,6 @@ description = "Pure-Python implementation of ASN.1 types and DER/BER/CER codecs
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629"},
     {file = "pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034"},
 ]
 
@@ -1082,7 +1041,6 @@ description = "A collection of ASN.1-based protocols modules"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pyasn1_modules-0.4.1-py3-none-any.whl", hash = "sha256:49bfa96b45a292b711e986f222502c1c9a5e1f4e568fc30e2574a6c7d07838fd"},
     {file = "pyasn1_modules-0.4.1.tar.gz", hash = "sha256:c28e2dbf9c06ad61c71a075c7e0f9fd0f1b0bb2d2ad4377f240d33ac2ab60a7c"},
 ]
 
@@ -1091,19 +1049,22 @@ pyasn1 = ">=0.4.6,<0.7.0"
 
 [[package]]
 name = "pydantic"
-version = "2.10.3"
+version = "2.9.1"
 description = "Data validation using Python type hints"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pydantic-2.10.3-py3-none-any.whl", hash = "sha256:be04d85bbc7b65651c5f8e6b9976ed9c6f41782a55524cef079a34a0bb82144d"},
-    {file = "pydantic-2.10.3.tar.gz", hash = "sha256:cb5ac360ce894ceacd69c403187900a02c4b20b693a9dd1d643e1effab9eadf9"},
+    {file = "pydantic-2.9.1-py3-none-any.whl", hash = "sha256:7aff4db5fdf3cf573d4b3c30926a510a10e19a0774d38fc4967f78beb6deb612"},
+    {file = "pydantic-2.9.1.tar.gz", hash = "sha256:1363c7d975c7036df0db2b4a61f2e062fbc0aa5ab5f2772e0ffc7191a4f4bce2"},
 ]
 
 [package.dependencies]
 annotated-types = ">=0.6.0"
-pydantic-core = "2.27.1"
-typing-extensions = ">=4.12.2"
+pydantic-core = "2.23.3"
+typing-extensions = [
+    {version = ">=4.12.2", markers = "python_version >= \"3.13\""},
+    {version = ">=4.6.1", markers = "python_version < \"3.13\""},
+]
 
 [package.extras]
 email = ["email-validator (>=2.0.0)"]
@@ -1111,111 +1072,100 @@ timezone = ["tzdata"]
 
 [[package]]
 name = "pydantic-core"
-version = "2.27.1"
+version = "2.23.3"
 description = "Core functionality for Pydantic validation and serialization"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pydantic_core-2.27.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:71a5e35c75c021aaf400ac048dacc855f000bdfed91614b4a726f7432f1f3d6a"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f82d068a2d6ecfc6e054726080af69a6764a10015467d7d7b9f66d6ed5afa23b"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:121ceb0e822f79163dd4699e4c54f5ad38b157084d97b34de8b232bcaad70278"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4603137322c18eaf2e06a4495f426aa8d8388940f3c457e7548145011bb68e05"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a33cd6ad9017bbeaa9ed78a2e0752c5e250eafb9534f308e7a5f7849b0b1bfb4"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:15cc53a3179ba0fcefe1e3ae50beb2784dede4003ad2dfd24f81bba4b23a454f"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45d9c5eb9273aa50999ad6adc6be5e0ecea7e09dbd0d31bd0c65a55a2592ca08"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8bf7b66ce12a2ac52d16f776b31d16d91033150266eb796967a7e4621707e4f6"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:655d7dd86f26cb15ce8a431036f66ce0318648f8853d709b4167786ec2fa4807"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:5556470f1a2157031e676f776c2bc20acd34c1990ca5f7e56f1ebf938b9ab57c"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:f69ed81ab24d5a3bd93861c8c4436f54afdf8e8cc421562b0c7504cf3be58206"},
-    {file = "pydantic_core-2.27.1-cp310-none-win32.whl", hash = "sha256:f5a823165e6d04ccea61a9f0576f345f8ce40ed533013580e087bd4d7442b52c"},
-    {file = "pydantic_core-2.27.1-cp310-none-win_amd64.whl", hash = "sha256:57866a76e0b3823e0b56692d1a0bf722bffb324839bb5b7226a7dbd6c9a40b17"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:ac3b20653bdbe160febbea8aa6c079d3df19310d50ac314911ed8cc4eb7f8cb8"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a5a8e19d7c707c4cadb8c18f5f60c843052ae83c20fa7d44f41594c644a1d330"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f7059ca8d64fea7f238994c97d91f75965216bcbe5f695bb44f354893f11d52"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bed0f8a0eeea9fb72937ba118f9db0cb7e90773462af7962d382445f3005e5a4"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a3cb37038123447cf0f3ea4c74751f6a9d7afef0eb71aa07bf5f652b5e6a132c"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:84286494f6c5d05243456e04223d5a9417d7f443c3b76065e75001beb26f88de"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acc07b2cfc5b835444b44a9956846b578d27beeacd4b52e45489e93276241025"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4fefee876e07a6e9aad7a8c8c9f85b0cdbe7df52b8a9552307b09050f7512c7e"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:258c57abf1188926c774a4c94dd29237e77eda19462e5bb901d88adcab6af919"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:35c14ac45fcfdf7167ca76cc80b2001205a8d5d16d80524e13508371fb8cdd9c"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d1b26e1dff225c31897696cab7d4f0a315d4c0d9e8666dbffdb28216f3b17fdc"},
-    {file = "pydantic_core-2.27.1-cp311-none-win32.whl", hash = "sha256:2cdf7d86886bc6982354862204ae3b2f7f96f21a3eb0ba5ca0ac42c7b38598b9"},
-    {file = "pydantic_core-2.27.1-cp311-none-win_amd64.whl", hash = "sha256:3af385b0cee8df3746c3f406f38bcbfdc9041b5c2d5ce3e5fc6637256e60bbc5"},
-    {file = "pydantic_core-2.27.1-cp311-none-win_arm64.whl", hash = "sha256:81f2ec23ddc1b476ff96563f2e8d723830b06dceae348ce02914a37cb4e74b89"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9cbd94fc661d2bab2bc702cddd2d3370bbdcc4cd0f8f57488a81bcce90c7a54f"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5f8c4718cd44ec1580e180cb739713ecda2bdee1341084c1467802a417fe0f02"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:15aae984e46de8d376df515f00450d1522077254ef6b7ce189b38ecee7c9677c"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1ba5e3963344ff25fc8c40da90f44b0afca8cfd89d12964feb79ac1411a260ac"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:992cea5f4f3b29d6b4f7f1726ed8ee46c8331c6b4eed6db5b40134c6fe1768bb"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0325336f348dbee6550d129b1627cb8f5351a9dc91aad141ffb96d4937bd9529"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7597c07fbd11515f654d6ece3d0e4e5093edc30a436c63142d9a4b8e22f19c35"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3bbd5d8cc692616d5ef6fbbbd50dbec142c7e6ad9beb66b78a96e9c16729b089"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:dc61505e73298a84a2f317255fcc72b710b72980f3a1f670447a21efc88f8381"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:e1f735dc43da318cad19b4173dd1ffce1d84aafd6c9b782b3abc04a0d5a6f5bb"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:f4e5658dbffe8843a0f12366a4c2d1c316dbe09bb4dfbdc9d2d9cd6031de8aae"},
-    {file = "pydantic_core-2.27.1-cp312-none-win32.whl", hash = "sha256:672ebbe820bb37988c4d136eca2652ee114992d5d41c7e4858cdd90ea94ffe5c"},
-    {file = "pydantic_core-2.27.1-cp312-none-win_amd64.whl", hash = "sha256:66ff044fd0bb1768688aecbe28b6190f6e799349221fb0de0e6f4048eca14c16"},
-    {file = "pydantic_core-2.27.1-cp312-none-win_arm64.whl", hash = "sha256:9a3b0793b1bbfd4146304e23d90045f2a9b5fd5823aa682665fbdaf2a6c28f3e"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f216dbce0e60e4d03e0c4353c7023b202d95cbaeff12e5fd2e82ea0a66905073"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a2e02889071850bbfd36b56fd6bc98945e23670773bc7a76657e90e6b6603c08"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42b0e23f119b2b456d07ca91b307ae167cc3f6c846a7b169fca5326e32fdc6cf"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:764be71193f87d460a03f1f7385a82e226639732214b402f9aa61f0d025f0737"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1c00666a3bd2f84920a4e94434f5974d7bbc57e461318d6bb34ce9cdbbc1f6b2"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3ccaa88b24eebc0f849ce0a4d09e8a408ec5a94afff395eb69baf868f5183107"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c65af9088ac534313e1963443d0ec360bb2b9cba6c2909478d22c2e363d98a51"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:206b5cf6f0c513baffaeae7bd817717140770c74528f3e4c3e1cec7871ddd61a"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:062f60e512fc7fff8b8a9d680ff0ddaaef0193dba9fa83e679c0c5f5fbd018bc"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:a0697803ed7d4af5e4c1adf1670af078f8fcab7a86350e969f454daf598c4960"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:58ca98a950171f3151c603aeea9303ef6c235f692fe555e883591103da709b23"},
-    {file = "pydantic_core-2.27.1-cp313-none-win32.whl", hash = "sha256:8065914ff79f7eab1599bd80406681f0ad08f8e47c880f17b416c9f8f7a26d05"},
-    {file = "pydantic_core-2.27.1-cp313-none-win_amd64.whl", hash = "sha256:ba630d5e3db74c79300d9a5bdaaf6200172b107f263c98a0539eeecb857b2337"},
-    {file = "pydantic_core-2.27.1-cp313-none-win_arm64.whl", hash = "sha256:45cf8588c066860b623cd11c4ba687f8d7175d5f7ef65f7129df8a394c502de5"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:5897bec80a09b4084aee23f9b73a9477a46c3304ad1d2d07acca19723fb1de62"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:d0165ab2914379bd56908c02294ed8405c252250668ebcb438a55494c69f44ab"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b9af86e1d8e4cfc82c2022bfaa6f459381a50b94a29e95dcdda8442d6d83864"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f6c8a66741c5f5447e047ab0ba7a1c61d1e95580d64bce852e3df1f895c4067"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a42d6a8156ff78981f8aa56eb6394114e0dedb217cf8b729f438f643608cbcd"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:64c65f40b4cd8b0e049a8edde07e38b476da7e3aaebe63287c899d2cff253fa5"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdcf339322a3fae5cbd504edcefddd5a50d9ee00d968696846f089b4432cf78"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bf99c8404f008750c846cb4ac4667b798a9f7de673ff719d705d9b2d6de49c5f"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:8f1edcea27918d748c7e5e4d917297b2a0ab80cad10f86631e488b7cddf76a36"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-musllinux_1_1_armv7l.whl", hash = "sha256:159cac0a3d096f79ab6a44d77a961917219707e2a130739c64d4dd46281f5c2a"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:029d9757eb621cc6e1848fa0b0310310de7301057f623985698ed7ebb014391b"},
-    {file = "pydantic_core-2.27.1-cp38-none-win32.whl", hash = "sha256:a28af0695a45f7060e6f9b7092558a928a28553366519f64083c63a44f70e618"},
-    {file = "pydantic_core-2.27.1-cp38-none-win_amd64.whl", hash = "sha256:2d4567c850905d5eaaed2f7a404e61012a51caf288292e016360aa2b96ff38d4"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:e9386266798d64eeb19dd3677051f5705bf873e98e15897ddb7d76f477131967"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4228b5b646caa73f119b1ae756216b59cc6e2267201c27d3912b592c5e323b60"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b3dfe500de26c52abe0477dde16192ac39c98f05bf2d80e76102d394bd13854"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:aee66be87825cdf72ac64cb03ad4c15ffef4143dbf5c113f64a5ff4f81477bf9"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3b748c44bb9f53031c8cbc99a8a061bc181c1000c60a30f55393b6e9c45cc5bd"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ca038c7f6a0afd0b2448941b6ef9d5e1949e999f9e5517692eb6da58e9d44be"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e0bd57539da59a3e4671b90a502da9a28c72322a4f17866ba3ac63a82c4498e"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ac6c2c45c847bbf8f91930d88716a0fb924b51e0c6dad329b793d670ec5db792"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b94d4ba43739bbe8b0ce4262bcc3b7b9f31459ad120fb595627eaeb7f9b9ca01"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-musllinux_1_1_armv7l.whl", hash = "sha256:00e6424f4b26fe82d44577b4c842d7df97c20be6439e8e685d0d715feceb9fb9"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:38de0a70160dd97540335b7ad3a74571b24f1dc3ed33f815f0880682e6880131"},
-    {file = "pydantic_core-2.27.1-cp39-none-win32.whl", hash = "sha256:7ccebf51efc61634f6c2344da73e366c75e735960b5654b63d7e6f69a5885fa3"},
-    {file = "pydantic_core-2.27.1-cp39-none-win_amd64.whl", hash = "sha256:a57847b090d7892f123726202b7daa20df6694cbd583b67a592e856bff603d6c"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3fa80ac2bd5856580e242dbc202db873c60a01b20309c8319b5c5986fbe53ce6"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:d950caa237bb1954f1b8c9227b5065ba6875ac9771bb8ec790d956a699b78676"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e4216e64d203e39c62df627aa882f02a2438d18a5f21d7f721621f7a5d3611d"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:02a3d637bd387c41d46b002f0e49c52642281edacd2740e5a42f7017feea3f2c"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:161c27ccce13b6b0c8689418da3885d3220ed2eae2ea5e9b2f7f3d48f1d52c27"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:19910754e4cc9c63bc1c7f6d73aa1cfee82f42007e407c0f413695c2f7ed777f"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:e173486019cc283dc9778315fa29a363579372fe67045e971e89b6365cc035ed"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:af52d26579b308921b73b956153066481f064875140ccd1dfd4e77db89dbb12f"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:981fb88516bd1ae8b0cbbd2034678a39dedc98752f264ac9bc5839d3923fa04c"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5fde892e6c697ce3e30c61b239330fc5d569a71fefd4eb6512fc6caec9dd9e2f"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:816f5aa087094099fff7edabb5e01cc370eb21aa1a1d44fe2d2aefdfb5599b31"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c10c309e18e443ddb108f0ef64e8729363adbfd92d6d57beec680f6261556f3"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98476c98b02c8e9b2eec76ac4156fd006628b1b2d0ef27e548ffa978393fd154"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c3027001c28434e7ca5a6e1e527487051136aa81803ac812be51802150d880dd"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:7699b1df36a48169cdebda7ab5a2bac265204003f153b4bd17276153d997670a"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:1c39b07d90be6b48968ddc8c19e7585052088fd7ec8d568bb31ff64c70ae3c97"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:46ccfe3032b3915586e469d4972973f893c0a2bb65669194a5bdea9bacc088c2"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:62ba45e21cf6571d7f716d903b5b7b6d2617e2d5d67c0923dc47b9d41369f840"},
-    {file = "pydantic_core-2.27.1.tar.gz", hash = "sha256:62a763352879b84aa31058fc931884055fd75089cccbd9d58bb6afd01141b235"},
+    {file = "pydantic_core-2.23.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:7f10a5d1b9281392f1bf507d16ac720e78285dfd635b05737c3911637601bae6"},
+    {file = "pydantic_core-2.23.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3c09a7885dd33ee8c65266e5aa7fb7e2f23d49d8043f089989726391dd7350c5"},
+    {file = "pydantic_core-2.23.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6470b5a1ec4d1c2e9afe928c6cb37eb33381cab99292a708b8cb9aa89e62429b"},
+    {file = "pydantic_core-2.23.3-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9172d2088e27d9a185ea0a6c8cebe227a9139fd90295221d7d495944d2367700"},
+    {file = "pydantic_core-2.23.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86fc6c762ca7ac8fbbdff80d61b2c59fb6b7d144aa46e2d54d9e1b7b0e780e01"},
+    {file = "pydantic_core-2.23.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f0cb80fd5c2df4898693aa841425ea1727b1b6d2167448253077d2a49003e0ed"},
+    {file = "pydantic_core-2.23.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03667cec5daf43ac4995cefa8aaf58f99de036204a37b889c24a80927b629cec"},
+    {file = "pydantic_core-2.23.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:047531242f8e9c2db733599f1c612925de095e93c9cc0e599e96cf536aaf56ba"},
+    {file = "pydantic_core-2.23.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:5499798317fff7f25dbef9347f4451b91ac2a4330c6669821c8202fd354c7bee"},
+    {file = "pydantic_core-2.23.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bbb5e45eab7624440516ee3722a3044b83fff4c0372efe183fd6ba678ff681fe"},
+    {file = "pydantic_core-2.23.3-cp310-none-win32.whl", hash = "sha256:8b5b3ed73abb147704a6e9f556d8c5cb078f8c095be4588e669d315e0d11893b"},
+    {file = "pydantic_core-2.23.3-cp310-none-win_amd64.whl", hash = "sha256:2b603cde285322758a0279995b5796d64b63060bfbe214b50a3ca23b5cee3e83"},
+    {file = "pydantic_core-2.23.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:c889fd87e1f1bbeb877c2ee56b63bb297de4636661cc9bbfcf4b34e5e925bc27"},
+    {file = "pydantic_core-2.23.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ea85bda3189fb27503af4c45273735bcde3dd31c1ab17d11f37b04877859ef45"},
+    {file = "pydantic_core-2.23.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a7f7f72f721223f33d3dc98a791666ebc6a91fa023ce63733709f4894a7dc611"},
+    {file = "pydantic_core-2.23.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b2b55b0448e9da68f56b696f313949cda1039e8ec7b5d294285335b53104b61"},
+    {file = "pydantic_core-2.23.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c24574c7e92e2c56379706b9a3f07c1e0c7f2f87a41b6ee86653100c4ce343e5"},
+    {file = "pydantic_core-2.23.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f2b05e6ccbee333a8f4b8f4d7c244fdb7a979e90977ad9c51ea31261e2085ce0"},
+    {file = "pydantic_core-2.23.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2c409ce1c219c091e47cb03feb3c4ed8c2b8e004efc940da0166aaee8f9d6c8"},
+    {file = "pydantic_core-2.23.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d965e8b325f443ed3196db890d85dfebbb09f7384486a77461347f4adb1fa7f8"},
+    {file = "pydantic_core-2.23.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f56af3a420fb1ffaf43ece3ea09c2d27c444e7c40dcb7c6e7cf57aae764f2b48"},
+    {file = "pydantic_core-2.23.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5b01a078dd4f9a52494370af21aa52964e0a96d4862ac64ff7cea06e0f12d2c5"},
+    {file = "pydantic_core-2.23.3-cp311-none-win32.whl", hash = "sha256:560e32f0df04ac69b3dd818f71339983f6d1f70eb99d4d1f8e9705fb6c34a5c1"},
+    {file = "pydantic_core-2.23.3-cp311-none-win_amd64.whl", hash = "sha256:c744fa100fdea0d000d8bcddee95213d2de2e95b9c12be083370b2072333a0fa"},
+    {file = "pydantic_core-2.23.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:e0ec50663feedf64d21bad0809f5857bac1ce91deded203efc4a84b31b2e4305"},
+    {file = "pydantic_core-2.23.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:db6e6afcb95edbe6b357786684b71008499836e91f2a4a1e55b840955b341dbb"},
+    {file = "pydantic_core-2.23.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:98ccd69edcf49f0875d86942f4418a4e83eb3047f20eb897bffa62a5d419c8fa"},
+    {file = "pydantic_core-2.23.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a678c1ac5c5ec5685af0133262103defb427114e62eafeda12f1357a12140162"},
+    {file = "pydantic_core-2.23.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:01491d8b4d8db9f3391d93b0df60701e644ff0894352947f31fff3e52bd5c801"},
+    {file = "pydantic_core-2.23.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fcf31facf2796a2d3b7fe338fe8640aa0166e4e55b4cb108dbfd1058049bf4cb"},
+    {file = "pydantic_core-2.23.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7200fd561fb3be06827340da066df4311d0b6b8eb0c2116a110be5245dceb326"},
+    {file = "pydantic_core-2.23.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:dc1636770a809dee2bd44dd74b89cc80eb41172bcad8af75dd0bc182c2666d4c"},
+    {file = "pydantic_core-2.23.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:67a5def279309f2e23014b608c4150b0c2d323bd7bccd27ff07b001c12c2415c"},
+    {file = "pydantic_core-2.23.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:748bdf985014c6dd3e1e4cc3db90f1c3ecc7246ff5a3cd4ddab20c768b2f1dab"},
+    {file = "pydantic_core-2.23.3-cp312-none-win32.whl", hash = "sha256:255ec6dcb899c115f1e2a64bc9ebc24cc0e3ab097775755244f77360d1f3c06c"},
+    {file = "pydantic_core-2.23.3-cp312-none-win_amd64.whl", hash = "sha256:40b8441be16c1e940abebed83cd006ddb9e3737a279e339dbd6d31578b802f7b"},
+    {file = "pydantic_core-2.23.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:6daaf5b1ba1369a22c8b050b643250e3e5efc6a78366d323294aee54953a4d5f"},
+    {file = "pydantic_core-2.23.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d015e63b985a78a3d4ccffd3bdf22b7c20b3bbd4b8227809b3e8e75bc37f9cb2"},
+    {file = "pydantic_core-2.23.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3fc572d9b5b5cfe13f8e8a6e26271d5d13f80173724b738557a8c7f3a8a3791"},
+    {file = "pydantic_core-2.23.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f6bd91345b5163ee7448bee201ed7dd601ca24f43f439109b0212e296eb5b423"},
+    {file = "pydantic_core-2.23.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc379c73fd66606628b866f661e8785088afe2adaba78e6bbe80796baf708a63"},
+    {file = "pydantic_core-2.23.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fbdce4b47592f9e296e19ac31667daed8753c8367ebb34b9a9bd89dacaa299c9"},
+    {file = "pydantic_core-2.23.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc3cf31edf405a161a0adad83246568647c54404739b614b1ff43dad2b02e6d5"},
+    {file = "pydantic_core-2.23.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8e22b477bf90db71c156f89a55bfe4d25177b81fce4aa09294d9e805eec13855"},
+    {file = "pydantic_core-2.23.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:0a0137ddf462575d9bce863c4c95bac3493ba8e22f8c28ca94634b4a1d3e2bb4"},
+    {file = "pydantic_core-2.23.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:203171e48946c3164fe7691fc349c79241ff8f28306abd4cad5f4f75ed80bc8d"},
+    {file = "pydantic_core-2.23.3-cp313-none-win32.whl", hash = "sha256:76bdab0de4acb3f119c2a4bff740e0c7dc2e6de7692774620f7452ce11ca76c8"},
+    {file = "pydantic_core-2.23.3-cp313-none-win_amd64.whl", hash = "sha256:37ba321ac2a46100c578a92e9a6aa33afe9ec99ffa084424291d84e456f490c1"},
+    {file = "pydantic_core-2.23.3-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:d063c6b9fed7d992bcbebfc9133f4c24b7a7f215d6b102f3e082b1117cddb72c"},
+    {file = "pydantic_core-2.23.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:6cb968da9a0746a0cf521b2b5ef25fc5a0bee9b9a1a8214e0a1cfaea5be7e8a4"},
+    {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:edbefe079a520c5984e30e1f1f29325054b59534729c25b874a16a5048028d16"},
+    {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cbaaf2ef20d282659093913da9d402108203f7cb5955020bd8d1ae5a2325d1c4"},
+    {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fb539d7e5dc4aac345846f290cf504d2fd3c1be26ac4e8b5e4c2b688069ff4cf"},
+    {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7e6f33503c5495059148cc486867e1d24ca35df5fc064686e631e314d959ad5b"},
+    {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:04b07490bc2f6f2717b10c3969e1b830f5720b632f8ae2f3b8b1542394c47a8e"},
+    {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:03795b9e8a5d7fda05f3873efc3f59105e2dcff14231680296b87b80bb327295"},
+    {file = "pydantic_core-2.23.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:c483dab0f14b8d3f0df0c6c18d70b21b086f74c87ab03c59250dbf6d3c89baba"},
+    {file = "pydantic_core-2.23.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8b2682038e255e94baf2c473dca914a7460069171ff5cdd4080be18ab8a7fd6e"},
+    {file = "pydantic_core-2.23.3-cp38-none-win32.whl", hash = "sha256:f4a57db8966b3a1d1a350012839c6a0099f0898c56512dfade8a1fe5fb278710"},
+    {file = "pydantic_core-2.23.3-cp38-none-win_amd64.whl", hash = "sha256:13dd45ba2561603681a2676ca56006d6dee94493f03d5cadc055d2055615c3ea"},
+    {file = "pydantic_core-2.23.3-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:82da2f4703894134a9f000e24965df73cc103e31e8c31906cc1ee89fde72cbd8"},
+    {file = "pydantic_core-2.23.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:dd9be0a42de08f4b58a3cc73a123f124f65c24698b95a54c1543065baca8cf0e"},
+    {file = "pydantic_core-2.23.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89b731f25c80830c76fdb13705c68fef6a2b6dc494402987c7ea9584fe189f5d"},
+    {file = "pydantic_core-2.23.3-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c6de1ec30c4bb94f3a69c9f5f2182baeda5b809f806676675e9ef6b8dc936f28"},
+    {file = "pydantic_core-2.23.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bb68b41c3fa64587412b104294b9cbb027509dc2f6958446c502638d481525ef"},
+    {file = "pydantic_core-2.23.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1c3980f2843de5184656aab58698011b42763ccba11c4a8c35936c8dd6c7068c"},
+    {file = "pydantic_core-2.23.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:94f85614f2cba13f62c3c6481716e4adeae48e1eaa7e8bac379b9d177d93947a"},
+    {file = "pydantic_core-2.23.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:510b7fb0a86dc8f10a8bb43bd2f97beb63cffad1203071dc434dac26453955cd"},
+    {file = "pydantic_core-2.23.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:1eba2f7ce3e30ee2170410e2171867ea73dbd692433b81a93758ab2de6c64835"},
+    {file = "pydantic_core-2.23.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:4b259fd8409ab84b4041b7b3f24dcc41e4696f180b775961ca8142b5b21d0e70"},
+    {file = "pydantic_core-2.23.3-cp39-none-win32.whl", hash = "sha256:40d9bd259538dba2f40963286009bf7caf18b5112b19d2b55b09c14dde6db6a7"},
+    {file = "pydantic_core-2.23.3-cp39-none-win_amd64.whl", hash = "sha256:5a8cd3074a98ee70173a8633ad3c10e00dcb991ecec57263aacb4095c5efb958"},
+    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f399e8657c67313476a121a6944311fab377085ca7f490648c9af97fc732732d"},
+    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:6b5547d098c76e1694ba85f05b595720d7c60d342f24d5aad32c3049131fa5c4"},
+    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0dda0290a6f608504882d9f7650975b4651ff91c85673341789a476b1159f211"},
+    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:65b6e5da855e9c55a0c67f4db8a492bf13d8d3316a59999cfbaf98cc6e401961"},
+    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:09e926397f392059ce0afdcac920df29d9c833256354d0c55f1584b0b70cf07e"},
+    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:87cfa0ed6b8c5bd6ae8b66de941cece179281239d482f363814d2b986b79cedc"},
+    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:e61328920154b6a44d98cabcb709f10e8b74276bc709c9a513a8c37a18786cc4"},
+    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ce3317d155628301d649fe5e16a99528d5680af4ec7aa70b90b8dacd2d725c9b"},
+    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:e89513f014c6be0d17b00a9a7c81b1c426f4eb9224b15433f3d98c1a071f8433"},
+    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:4f62c1c953d7ee375df5eb2e44ad50ce2f5aff931723b398b8bc6f0ac159791a"},
+    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2718443bc671c7ac331de4eef9b673063b10af32a0bb385019ad61dcf2cc8f6c"},
+    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0d90e08b2727c5d01af1b5ef4121d2f0c99fbee692c762f4d9d0409c9da6541"},
+    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2b676583fc459c64146debea14ba3af54e540b61762dfc0613dc4e98c3f66eeb"},
+    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:50e4661f3337977740fdbfbae084ae5693e505ca2b3130a6d4eb0f2281dc43b8"},
+    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:68f4cf373f0de6abfe599a38307f4417c1c867ca381c03df27c873a9069cda25"},
+    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:59d52cf01854cb26c46958552a21acb10dd78a52aa34c86f284e66b209db8cab"},
+    {file = "pydantic_core-2.23.3.tar.gz", hash = "sha256:3cb0f65d8b4121c1b015c60104a685feb929a29d7cf204387c7f2688c7974690"},
 ]
 
 [package.dependencies]
@@ -1223,13 +1173,13 @@ typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0"
 
 [[package]]
 name = "pydantic-settings"
-version = "2.7.0"
+version = "2.5.2"
 description = "Settings management using Pydantic"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pydantic_settings-2.7.0-py3-none-any.whl", hash = "sha256:e00c05d5fa6cbbb227c84bd7487c5c1065084119b750df7c8c1a554aed236eb5"},
-    {file = "pydantic_settings-2.7.0.tar.gz", hash = "sha256:ac4bfd4a36831a48dbf8b2d9325425b549a0a6f18cea118436d728eb4f1c4d66"},
+    {file = "pydantic_settings-2.5.2-py3-none-any.whl", hash = "sha256:2c912e55fd5794a59bf8c832b9de832dcfdf4778d79ff79b708744eed499a907"},
+    {file = "pydantic_settings-2.5.2.tar.gz", hash = "sha256:f90b139682bee4d2065273d5185d71d37ea46cfe57e1b5ae184fc6a0b2484ca0"},
 ]
 
 [package.dependencies]
@@ -1243,13 +1193,13 @@ yaml = ["pyyaml (>=6.0.1)"]
 
 [[package]]
 name = "pyjwt"
-version = "2.10.1"
+version = "2.9.0"
 description = "JSON Web Token implementation in Python"
 optional = false
-python-versions = ">=3.9"
+python-versions = ">=3.8"
 files = [
-    {file = "PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb"},
-    {file = "pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953"},
+    {file = "PyJWT-2.9.0-py3-none-any.whl", hash = "sha256:3b02fb0f44517787776cf48f2ae25d8e14f300e6d7545a4315cee571a415e850"},
+    {file = "pyjwt-2.9.0.tar.gz", hash = "sha256:7e1e5b56cc735432a7369cbfa0efe50fa113ebecdc04ae6922deba8b84582d0c"},
 ]
 
 [package.extras]
@@ -1258,63 +1208,6 @@ dev = ["coverage[toml] (==5.0.4)", "cryptography (>=3.4.0)", "pre-commit", "pyte
 docs = ["sphinx", "sphinx-rtd-theme", "zope.interface"]
 tests = ["coverage[toml] (==5.0.4)", "pytest (>=6.0.0,<7.0.0)"]
 
-[[package]]
-name = "pytest"
-version = "8.3.3"
-description = "pytest: simple powerful testing with Python"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2"},
-    {file = "pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181"},
-]
-
-[package.dependencies]
-colorama = {version = "*", markers = "sys_platform == \"win32\""}
-exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""}
-iniconfig = "*"
-packaging = "*"
-pluggy = ">=1.5,<2"
-tomli = {version = ">=1", markers = "python_version < \"3.11\""}
-
-[package.extras]
-dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
-
-[[package]]
-name = "pytest-asyncio"
-version = "0.25.0"
-description = "Pytest support for asyncio"
-optional = false
-python-versions = ">=3.9"
-files = [
-    {file = "pytest_asyncio-0.25.0-py3-none-any.whl", hash = "sha256:db5432d18eac6b7e28b46dcd9b69921b55c3b1086e85febfe04e70b18d9e81b3"},
-    {file = "pytest_asyncio-0.25.0.tar.gz", hash = "sha256:8c0610303c9e0442a5db8604505fc0f545456ba1528824842b37b4a626cbf609"},
-]
-
-[package.dependencies]
-pytest = ">=8.2,<9"
-
-[package.extras]
-docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1)"]
-testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"]
-
-[[package]]
-name = "pytest-mock"
-version = "3.14.0"
-description = "Thin-wrapper around the mock package for easier use with pytest"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pytest-mock-3.14.0.tar.gz", hash = "sha256:2719255a1efeceadbc056d6bf3df3d1c5015530fb40cf347c0f9afac88410bd0"},
-    {file = "pytest_mock-3.14.0-py3-none-any.whl", hash = "sha256:0b72c38033392a5f4621342fe11e9219ac11ec9d375f8e2a0c164539e0d70f6f"},
-]
-
-[package.dependencies]
-pytest = ">=6.2.5"
-
-[package.extras]
-dev = ["pre-commit", "pytest-asyncio", "tox"]
-
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"
@@ -1360,24 +1253,6 @@ python-dateutil = ">=2.8.1,<3.0.0"
 typing-extensions = ">=4.12.2,<5.0.0"
 websockets = ">=11,<13"
 
-[[package]]
-name = "redis"
-version = "5.2.1"
-description = "Python client for Redis database and key-value store"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "redis-5.2.1-py3-none-any.whl", hash = "sha256:ee7e1056b9aea0f04c6c2ed59452947f34c4940ee025f5dd83e6a6418b6989e4"},
-    {file = "redis-5.2.1.tar.gz", hash = "sha256:16f2e22dff21d5125e8481515e386711a34cbec50f0e44413dd7d9c060a54e0f"},
-]
-
-[package.dependencies]
-async-timeout = {version = ">=4.0.3", markers = "python_full_version < \"3.11.3\""}
-
-[package.extras]
-hiredis = ["hiredis (>=3.0.0)"]
-ocsp = ["cryptography (>=36.0.1)", "pyopenssl (==23.2.1)", "requests (>=2.31.0)"]
-
 [[package]]
 name = "requests"
 version = "2.32.3"
@@ -1413,33 +1288,6 @@ files = [
 [package.dependencies]
 pyasn1 = ">=0.1.3"
 
-[[package]]
-name = "ruff"
-version = "0.8.6"
-description = "An extremely fast Python linter and code formatter, written in Rust."
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "ruff-0.8.6-py3-none-linux_armv6l.whl", hash = "sha256:defed167955d42c68b407e8f2e6f56ba52520e790aba4ca707a9c88619e580e3"},
-    {file = "ruff-0.8.6-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:54799ca3d67ae5e0b7a7ac234baa657a9c1784b48ec954a094da7c206e0365b1"},
-    {file = "ruff-0.8.6-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e88b8f6d901477c41559ba540beeb5a671e14cd29ebd5683903572f4b40a9807"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0509e8da430228236a18a677fcdb0c1f102dd26d5520f71f79b094963322ed25"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:91a7ddb221779871cf226100e677b5ea38c2d54e9e2c8ed847450ebbdf99b32d"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:248b1fb3f739d01d528cc50b35ee9c4812aa58cc5935998e776bf8ed5b251e75"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:bc3c083c50390cf69e7e1b5a5a7303898966be973664ec0c4a4acea82c1d4315"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:52d587092ab8df308635762386f45f4638badb0866355b2b86760f6d3c076188"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:61323159cf21bc3897674e5adb27cd9e7700bab6b84de40d7be28c3d46dc67cf"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ae4478b1471fc0c44ed52a6fb787e641a2ac58b1c1f91763bafbc2faddc5117"},
-    {file = "ruff-0.8.6-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:0c000a471d519b3e6cfc9c6680025d923b4ca140ce3e4612d1a2ef58e11f11fe"},
-    {file = "ruff-0.8.6-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:9257aa841e9e8d9b727423086f0fa9a86b6b420fbf4bf9e1465d1250ce8e4d8d"},
-    {file = "ruff-0.8.6-py3-none-musllinux_1_2_i686.whl", hash = "sha256:45a56f61b24682f6f6709636949ae8cc82ae229d8d773b4c76c09ec83964a95a"},
-    {file = "ruff-0.8.6-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:496dd38a53aa173481a7d8866bcd6451bd934d06976a2505028a50583e001b76"},
-    {file = "ruff-0.8.6-py3-none-win32.whl", hash = "sha256:e169ea1b9eae61c99b257dc83b9ee6c76f89042752cb2d83486a7d6e48e8f764"},
-    {file = "ruff-0.8.6-py3-none-win_amd64.whl", hash = "sha256:f1d70bef3d16fdc897ee290d7d20da3cbe4e26349f62e8a0274e7a3f4ce7a905"},
-    {file = "ruff-0.8.6-py3-none-win_arm64.whl", hash = "sha256:7d7fc2377a04b6e04ffe588caad613d0c460eb2ecba4c0ccbbfe2bc973cbc162"},
-    {file = "ruff-0.8.6.tar.gz", hash = "sha256:dcad24b81b62650b0eb8814f576fc65cfee8674772a6e24c9b747911801eeaa5"},
-]
-
 [[package]]
 name = "six"
 version = "1.16.0"
@@ -1464,18 +1312,19 @@ files = [
 
 [[package]]
 name = "storage3"
-version = "0.9.0"
+version = "0.7.7"
 description = "Supabase Storage client for Python."
 optional = false
-python-versions = "<4.0,>=3.9"
+python-versions = "<4.0,>=3.8"
 files = [
-    {file = "storage3-0.9.0-py3-none-any.whl", hash = "sha256:8b2fb91f0c61583a2f4eac74a8bae67e00d41ff38095c8a6cd3f2ce5e0ab76e7"},
-    {file = "storage3-0.9.0.tar.gz", hash = "sha256:e16697f60894c94e1d9df0d2e4af783c1b3f7dd08c9013d61978825c624188c4"},
+    {file = "storage3-0.7.7-py3-none-any.whl", hash = "sha256:ed80a2546cd0b5c22e2c30ea71096db6c99268daf2958c603488e7d72efb8426"},
+    {file = "storage3-0.7.7.tar.gz", hash = "sha256:9fba680cf761d139ad764f43f0e91c245d1ce1af2cc3afe716652f835f48f83e"},
 ]
 
 [package.dependencies]
-httpx = {version = ">=0.26,<0.28", extras = ["http2"]}
+httpx = {version = ">=0.24,<0.28", extras = ["http2"]}
 python-dateutil = ">=2.8.2,<3.0.0"
+typing-extensions = ">=4.2.0,<5.0.0"
 
 [[package]]
 name = "strenum"
@@ -1495,47 +1344,36 @@ test = ["pylint", "pytest", "pytest-black", "pytest-cov", "pytest-pylint"]
 
 [[package]]
 name = "supabase"
-version = "2.10.0"
+version = "2.7.4"
 description = "Supabase client for Python."
 optional = false
 python-versions = "<4.0,>=3.9"
 files = [
-    {file = "supabase-2.10.0-py3-none-any.whl", hash = "sha256:183fb23c04528593f8f81c24ceb8178f3a56bff40fec7ed873b6c55ebc2e420a"},
-    {file = "supabase-2.10.0.tar.gz", hash = "sha256:9ac095f8947bf60780e67c0edcbab53e2db3f6f3f022329397b093500bf2607c"},
+    {file = "supabase-2.7.4-py3-none-any.whl", hash = "sha256:01815fbc30cac753933d4a44a2529fd13cb7634b56c705c65b12a02c8e75982b"},
+    {file = "supabase-2.7.4.tar.gz", hash = "sha256:5a979c7711b3c5ce688514fa0afc015780522569494e1a9a9d25d03b7c3d654b"},
 ]
 
 [package.dependencies]
-gotrue = ">=2.10.0,<3.0.0"
-httpx = ">=0.26,<0.28"
-postgrest = ">=0.18,<0.19"
+gotrue = ">=1.3,<3.0"
+httpx = ">=0.24,<0.28"
+postgrest = ">=0.14,<0.17.0"
 realtime = ">=2.0.0,<3.0.0"
-storage3 = ">=0.9.0,<0.10.0"
-supafunc = ">=0.7.0,<0.8.0"
+storage3 = ">=0.5.3,<0.8.0"
+supafunc = ">=0.3.1,<0.6.0"
 
 [[package]]
 name = "supafunc"
-version = "0.7.0"
+version = "0.5.1"
 description = "Library for Supabase Functions"
 optional = false
-python-versions = "<4.0,>=3.9"
+python-versions = "<4.0,>=3.8"
 files = [
-    {file = "supafunc-0.7.0-py3-none-any.whl", hash = "sha256:4160260dc02bdd906be1e2ffd7cb3ae8b74ae437c892bb475352b6a99d9ff8eb"},
-    {file = "supafunc-0.7.0.tar.gz", hash = "sha256:5b1c415fba1395740b2b4eedd1d786384bd58b98f6333a11ba7889820a48b6a7"},
+    {file = "supafunc-0.5.1-py3-none-any.whl", hash = "sha256:b05e99a2b41270211a3f90ec843c04c5f27a5618f2d2d2eb8e07f41eb962a910"},
+    {file = "supafunc-0.5.1.tar.gz", hash = "sha256:1ae9dce6bd935939c561650e86abb676af9665ecf5d4ffc1c7ec3c4932c84334"},
 ]
 
 [package.dependencies]
-httpx = {version = ">=0.26,<0.28", extras = ["http2"]}
-
-[[package]]
-name = "tomli"
-version = "2.1.0"
-description = "A lil' TOML parser"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "tomli-2.1.0-py3-none-any.whl", hash = "sha256:a5c57c3d1c56f5ccdf89f6523458f60ef716e210fc47c4cfb188c5ba473e0391"},
-    {file = "tomli-2.1.0.tar.gz", hash = "sha256:3f646cae2aec94e17d04973e4249548320197cfabdf130015d023de4b74d8ab8"},
-]
+httpx = {version = ">=0.24,<0.28", extras = ["http2"]}
 
 [[package]]
 name = "typing-extensions"
@@ -1852,4 +1690,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.10,<4.0"
-content-hash = "bf1b0125759dadb1369fff05ffba64fea3e82b9b7a43d0068e1c80974a4ebc1c"
+content-hash = "e9b6e5d877eeb9c9f1ebc69dead1985d749facc160afbe61f3bf37e9a6e35aa5"

autogpt_platform/autogpt_libs/pyproject.toml

@@ -8,27 +8,14 @@ packages = [{ include = "autogpt_libs" }]
 
 [tool.poetry.dependencies]
 colorama = "^0.4.6"
-expiringdict = "^1.2.2"
-google-cloud-logging = "^3.11.3"
-pydantic = "^2.10.3"
-pydantic-settings = "^2.7.0"
-pyjwt = "^2.10.1"
-pytest-asyncio = "^0.25.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"
 python-dotenv = "^1.0.1"
-supabase = "^2.10.0"
-
-[tool.poetry.group.dev.dependencies]
-redis = "^5.2.1"
-ruff = "^0.8.6"
+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

@@ -1,77 +1,21 @@
-DB_USER=postgres
-DB_PASS=your-super-secret-and-long-postgres-password
-DB_NAME=postgres
-DB_PORT=5432
-DATABASE_URL="postgresql://${DB_USER}:${DB_PASS}@localhost:${DB_PORT}/${DB_NAME}?connect_timeout=60&schema=platform"
+DB_USER=agpt_user
+DB_PASS=pass123
+DB_NAME=agpt_local
+DB_PORT=5433
+DATABASE_URL="postgresql://${DB_USER}:${DB_PASS}@localhost:${DB_PORT}/${DB_NAME}"
 PRISMA_SCHEMA="postgres/schema.prisma"
 
-BACKEND_CORS_ALLOW_ORIGINS=["http://localhost:3000"]
-
-# generate using `from cryptography.fernet import Fernet;Fernet.generate_key().decode()`
-ENCRYPTION_KEY='dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw='
-
 REDIS_HOST=localhost
 REDIS_PORT=6379
 REDIS_PASSWORD=password
 
+ENABLE_AUTH=false
 ENABLE_CREDIT=false
-# 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=
-
-## User auth with Supabase is required for any of the 3rd party integrations with auth to work.
-ENABLE_AUTH=true
-SUPABASE_URL=http://localhost:8000
-SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJzZXJ2aWNlX3JvbGUiLAogICAgImlzcyI6ICJzdXBhYmFzZS1kZW1vIiwKICAgICJpYXQiOiAxNjQxNzY5MjAwLAogICAgImV4cCI6IDE3OTk1MzU2MDAKfQ.DaYlNEoUrrEn2Ig7tqibS-PHK5vgusbcbo7X36XVt4Q
-SUPABASE_JWT_SECRET=your-super-secret-jwt-token-with-at-least-32-characters-long
-
-## For local development, you may need to set FRONTEND_BASE_URL for the OAuth flow
-## for integrations to work. Defaults to the value of PLATFORM_BASE_URL if not set.
-# 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=https://your-public-url-here
-
-## == INTEGRATION CREDENTIALS == ##
-# Each set of server side credentials is required for the corresponding 3rd party
-# integration to work.
-
-# For the OAuth callback URL, use <your_frontend_url>/auth/integrations/oauth_callback,
-# e.g. http://localhost:3000/auth/integrations/oauth_callback
-
-# GitHub OAuth App server credentials - https://github.com/settings/developers
-GITHUB_CLIENT_ID=
-GITHUB_CLIENT_SECRET=
-
-# 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=
-
+# This is needed when ENABLE_AUTH is true
+SUPABASE_JWT_SECRET=
 
 ## ===== OPTIONAL API KEYS ===== ##
 
@@ -79,7 +23,6 @@ TWITTER_CLIENT_SECRET=
 OPENAI_API_KEY=
 ANTHROPIC_API_KEY=
 GROQ_API_KEY=
-OPEN_ROUTER_API_KEY=
 
 # Reddit
 REDDIT_CLIENT_ID=
@@ -112,26 +55,6 @@ SMTP_PASSWORD=
 MEDIUM_API_KEY=
 MEDIUM_AUTHOR_ID=
 
-# Google Maps
-GOOGLE_MAPS_API_KEY=
-
-# Replicate
-REPLICATE_API_KEY=
-
-# Ideogram
-IDEOGRAM_API_KEY=
-
-# Fal
-FAL_API_KEY=
-
-# Exa
-EXA_API_KEY=
-
-# E2B
-E2B_API_KEY=
-
-# Nvidia
-NVIDIA_API_KEY=
 
 # Logging Configuration
 LOG_LEVEL=INFO

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

@@ -37,7 +37,7 @@ We use the Poetry to manage the dependencies. To set up the project, follow thes
 5. Generate the Prisma client
 
    ```sh
-   poetry run prisma generate
+   poetry run prisma generate --schema postgres/schema.prisma
    ```
    
 
@@ -61,7 +61,7 @@ We use the Poetry to manage the dependencies. To set up the project, follow thes
 
    ```sh
    cd ../backend
-   prisma migrate deploy
+   prisma migrate dev --schema postgres/schema.prisma
    ```
 
 ## Running The Server

autogpt_platform/backend/README.md

@@ -58,18 +58,17 @@ We use the Poetry to manage the dependencies. To set up the project, follow thes
 6. Migrate the database. Be careful because this deletes current data in the database.
 
    ```sh
-   docker compose up db -d
-   poetry run prisma migrate deploy
+   docker compose up postgres redis -d
+   poetry run prisma migrate dev 
    ```
 
 ## Running The Server
 
 ### Starting the server without Docker
 
-Run the following command to run database in docker but the application locally:
+Run the following command to build the dockerfiles:
 
 ```sh
-docker compose --profile local up deps --build --detach
 poetry run app
 ```
 
@@ -200,4 +199,4 @@ To add a new agent block, you need to create a new class that inherits from `Blo
 * `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 `poetry run pytest -s test/block/test_block.py`.
+* 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

@@ -24,12 +24,10 @@ def main(**kwargs):
     Run all the processes required for the AutoGPT-server (REST and WebSocket APIs).
     """
 
-    from backend.executor import DatabaseManager, ExecutionManager, ExecutionScheduler
-    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(),
         ExecutionScheduler(),
         WebsocketServer(),

autogpt_platform/backend/backend/blocks/__init__.py

@@ -1,55 +1,52 @@
+import glob
 import importlib
 import os
 import re
 from pathlib import Path
-from typing import Type, TypeVar
 
 from backend.data.block import Block
 
 # Dynamically load all modules under backend.blocks
 AVAILABLE_MODULES = []
-current_dir = Path(__file__).parent
+current_dir = os.path.dirname(__file__)
+modules = glob.glob(os.path.join(current_dir, "*.py"))
 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"
+    Path(f).stem
+    for f in modules
+    if os.path.isfile(f) and f.endswith(".py") and not f.endswith("__init__.py")
 ]
 for module in modules:
-    if not re.match("^[a-z0-9_.]+$", module):
+    if not re.match("^[a-z_]+$", module):
         raise ValueError(
-            f"Block module {module} error: module name must be lowercase, "
-            "and contain only alphanumeric characters and underscores."
+            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: dict[str, Type[Block]] = {}
+AVAILABLE_BLOCKS = {}
 
 
-T = TypeVar("T")
-
-
-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 block_cls in all_subclasses(Block):
-    name = block_cls.__name__
+for cls in all_subclasses(Block):
+    name = cls.__name__
 
-    if block_cls.__name__.endswith("Base"):
+    if cls.__name__.endswith("Base"):
         continue
 
-    if not block_cls.__name__.endswith("Block"):
+    if not cls.__name__.endswith("Block"):
         raise ValueError(
-            f"Block class {block_cls.__name__} does not end with 'Block', If you are creating an abstract class, please name the class with 'Base' at the end"
+            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 = block_cls.create()
+    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")
@@ -57,26 +54,15 @@ for block_cls in all_subclasses(Block):
     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:
+    # 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} `error` field in output_schema must be a string"
+            f"{block.name} has duplicate field names in input_schema and output_schema: {duplicate_field_names}"
         )
 
-    # Make sure all fields in input_schema and output_schema are annotated and has a value
-    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")
@@ -84,6 +70,6 @@ for block_cls in all_subclasses(Block):
     if block.disabled:
         continue
 
-    AVAILABLE_BLOCKS[block.id] = block_cls
+    AVAILABLE_BLOCKS[block.id] = block
 
 __all__ = ["AVAILABLE_MODULES", "AVAILABLE_BLOCKS"]

autogpt_platform/backend/backend/blocks/agent.py

@@ -1,104 +0,0 @@
-import logging
-
-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
-
-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")
-
-    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:
-        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(
-            graph_id=graph_exec.graph_id, graph_exec_id=graph_exec.graph_exec_id
-        ):
-            logger.info(
-                f"Execution {log_id} produced input {event.input_data} output {event.output_data}"
-            )
-
-            if not event.node_id:
-                if event.status in [
-                    ExecutionStatus.COMPLETED,
-                    ExecutionStatus.TERMINATED,
-                    ExecutionStatus.FAILED,
-                ]:
-                    logger.info(f"Execution {log_id} ended with status {event.status}")
-                    break
-                else:
-                    continue
-
-            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,323 +0,0 @@
-import logging
-import time
-from enum import Enum
-from typing import Literal
-
-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
-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,
-}
-
-
-class AudioTrack(str, Enum):
-    OBSERVER = ("Observer",)
-    FUTURISTIC_BEAT = ("Futuristic Beat",)
-    SCIENCE_DOCUMENTARY = ("Science Documentary",)
-    HOTLINE = ("Hotline",)
-    BLADERUNNER_2049 = ("Bladerunner 2049",)
-    A_FUTURE = ("A Future",)
-    ELYSIAN_EMBERS = ("Elysian Embers",)
-    INSPIRING_CINEMATIC = ("Inspiring Cinematic",)
-    BLADERUNNER_REMIX = ("Bladerunner Remix",)
-    IZZAMUZZIC = ("Izzamuzzic",)
-    NAS = ("Nas",)
-    PARIS_ELSE = ("Paris - Else",)
-    SNOWFALL = ("Snowfall",)
-    BURLESQUE = ("Burlesque",)
-    CORNY_CANDY = ("Corny Candy",)
-    HIGHWAY_NOCTURNE = ("Highway Nocturne",)
-    I_DONT_THINK_SO = ("I Don't Think So",)
-    LOSING_YOUR_MARBLES = ("Losing Your Marbles",)
-    REFRESHER = ("Refresher",)
-    TOURIST = ("Tourist",)
-    TWIN_TYCHES = ("Twin Tyches",)
-
-    @property
-    def audio_url(self):
-        audio_urls = {
-            AudioTrack.OBSERVER: "https://cdn.tfrv.xyz/audio/observer.mp3",
-            AudioTrack.FUTURISTIC_BEAT: "https://cdn.tfrv.xyz/audio/_futuristic-beat.mp3",
-            AudioTrack.SCIENCE_DOCUMENTARY: "https://cdn.tfrv.xyz/audio/_science-documentary.mp3",
-            AudioTrack.HOTLINE: "https://cdn.tfrv.xyz/audio/_hotline.mp3",
-            AudioTrack.BLADERUNNER_2049: "https://cdn.tfrv.xyz/audio/_bladerunner-2049.mp3",
-            AudioTrack.A_FUTURE: "https://cdn.tfrv.xyz/audio/a-future.mp3",
-            AudioTrack.ELYSIAN_EMBERS: "https://cdn.tfrv.xyz/audio/elysian-embers.mp3",
-            AudioTrack.INSPIRING_CINEMATIC: "https://cdn.tfrv.xyz/audio/inspiring-cinematic-ambient.mp3",
-            AudioTrack.BLADERUNNER_REMIX: "https://cdn.tfrv.xyz/audio/bladerunner-remix.mp3",
-            AudioTrack.IZZAMUZZIC: "https://cdn.tfrv.xyz/audio/_izzamuzzic.mp3",
-            AudioTrack.NAS: "https://cdn.tfrv.xyz/audio/_nas.mp3",
-            AudioTrack.PARIS_ELSE: "https://cdn.tfrv.xyz/audio/_paris-else.mp3",
-            AudioTrack.SNOWFALL: "https://cdn.tfrv.xyz/audio/_snowfall.mp3",
-            AudioTrack.BURLESQUE: "https://cdn.tfrv.xyz/audio/burlesque.mp3",
-            AudioTrack.CORNY_CANDY: "https://cdn.tfrv.xyz/audio/corny-candy.mp3",
-            AudioTrack.HIGHWAY_NOCTURNE: "https://cdn.tfrv.xyz/audio/highway-nocturne.mp3",
-            AudioTrack.I_DONT_THINK_SO: "https://cdn.tfrv.xyz/audio/i-dont-think-so.mp3",
-            AudioTrack.LOSING_YOUR_MARBLES: "https://cdn.tfrv.xyz/audio/losing-your-marbles.mp3",
-            AudioTrack.REFRESHER: "https://cdn.tfrv.xyz/audio/refresher.mp3",
-            AudioTrack.TOURIST: "https://cdn.tfrv.xyz/audio/tourist.mp3",
-            AudioTrack.TWIN_TYCHES: "https://cdn.tfrv.xyz/audio/twin-tynches.mp3",
-        }
-        return audio_urls[self]
-
-
-class GenerationPreset(str, Enum):
-    LEONARDO = ("Default",)
-    ANIME = ("Anime",)
-    REALISM = ("Realist",)
-    ILLUSTRATION = ("Illustration",)
-    SKETCH_COLOR = ("Sketch Color",)
-    SKETCH_BW = ("Sketch B&W",)
-    PIXAR = ("Pixar",)
-    INK = ("Japanese Ink",)
-    RENDER_3D = ("3D Render",)
-    LEGO = ("Lego",)
-    SCIFI = ("Sci-Fi",)
-    RECRO_CARTOON = ("Retro Cartoon",)
-    PIXEL_ART = ("Pixel Art",)
-    CREATIVE = ("Creative",)
-    PHOTOGRAPHY = ("Photography",)
-    RAYTRACED = ("Raytraced",)
-    ENVIRONMENT = ("Environment",)
-    FANTASY = ("Fantasy",)
-    ANIME_SR = ("Anime Realism",)
-    MOVIE = ("Movie",)
-    STYLIZED_ILLUSTRATION = ("Stylized Illustration",)
-    MANGA = ("Manga",)
-
-
-class Voice(str, Enum):
-    LILY = "Lily"
-    DANIEL = "Daniel"
-    BRIAN = "Brian"
-    JESSICA = "Jessica"
-    CHARLOTTE = "Charlotte"
-    CALLUM = "Callum"
-
-    @property
-    def voice_id(self):
-        voice_id_map = {
-            Voice.LILY: "pFZP5JQG7iQjIQuC4Bku",
-            Voice.DANIEL: "onwK4e9ZLuTAKqWW03F9",
-            Voice.BRIAN: "nPczCjzI2devNBz1zQrb",
-            Voice.JESSICA: "cgSgspJ2msm6clMCkdW9",
-            Voice.CHARLOTTE: "XB0fDUnXU5powFXDhCwa",
-            Voice.CALLUM: "N2lVS1w4EtoT3dr4eOWO",
-        }
-        return voice_id_map[self]
-
-    def __str__(self):
-        return self.value
-
-
-class VisualMediaType(str, Enum):
-    STOCK_VIDEOS = ("stockVideo",)
-    MOVING_AI_IMAGES = ("movingImage",)
-    AI_VIDEO = ("aiVideo",)
-
-
-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.",
-        )
-        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)
-        generation_preset: GenerationPreset = SchemaField(
-            description="Generation preset for visual style - only effects AI generated visuals",
-            default=GenerationPreset.LEONARDO,
-            placeholder=GenerationPreset.LEONARDO,
-        )
-        background_music: AudioTrack = SchemaField(
-            description="Background music track",
-            default=AudioTrack.HIGHWAY_NOCTURNE,
-            placeholder=AudioTrack.HIGHWAY_NOCTURNE,
-        )
-        voice: Voice = SchemaField(
-            description="AI voice to use for narration",
-            default=Voice.LILY,
-            placeholder=Voice.LILY,
-        )
-        video_style: VisualMediaType = SchemaField(
-            description="Type of visual media to use for the video",
-            default=VisualMediaType.STOCK_VIDEOS,
-            placeholder=VisualMediaType.STOCK_VIDEOS,
-        )
-
-    class Output(BlockSchema):
-        video_url: str = SchemaField(description="The URL of the created video")
-        error: str = SchemaField(description="Error message if the request failed")
-
-    def __init__(self):
-        super().__init__(
-            id="361697fb-0c4f-4feb-aed3-8320c88c771b",
-            description="Creates a shortform video using revid.ai",
-            categories={BlockCategory.SOCIAL, BlockCategory.AI},
-            input_schema=AIShortformVideoCreatorBlock.Input,
-            output_schema=AIShortformVideoCreatorBlock.Output,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "script": "[close-up of a cat] Meow!",
-                "ratio": "9 / 16",
-                "resolution": "720p",
-                "frame_rate": 60,
-                "generation_preset": GenerationPreset.LEONARDO,
-                "background_music": AudioTrack.HIGHWAY_NOCTURNE,
-                "voice": Voice.LILY,
-                "video_style": VisualMediaType.STOCK_VIDEOS,
-            },
-            test_output=(
-                "video_url",
-                "https://example.com/video.mp4",
-            ),
-            test_mock={
-                "create_webhook": lambda: (
-                    "test_uuid",
-                    "https://webhook.site/test_uuid",
-                ),
-                "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)
-        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:
-        url = "https://www.revid.ai/api/public/v2/render"
-        headers = {"key": api_key.get_secret_value()}
-        response = requests.post(url, json=payload, headers=headers)
-        logger.debug(
-            f"API Response Status Code: {response.status_code}, Content: {response.text}"
-        )
-        return response.json()
-
-    def check_video_status(self, api_key: SecretStr, pid: str) -> dict:
-        url = f"https://www.revid.ai/api/public/v2/status?pid={pid}"
-        headers = {"key": api_key.get_secret_value()}
-        response = requests.get(url, headers=headers)
-        return response.json()
-
-    def wait_for_video(
-        self,
-        api_key: SecretStr,
-        pid: str,
-        webhook_token: str,
-        max_wait_time: int = 1000,
-    ) -> str:
-        start_time = time.time()
-        while time.time() - start_time < max_wait_time:
-            status = self.check_video_status(api_key, pid)
-            logger.debug(f"Video status: {status}")
-
-            if status.get("status") == "ready" and "videoUrl" in status:
-                return status["videoUrl"]
-            elif status.get("status") == "error":
-                error_message = status.get("error", "Unknown error occurred")
-                logger.error(f"Video creation failed: {error_message}")
-                raise ValueError(f"Video creation failed: {error_message}")
-            elif status.get("status") in ["FAILED", "CANCELED"]:
-                logger.error(f"Video creation failed: {status.get('message')}")
-                raise ValueError(f"Video creation failed: {status.get('message')}")
-
-            time.sleep(10)
-
-        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}")
-
-        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,
-            },
-        }
-
-        logger.debug("Creating video...")
-        response = self.create_video(credentials.api_key, 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

autogpt_platform/backend/backend/blocks/basic.py

@@ -1,11 +1,20 @@
+import re
 from typing import Any, List
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema, BlockType
+from jinja2 import BaseLoader, Environment
+from pydantic import Field
+
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchema,
+    BlockUIType,
+)
 from backend.data.model import SchemaField
 from backend.util.mock import MockObject
-from backend.util.text import TextFormatter
 
-formatter = TextFormatter()
+jinja = Environment(loader=BaseLoader())
 
 
 class StoreValueBlock(Block):
@@ -16,23 +25,24 @@ 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__(
             id="1ff065e9-88e8-4358-9d82-8dc91f622ba9",
-            description="This block forwards an input value as output, allowing reuse without change.",
+            description="This block forwards the `input` pin to `output` pin. "
+            "This block output will be static, the output can be consumed many times.",
             categories={BlockCategory.BASIC},
             input_schema=StoreValueBlock.Input,
             output_schema=StoreValueBlock.Output,
@@ -47,16 +57,16 @@ class StoreValueBlock(Block):
             static_output=True,
         )
 
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input) -> BlockOutput:
         yield "output", input_data.data or input_data.input
 
 
 class PrintToConsoleBlock(Block):
     class Input(BlockSchema):
-        text: str = SchemaField(description="The text to print to the console.")
+        text: str
 
     class Output(BlockSchema):
-        status: str = SchemaField(description="The status of the print operation.")
+        status: str
 
     def __init__(self):
         super().__init__(
@@ -69,25 +79,23 @@ class PrintToConsoleBlock(Block):
             test_output=("status", "printed"),
         )
 
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input) -> BlockOutput:
         print(">>>>> Print: ", input_data.text)
         yield "status", "printed"
 
 
 class FindInDictionaryBlock(Block):
     class Input(BlockSchema):
-        input: Any = SchemaField(description="Dictionary to lookup from")
-        key: str | int = SchemaField(description="Key to lookup in the dictionary")
+        input: Any = Field(description="Dictionary to lookup from")
+        key: str | int = Field(description="Key to lookup in the dictionary")
 
     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"
-        )
+        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",
+            id="b2g2c3d4-5e6f-7g8h-9i0j-k1l2m3n4o5p6",
             description="Lookup the given key in the input dictionary/object/list and return the value.",
             input_schema=FindInDictionaryBlock.Input,
             output_schema=FindInDictionaryBlock.Output,
@@ -110,7 +118,7 @@ class FindInDictionaryBlock(Block):
             categories={BlockCategory.BASIC},
         )
 
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input) -> BlockOutput:
         obj = input_data.input
         key = input_data.key
 
@@ -141,17 +149,11 @@ class AgentInputBlock(Block):
     """
 
     class Input(BlockSchema):
+        value: Any = SchemaField(description="The value to be passed as input.")
         name: str = SchemaField(description="The name of the input.")
-        value: Any = SchemaField(
-            description="The value to be passed as input.",
-            default=None,
-        )
-        title: str | None = SchemaField(
-            description="The title of the input.", default=None, advanced=True
-        )
-        description: str | None = SchemaField(
+        description: str = SchemaField(
             description="The description of the input.",
-            default=None,
+            default="",
             advanced=True,
         )
         placeholder_values: List[Any] = SchemaField(
@@ -164,16 +166,6 @@ class AgentInputBlock(Block):
             default=False,
             advanced=True,
         )
-        advanced: bool = SchemaField(
-            description="Whether to show the input in the advanced section, if the field is not required.",
-            default=False,
-            advanced=True,
-        )
-        secret: bool = SchemaField(
-            description="Whether the input should be treated as a secret.",
-            default=False,
-            advanced=True,
-        )
 
     class Output(BlockSchema):
         result: Any = SchemaField(description="The value passed as input.")
@@ -205,11 +197,10 @@ class AgentInputBlock(Block):
                 ("result", "Hello, World!"),
             ],
             categories={BlockCategory.INPUT, BlockCategory.BASIC},
-            block_type=BlockType.INPUT,
-            static_output=True,
+            ui_type=BlockUIType.INPUT,
         )
 
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input) -> BlockOutput:
         yield "result", input_data.value
 
 
@@ -217,42 +208,33 @@ 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 `format` is provided and the `value` is of a type that can be formatted,
-        the block attempts to format the recorded_value using the `format`.
-        If formatting fails or no `format` is provided, the raw `value` is output.
+        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.",
-            default=None,
-            advanced=False,
-        )
+        value: Any = SchemaField(description="The value to be recorded as output.")
         name: str = SchemaField(description="The name of the output.")
-        title: str | None = SchemaField(
-            description="The title of the output.",
-            default=None,
-            advanced=True,
-        )
-        description: str | None = SchemaField(
+        description: str = SchemaField(
             description="The description of the output.",
-            default=None,
-            advanced=True,
-        )
-        format: str = SchemaField(
-            description="The format string to be used to format the recorded_value. Use Jinja2 syntax.",
             default="",
             advanced=True,
         )
-        advanced: bool = SchemaField(
-            description="Whether to treat the output as advanced.",
-            default=False,
-            advanced=True,
-        )
-        secret: bool = SchemaField(
-            description="Whether the output should be treated as a secret.",
-            default=False,
+        format: str = SchemaField(
+            description="The format string to be used to format the recorded_value.",
+            default="",
             advanced=True,
         )
 
@@ -262,7 +244,14 @@ class AgentOutputBlock(Block):
     def __init__(self):
         super().__init__(
             id="363ae599-353e-4804-937e-b2ee3cef3da4",
-            description="Stores the output of the graph for users to see.",
+            description=(
+                "This block records the graph output. It takes a value to record, "
+                "with a name, description, and optional format string. If a format "
+                "string is given, it tries to format the recorded value. The "
+                "formatted (or raw, if formatting fails) value is then output. "
+                "This block is key for capturing and presenting final results or "
+                "important intermediate outputs of the graph execution."
+            ),
             input_schema=AgentOutputBlock.Input,
             output_schema=AgentOutputBlock.Output,
             test_input=[
@@ -291,20 +280,19 @@ class AgentOutputBlock(Block):
                 ("output", MockObject(value="!!", key="key")),
             ],
             categories={BlockCategory.OUTPUT, BlockCategory.BASIC},
-            block_type=BlockType.OUTPUT,
-            static_output=True,
+            ui_type=BlockUIType.OUTPUT,
         )
 
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input) -> 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:
-                yield "output", formatter.format_string(
-                    input_data.format, {input_data.name: input_data.value}
-                )
+                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:
@@ -313,26 +301,16 @@ class AgentOutputBlock(Block):
 
 class AddToDictionaryBlock(Block):
     class Input(BlockSchema):
-        dictionary: dict[Any, Any] = SchemaField(
-            default={},
+        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={},
-            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):
@@ -355,10 +333,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=[
                 (
@@ -366,49 +340,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()
+    def run(self, input_data: Input) -> BlockOutput:
+        try:
+            # If no dictionary is provided, create a new one
+            if input_data.dictionary is None:
+                updated_dict = {}
+            else:
+                # Create a copy of the input dictionary to avoid modifying the original
+                updated_dict = input_data.dictionary.copy()
 
-        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=[],
-            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=[],
-            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):
@@ -432,12 +398,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=[
                 (
@@ -451,22 +411,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)
+    def run(self, input_data: Input) -> BlockOutput:
+        try:
+            # If no list is provided, create a new one
+            if input_data.list is None:
+                updated_list = []
+            else:
+                # Create a copy of the input list to avoid modifying the original
+                updated_list = input_data.list.copy()
 
-        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
+            # 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
+            yield "updated_list", updated_list
+        except Exception as e:
+            yield "error", f"Failed to add entry to list: {str(e)}"
 
 
 class NoteBlock(Block):
@@ -478,7 +443,7 @@ class NoteBlock(Block):
 
     def __init__(self):
         super().__init__(
-            id="cc10ff7b-7753-4ff2-9af6-9399b1a7eddc",
+            id="31d1064e-7446-4693-o7d4-65e5ca9110d1",
             description="This block is used to display a sticky note with the given text.",
             categories={BlockCategory.BASIC},
             input_schema=NoteBlock.Input,
@@ -487,106 +452,8 @@ class NoteBlock(Block):
             test_output=[
                 ("output", "Hello, World!"),
             ],
-            block_type=BlockType.NOTE,
+            ui_type=BlockUIType.NOTE,
         )
 
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input) -> 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)}"

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__(
@@ -38,18 +31,20 @@ class BlockInstallationBlock(Block):
             disabled=True,
         )
 
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input) -> BlockOutput:
         code = input_data.code
 
         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

@@ -70,25 +70,12 @@ class ConditionBlock(Block):
             ],
         )
 
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        operator = input_data.operator
-
+    def run(self, input_data: Input) -> BlockOutput:
         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,11 +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
+
+        except Exception:
+            yield "result", None
+            yield "yes_output", None
+            yield "no_output", None

autogpt_platform/backend/backend/blocks/code_executor.py

@@ -1,190 +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=[],
-            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)

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,59 +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.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="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,58 +1,29 @@
 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=[],
-        )
+        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__(
             id="acf7625e-d2cb-4941-bfeb-2819fc6fc015",
             input_schema=ReadCsvBlock.Input,
             output_schema=ReadCsvBlock.Output,
-            description="Reads a CSV file and outputs the data as a list of dictionaries and individual rows via rows.",
             contributors=[ContributorDetails(name="Nicholas Tindle")],
-            categories={BlockCategory.TEXT, BlockCategory.DATA},
+            categories={BlockCategory.TEXT},
             test_input={
                 "contents": "a, b, c\n1,2,3\n4,5,6",
             },
@@ -69,7 +40,7 @@ class ReadCsvBlock(Block):
             ],
         )
 
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input) -> BlockOutput:
         import csv
         from io import StringIO
 

autogpt_platform/backend/backend/blocks/decoder_block.py

@@ -1,39 +0,0 @@
-import codecs
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-
-class TextDecoderBlock(Block):
-    class Input(BlockSchema):
-        text: str = SchemaField(
-            description="A string containing escaped characters to be decoded",
-            placeholder='Your entire text block with \\n and \\" escaped characters',
-        )
-
-    class Output(BlockSchema):
-        decoded_text: str = SchemaField(
-            description="The decoded text with escape sequences processed"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="2570e8fe-8447-43ed-84c7-70d657923231",
-            description="Decodes a string containing escape sequences into actual text",
-            categories={BlockCategory.TEXT},
-            input_schema=TextDecoderBlock.Input,
-            output_schema=TextDecoderBlock.Output,
-            test_input={"text": """Hello\nWorld!\nThis is a \"quoted\" string."""},
-            test_output=[
-                (
-                    "decoded_text",
-                    """Hello
-World!
-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

autogpt_platform/backend/backend/blocks/discord.py

@@ -1,70 +1,38 @@
 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"
         )
 
     def __init__(self):
         super().__init__(
-            id="df06086a-d5ac-4abb-9996-2ad0acb2eff7",
+            id="d3f4g5h6-1i2j-3k4l-5m6n-7o8p9q0r1s2t",  # Unique ID for the node
             input_schema=ReadDiscordMessagesBlock.Input,  # Assign input schema
             output_schema=ReadDiscordMessagesBlock.Output,  # Assign output schema
-            description="Reads messages from a Discord channel using a bot token.",
             categories={BlockCategory.SOCIAL},
-            test_input={
-                "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 +46,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 +79,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: "ReadDiscordMessagesBlock.Input") -> 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: "ReadDiscordMessagesBlock.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,36 +130,34 @@ 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')"
         )
 
     def __init__(self):
         super().__init__(
-            id="d0822ab5-9f8a-44a3-8971-531dd0178b6b",
+            id="h1i2j3k4-5l6m-7n8o-9p0q-r1s2t3u4v5w6",  # Unique ID for the node
             input_schema=SendDiscordMessageBlock.Input,  # Assign input schema
             output_schema=SendDiscordMessageBlock.Output,  # Assign output schema
-            description="Sends a message to a Discord channel using a bot token.",
             categories={BlockCategory.SOCIAL},
             test_input={
+                "discord_bot_token": "YOUR_DISCORD_BOT_TOKEN",
                 "channel_name": "general",
                 "message_content": "Hello, Discord!",
-                "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 +187,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: "SendDiscordMessageBlock.Input") -> 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

@@ -2,17 +2,17 @@ import smtplib
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import BlockSecret, SchemaField, SecretField
 
 
 class EmailCredentials(BaseModel):
-    smtp_server: str = SchemaField(
+    smtp_server: str = Field(
         default="smtp.gmail.com", description="SMTP server address"
     )
-    smtp_port: int = SchemaField(default=25, description="SMTP port number")
+    smtp_port: int = Field(default=25, description="SMTP port number")
     smtp_username: BlockSecret = SecretField(key="smtp_username")
     smtp_password: BlockSecret = SecretField(key="smtp_password")
 
@@ -30,7 +30,7 @@ class SendEmailBlock(Block):
         body: str = SchemaField(
             description="Body of the email", placeholder="Enter the email body"
         )
-        creds: EmailCredentials = SchemaField(
+        creds: EmailCredentials = Field(
             description="SMTP credentials",
             default=EmailCredentials(),
         )
@@ -43,8 +43,7 @@ class SendEmailBlock(Block):
 
     def __init__(self):
         super().__init__(
-            disabled=True,
-            id="4335878a-394e-4e67-adf2-919877ff49ae",
+            id="a1234567-89ab-cdef-0123-456789abcdef",
             description="This block sends an email using the provided SMTP credentials.",
             categories={BlockCategory.OUTPUT},
             input_schema=SendEmailBlock.Input,
@@ -68,28 +67,35 @@ class SendEmailBlock(Block):
     def send_email(
         creds: EmailCredentials, to_email: str, subject: str, body: str
     ) -> str:
-        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()
+        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, **kwargs) -> BlockOutput:
-        yield "status", self.send_email(
+    def run(self, input_data: Input) -> 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,87 +0,0 @@
-from typing import List, Optional
-
-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=[],
-        )
-
-    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=[],
-        )
-        exclude_domains: List[str] = SchemaField(
-            description="Domains to exclude from search",
-            default=[],
-            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=[],
-            advanced=True,
-        )
-        exclude_text: List[str] = SchemaField(
-            description="Text patterns to exclude",
-            default=[],
-            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=[],
-        )
-
-    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=[],
-            advanced=True,
-        )
-        exclude_domains: List[str] = SchemaField(
-            description="Domains to exclude from search",
-            default=[],
-            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=[],
-            advanced=True,
-        )
-        exclude_text: List[str] = SchemaField(
-            description="Text patterns to exclude (max 1 string, up to 5 words)",
-            default=[],
-            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=[],
-        )
-
-    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.", optional=True
-        )
-
-    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/github/_api.py

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

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

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

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

autogpt_platform/backend/backend/blocks/github/triggers.py

@@ -1,158 +0,0 @@
-import json
-import logging
-from pathlib import Path
-
-from pydantic import BaseModel
-
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchema,
-    BlockWebhookConfig,
-)
-from backend.data.model import SchemaField
-
-from ._auth import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    GithubCredentialsField,
-    GithubCredentialsInput,
-)
-
-logger = logging.getLogger(__name__)
-
-
-# --8<-- [start:GithubTriggerExample]
-class GitHubTriggerBase:
-    class Input(BlockSchema):
-        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
-        repo: str = SchemaField(
-            description=(
-                "Repository to subscribe to.\n\n"
-                "**Note:** Make sure your GitHub credentials have permissions "
-                "to create webhooks on this repo."
-            ),
-            placeholder="{owner}/{repo}",
-        )
-        # --8<-- [start:example-payload-field]
-        payload: dict = SchemaField(hidden=True, default={})
-        # --8<-- [end:example-payload-field]
-
-    class Output(BlockSchema):
-        payload: dict = SchemaField(
-            description="The complete webhook payload that was received from GitHub. "
-            "Includes information about the affected resource (e.g. pull request), "
-            "the event, and the user who triggered the event."
-        )
-        triggered_by_user: dict = SchemaField(
-            description="Object representing the GitHub user who triggered the event"
-        )
-        error: str = SchemaField(
-            description="Error message if the payload could not be processed"
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        yield "payload", input_data.payload
-        yield "triggered_by_user", input_data.payload["sender"]
-
-
-class GithubPullRequestTriggerBlock(GitHubTriggerBase, Block):
-    EXAMPLE_PAYLOAD_FILE = (
-        Path(__file__).parent / "example_payloads" / "pull_request.synchronize.json"
-    )
-
-    # --8<-- [start:example-event-filter]
-    class Input(GitHubTriggerBase.Input):
-        class EventsFilter(BaseModel):
-            """
-            https://docs.github.com/en/webhooks/webhook-events-and-payloads#pull_request
-            """
-
-            opened: bool = False
-            edited: bool = False
-            closed: bool = False
-            reopened: bool = False
-            synchronize: bool = False
-            assigned: bool = False
-            unassigned: bool = False
-            labeled: bool = False
-            unlabeled: bool = False
-            converted_to_draft: bool = False
-            locked: bool = False
-            unlocked: bool = False
-            enqueued: bool = False
-            dequeued: bool = False
-            milestoned: bool = False
-            demilestoned: bool = False
-            ready_for_review: bool = False
-            review_requested: bool = False
-            review_request_removed: bool = False
-            auto_merge_enabled: bool = False
-            auto_merge_disabled: bool = False
-
-        events: EventsFilter = SchemaField(
-            title="Events", description="The events to subscribe to"
-        )
-        # --8<-- [end:example-event-filter]
-
-    class Output(GitHubTriggerBase.Output):
-        event: str = SchemaField(
-            description="The PR event that triggered the webhook (e.g. 'opened')"
-        )
-        number: int = SchemaField(description="The number of the affected pull request")
-        pull_request: dict = SchemaField(
-            description="Object representing the affected pull request"
-        )
-        pull_request_url: str = SchemaField(
-            description="The URL of the affected pull request"
-        )
-
-    def __init__(self):
-        from backend.integrations.webhooks.github import GithubWebhookType
-
-        example_payload = json.loads(
-            self.EXAMPLE_PAYLOAD_FILE.read_text(encoding="utf-8")
-        )
-
-        super().__init__(
-            id="6c60ec01-8128-419e-988f-96a063ee2fea",
-            description="This block triggers on pull request events and outputs the event type and payload.",
-            categories={BlockCategory.DEVELOPER_TOOLS, BlockCategory.INPUT},
-            input_schema=GithubPullRequestTriggerBlock.Input,
-            output_schema=GithubPullRequestTriggerBlock.Output,
-            # --8<-- [start:example-webhook_config]
-            webhook_config=BlockWebhookConfig(
-                provider="github",
-                webhook_type=GithubWebhookType.REPO,
-                resource_format="{repo}",
-                event_filter_input="events",
-                event_format="pull_request.{event}",
-            ),
-            # --8<-- [end:example-webhook_config]
-            test_input={
-                "repo": "Significant-Gravitas/AutoGPT",
-                "events": {"opened": True, "synchronize": True},
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "payload": example_payload,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                ("payload", example_payload),
-                ("triggered_by_user", example_payload["sender"]),
-                ("event", example_payload["action"]),
-                ("number", example_payload["number"]),
-                ("pull_request", example_payload["pull_request"]),
-                ("pull_request_url", example_payload["pull_request"]["html_url"]),
-            ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:  # type: ignore
-        yield from super().run(input_data, **kwargs)
-        yield "event", input_data.payload["action"]
-        yield "number", input_data.payload["number"]
-        yield "pull_request", input_data.payload["pull_request"]
-        yield "pull_request_url", input_data.payload["pull_request"]["html_url"]
-
-
-# --8<-- [end:GithubTriggerExample]

autogpt_platform/backend/backend/blocks/google/_auth.py

@@ -1,54 +0,0 @@
-from typing import Literal
-
-from pydantic import SecretStr
-
-from backend.data.model import CredentialsField, CredentialsMetaInput, OAuth2Credentials
-from backend.integrations.providers import ProviderName
-from backend.util.settings import Secrets
-
-# --8<-- [start:GoogleOAuthIsConfigured]
-secrets = Secrets()
-GOOGLE_OAUTH_IS_CONFIGURED = bool(
-    secrets.google_client_id and secrets.google_client_secret
-)
-# --8<-- [end:GoogleOAuthIsConfigured]
-GoogleCredentials = OAuth2Credentials
-GoogleCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.GOOGLE], Literal["oauth2"]
-]
-
-
-def GoogleCredentialsField(scopes: list[str]) -> GoogleCredentialsInput:
-    """
-    Creates a Google credentials input on a block.
-
-    Params:
-        scopes: The authorization scopes needed for the block to work.
-    """
-    return CredentialsField(
-        required_scopes=set(scopes),
-        description="The Google integration requires OAuth2 authentication.",
-    )
-
-
-TEST_CREDENTIALS = OAuth2Credentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="google",
-    access_token=SecretStr("mock-google-access-token"),
-    refresh_token=SecretStr("mock-google-refresh-token"),
-    access_token_expires_at=1234567890,
-    scopes=[
-        "https://www.googleapis.com/auth/gmail.readonly",
-        "https://www.googleapis.com/auth/gmail.send",
-    ],
-    title="Mock Google OAuth2 Credentials",
-    username="mock-google-username",
-    refresh_token_expires_at=1234567890,
-)
-
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.title,
-}

autogpt_platform/backend/backend/blocks/google/gmail.py

@@ -1,529 +0,0 @@
-import base64
-from email.utils import parseaddr
-from typing import List
-
-from google.oauth2.credentials import Credentials
-from googleapiclient.discovery import build
-from pydantic import BaseModel
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-from ._auth import (
-    GOOGLE_OAUTH_IS_CONFIGURED,
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    GoogleCredentials,
-    GoogleCredentialsField,
-    GoogleCredentialsInput,
-)
-
-
-class Attachment(BaseModel):
-    filename: str
-    content_type: str
-    size: int
-    attachment_id: str
-
-
-class Email(BaseModel):
-    id: str
-    subject: str
-    snippet: str
-    from_: str
-    to: str
-    date: str
-    body: str = ""  # Default to an empty string
-    sizeEstimate: int
-    attachments: List[Attachment]
-
-
-class GmailReadBlock(Block):
-    class Input(BlockSchema):
-        credentials: GoogleCredentialsInput = GoogleCredentialsField(
-            ["https://www.googleapis.com/auth/gmail.readonly"]
-        )
-        query: str = SchemaField(
-            description="Search query for reading emails",
-            default="is:unread",
-        )
-        max_results: int = SchemaField(
-            description="Maximum number of emails to retrieve",
-            default=10,
-        )
-
-    class Output(BlockSchema):
-        email: Email = SchemaField(
-            description="Email data",
-        )
-        emails: list[Email] = SchemaField(
-            description="List of email data",
-        )
-        error: str = SchemaField(
-            description="Error message if any",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="25310c70-b89b-43ba-b25c-4dfa7e2a481c",
-            description="This block reads emails from Gmail.",
-            categories={BlockCategory.COMMUNICATION},
-            disabled=not GOOGLE_OAUTH_IS_CONFIGURED,
-            input_schema=GmailReadBlock.Input,
-            output_schema=GmailReadBlock.Output,
-            test_input={
-                "query": "is:unread",
-                "max_results": 5,
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "email",
-                    {
-                        "id": "1",
-                        "subject": "Test Email",
-                        "snippet": "This is a test email",
-                        "from_": "test@example.com",
-                        "to": "recipient@example.com",
-                        "date": "2024-01-01",
-                        "body": "This is a test email",
-                        "sizeEstimate": 100,
-                        "attachments": [],
-                    },
-                ),
-                (
-                    "emails",
-                    [
-                        {
-                            "id": "1",
-                            "subject": "Test Email",
-                            "snippet": "This is a test email",
-                            "from_": "test@example.com",
-                            "to": "recipient@example.com",
-                            "date": "2024-01-01",
-                            "body": "This is a test email",
-                            "sizeEstimate": 100,
-                            "attachments": [],
-                        }
-                    ],
-                ),
-            ],
-            test_mock={
-                "_read_emails": lambda *args, **kwargs: [
-                    {
-                        "id": "1",
-                        "subject": "Test Email",
-                        "snippet": "This is a test email",
-                        "from_": "test@example.com",
-                        "to": "recipient@example.com",
-                        "date": "2024-01-01",
-                        "body": "This is a test email",
-                        "sizeEstimate": 100,
-                        "attachments": [],
-                    }
-                ],
-                "_send_email": lambda *args, **kwargs: {"id": "1", "status": "sent"},
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: GoogleCredentials, **kwargs
-    ) -> BlockOutput:
-        service = self._build_service(credentials, **kwargs)
-        messages = self._read_emails(service, input_data.query, input_data.max_results)
-        for email in messages:
-            yield "email", email
-        yield "emails", messages
-
-    @staticmethod
-    def _build_service(credentials: GoogleCredentials, **kwargs):
-        creds = Credentials(
-            token=(
-                credentials.access_token.get_secret_value()
-                if credentials.access_token
-                else None
-            ),
-            refresh_token=(
-                credentials.refresh_token.get_secret_value()
-                if credentials.refresh_token
-                else None
-            ),
-            token_uri="https://oauth2.googleapis.com/token",
-            client_id=kwargs.get("client_id"),
-            client_secret=kwargs.get("client_secret"),
-            scopes=credentials.scopes,
-        )
-        return build("gmail", "v1", credentials=creds)
-
-    def _read_emails(
-        self, service, query: str | None, max_results: int | None
-    ) -> list[Email]:
-        results = (
-            service.users()
-            .messages()
-            .list(userId="me", q=query or "", maxResults=max_results or 10)
-            .execute()
-        )
-        messages = results.get("messages", [])
-
-        email_data = []
-        for message in messages:
-            msg = (
-                service.users()
-                .messages()
-                .get(userId="me", id=message["id"], format="full")
-                .execute()
-            )
-
-            headers = {
-                header["name"].lower(): header["value"]
-                for header in msg["payload"]["headers"]
-            }
-
-            attachments = self._get_attachments(service, msg)
-
-            email = Email(
-                id=msg["id"],
-                subject=headers.get("subject", "No Subject"),
-                snippet=msg["snippet"],
-                from_=parseaddr(headers.get("from", ""))[1],
-                to=parseaddr(headers.get("to", ""))[1],
-                date=headers.get("date", ""),
-                body=self._get_email_body(msg),
-                sizeEstimate=msg["sizeEstimate"],
-                attachments=attachments,
-            )
-            email_data.append(email)
-
-        return email_data
-
-    def _get_email_body(self, msg):
-        if "parts" in msg["payload"]:
-            for part in msg["payload"]["parts"]:
-                if part["mimeType"] == "text/plain":
-                    return base64.urlsafe_b64decode(part["body"]["data"]).decode(
-                        "utf-8"
-                    )
-        elif msg["payload"]["mimeType"] == "text/plain":
-            return base64.urlsafe_b64decode(msg["payload"]["body"]["data"]).decode(
-                "utf-8"
-            )
-
-        return "This email does not contain a text body."
-
-    def _get_attachments(self, service, message):
-        attachments = []
-        if "parts" in message["payload"]:
-            for part in message["payload"]["parts"]:
-                if part["filename"]:
-                    attachment = Attachment(
-                        filename=part["filename"],
-                        content_type=part["mimeType"],
-                        size=int(part["body"].get("size", 0)),
-                        attachment_id=part["body"]["attachmentId"],
-                    )
-                    attachments.append(attachment)
-        return attachments
-
-    # Add a new method to download attachment content
-    def download_attachment(self, service, message_id: str, attachment_id: str):
-        attachment = (
-            service.users()
-            .messages()
-            .attachments()
-            .get(userId="me", messageId=message_id, id=attachment_id)
-            .execute()
-        )
-        file_data = base64.urlsafe_b64decode(attachment["data"].encode("UTF-8"))
-        return file_data
-
-
-class GmailSendBlock(Block):
-    class Input(BlockSchema):
-        credentials: GoogleCredentialsInput = GoogleCredentialsField(
-            ["https://www.googleapis.com/auth/gmail.send"]
-        )
-        to: str = SchemaField(
-            description="Recipient email address",
-        )
-        subject: str = SchemaField(
-            description="Email subject",
-        )
-        body: str = SchemaField(
-            description="Email body",
-        )
-
-    class Output(BlockSchema):
-        result: dict = SchemaField(
-            description="Send confirmation",
-        )
-        error: str = SchemaField(
-            description="Error message if any",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="6c27abc2-e51d-499e-a85f-5a0041ba94f0",
-            description="This block sends an email using Gmail.",
-            categories={BlockCategory.COMMUNICATION},
-            input_schema=GmailSendBlock.Input,
-            output_schema=GmailSendBlock.Output,
-            disabled=not GOOGLE_OAUTH_IS_CONFIGURED,
-            test_input={
-                "to": "recipient@example.com",
-                "subject": "Test Email",
-                "body": "This is a test email sent from GmailSendBlock.",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                ("result", {"id": "1", "status": "sent"}),
-            ],
-            test_mock={
-                "_send_email": lambda *args, **kwargs: {"id": "1", "status": "sent"},
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: GoogleCredentials, **kwargs
-    ) -> BlockOutput:
-        service = GmailReadBlock._build_service(credentials, **kwargs)
-        send_result = self._send_email(
-            service, input_data.to, input_data.subject, input_data.body
-        )
-        yield "result", send_result
-
-    def _send_email(self, service, to: str, subject: str, body: str) -> dict:
-        if not to or not subject or not body:
-            raise ValueError("To, subject, and body are required for sending an email")
-        message = self._create_message(to, subject, body)
-        sent_message = (
-            service.users().messages().send(userId="me", body=message).execute()
-        )
-        return {"id": sent_message["id"], "status": "sent"}
-
-    def _create_message(self, to: str, subject: str, body: str) -> dict:
-        import base64
-        from email.mime.text import MIMEText
-
-        message = MIMEText(body)
-        message["to"] = to
-        message["subject"] = subject
-        raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode("utf-8")
-        return {"raw": raw_message}
-
-
-class GmailListLabelsBlock(Block):
-    class Input(BlockSchema):
-        credentials: GoogleCredentialsInput = GoogleCredentialsField(
-            ["https://www.googleapis.com/auth/gmail.labels"]
-        )
-
-    class Output(BlockSchema):
-        result: list[dict] = SchemaField(
-            description="List of labels",
-        )
-        error: str = SchemaField(
-            description="Error message if any",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="3e1c2c1c-c689-4520-b956-1f3bf4e02bb7",
-            description="This block lists all labels in Gmail.",
-            categories={BlockCategory.COMMUNICATION},
-            input_schema=GmailListLabelsBlock.Input,
-            output_schema=GmailListLabelsBlock.Output,
-            disabled=not GOOGLE_OAUTH_IS_CONFIGURED,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "result",
-                    [
-                        {"id": "Label_1", "name": "Important"},
-                        {"id": "Label_2", "name": "Work"},
-                    ],
-                ),
-            ],
-            test_mock={
-                "_list_labels": lambda *args, **kwargs: [
-                    {"id": "Label_1", "name": "Important"},
-                    {"id": "Label_2", "name": "Work"},
-                ],
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: GoogleCredentials, **kwargs
-    ) -> BlockOutput:
-        service = GmailReadBlock._build_service(credentials, **kwargs)
-        labels = self._list_labels(service)
-        yield "result", labels
-
-    def _list_labels(self, service) -> list[dict]:
-        results = service.users().labels().list(userId="me").execute()
-        labels = results.get("labels", [])
-        return [{"id": label["id"], "name": label["name"]} for label in labels]
-
-
-class GmailAddLabelBlock(Block):
-    class Input(BlockSchema):
-        credentials: GoogleCredentialsInput = GoogleCredentialsField(
-            ["https://www.googleapis.com/auth/gmail.modify"]
-        )
-        message_id: str = SchemaField(
-            description="Message ID to add label to",
-        )
-        label_name: str = SchemaField(
-            description="Label name to add",
-        )
-
-    class Output(BlockSchema):
-        result: dict = SchemaField(
-            description="Label addition result",
-        )
-        error: str = SchemaField(
-            description="Error message if any",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="f884b2fb-04f4-4265-9658-14f433926ac9",
-            description="This block adds a label to a Gmail message.",
-            categories={BlockCategory.COMMUNICATION},
-            input_schema=GmailAddLabelBlock.Input,
-            output_schema=GmailAddLabelBlock.Output,
-            disabled=not GOOGLE_OAUTH_IS_CONFIGURED,
-            test_input={
-                "message_id": "12345",
-                "label_name": "Important",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "result",
-                    {"status": "Label added successfully", "label_id": "Label_1"},
-                ),
-            ],
-            test_mock={
-                "_add_label": lambda *args, **kwargs: {
-                    "status": "Label added successfully",
-                    "label_id": "Label_1",
-                },
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: GoogleCredentials, **kwargs
-    ) -> BlockOutput:
-        service = GmailReadBlock._build_service(credentials, **kwargs)
-        result = self._add_label(service, input_data.message_id, input_data.label_name)
-        yield "result", result
-
-    def _add_label(self, service, message_id: str, label_name: str) -> dict:
-        label_id = self._get_or_create_label(service, label_name)
-        service.users().messages().modify(
-            userId="me", id=message_id, body={"addLabelIds": [label_id]}
-        ).execute()
-        return {"status": "Label added successfully", "label_id": label_id}
-
-    def _get_or_create_label(self, service, label_name: str) -> str:
-        label_id = self._get_label_id(service, label_name)
-        if not label_id:
-            label = (
-                service.users()
-                .labels()
-                .create(userId="me", body={"name": label_name})
-                .execute()
-            )
-            label_id = label["id"]
-        return label_id
-
-    def _get_label_id(self, service, label_name: str) -> str | None:
-        results = service.users().labels().list(userId="me").execute()
-        labels = results.get("labels", [])
-        for label in labels:
-            if label["name"] == label_name:
-                return label["id"]
-        return None
-
-
-class GmailRemoveLabelBlock(Block):
-    class Input(BlockSchema):
-        credentials: GoogleCredentialsInput = GoogleCredentialsField(
-            ["https://www.googleapis.com/auth/gmail.modify"]
-        )
-        message_id: str = SchemaField(
-            description="Message ID to remove label from",
-        )
-        label_name: str = SchemaField(
-            description="Label name to remove",
-        )
-
-    class Output(BlockSchema):
-        result: dict = SchemaField(
-            description="Label removal result",
-        )
-        error: str = SchemaField(
-            description="Error message if any",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="0afc0526-aba1-4b2b-888e-a22b7c3f359d",
-            description="This block removes a label from a Gmail message.",
-            categories={BlockCategory.COMMUNICATION},
-            input_schema=GmailRemoveLabelBlock.Input,
-            output_schema=GmailRemoveLabelBlock.Output,
-            disabled=not GOOGLE_OAUTH_IS_CONFIGURED,
-            test_input={
-                "message_id": "12345",
-                "label_name": "Important",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "result",
-                    {"status": "Label removed successfully", "label_id": "Label_1"},
-                ),
-            ],
-            test_mock={
-                "_remove_label": lambda *args, **kwargs: {
-                    "status": "Label removed successfully",
-                    "label_id": "Label_1",
-                },
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: GoogleCredentials, **kwargs
-    ) -> BlockOutput:
-        service = GmailReadBlock._build_service(credentials, **kwargs)
-        result = self._remove_label(
-            service, input_data.message_id, input_data.label_name
-        )
-        yield "result", result
-
-    def _remove_label(self, service, message_id: str, label_name: str) -> dict:
-        label_id = self._get_label_id(service, label_name)
-        if label_id:
-            service.users().messages().modify(
-                userId="me", id=message_id, body={"removeLabelIds": [label_id]}
-            ).execute()
-            return {"status": "Label removed successfully", "label_id": label_id}
-        else:
-            return {"status": "Label not found", "label_name": label_name}
-
-    def _get_label_id(self, service, label_name: str) -> str | None:
-        results = service.users().labels().list(userId="me").execute()
-        labels = results.get("labels", [])
-        for label in labels:
-            if label["name"] == label_name:
-                return label["id"]
-        return None

autogpt_platform/backend/backend/blocks/google/sheets.py

@@ -1,184 +0,0 @@
-from google.oauth2.credentials import Credentials
-from googleapiclient.discovery import build
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-from ._auth import (
-    GOOGLE_OAUTH_IS_CONFIGURED,
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    GoogleCredentials,
-    GoogleCredentialsField,
-    GoogleCredentialsInput,
-)
-
-
-class GoogleSheetsReadBlock(Block):
-    class Input(BlockSchema):
-        credentials: GoogleCredentialsInput = GoogleCredentialsField(
-            ["https://www.googleapis.com/auth/spreadsheets.readonly"]
-        )
-        spreadsheet_id: str = SchemaField(
-            description="The ID of the spreadsheet to read from",
-        )
-        range: str = SchemaField(
-            description="The A1 notation of the range to read",
-        )
-
-    class Output(BlockSchema):
-        result: list[list[str]] = SchemaField(
-            description="The data read from the spreadsheet",
-        )
-        error: str = SchemaField(
-            description="Error message if any",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="5724e902-3635-47e9-a108-aaa0263a4988",
-            description="This block reads data from a Google Sheets spreadsheet.",
-            categories={BlockCategory.DATA},
-            input_schema=GoogleSheetsReadBlock.Input,
-            output_schema=GoogleSheetsReadBlock.Output,
-            disabled=not GOOGLE_OAUTH_IS_CONFIGURED,
-            test_input={
-                "spreadsheet_id": "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms",
-                "range": "Sheet1!A1:B2",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "result",
-                    [
-                        ["Name", "Score"],
-                        ["Alice", "85"],
-                    ],
-                ),
-            ],
-            test_mock={
-                "_read_sheet": lambda *args, **kwargs: [
-                    ["Name", "Score"],
-                    ["Alice", "85"],
-                ],
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: GoogleCredentials, **kwargs
-    ) -> BlockOutput:
-        service = self._build_service(credentials, **kwargs)
-        data = self._read_sheet(service, input_data.spreadsheet_id, input_data.range)
-        yield "result", data
-
-    @staticmethod
-    def _build_service(credentials: GoogleCredentials, **kwargs):
-        creds = Credentials(
-            token=(
-                credentials.access_token.get_secret_value()
-                if credentials.access_token
-                else None
-            ),
-            refresh_token=(
-                credentials.refresh_token.get_secret_value()
-                if credentials.refresh_token
-                else None
-            ),
-            token_uri="https://oauth2.googleapis.com/token",
-            client_id=kwargs.get("client_id"),
-            client_secret=kwargs.get("client_secret"),
-            scopes=credentials.scopes,
-        )
-        return build("sheets", "v4", credentials=creds)
-
-    def _read_sheet(self, service, spreadsheet_id: str, range: str) -> list[list[str]]:
-        sheet = service.spreadsheets()
-        result = sheet.values().get(spreadsheetId=spreadsheet_id, range=range).execute()
-        return result.get("values", [])
-
-
-class GoogleSheetsWriteBlock(Block):
-    class Input(BlockSchema):
-        credentials: GoogleCredentialsInput = GoogleCredentialsField(
-            ["https://www.googleapis.com/auth/spreadsheets"]
-        )
-        spreadsheet_id: str = SchemaField(
-            description="The ID of the spreadsheet to write to",
-        )
-        range: str = SchemaField(
-            description="The A1 notation of the range to write",
-        )
-        values: list[list[str]] = SchemaField(
-            description="The data to write to the spreadsheet",
-        )
-
-    class Output(BlockSchema):
-        result: dict = SchemaField(
-            description="The result of the write operation",
-        )
-        error: str = SchemaField(
-            description="Error message if any",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="d9291e87-301d-47a8-91fe-907fb55460e5",
-            description="This block writes data to a Google Sheets spreadsheet.",
-            categories={BlockCategory.DATA},
-            input_schema=GoogleSheetsWriteBlock.Input,
-            output_schema=GoogleSheetsWriteBlock.Output,
-            disabled=not GOOGLE_OAUTH_IS_CONFIGURED,
-            test_input={
-                "spreadsheet_id": "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms",
-                "range": "Sheet1!A1:B2",
-                "values": [
-                    ["Name", "Score"],
-                    ["Bob", "90"],
-                ],
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "result",
-                    {"updatedCells": 4, "updatedColumns": 2, "updatedRows": 2},
-                ),
-            ],
-            test_mock={
-                "_write_sheet": lambda *args, **kwargs: {
-                    "updatedCells": 4,
-                    "updatedColumns": 2,
-                    "updatedRows": 2,
-                },
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: GoogleCredentials, **kwargs
-    ) -> BlockOutput:
-        service = GoogleSheetsReadBlock._build_service(credentials, **kwargs)
-        result = self._write_sheet(
-            service,
-            input_data.spreadsheet_id,
-            input_data.range,
-            input_data.values,
-        )
-        yield "result", result
-
-    def _write_sheet(
-        self, service, spreadsheet_id: str, range: str, values: list[list[str]]
-    ) -> dict:
-        body = {"values": values}
-        result = (
-            service.spreadsheets()
-            .values()
-            .update(
-                spreadsheetId=spreadsheet_id,
-                range=range,
-                valueInputOption="USER_ENTERED",
-                body=body,
-            )
-            .execute()
-        )
-        return result

autogpt_platform/backend/backend/blocks/google_maps.py

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

autogpt_platform/backend/backend/blocks/helpers/http.py

@@ -1,14 +0,0 @@
-from typing import Any, Optional
-
-from backend.util.request import requests
-
-
-class GetRequest:
-    @classmethod
-    def get_request(
-        cls, url: str, headers: Optional[dict] = None, json: bool = False
-    ) -> Any:
-        if headers is None:
-            headers = {}
-        response = requests.get(url, headers=headers)
-        return response.json() if json else response.text

autogpt_platform/backend/backend/blocks/http.py

@@ -1,10 +1,9 @@
 import json
 from enum import Enum
-from typing import Any
+
+import requests
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-from backend.util.request import requests
 
 
 class HttpMethod(Enum):
@@ -19,32 +18,15 @@ class HttpMethod(Enum):
 
 class SendWebRequestBlock(Block):
     class Input(BlockSchema):
-        url: str = SchemaField(
-            description="The URL to send the request to",
-            placeholder="https://api.example.com",
-        )
-        method: HttpMethod = SchemaField(
-            description="The HTTP method to use for the request",
-            default=HttpMethod.POST,
-        )
-        headers: dict[str, str] = SchemaField(
-            description="The headers to include in the request",
-            default={},
-        )
-        json_format: bool = SchemaField(
-            title="JSON format",
-            description="Whether to send and receive body as JSON",
-            default=True,
-        )
-        body: Any = SchemaField(
-            description="The body of the request",
-            default=None,
-        )
+        url: str
+        method: HttpMethod = HttpMethod.POST
+        headers: dict[str, str] = {}
+        body: object = {}
 
     class Output(BlockSchema):
-        response: object = SchemaField(description="The response from the server")
-        client_error: object = SchemaField(description="The error on 4xx status codes")
-        server_error: object = SchemaField(description="The error on 5xx status codes")
+        response: object
+        client_error: object
+        server_error: object
 
     def __init__(self):
         super().__init__(
@@ -55,33 +37,21 @@ class SendWebRequestBlock(Block):
             output_schema=SendWebRequestBlock.Output,
         )
 
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        body = input_data.body
-
-        if input_data.json_format:
-            if isinstance(body, str):
-                try:
-                    # Try to parse as JSON first
-                    body = json.loads(body)
-                except json.JSONDecodeError:
-                    # If it's not valid JSON and just plain text,
-                    # we should send it as plain text instead
-                    input_data.json_format = False
+    def run(self, input_data: Input) -> BlockOutput:
+        if isinstance(input_data.body, str):
+            input_data.body = json.loads(input_data.body)
 
         response = requests.request(
             input_data.method.value,
             input_data.url,
             headers=input_data.headers,
-            json=body if input_data.json_format else None,
-            data=body if not input_data.json_format else None,
+            json=input_data.body,
         )
-        result = response.json() if input_data.json_format else response.text
-
         if response.status_code // 100 == 2:
-            yield "response", result
+            yield "response", response.json()
         elif response.status_code // 100 == 4:
-            yield "client_error", result
+            yield "client_error", response.json()
         elif response.status_code // 100 == 5:
-            yield "server_error", result
+            yield "server_error", response.json()
         else:
             raise ValueError(f"Unexpected status code: {response.status_code}")

autogpt_platform/backend/backend/blocks/hubspot/_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
-
-HubSpotCredentials = APIKeyCredentials
-HubSpotCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.HUBSPOT],
-    Literal["api_key"],
-]
-
-
-def HubSpotCredentialsField() -> HubSpotCredentialsInput:
-    """Creates a HubSpot credentials input on a block."""
-    return CredentialsField(
-        description="The HubSpot integration requires an API Key.",
-    )
-
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="hubspot",
-    api_key=SecretStr("mock-hubspot-api-key"),
-    title="Mock HubSpot 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/hubspot/company.py

@@ -1,106 +0,0 @@
-from backend.blocks.hubspot._auth import (
-    HubSpotCredentials,
-    HubSpotCredentialsField,
-    HubSpotCredentialsInput,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-from backend.util.request import requests
-
-
-class HubSpotCompanyBlock(Block):
-    class Input(BlockSchema):
-        credentials: HubSpotCredentialsInput = HubSpotCredentialsField()
-        operation: str = SchemaField(
-            description="Operation to perform (create, update, get)", default="get"
-        )
-        company_data: dict = SchemaField(
-            description="Company data for create/update operations", default={}
-        )
-        domain: str = SchemaField(
-            description="Company domain for get/update operations", default=""
-        )
-
-    class Output(BlockSchema):
-        company: dict = SchemaField(description="Company information")
-        status: str = SchemaField(description="Operation status")
-
-    def __init__(self):
-        super().__init__(
-            id="3ae02219-d540-47cd-9c78-3ad6c7d9820a",
-            description="Manages HubSpot companies - create, update, and retrieve company information",
-            categories={BlockCategory.CRM},
-            input_schema=HubSpotCompanyBlock.Input,
-            output_schema=HubSpotCompanyBlock.Output,
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: HubSpotCredentials, **kwargs
-    ) -> BlockOutput:
-        base_url = "https://api.hubapi.com/crm/v3/objects/companies"
-        headers = {
-            "Authorization": f"Bearer {credentials.api_key.get_secret_value()}",
-            "Content-Type": "application/json",
-        }
-
-        if input_data.operation == "create":
-            response = requests.post(
-                base_url, headers=headers, json={"properties": input_data.company_data}
-            )
-            result = response.json()
-            yield "company", result
-            yield "status", "created"
-
-        elif input_data.operation == "get":
-            search_url = f"{base_url}/search"
-            search_data = {
-                "filterGroups": [
-                    {
-                        "filters": [
-                            {
-                                "propertyName": "domain",
-                                "operator": "EQ",
-                                "value": input_data.domain,
-                            }
-                        ]
-                    }
-                ]
-            }
-            response = requests.post(search_url, headers=headers, json=search_data)
-            result = response.json()
-            yield "company", result.get("results", [{}])[0]
-            yield "status", "retrieved"
-
-        elif input_data.operation == "update":
-            # First get company ID by domain
-            search_response = requests.post(
-                f"{base_url}/search",
-                headers=headers,
-                json={
-                    "filterGroups": [
-                        {
-                            "filters": [
-                                {
-                                    "propertyName": "domain",
-                                    "operator": "EQ",
-                                    "value": input_data.domain,
-                                }
-                            ]
-                        }
-                    ]
-                },
-            )
-            company_id = search_response.json().get("results", [{}])[0].get("id")
-
-            if company_id:
-                response = requests.patch(
-                    f"{base_url}/{company_id}",
-                    headers=headers,
-                    json={"properties": input_data.company_data},
-                )
-                result = response.json()
-                yield "company", result
-                yield "status", "updated"
-            else:
-                yield "company", {}
-                yield "status", "company_not_found"

autogpt_platform/backend/backend/blocks/hubspot/contact.py

@@ -1,106 +0,0 @@
-from backend.blocks.hubspot._auth import (
-    HubSpotCredentials,
-    HubSpotCredentialsField,
-    HubSpotCredentialsInput,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-from backend.util.request import requests
-
-
-class HubSpotContactBlock(Block):
-    class Input(BlockSchema):
-        credentials: HubSpotCredentialsInput = HubSpotCredentialsField()
-        operation: str = SchemaField(
-            description="Operation to perform (create, update, get)", default="get"
-        )
-        contact_data: dict = SchemaField(
-            description="Contact data for create/update operations", default={}
-        )
-        email: str = SchemaField(
-            description="Email address for get/update operations", default=""
-        )
-
-    class Output(BlockSchema):
-        contact: dict = SchemaField(description="Contact information")
-        status: str = SchemaField(description="Operation status")
-
-    def __init__(self):
-        super().__init__(
-            id="5267326e-c4c1-4016-9f54-4e72ad02f813",
-            description="Manages HubSpot contacts - create, update, and retrieve contact information",
-            categories={BlockCategory.CRM},
-            input_schema=HubSpotContactBlock.Input,
-            output_schema=HubSpotContactBlock.Output,
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: HubSpotCredentials, **kwargs
-    ) -> BlockOutput:
-        base_url = "https://api.hubapi.com/crm/v3/objects/contacts"
-        headers = {
-            "Authorization": f"Bearer {credentials.api_key.get_secret_value()}",
-            "Content-Type": "application/json",
-        }
-
-        if input_data.operation == "create":
-            response = requests.post(
-                base_url, headers=headers, json={"properties": input_data.contact_data}
-            )
-            result = response.json()
-            yield "contact", result
-            yield "status", "created"
-
-        elif input_data.operation == "get":
-            # Search for contact by email
-            search_url = f"{base_url}/search"
-            search_data = {
-                "filterGroups": [
-                    {
-                        "filters": [
-                            {
-                                "propertyName": "email",
-                                "operator": "EQ",
-                                "value": input_data.email,
-                            }
-                        ]
-                    }
-                ]
-            }
-            response = requests.post(search_url, headers=headers, json=search_data)
-            result = response.json()
-            yield "contact", result.get("results", [{}])[0]
-            yield "status", "retrieved"
-
-        elif input_data.operation == "update":
-            search_response = requests.post(
-                f"{base_url}/search",
-                headers=headers,
-                json={
-                    "filterGroups": [
-                        {
-                            "filters": [
-                                {
-                                    "propertyName": "email",
-                                    "operator": "EQ",
-                                    "value": input_data.email,
-                                }
-                            ]
-                        }
-                    ]
-                },
-            )
-            contact_id = search_response.json().get("results", [{}])[0].get("id")
-
-            if contact_id:
-                response = requests.patch(
-                    f"{base_url}/{contact_id}",
-                    headers=headers,
-                    json={"properties": input_data.contact_data},
-                )
-                result = response.json()
-                yield "contact", result
-                yield "status", "updated"
-            else:
-                yield "contact", {}
-                yield "status", "contact_not_found"