Remove replicated code

.deepsource.toml

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

.dockerignore

@@ -1,61 +1,40 @@
 # Ignore everything by default, selectively add things to context
-*
+classic/run
 
-# Platform - Libs
-!autogpt_platform/autogpt_libs/autogpt_libs/
-!autogpt_platform/autogpt_libs/pyproject.toml
-!autogpt_platform/autogpt_libs/poetry.lock
-!autogpt_platform/autogpt_libs/README.md
-
-# Platform - Backend
-!autogpt_platform/backend/backend/
-!autogpt_platform/backend/migrations/
-!autogpt_platform/backend/schema.prisma
-!autogpt_platform/backend/pyproject.toml
-!autogpt_platform/backend/poetry.lock
-!autogpt_platform/backend/README.md
-
-# Platform - Market
-!autogpt_platform/market/market/
-!autogpt_platform/market/scripts.py
-!autogpt_platform/market/schema.prisma
-!autogpt_platform/market/pyproject.toml
-!autogpt_platform/market/poetry.lock
-!autogpt_platform/market/README.md
-
-# Platform - Frontend
-!autogpt_platform/frontend/src/
-!autogpt_platform/frontend/public/
-!autogpt_platform/frontend/package.json
-!autogpt_platform/frontend/pnpm-lock.yaml
-!autogpt_platform/frontend/tsconfig.json
-!autogpt_platform/frontend/README.md
-## config
-!autogpt_platform/frontend/*.config.*
-!autogpt_platform/frontend/.env.*
-
-# Classic - AutoGPT
+# AutoGPT
 !classic/original_autogpt/autogpt/
 !classic/original_autogpt/pyproject.toml
 !classic/original_autogpt/poetry.lock
 !classic/original_autogpt/README.md
 !classic/original_autogpt/tests/
 
-# Classic - Benchmark
+# Benchmark
 !classic/benchmark/agbenchmark/
 !classic/benchmark/pyproject.toml
 !classic/benchmark/poetry.lock
 !classic/benchmark/README.md
 
-# Classic - Forge
+# Forge
 !classic/forge/
 !classic/forge/pyproject.toml
 !classic/forge/poetry.lock
 !classic/forge/README.md
 
-# Classic - Frontend
+# Frontend
 !classic/frontend/build/web/
 
+# Platform
+!autogpt_platform/
+
 # Explicitly re-ignore some folders
 .*
 **/__pycache__
+
+autogpt_platform/frontend/.next/
+autogpt_platform/frontend/node_modules
+autogpt_platform/frontend/.env.example
+autogpt_platform/frontend/.env.local
+autogpt_platform/backend/.env
+autogpt_platform/backend/.venv/
+
+autogpt_platform/market/.env

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,38 +1,36 @@
+### 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**)
+- 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>
-  <summary>Examples of configuration changes</summary>
+### Configuration Changes 📝
+> [!NOTE] 
+Only for the new autogpt platform, currently in autogpt_platform/
 
-  - 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>
+If you're making configuration or infrastructure changes, please remember to check you've updated the related infrastructure code in the autogpt_platform/infra folder.
+
+Examples of such changes might include: 
+
+- Changing ports
+- Adding new services that need to communicate with each other
+- Secrets or environment variable changes
+- New or infrastructure changes such as databases

.github/dependabot.yml

@@ -7,22 +7,17 @@ updates:
       interval: "weekly"
     open-pull-requests-limit: 10
     target-branch: "dev"
-    commit-message:
-      prefix: "chore(libs/deps)"
-      prefix-development: "chore(libs/deps-dev)"
-    ignore:
-      - dependency-name: "poetry"
     groups:
       production-dependencies:
         dependency-type: "production"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
 
   # backend (Poetry project)
   - package-ecosystem: "pip"
@@ -31,22 +26,18 @@ updates:
       interval: "weekly"
     open-pull-requests-limit: 10
     target-branch: "dev"
-    commit-message:
-      prefix: "chore(backend/deps)"
-      prefix-development: "chore(backend/deps-dev)"
-    ignore:
-      - dependency-name: "poetry"
     groups:
       production-dependencies:
         dependency-type: "production"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
+
 
   # frontend (Next.js project)
   - package-ecosystem: "npm"
@@ -55,20 +46,18 @@ updates:
       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"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
+
 
   # infra (Terraform)
   - package-ecosystem: "terraform"
@@ -77,21 +66,38 @@ updates:
       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"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
+
+
+  # market (Poetry project)
+  - package-ecosystem: "pip"
+    directory: "autogpt_platform/market"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 10
+    target-branch: "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"
@@ -104,13 +110,14 @@ updates:
       production-dependencies:
         dependency-type: "production"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
+
 
   # Docker
   - package-ecosystem: "docker"
@@ -123,31 +130,50 @@ updates:
       production-dependencies:
         dependency-type: "production"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
+
+
+  # Submodules
+  - package-ecosystem: "gitsubmodule"
+    directory: "autogpt_platform/supabase"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 1
+    target-branch: "dev"
+    groups:
+      production-dependencies:
+        dependency-type: "production"
+        update-types:
+        - "minor"
+        - "patch"
+      development-dependencies:
+        dependency-type: "development"
+        update-types:
+        - "minor"
+        - "patch"
+
 
   # Docs
-  - package-ecosystem: "pip"
+  - 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"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"

.github/labeler.yml

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

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

@@ -115,7 +115,6 @@ jobs:
           poetry run pytest -vv \
             --cov=autogpt --cov-branch --cov-report term-missing --cov-report xml \
             --numprocesses=logical --durations=10 \
-            --junitxml=junit.xml -o junit_family=legacy \
             tests/unit tests/integration
         env:
           CI: true
@@ -125,14 +124,8 @@ jobs:
           AWS_ACCESS_KEY_ID: minioadmin
           AWS_SECRET_ACCESS_KEY: minioadmin
 
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}  # Run even if tests fail
-        uses: codecov/test-results-action@v1
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           flags: autogpt-agent,${{ runner.os }}

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

@@ -5,7 +5,7 @@ on:
     - cron: 20 4 * * 1,4
 
 env:
-  BASE_BRANCH: dev
+  BASE_BRANCH: development
   IMAGE_NAME: auto-gpt
 
 jobs:
@@ -15,46 +15,46 @@ jobs:
       matrix:
         build-type: [release, dev]
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+    - name: Checkout repository
+      uses: actions/checkout@v4
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
 
-      - id: build
-        name: Build image
-        uses: docker/build-push-action@v6
-        with:
-          context: classic/
-          file: classic/Dockerfile.autogpt
-          build-args: BUILD_TYPE=${{ matrix.build-type }}
-          load: true # save to docker images
-          # use GHA cache as read-only
-          cache-to: type=gha,scope=autogpt-docker-${{ matrix.build-type }},mode=max
+    - id: build
+      name: Build image
+      uses: docker/build-push-action@v5
+      with:
+        context: classic/
+        file: classic/Dockerfile.autogpt
+        build-args: BUILD_TYPE=${{ matrix.build-type }}
+        load: true    # save to docker images
+        # use GHA cache as read-only
+        cache-to: type=gha,scope=autogpt-docker-${{ matrix.build-type }},mode=max
 
-      - name: Generate build report
-        env:
-          event_name: ${{ github.event_name }}
-          event_ref: ${{ github.event.schedule }}
+    - name: Generate build report
+      env:
+        event_name: ${{ github.event_name }}
+        event_ref: ${{ github.event.schedule }}
 
-          build_type: ${{ matrix.build-type }}
+        build_type: ${{ matrix.build-type }}
 
-          prod_branch: master
-          dev_branch: dev
-          repository: ${{ github.repository }}
-          base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'dev' && 'dev' || 'master' }}
+        prod_branch: master
+        dev_branch: development
+        repository: ${{ github.repository }}
+        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'development' && 'development' || 'master' }}
 
-          current_ref: ${{ github.ref_name }}
-          commit_hash: ${{ github.sha }}
-          source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.sha) }}
-          push_forced_label:
+        current_ref: ${{ github.ref_name }}
+        commit_hash: ${{ github.sha }}
+        source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.sha) }}
+        push_forced_label:
 
-          new_commits_json: ${{ null }}
-          compare_url_template: ${{ format('/{0}/compare/{{base}}...{{head}}', github.repository) }}
+        new_commits_json: ${{ null }}
+        compare_url_template: ${{ format('/{0}/compare/{{base}}...{{head}}', github.repository) }}
 
-          github_context_json: ${{ toJSON(github) }}
-          job_env_json: ${{ toJSON(env) }}
-          vars_json: ${{ toJSON(vars) }}
+        github_context_json: ${{ toJSON(github) }}
+        job_env_json: ${{ toJSON(env) }}
+        vars_json: ${{ toJSON(vars) }}
 
-        run: .github/workflows/scripts/docker-ci-summary.sh >> $GITHUB_STEP_SUMMARY
-        continue-on-error: true
+      run: .github/workflows/scripts/docker-ci-summary.sh >> $GITHUB_STEP_SUMMARY
+      continue-on-error: true

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

@@ -2,7 +2,7 @@ name: Classic - AutoGPT Docker CI
 
 on:
   push:
-    branches: [master, dev]
+    branches: [ master, development ]
     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-benchmark-ci.yml

@@ -87,20 +87,13 @@ jobs:
           poetry run pytest -vv \
             --cov=agbenchmark --cov-branch --cov-report term-missing --cov-report xml \
             --durations=10 \
-            --junitxml=junit.xml -o junit_family=legacy \
             tests
         env:
           CI: true
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
 
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}  # Run even if tests fail
-        uses: codecov/test-results-action@v1
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           flags: agbenchmark,${{ runner.os }}
@@ -109,7 +102,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        agent-name: [forge]
+        agent-name: [ forge ]
       fail-fast: false
     timeout-minutes: 20
     steps:
@@ -153,23 +146,23 @@ jobs:
           echo "Running the following command: poetry run agbenchmark --mock --category=coding"
           poetry run agbenchmark --mock --category=coding
 
-          # echo "Running the following command: poetry run agbenchmark --test=WriteFile"
-          # poetry run agbenchmark --test=WriteFile
+          echo "Running the following command: poetry run agbenchmark --test=WriteFile"
+          poetry run agbenchmark --test=WriteFile
           cd ../benchmark
           poetry install
           echo "Adding the BUILD_SKILL_TREE environment variable. This will attempt to add new elements in the skill tree. If new elements are added, the CI fails because they should have been pushed"
           export BUILD_SKILL_TREE=true
 
-          # poetry run agbenchmark --mock
+          poetry run agbenchmark --mock
 
-          # CHANGED=$(git diff --name-only | grep -E '(agbenchmark/challenges)|(../classic/frontend/assets)') || echo "No diffs"
-          # if [ ! -z "$CHANGED" ]; then
-          #   echo "There are unstaged changes please run agbenchmark and commit those changes since they are needed."
-          #   echo "$CHANGED"
-          #   exit 1
-          # else
-          #   echo "No unstaged changes."
-          # fi
+          CHANGED=$(git diff --name-only | grep -E '(agbenchmark/challenges)|(../classic/frontend/assets)') || echo "No diffs"
+          if [ ! -z "$CHANGED" ]; then
+            echo "There are unstaged changes please run agbenchmark and commit those changes since they are needed."
+            echo "$CHANGED"
+            exit 1
+          else
+            echo "No unstaged changes."
+          fi
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
           TELEMETRY_ENVIRONMENT: autogpt-benchmark-ci

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

@@ -139,7 +139,6 @@ jobs:
           poetry run pytest -vv \
             --cov=forge --cov-branch --cov-report term-missing --cov-report xml \
             --durations=10 \
-            --junitxml=junit.xml -o junit_family=legacy \
             forge
         env:
           CI: true
@@ -149,14 +148,8 @@ jobs:
           AWS_ACCESS_KEY_ID: minioadmin
           AWS_SECRET_ACCESS_KEY: minioadmin
 
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}  # Run even if tests fail
-        uses: codecov/test-results-action@v1
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           flags: forge,${{ runner.os }}

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

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

.github/workflows/claude.yml

@@ -1,47 +0,0 @@
-name: Claude Code
-
-on:
-  issue_comment:
-    types: [created]
-  pull_request_review_comment:
-    types: [created]
-  issues:
-    types: [opened, assigned]
-  pull_request_review:
-    types: [submitted]
-
-jobs:
-  claude:
-    if: |
-      (
-        (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
-        (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
-        (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
-        (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
-      ) && (
-        github.event.comment.author_association == 'OWNER' ||
-        github.event.comment.author_association == 'MEMBER' ||
-        github.event.comment.author_association == 'COLLABORATOR' ||
-        github.event.review.author_association == 'OWNER' ||
-        github.event.review.author_association == 'MEMBER' ||
-        github.event.review.author_association == 'COLLABORATOR' ||
-        github.event.issue.author_association == 'OWNER' ||
-        github.event.issue.author_association == 'MEMBER' ||
-        github.event.issue.author_association == 'COLLABORATOR'
-      )
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: read
-      issues: read
-      id-token: write
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 1
-      - name: Run Claude Code
-        id: claude
-        uses: anthropics/claude-code-action@beta
-        with:
-          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}

.github/workflows/codeql.yml

@@ -16,7 +16,6 @@ on:
     branches: [ "master", "release-*", "dev" ]
   pull_request:
     branches: [ "master", "release-*", "dev" ]
-  merge_group:
   schedule:
     - cron: '15 4 * * 0'
 

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

@@ -1,4 +1,4 @@
-name: AutoGPT Platform - Deploy Prod Environment
+name: AutoGPT Platform - Build, Push, and Deploy Prod Environment
 
 on:
   release:
@@ -8,6 +8,12 @@ permissions:
   contents: 'read'
   id-token: 'write'
 
+env:
+  PROJECT_ID: ${{ secrets.GCP_PROJECT_ID }}
+  GKE_CLUSTER: prod-gke-cluster
+  GKE_ZONE: us-central1-a
+  NAMESPACE: prod-agpt
+
 jobs:
   migrate:
     environment: production
@@ -34,17 +40,143 @@ jobs:
           python -m prisma migrate deploy
         env:
           DATABASE_URL: ${{ secrets.BACKEND_DATABASE_URL }}
-          DIRECT_URL: ${{ secrets.BACKEND_DATABASE_URL }}
 
+      - name: Run Market Migrations
+        working-directory: ./autogpt_platform/market
+        run: |
+          python -m prisma migrate deploy
+        env:
+          DATABASE_URL: ${{ secrets.MARKET_DATABASE_URL }}
           
-  trigger:
-    needs: migrate
+  build-push-deploy:
+    environment: production
+    name: Build, Push, and Deploy
     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 }}"}'
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - id: 'auth'
+      uses: 'google-github-actions/auth@v2'
+      with:
+        workload_identity_provider: 'projects/1021527134101/locations/global/workloadIdentityPools/prod-pool/providers/github'
+        service_account: 'prod-github-actions-sa@agpt-prod.iam.gserviceaccount.com'
+        token_format: 'access_token'
+        create_credentials_file: true
+
+    - name: 'Set up Cloud SDK'
+      uses: 'google-github-actions/setup-gcloud@v2'
+
+    - name: 'Configure Docker'
+      run: |
+        gcloud auth configure-docker us-east1-docker.pkg.dev
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Cache Docker layers
+      uses: actions/cache@v4
+      with:
+        path: /tmp/.buildx-cache
+        key: ${{ runner.os }}-buildx-${{ github.sha }}
+        restore-keys: |
+          ${{ runner.os }}-buildx-
+
+    - name: Check for changes
+      id: check_changes
+      run: |
+        git fetch origin master
+        BACKEND_CHANGED=$(git diff --name-only origin/master HEAD | grep "^autogpt_platform/backend/" && echo "true" || echo "false")
+        FRONTEND_CHANGED=$(git diff --name-only origin/master HEAD | grep "^autogpt_platform/frontend/" && echo "true" || echo "false")
+        MARKET_CHANGED=$(git diff --name-only origin/master HEAD | grep "^autogpt_platform/market/" && echo "true" || echo "false")
+        echo "backend_changed=$BACKEND_CHANGED" >> $GITHUB_OUTPUT
+        echo "frontend_changed=$FRONTEND_CHANGED" >> $GITHUB_OUTPUT
+        echo "market_changed=$MARKET_CHANGED" >> $GITHUB_OUTPUT
+
+    - name: Get GKE credentials
+      uses: 'google-github-actions/get-gke-credentials@v2'
+      with:
+        cluster_name: ${{ env.GKE_CLUSTER }}
+        location: ${{ env.GKE_ZONE }}
+
+    - name: Build and Push Backend
+      if: steps.check_changes.outputs.backend_changed == 'true'
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./autogpt_platform/backend/Dockerfile
+        push: true
+        tags: us-east1-docker.pkg.dev/agpt-prod/agpt-backend-prod/agpt-backend-prod:${{ github.sha }}
+        cache-from: type=local,src=/tmp/.buildx-cache
+        cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+    - name: Build and Push Frontend
+      if: steps.check_changes.outputs.frontend_changed == 'true'
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./autogpt_platform/frontend/Dockerfile
+        push: true
+        tags: us-east1-docker.pkg.dev/agpt-prod/agpt-frontend-prod/agpt-frontend-prod:${{ github.sha }}
+        cache-from: type=local,src=/tmp/.buildx-cache
+        cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+    - name: Build and Push Market
+      if: steps.check_changes.outputs.market_changed == 'true'
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./autogpt_platform/market/Dockerfile
+        push: true
+        tags: us-east1-docker.pkg.dev/agpt-prod/agpt-market-prod/agpt-market-prod:${{ github.sha }}
+        cache-from: type=local,src=/tmp/.buildx-cache
+        cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+    - name: Move cache
+      run: |
+        rm -rf /tmp/.buildx-cache
+        mv /tmp/.buildx-cache-new /tmp/.buildx-cache
+
+    - name: Set up Helm
+      uses: azure/setup-helm@v4
+      with:
+        version: v3.4.0
+
+    - name: Deploy Backend
+      if: steps.check_changes.outputs.backend_changed == 'true'
+      run: |
+        helm upgrade autogpt-server ./autogpt-server \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-server/values.yaml \
+          -f autogpt-server/values.prod.yaml \
+          --set image.tag=${{ github.sha }}
+
+    - name: Deploy Websocket
+      if: steps.check_changes.outputs.backend_changed == 'true'
+      run: |
+        helm upgrade autogpt-websocket-server ./autogpt-websocket-server \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-websocket-server/values.yaml \
+          -f autogpt-websocket-server/values.prod.yaml \
+          --set image.tag=${{ github.sha }}
+
+    - name: Deploy Market
+      if: steps.check_changes.outputs.market_changed == 'true'
+      run: |
+        helm upgrade autogpt-market ./autogpt-market \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-market/values.yaml \
+          -f autogpt-market/values.prod.yaml \
+          --set image.tag=${{ github.sha }}
+
+    - name: Deploy Frontend
+      if: steps.check_changes.outputs.frontend_changed == 'true'
+      run: |
+        helm upgrade autogpt-builder ./autogpt-builder \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-builder/values.yaml \
+          -f autogpt-builder/values.prod.yaml \
+          --set image.tag=${{ github.sha }}

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

@@ -1,51 +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 }}
-          DIRECT_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-deploy.yaml

@@ -0,0 +1,186 @@
+name: AutoGPT Platform - Build, Push, and Deploy Dev Environment
+
+on:
+  push:
+    branches: [ dev ]
+    paths:
+      - 'autogpt_platform/backend/**'
+      - 'autogpt_platform/frontend/**'
+      - 'autogpt_platform/market/**'
+
+permissions:
+  contents: 'read'
+  id-token: 'write'
+
+env:
+  PROJECT_ID: ${{ secrets.GCP_PROJECT_ID }}
+  GKE_CLUSTER: dev-gke-cluster
+  GKE_ZONE: us-central1-a
+  NAMESPACE: dev-agpt
+
+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 }}
+
+      - name: Run Market Migrations
+        working-directory: ./autogpt_platform/market
+        run: |
+          python -m prisma migrate deploy
+        env:
+          DATABASE_URL: ${{ secrets.MARKET_DATABASE_URL }}
+
+  build-push-deploy:
+    name: Build, Push, and Deploy
+    needs: migrate
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - id: 'auth'
+      uses: 'google-github-actions/auth@v2'
+      with:
+        workload_identity_provider: 'projects/638488734936/locations/global/workloadIdentityPools/dev-pool/providers/github'
+        service_account: 'dev-github-actions-sa@agpt-dev.iam.gserviceaccount.com'
+        token_format: 'access_token'
+        create_credentials_file: true
+
+    - name: 'Set up Cloud SDK'
+      uses: 'google-github-actions/setup-gcloud@v2'
+
+    - name: 'Configure Docker'
+      run: |
+        gcloud auth configure-docker us-east1-docker.pkg.dev
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Cache Docker layers
+      uses: actions/cache@v4
+      with:
+        path: /tmp/.buildx-cache
+        key: ${{ runner.os }}-buildx-${{ github.sha }}
+        restore-keys: |
+          ${{ runner.os }}-buildx-
+
+    - name: Check for changes
+      id: check_changes
+      run: |
+        git fetch origin dev
+        BACKEND_CHANGED=$(git diff --name-only origin/dev HEAD | grep "^autogpt_platform/backend/" && echo "true" || echo "false")
+        FRONTEND_CHANGED=$(git diff --name-only origin/dev HEAD | grep "^autogpt_platform/frontend/" && echo "true" || echo "false")
+        MARKET_CHANGED=$(git diff --name-only origin/dev HEAD | grep "^autogpt_platform/market/" && echo "true" || echo "false")
+        echo "backend_changed=$BACKEND_CHANGED" >> $GITHUB_OUTPUT
+        echo "frontend_changed=$FRONTEND_CHANGED" >> $GITHUB_OUTPUT
+        echo "market_changed=$MARKET_CHANGED" >> $GITHUB_OUTPUT
+
+    - name: Get GKE credentials
+      uses: 'google-github-actions/get-gke-credentials@v2'
+      with:
+        cluster_name: ${{ env.GKE_CLUSTER }}
+        location: ${{ env.GKE_ZONE }}
+
+    - name: Build and Push Backend
+      if: steps.check_changes.outputs.backend_changed == 'true'
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./autogpt_platform/backend/Dockerfile
+        push: true
+        tags: us-east1-docker.pkg.dev/agpt-dev/agpt-backend-dev/agpt-backend-dev:${{ github.sha }}
+        cache-from: type=local,src=/tmp/.buildx-cache
+        cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+    - name: Build and Push Frontend
+      if: steps.check_changes.outputs.frontend_changed == 'true'
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./autogpt_platform/frontend/Dockerfile
+        push: true
+        tags: us-east1-docker.pkg.dev/agpt-dev/agpt-frontend-dev/agpt-frontend-dev:${{ github.sha }}
+        cache-from: type=local,src=/tmp/.buildx-cache
+        cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+    - name: Build and Push Market
+      if: steps.check_changes.outputs.market_changed == 'true'
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./autogpt_platform/market/Dockerfile
+        push: true
+        tags: us-east1-docker.pkg.dev/agpt-dev/agpt-market-dev/agpt-market-dev:${{ github.sha }}
+        cache-from: type=local,src=/tmp/.buildx-cache
+        cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+    - name: Move cache
+      run: |
+        rm -rf /tmp/.buildx-cache
+        mv /tmp/.buildx-cache-new /tmp/.buildx-cache
+
+    - name: Set up Helm
+      uses: azure/setup-helm@v4
+      with:
+        version: v3.4.0
+
+    - name: Deploy Backend
+      if: steps.check_changes.outputs.backend_changed == 'true'
+      run: |
+        helm upgrade autogpt-server ./autogpt-server \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-server/values.yaml \
+          -f autogpt-server/values.dev.yaml \
+          --set image.tag=${{ github.sha }}
+
+    - name: Deploy Websocket
+      if: steps.check_changes.outputs.backend_changed == 'true'
+      run: |
+        helm upgrade autogpt-websocket-server ./autogpt-websocket-server \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-websocket-server/values.yaml \
+          -f autogpt-websocket-server/values.dev.yaml \
+          --set image.tag=${{ github.sha }}
+
+    - name: Deploy Market
+      if: steps.check_changes.outputs.market_changed == 'true'
+      run: |
+        helm upgrade autogpt-market ./autogpt-market \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-market/values.yaml \
+          -f autogpt-market/values.dev.yaml \
+          --set image.tag=${{ github.sha }}
+
+    - name: Deploy Frontend
+      if: steps.check_changes.outputs.frontend_changed == 'true'
+      run: |
+        helm upgrade autogpt-builder ./autogpt-builder \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-builder/values.yaml \
+          -f autogpt-builder/values.dev.yaml \
+          --set image.tag=${{ github.sha }}

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

@@ -0,0 +1,56 @@
+name: AutoGPT Platform - Infra
+
+on:
+  push:
+    branches: [ master, dev ]
+    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@v4
+        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
+        with:
+          version: v3.14.4
+
+      - name: Set up chart-testing
+        uses: helm/chart-testing-action@v2.6.1
+
+      - 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

@@ -6,14 +6,11 @@ on:
     paths:
       - ".github/workflows/platform-backend-ci.yml"
       - "autogpt_platform/backend/**"
-      - "autogpt_platform/autogpt_libs/**"
   pull_request:
     branches: [master, dev, 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) }}
@@ -32,7 +29,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.11"]
+        python-version: ["3.10"]
     runs-on: ubuntu-latest
 
     services:
@@ -42,31 +39,6 @@ jobs:
           REDIS_PASSWORD: testpassword
         ports:
           - 6379:6379
-      rabbitmq:
-        image: rabbitmq:3.12-management
-        ports:
-          - 5672:5672
-          - 15672:15672
-        env:
-          RABBITMQ_DEFAULT_USER: ${{ env.RABBITMQ_DEFAULT_USER }}
-          RABBITMQ_DEFAULT_PASS: ${{ env.RABBITMQ_DEFAULT_PASS }}
-      clamav:
-        image: clamav/clamav-debian:latest
-        ports:
-          - 3310:3310
-        env:
-          CLAMAV_NO_FRESHCLAMD: false
-          CLAMD_CONF_StreamMaxLength: 50M
-          CLAMD_CONF_MaxFileSize: 100M
-          CLAMD_CONF_MaxScanSize: 100M
-          CLAMD_CONF_MaxThreads: 4
-          CLAMD_CONF_ReadTimeout: 300
-        options: >-
-          --health-cmd "clamdscan --version || exit 1"
-          --health-interval 30s
-          --health-timeout 10s
-          --health-retries 5
-          --health-start-period 180s
 
     steps:
       - name: Checkout repository
@@ -83,7 +55,7 @@ jobs:
       - name: Setup Supabase
         uses: supabase/setup-cli@v1
         with:
-          version: 1.178.1
+          version: latest
 
       - id: get_date
         name: Get date
@@ -97,40 +69,12 @@ jobs:
 
       - name: Install Poetry (Unix)
         run: |
-          # Extract Poetry version from backend/poetry.lock
-          HEAD_POETRY_VERSION=$(python ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          echo "Found Poetry version ${HEAD_POETRY_VERSION} in backend/poetry.lock"
-
-          if [ -n "$BASE_REF" ]; then
-            BASE_BRANCH=${BASE_REF/refs\/heads\//}
-            BASE_POETRY_VERSION=$((git show "origin/$BASE_BRANCH":./poetry.lock; true) | python ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry -)
-            echo "Found Poetry version ${BASE_POETRY_VERSION} in backend/poetry.lock on ${BASE_REF}"
-            POETRY_VERSION=$(printf '%s\n' "$HEAD_POETRY_VERSION" "$BASE_POETRY_VERSION" | sort -V | tail -n1)
-          else
-            POETRY_VERSION=$HEAD_POETRY_VERSION
-          fi
-          echo "Using Poetry version ${POETRY_VERSION}"
-
-          # Install Poetry
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$POETRY_VERSION python3 -
+          curl -sSL https://install.python-poetry.org | python3 -
 
           if [ "${{ runner.os }}" = "macOS" ]; then
             PATH="$HOME/.local/bin:$PATH"
             echo "$HOME/.local/bin" >> $GITHUB_PATH
           fi
-        env:
-          BASE_REF: ${{ github.base_ref || github.event.merge_group.base_ref }}
-
-      - name: Check poetry.lock
-        run: |
-          poetry lock
-
-          if ! git diff --quiet --ignore-matching-lines="^# " poetry.lock; then
-            echo "Error: poetry.lock not up to date."
-            echo
-            git diff poetry.lock
-            exit 1
-          fi
 
       - name: Install Python dependencies
         run: poetry install
@@ -148,40 +92,10 @@ jobs:
         # outputs:
         # DB_URL, API_URL, GRAPHQL_URL, ANON_KEY, SERVICE_ROLE_KEY, JWT_SECRET
 
-      - name: Wait for ClamAV to be ready
-        run: |
-          echo "Waiting for ClamAV daemon to start..."
-          max_attempts=60
-          attempt=0
-          
-          until nc -z localhost 3310 || [ $attempt -eq $max_attempts ]; do
-            echo "ClamAV is unavailable - sleeping (attempt $((attempt+1))/$max_attempts)"
-            sleep 5
-            attempt=$((attempt+1))
-          done
-          
-          if [ $attempt -eq $max_attempts ]; then
-            echo "ClamAV failed to start after $((max_attempts*5)) seconds"
-            echo "Checking ClamAV service logs..."
-            docker logs $(docker ps -q --filter "ancestor=clamav/clamav-debian:latest") 2>&1 | tail -50 || echo "No ClamAV container found"
-            exit 1
-          fi
-          
-          echo "ClamAV is ready!"
-          
-          # Verify ClamAV is responsive
-          echo "Testing ClamAV connection..."
-          timeout 10 bash -c 'echo "PING" | nc localhost 3310' || {
-            echo "ClamAV is not responding to PING"
-            docker logs $(docker ps -q --filter "ancestor=clamav/clamav-debian:latest") 2>&1 | tail -50 || echo "No ClamAV container found"
-            exit 1
-          }
-
       - name: Run Database Migrations
         run: poetry run prisma migrate dev --name updates
         env:
           DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
-          DIRECT_URL: ${{ steps.supabase.outputs.DB_URL }}
 
       - id: lint
         name: Run Linter
@@ -190,22 +104,20 @@ 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
+            poetry run pytest -s -vv -o log_cli=true -o log_cli_level=DEBUG test
           else
-            poetry run pytest -s -vv
+            poetry run pytest -s -vv test
           fi
         if: success() || (failure() && steps.lint.outcome == 'failure')
         env:
           LOG_LEVEL: ${{ runner.debug && 'DEBUG' || 'INFO' }}
           DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
-          DIRECT_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"
-          ENCRYPTION_KEY: "dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw=" # DO NOT USE IN PRODUCTION!!
+          REDIS_HOST: 'localhost'
+          REDIS_PORT: '6379'
+          REDIS_PASSWORD: 'testpassword'
 
     env:
       CI: true
@@ -213,13 +125,6 @@ jobs:
       RUN_ENV: local
       PORT: 8080
       OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-      # We know these are here, don't report this as a security vulnerability
-      # This is used as the default credential for the entire system's RabbitMQ instance
-      # If you want to replace this, you can do so by making our entire system generate
-      # new credentials for each local user and update the environment variables in
-      # the backend service, docker composes, and examples
-      RABBITMQ_DEFAULT_USER: "rabbitmq_user_default"
-      RABBITMQ_DEFAULT_PASS: "k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7"
 
       # - name: Upload coverage reports to Codecov
       #   uses: codecov/codecov-action@v4

.github/workflows/platform-dev-deploy-event-dispatcher.yml

@@ -1,198 +0,0 @@
-name: AutoGPT Platform - Dev Deploy PR Event Dispatcher
-
-on:
-  pull_request:
-    types: [closed]
-  issue_comment:
-    types: [created]
-
-permissions:
-  issues: write
-  pull-requests: write
-
-jobs:
-  dispatch:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check comment permissions and deployment status
-        id: check_status
-        if: github.event_name == 'issue_comment' && github.event.issue.pull_request
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const commentBody = context.payload.comment.body.trim();
-            const commentUser = context.payload.comment.user.login;
-            const prAuthor = context.payload.issue.user.login;
-            const authorAssociation = context.payload.comment.author_association;
-            
-            // Check permissions
-            const hasPermission = (
-              authorAssociation === 'OWNER' ||
-              authorAssociation === 'MEMBER' ||
-              authorAssociation === 'COLLABORATOR'
-            );
-            
-            core.setOutput('comment_body', commentBody);
-            core.setOutput('has_permission', hasPermission);
-            
-            if (!hasPermission && (commentBody === '!deploy' || commentBody === '!undeploy')) {
-              core.setOutput('permission_denied', 'true');
-              return;
-            }
-            
-            if (commentBody !== '!deploy' && commentBody !== '!undeploy') {
-              return;
-            }
-            
-            // Process deploy command
-            if (commentBody === '!deploy') {
-              core.setOutput('should_deploy', 'true');
-            }
-            // Process undeploy command
-            else if (commentBody === '!undeploy') {
-              core.setOutput('should_undeploy', 'true');
-            }
-
-      - name: Post permission denied comment
-        if: steps.check_status.outputs.permission_denied == 'true'
-        uses: actions/github-script@v7
-        with:
-          script: |
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              body: `❌ **Permission denied**: Only the repository owners, members, or collaborators can use deployment commands.`
-            });
-
-      - name: Get PR details for deployment
-        id: pr_details
-        if: steps.check_status.outputs.should_deploy == 'true' || steps.check_status.outputs.should_undeploy == 'true'
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const pr = await github.rest.pulls.get({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              pull_number: context.issue.number
-            });
-            core.setOutput('pr_number', pr.data.number);
-            core.setOutput('pr_title', pr.data.title);
-            core.setOutput('pr_state', pr.data.state);
-          
-      - name: Dispatch Deploy Event
-        if: steps.check_status.outputs.should_deploy == 'true'
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          token: ${{ secrets.DISPATCH_TOKEN }}
-          repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
-          event-type: pr-event
-          client-payload: |
-            {
-              "action": "deploy",
-              "pr_number": "${{ steps.pr_details.outputs.pr_number }}",
-              "pr_title": "${{ steps.pr_details.outputs.pr_title }}",
-              "pr_state": "${{ steps.pr_details.outputs.pr_state }}",
-              "repo": "${{ github.repository }}"
-            }
-
-      - name: Post deploy success comment
-        if: steps.check_status.outputs.should_deploy == 'true'
-        uses: actions/github-script@v7
-        with:
-          script: |
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              body: `🚀 **Deploying PR #${{ steps.pr_details.outputs.pr_number }}** to development environment...`
-            });
-
-      - name: Dispatch Undeploy Event (from comment)
-        if: steps.check_status.outputs.should_undeploy == 'true'
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          token: ${{ secrets.DISPATCH_TOKEN }}
-          repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
-          event-type: pr-event
-          client-payload: |
-            {
-              "action": "undeploy",
-              "pr_number": "${{ steps.pr_details.outputs.pr_number }}",
-              "pr_title": "${{ steps.pr_details.outputs.pr_title }}",
-              "pr_state": "${{ steps.pr_details.outputs.pr_state }}",
-              "repo": "${{ github.repository }}"
-            }
-
-      - name: Post undeploy success comment
-        if: steps.check_status.outputs.should_undeploy == 'true'
-        uses: actions/github-script@v7
-        with:
-          script: |
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              body: `🗑️ **Undeploying PR #${{ steps.pr_details.outputs.pr_number }}** from development environment...`
-            });
-
-      - name: Check deployment status on PR close
-        id: check_pr_close
-        if: github.event_name == 'pull_request' && github.event.action == 'closed'
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const comments = await github.rest.issues.listComments({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number
-            });
-            
-            let lastDeployIndex = -1;
-            let lastUndeployIndex = -1;
-            
-            comments.data.forEach((comment, index) => {
-              if (comment.body.trim() === '!deploy') {
-                lastDeployIndex = index;
-              } else if (comment.body.trim() === '!undeploy') {
-                lastUndeployIndex = index;
-              }
-            });
-            
-            // Should undeploy if there's a !deploy without a subsequent !undeploy
-            const shouldUndeploy = lastDeployIndex !== -1 && lastDeployIndex > lastUndeployIndex;
-            core.setOutput('should_undeploy', shouldUndeploy);
-            
-      - name: Dispatch Undeploy Event (PR closed with active deployment)
-        if: >-
-          github.event_name == 'pull_request' &&
-          github.event.action == 'closed' &&
-          steps.check_pr_close.outputs.should_undeploy == 'true'
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          token: ${{ secrets.DISPATCH_TOKEN }}
-          repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
-          event-type: pr-event
-          client-payload: |
-            {
-              "action": "undeploy",
-              "pr_number": "${{ github.event.pull_request.number }}",
-              "pr_title": "${{ github.event.pull_request.title }}",
-              "pr_state": "${{ github.event.pull_request.state }}",
-              "repo": "${{ github.repository }}"
-            }
-
-      - name: Post PR close undeploy comment
-        if: >-
-          github.event_name == 'pull_request' &&
-          github.event.action == 'closed' &&
-          steps.check_pr_close.outputs.should_undeploy == 'true'
-        uses: actions/github-script@v7
-        with:
-          script: |
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              body: `🧹 **Auto-undeploying**: PR closed with active deployment. Cleaning up development environment for PR #${{ github.event.pull_request.number }}.`
-            });

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

@@ -10,7 +10,6 @@ on:
     paths:
       - ".github/workflows/platform-frontend-ci.yml"
       - "autogpt_platform/frontend/**"
-  merge_group:
 
 defaults:
   run:
@@ -18,146 +17,44 @@ defaults:
     working-directory: autogpt_platform/frontend
 
 jobs:
-  setup:
-    runs-on: ubuntu-latest
-    outputs:
-      cache-key: ${{ steps.cache-key.outputs.key }}
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "21"
-
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Generate cache key
-        id: cache-key
-        run: echo "key=${{ runner.os }}-pnpm-${{ hashFiles('**/pnpm-lock.yaml') }}" >> $GITHUB_OUTPUT
-
-      - name: Cache dependencies
-        uses: actions/cache@v4
-        with:
-          path: ~/.pnpm-store
-          key: ${{ steps.cache-key.outputs.key }}
-          restore-keys: |
-            ${{ runner.os }}-pnpm-
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
   lint:
     runs-on: ubuntu-latest
-    needs: setup
 
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
+      - uses: actions/checkout@v4
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
           node-version: "21"
 
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Restore dependencies cache
-        uses: actions/cache@v4
-        with:
-          path: ~/.pnpm-store
-          key: ${{ needs.setup.outputs.cache-key }}
-          restore-keys: |
-            ${{ runner.os }}-pnpm-
-
       - name: Install dependencies
-        run: pnpm install --frozen-lockfile
+        run: |
+          yarn install --frozen-lockfile
 
       - name: Run lint
-        run: pnpm lint
-
-  type-check:
-    runs-on: ubuntu-latest
-    needs: setup
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "21"
-
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Restore dependencies cache
-        uses: actions/cache@v4
-        with:
-          path: ~/.pnpm-store
-          key: ${{ needs.setup.outputs.cache-key }}
-          restore-keys: |
-            ${{ runner.os }}-pnpm-
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run tsc check
-        run: pnpm type-check
-
-  chromatic:
-    runs-on: ubuntu-latest
-    needs: setup
-    # Only run on dev branch pushes or PRs targeting dev
-    if: github.ref == 'refs/heads/dev' || github.base_ref == 'dev'
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "21"
-
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Restore dependencies cache
-        uses: actions/cache@v4
-        with:
-          path: ~/.pnpm-store
-          key: ${{ needs.setup.outputs.cache-key }}
-          restore-keys: |
-            ${{ runner.os }}-pnpm-
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run Chromatic
-        uses: chromaui/action@latest
-        with:
-          projectToken: chpt_9e7c1a76478c9c8
-          onlyChanged: true
-          workingDir: autogpt_platform/frontend
-          token: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          yarn lint
 
   test:
     runs-on: ubuntu-latest
-    needs: setup
-    strategy:
-      fail-fast: false
-      matrix:
-        browser: [chromium, webkit]
 
     steps:
+      - name: Free Disk Space (Ubuntu)
+        uses: jlumbroso/free-disk-space@main
+        with:
+          # this might remove tools that are actually needed,
+          # if set to "true" but frees about 6 GB
+          tool-cache: false
+
+          # all of these default to true, but feel free to set to
+          # "false" if necessary for your workflow
+          android: false
+          dotnet: false
+          haskell: false
+          large-packages: true
+          docker-images: true
+          swap-storage: true
+
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
@@ -168,60 +65,32 @@ jobs:
         with:
           node-version: "21"
 
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
-        with:
-          large-packages: false # slow
-          docker-images: false # limited benefit
-
       - name: Copy default supabase .env
         run: |
-          cp ../.env.example ../.env
-
-      - name: Copy backend .env
-        run: |
-          cp ../backend/.env.example ../backend/.env
+          cp ../supabase/docker/.env.example ../.env
 
       - name: Run docker compose
         run: |
           docker compose -f ../docker-compose.yml up -d
 
-      - name: Restore dependencies cache
-        uses: actions/cache@v4
-        with:
-          path: ~/.pnpm-store
-          key: ${{ needs.setup.outputs.cache-key }}
-          restore-keys: |
-            ${{ runner.os }}-pnpm-
-
       - name: Install dependencies
-        run: pnpm install --frozen-lockfile
+        run: |
+          yarn install --frozen-lockfile
 
-      - name: Setup .env
-        run: cp .env.example .env
+      - name: Setup Builder .env
+        run: |
+          cp .env.example .env
 
-      - name: Build frontend
-        run: pnpm build --turbo
-        # uses Turbopack, much faster and safe enough for a test pipeline
+      - name: Install Playwright Browsers
+        run: yarn playwright install --with-deps
 
-      - name: Install Browser '${{ matrix.browser }}'
-        run: pnpm playwright install --with-deps ${{ matrix.browser }}
-
-      - name: Run Playwright tests
-        run: pnpm test:no-build --project=${{ matrix.browser }}
-        env:
-          BROWSER_TYPE: ${{ matrix.browser }}
-
-      - name: Print Final Docker Compose logs
-        if: always()
-        run: docker compose -f ../docker-compose.yml logs
+      - name: Run tests
+        run: |
+          yarn test
 
       - uses: actions/upload-artifact@v4
         if: ${{ !cancelled() }}
         with:
-          name: playwright-report-${{ matrix.browser }}
+          name: playwright-report
           path: playwright-report/
           retention-days: 30

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

@@ -0,0 +1,125 @@
+name: AutoGPT Platform - Backend CI
+
+on:
+  push:
+    branches: [master, dev, ci-test*]
+    paths:
+      - ".github/workflows/platform-market-ci.yml"
+      - "autogpt_platform/market/**"
+  pull_request:
+    branches: [master, dev, release-*]
+    paths:
+      - ".github/workflows/platform-market-ci.yml"
+      - "autogpt_platform/market/**"
+
+concurrency:
+  group: ${{ format('backend-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
+  cancel-in-progress: ${{ startsWith(github.event_name, 'pull_request') }}
+
+defaults:
+  run:
+    shell: bash
+    working-directory: autogpt_platform/market
+
+jobs:
+  test:
+    permissions:
+      contents: read
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10"]
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Setup Supabase
+        uses: supabase/setup-cli@v1
+        with:
+          version: latest
+
+      - id: get_date
+        name: Get date
+        run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
+
+      - name: Set up Python dependency cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pypoetry
+          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/market/poetry.lock') }}
+
+      - name: Install Poetry (Unix)
+        run: |
+          curl -sSL https://install.python-poetry.org | python3 -
+
+          if [ "${{ runner.os }}" = "macOS" ]; then
+            PATH="$HOME/.local/bin:$PATH"
+            echo "$HOME/.local/bin" >> $GITHUB_PATH
+          fi
+
+      - name: Install Python dependencies
+        run: poetry install
+
+      - name: Generate Prisma Client
+        run: poetry run prisma generate
+
+      - id: supabase
+        name: Start Supabase
+        working-directory: .
+        run: |
+          supabase init
+          supabase start --exclude postgres-meta,realtime,storage-api,imgproxy,inbucket,studio,edge-runtime,logflare,vector,supavisor
+          supabase status -o env | sed 's/="/=/; s/"$//' >> $GITHUB_OUTPUT
+        # outputs:
+        # DB_URL, API_URL, GRAPHQL_URL, ANON_KEY, SERVICE_ROLE_KEY, JWT_SECRET
+
+      - name: Run Database Migrations
+        run: poetry run prisma migrate dev --name updates
+        env:
+          DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
+
+      - id: lint
+        name: Run Linter
+        run: poetry run lint
+
+      # Tests comment out because they do not work with prisma mock, nor have they been updated since they were created
+      # - 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
+      #     else
+      #       poetry run pytest -s -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
+      RUN_ENV: local
+      PORT: 8080
+
+      # - name: Upload coverage reports to Codecov
+      #   uses: codecov/codecov-action@v4
+      #   with:
+      #     token: ${{ secrets.CODECOV_TOKEN }}
+      #     flags: backend,${{ runner.os }}

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

@@ -16,7 +16,7 @@ jobs:
           # operations-per-run: 5000
           stale-issue-message: >
             This issue has automatically been marked as _stale_ because it has not had
-            any activity in the last 170 days. You can _unstale_ it by commenting or
+            any activity in the last 50 days. You can _unstale_ it by commenting or
             removing the label. Otherwise, this issue will be closed in 10 days.
           stale-pr-message: >
             This pull request has automatically been marked as _stale_ because it has
@@ -25,7 +25,7 @@ jobs:
           close-issue-message: >
             This issue was closed automatically because it has been stale for 10 days
             with no activity.
-          days-before-stale: 170
+          days-before-stale: 50
           days-before-close: 10
           # Do not touch meta issues:
           exempt-issue-labels: meta,fridge,project management

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

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

.github/workflows/scripts/check_actions_status.py

@@ -7,18 +7,13 @@ from typing import Dict, List, Tuple
 
 CHECK_INTERVAL = 30
 
-
 def get_environment_variables() -> Tuple[str, str, str, str, str]:
     """Retrieve and return necessary environment variables."""
     try:
         with open(os.environ["GITHUB_EVENT_PATH"]) as f:
             event = json.load(f)
 
-        # Handle both PR and merge group events
-        if "pull_request" in event:
-            sha = event["pull_request"]["head"]["sha"]
-        else:
-            sha = os.environ["GITHUB_SHA"]
+        sha = event["pull_request"]["head"]["sha"]
 
         return (
             os.environ["GITHUB_API_URL"],

.github/workflows/scripts/get_package_version_from_lockfile.py

@@ -1,60 +0,0 @@
-#!/usr/bin/env python3
-import sys
-
-if sys.version_info < (3, 11):
-    print("Python version 3.11 or higher required")
-    sys.exit(1)
-
-import tomllib
-
-
-def get_package_version(package_name: str, lockfile_path: str) -> str | None:
-    """Extract package version from poetry.lock file."""
-    try:
-        if lockfile_path == "-":
-            data = tomllib.load(sys.stdin.buffer)
-        else:
-            with open(lockfile_path, "rb") as f:
-                data = tomllib.load(f)
-    except FileNotFoundError:
-        print(f"Error: File '{lockfile_path}' not found", file=sys.stderr)
-        sys.exit(1)
-    except tomllib.TOMLDecodeError as e:
-        print(f"Error parsing TOML file: {e}", file=sys.stderr)
-        sys.exit(1)
-    except Exception as e:
-        print(f"Error reading file: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    # Look for the package in the packages list
-    packages = data.get("package", [])
-    for package in packages:
-        if package.get("name", "").lower() == package_name.lower():
-            return package.get("version")
-
-    return None
-
-
-def main():
-    if len(sys.argv) not in (2, 3):
-        print(
-            "Usages: python get_package_version_from_lockfile.py <package name> [poetry.lock path]\n"
-            "        cat poetry.lock | python get_package_version_from_lockfile.py <package name> -",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-
-    package_name = sys.argv[1]
-    lockfile_path = sys.argv[2] if len(sys.argv) == 3 else "poetry.lock"
-
-    version = get_package_version(package_name, lockfile_path)
-
-    if version:
-        print(version)
-    else:
-        print(f"Package '{package_name}' not found in {lockfile_path}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

.gitignore

@@ -165,15 +165,9 @@ package-lock.json
 
 # Allow for locally private items
 # private
-pri*
+pri* 
 # ignore
 ig*
 .github_access_token
 LICENSE.rtf
 autogpt_platform/backend/settings.py
-/.auth
-/autogpt_platform/frontend/.auth
-
-*.ign.*
-.test-contents
-.claude/settings.local.json

.gitmodules

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

.pre-commit-config.yaml

@@ -9,7 +9,7 @@ repos:
       - id: check-merge-conflict
       - id: check-symlinks
       - id: debug-statements
-
+  
   - repo: https://github.com/Yelp/detect-secrets
     rev: v1.5.0
     hooks:
@@ -17,135 +17,41 @@ repos:
         name: Detect secrets
         description: Detects high entropy strings that are likely to be passwords.
         files: ^autogpt_platform/
-        stages: [pre-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/
+        stages: [push]
 
   - repo: local
     # isort needs the context of which packages are installed to function, so we
     # can't use a vendored isort pre-commit hook (which runs in its own isolated venv).
     hooks:
-      - id: isort
-        name: Lint (isort) - AutoGPT Platform - Backend
-        alias: isort-platform-backend
-        entry: poetry -P autogpt_platform/backend run isort -p backend
-        files: ^autogpt_platform/backend/
-        types: [file, python]
-        language: system
-
-      - id: isort
-        name: Lint (isort) - Classic - AutoGPT
-        alias: isort-classic-autogpt
-        entry: poetry -P classic/original_autogpt run isort -p autogpt
+      - id: isort-autogpt
+        name: Lint (isort) - AutoGPT
+        entry: poetry -C classic/original_autogpt run isort
         files: ^classic/original_autogpt/
         types: [file, python]
         language: system
 
-      - id: isort
-        name: Lint (isort) - Classic - Forge
-        alias: isort-classic-forge
-        entry: poetry -P classic/forge run isort -p forge
+      - id: isort-forge
+        name: Lint (isort) - Forge
+        entry: poetry -C classic/forge run isort
         files: ^classic/forge/
         types: [file, python]
         language: system
 
-      - id: isort
-        name: Lint (isort) - Classic - Benchmark
-        alias: isort-classic-benchmark
-        entry: poetry -P classic/benchmark run isort -p agbenchmark
+      - id: isort-benchmark
+        name: Lint (isort) - Benchmark
+        entry: poetry -C classic/benchmark run isort
         files: ^classic/benchmark/
         types: [file, python]
         language: system
 
   - repo: https://github.com/psf/black
-    rev: 24.10.0
+    rev: 23.12.1
     # Black has sensible defaults, doesn't need package context, and ignores
     # everything in .gitignore, so it works fine without any config or arguments.
     hooks:
       - id: black
-        name: Format (Black)
+        name: Lint (Black)
+        language_version: python3.12
 
   - repo: https://github.com/PyCQA/flake8
     rev: 7.0.0
@@ -153,79 +59,53 @@ repos:
     # them separately.
     hooks:
       - id: flake8
-        name: Lint (Flake8) - Classic - AutoGPT
-        alias: flake8-classic-autogpt
+        name: Lint (Flake8) - AutoGPT
+        alias: flake8-autogpt
         files: ^classic/original_autogpt/(autogpt|scripts|tests)/
         args: [--config=classic/original_autogpt/.flake8]
 
       - id: flake8
-        name: Lint (Flake8) - Classic - Forge
-        alias: flake8-classic-forge
+        name: Lint (Flake8) - Forge
+        alias: flake8-forge
         files: ^classic/forge/(forge|tests)/
         args: [--config=classic/forge/.flake8]
 
       - id: flake8
-        name: Lint (Flake8) - Classic - Benchmark
-        alias: flake8-classic-benchmark
+        name: Lint (Flake8) - Benchmark
+        alias: flake8-benchmark
         files: ^classic/benchmark/(agbenchmark|tests)/((?!reports).)*[/.]
         args: [--config=classic/benchmark/.flake8]
 
-  - repo: local
-    hooks:
-      - id: prettier
-        name: Format (Prettier) - AutoGPT Platform - Frontend
-        alias: format-platform-frontend
-        entry: bash -c 'cd autogpt_platform/frontend && npx prettier --write $(echo "$@" | sed "s|autogpt_platform/frontend/||g")' --
-        files: ^autogpt_platform/frontend/
-        types: [file]
-        language: system
-
   - repo: local
     # To have watertight type checking, we check *all* the files in an affected
     # project. To trigger on poetry.lock we also reset the file `types` filter.
     hooks:
       - id: pyright
-        name: Typecheck - AutoGPT Platform - Backend
-        alias: pyright-platform-backend
-        entry: poetry -C autogpt_platform/backend run pyright
-        # include forge source (since it's a path dependency) but exclude *_test.py files:
-        files: ^autogpt_platform/(backend/((backend|test)/|(\w+\.py|poetry\.lock)$)|autogpt_libs/(autogpt_libs/.*(?<!_test)\.py|poetry\.lock)$)
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: pyright
-        name: Typecheck - AutoGPT Platform - Libs
-        alias: pyright-platform-libs
-        entry: poetry -C autogpt_platform/autogpt_libs run pyright
-        files: ^autogpt_platform/autogpt_libs/(autogpt_libs/|poetry\.lock$)
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: pyright
-        name: Typecheck - Classic - AutoGPT
-        alias: pyright-classic-autogpt
+        name: Typecheck - AutoGPT
+        alias: pyright-autogpt
         entry: poetry -C classic/original_autogpt run pyright
+        args: [-p, autogpt, autogpt]
         # include forge source (since it's a path dependency) but exclude *_test.py files:
-        files: ^(classic/original_autogpt/((autogpt|scripts|tests)/|poetry\.lock$)|classic/forge/(forge/.*(?<!_test)\.py|poetry\.lock)$)
+        files: ^(classic/original_autogpt/((autogpt|scripts|tests)/|poetry\.lock$)|classic/forge/(classic/forge/.*(?<!_test)\.py|poetry\.lock)$)
         types: [file]
         language: system
         pass_filenames: false
 
       - id: pyright
-        name: Typecheck - Classic - Forge
-        alias: pyright-classic-forge
+        name: Typecheck - Forge
+        alias: pyright-forge
         entry: poetry -C classic/forge run pyright
-        files: ^classic/forge/(forge/|poetry\.lock$)
+        args: [-p, forge, forge]
+        files: ^classic/forge/(classic/forge/|poetry\.lock$)
         types: [file]
         language: system
         pass_filenames: false
 
       - id: pyright
-        name: Typecheck - Classic - Benchmark
-        alias: pyright-classic-benchmark
+        name: Typecheck - Benchmark
+        alias: pyright-benchmark
         entry: poetry -C classic/benchmark run pyright
+        args: [-p, benchmark, benchmark]
         files: ^classic/benchmark/(agbenchmark/|tests/|poetry\.lock$)
         types: [file]
         language: system
@@ -233,46 +113,24 @@ repos:
 
   - repo: local
     hooks:
-      - id: tsc
-        name: Typecheck - AutoGPT Platform - Frontend
-        entry: bash -c 'cd autogpt_platform/frontend && pnpm type-check'
-        files: ^autogpt_platform/frontend/
-        types: [file]
+      - id: pytest-autogpt
+        name: Run tests - AutoGPT (excl. slow tests)
+        entry: bash -c 'cd classic/original_autogpt && poetry run pytest --cov=autogpt -m "not slow" tests/unit tests/integration'
+        # include forge source (since it's a path dependency) but exclude *_test.py files:
+        files: ^(classic/original_autogpt/((autogpt|tests)/|poetry\.lock$)|classic/forge/(classic/forge/.*(?<!_test)\.py|poetry\.lock)$)
         language: system
         pass_filenames: false
 
-  # - 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-forge
+        name: Run tests - Forge (excl. slow tests)
+        entry: bash -c 'cd classic/forge && poetry run pytest --cov=forge -m "not slow"'
+        files: ^classic/forge/(classic/forge/|tests/|poetry\.lock$)
+        language: system
+        pass_filenames: false
 
-  #     - id: pytest
-  #       name: Run tests - Classic - AutoGPT (excl. slow tests)
-  #       alias: pytest-classic-autogpt
-  #       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)$)
-  #       language: system
-  #       pass_filenames: false
-
-  #     - id: pytest
-  #       name: Run tests - Classic - Forge (excl. slow tests)
-  #       alias: pytest-classic-forge
-  #       entry: bash -c 'cd classic/forge && poetry run pytest --cov=forge -m "not slow"'
-  #       files: ^classic/forge/(forge/|tests/|poetry\.lock$)
-  #       language: system
-  #       pass_filenames: false
-
-  #     - id: pytest
-  #       name: Run tests - Classic - Benchmark
-  #       alias: pytest-classic-benchmark
-  #       entry: bash -c 'cd classic/benchmark && poetry run pytest --cov=benchmark'
-  #       files: ^classic/benchmark/(agbenchmark/|tests/|poetry\.lock$)
-  #       language: system
-  #       pass_filenames: false
+      - id: pytest-benchmark
+        name: Run tests - Benchmark
+        entry: bash -c 'cd classic/benchmark && poetry run pytest --cov=benchmark'
+        files: ^classic/benchmark/(agbenchmark/|tests/|poetry\.lock$)
+        language: system
+        pass_filenames: false

.vscode/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": {
-        "OBJC_DISABLE_INITIALIZE_FORK_SAFETY": "YES"
-      },
-      "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
-      }
-    }
-  ]
-}

AGENTS.md

@@ -1,53 +0,0 @@
-# AutoGPT Platform Contribution Guide
-
-This guide provides context for Codex when updating the **autogpt_platform** folder.
-
-## Directory overview
-
-- `autogpt_platform/backend` – FastAPI based backend service.
-- `autogpt_platform/autogpt_libs` – Shared Python libraries.
-- `autogpt_platform/frontend` – Next.js + Typescript frontend.
-- `autogpt_platform/docker-compose.yml` – development stack.
-
-See `docs/content/platform/getting-started.md` for setup instructions.
-
-## Code style
-
-- Format Python code with `poetry run format`.
-- Format frontend code using `pnpm format`.
-
-## Testing
-
-- Backend: `poetry run test` (runs pytest with a docker based postgres + prisma).
-- Frontend: `pnpm test` or `pnpm test-ui` for Playwright tests. See `docs/content/platform/contributing/tests.md` for tips.
-
-Always run the relevant linters and tests before committing.
-Use conventional commit messages for all commits (e.g. `feat(backend): add API`).
-  Types:
-    - feat
-    - fix
-    - refactor
-    - ci
-    - dx (developer experience)
-  Scopes:
-    - platform
-      - platform/library
-      - platform/marketplace
-      - backend
-        - backend/executor
-      - frontend
-        - frontend/library
-        - frontend/marketplace
-      - blocks
-
-## Pull requests
-
-- Use the template in `.github/PULL_REQUEST_TEMPLATE.md`.
-- Rely on the pre-commit checks for linting and formatting
-- Fill out the **Changes** section and the checklist.
-- Use conventional commit titles with a scope (e.g. `feat(frontend): add feature`).
-- Keep out-of-scope changes under 20% of the PR.
-- Ensure PR descriptions are complete.
-- For changes touching `data/*.py`, validate user ID checks or explain why not needed.
-- If adding protected frontend routes, update `frontend/lib/supabase/middleware.ts`.
-- Use the linear ticket branch structure if given codex/open-1668-resume-dropped-runs

CONTRIBUTING.md

@@ -2,6 +2,9 @@
 If you are reading this, you are probably looking for the full **[contribution guide]**,
 which is part of our [wiki].
 
+Also check out our [🚀 Roadmap][roadmap] for information about our priorities and associated tasks.
+<!-- You can find our immediate priorities and their progress on our public [kanban board]. -->
+
 [contribution guide]: https://github.com/Significant-Gravitas/AutoGPT/wiki/Contributing
 [wiki]: https://github.com/Significant-Gravitas/AutoGPT/wiki
 [roadmap]: https://github.com/Significant-Gravitas/AutoGPT/discussions/6971

README.md

@@ -15,38 +15,7 @@
 > Setting up and hosting the AutoGPT Platform yourself is a technical process. 
 > If you'd rather something that just works, we recommend [joining the waitlist](https://bit.ly/3ZDijAI) for the cloud-hosted beta.
 
-### System Requirements
-
-Before proceeding with the installation, ensure your system meets the following requirements:
-
-#### Hardware Requirements
-- CPU: 4+ cores recommended
-- RAM: Minimum 8GB, 16GB recommended
-- Storage: At least 10GB of free space
-
-#### Software Requirements
-- Operating Systems:
-  - Linux (Ubuntu 20.04 or newer recommended)
-  - macOS (10.15 or newer)
-  - Windows 10/11 with WSL2
-- Required Software (with minimum versions):
-  - Docker Engine (20.10.0 or newer)
-  - Docker Compose (2.0.0 or newer)
-  - Git (2.30 or newer)
-  - Node.js (16.x or newer)
-  - npm (8.x or newer)
-  - VSCode (1.60 or newer) or any modern code editor
-
-#### Network Requirements
-- Stable internet connection
-- Access to required ports (will be configured in Docker)
-- Ability to make outbound HTTPS connections
-
-### Updated Setup Instructions:
-We've moved to a fully maintained and regularly updated documentation site.
-
-👉 [Follow the official self-hosting guide here](https://docs.agpt.co/platform/getting-started/)
-
+https://github.com/user-attachments/assets/d04273a5-b36a-4a37-818e-f631ce72d603
 
 This tutorial assumes you have Docker, VSCode, git and npm installed.
 
@@ -66,7 +35,7 @@ The AutoGPT frontend is where users interact with our powerful AI automation pla
 
    **Monitoring and Analytics:** Keep track of your agents' performance and gain insights to continually improve your automation processes.
 
-[Read this guide](https://docs.agpt.co/platform/new_blocks/) to learn how to build your own custom blocks.
+[Read this guide](https://docs.agpt.co/server/new_blocks/) to learn how to build your own custom blocks.
 
 ### 💽 AutoGPT Server
 
@@ -179,7 +148,7 @@ Just clone the repo, install dependencies with `./run setup`, and you should be
 
 [![Join us on Discord](https://invidget.switchblade.xyz/autogpt)](https://discord.gg/autogpt)
 
-To report a bug or request a feature, create a [GitHub Issue](https://github.com/Significant-Gravitas/AutoGPT/issues/new/choose). Please ensure someone else hasn't created an issue for the same topic.
+To report a bug or request a feature, create a [GitHub Issue](https://github.com/Significant-Gravitas/AutoGPT/issues/new/choose). Please ensure someone else hasn’t created an issue for the same topic.
 
 ## 🤝 Sister projects
 

SECURITY.md

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

autogpt_platform/.env.example

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

autogpt_platform/CLAUDE.md

@@ -1,147 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Repository Overview
-
-AutoGPT Platform is a monorepo containing:
-- **Backend** (`/backend`): Python FastAPI server with async support
-- **Frontend** (`/frontend`): Next.js React application
-- **Shared Libraries** (`/autogpt_libs`): Common Python utilities
-
-## Essential Commands
-
-### Backend Development
-```bash
-# Install dependencies
-cd backend && poetry install
-
-# Run database migrations
-poetry run prisma migrate dev
-
-# Start all services (database, redis, rabbitmq, clamav)
-docker compose up -d
-
-# Run the backend server
-poetry run serve
-
-# Run tests
-poetry run test
-
-# Run specific test
-poetry run pytest path/to/test_file.py::test_function_name
-
-# Lint and format
-# prefer format if you want to just "fix" it and only get the errors that can't be autofixed
-poetry run format  # Black + isort
-poetry run lint    # ruff
-```
-More details can be found in TESTING.md
-
-#### Creating/Updating Snapshots
-
-When you first write a test or when the expected output changes:
-
-```bash
-poetry run pytest path/to/test.py --snapshot-update
-```
-
-⚠️ **Important**: Always review snapshot changes before committing! Use `git diff` to verify the changes are expected.
-
-
-### Frontend Development
-```bash
-# Install dependencies
-cd frontend && npm install
-
-# Start development server
-npm run dev
-
-# Run E2E tests
-npm run test
-
-# Run Storybook for component development
-npm run storybook
-
-# Build production
-npm run build
-
-# Type checking
-npm run type-check
-```
-
-## Architecture Overview
-
-### Backend Architecture
-- **API Layer**: FastAPI with REST and WebSocket endpoints
-- **Database**: PostgreSQL with Prisma ORM, includes pgvector for embeddings
-- **Queue System**: RabbitMQ for async task processing
-- **Execution Engine**: Separate executor service processes agent workflows
-- **Authentication**: JWT-based with Supabase integration
-- **Security**: Cache protection middleware prevents sensitive data caching in browsers/proxies
-
-### Frontend Architecture
-- **Framework**: Next.js App Router with React Server Components
-- **State Management**: React hooks + Supabase client for real-time updates
-- **Workflow Builder**: Visual graph editor using @xyflow/react
-- **UI Components**: Radix UI primitives with Tailwind CSS styling
-- **Feature Flags**: LaunchDarkly integration
-
-### Key Concepts
-1. **Agent Graphs**: Workflow definitions stored as JSON, executed by the backend
-2. **Blocks**: Reusable components in `/backend/blocks/` that perform specific tasks
-3. **Integrations**: OAuth and API connections stored per user
-4. **Store**: Marketplace for sharing agent templates
-5. **Virus Scanning**: ClamAV integration for file upload security
-
-### Testing Approach
-- Backend uses pytest with snapshot testing for API responses
-- Test files are colocated with source files (`*_test.py`)
-- Frontend uses Playwright for E2E tests
-- Component testing via Storybook
-
-### Database Schema
-Key models (defined in `/backend/schema.prisma`):
-- `User`: Authentication and profile data
-- `AgentGraph`: Workflow definitions with version control
-- `AgentGraphExecution`: Execution history and results
-- `AgentNode`: Individual nodes in a workflow
-- `StoreListing`: Marketplace listings for sharing agents
-
-### Environment Configuration
-- Backend: `.env` file in `/backend`
-- Frontend: `.env.local` file in `/frontend`
-- Both require Supabase credentials and API keys for various services
-
-### Common Development Tasks
-
-**Adding a new block:**
-1. Create new file in `/backend/backend/blocks/`
-2. Inherit from `Block` base class
-3. Define input/output schemas
-4. Implement `run` method
-5. Register in block registry
-6. Generate the block uuid using `uuid.uuid4()`
-
-**Modifying the API:**
-1. Update route in `/backend/backend/server/routers/`
-2. Add/update Pydantic models in same directory
-3. Write tests alongside the route file
-4. Run `poetry run test` to verify
-
-**Frontend feature development:**
-1. Components go in `/frontend/src/components/`
-2. Use existing UI components from `/frontend/src/components/ui/`
-3. Add Storybook stories for new components
-4. Test with Playwright if user-facing
-
-### Security Implementation
-
-**Cache Protection Middleware:**
-- Located in `/backend/backend/server/middleware/security.py`
-- Default behavior: Disables caching for ALL endpoints with `Cache-Control: no-store, no-cache, must-revalidate, private`
-- Uses an allow list approach - only explicitly permitted paths can be cached
-- Cacheable paths include: static assets (`/static/*`, `/_next/static/*`), health checks, public store pages, documentation
-- Prevents sensitive data (auth tokens, API keys, user data) from being cached by browsers/proxies
-- To allow caching for a new endpoint, add it to `CACHEABLE_PATHS` in the middleware
-- Applied to both main API server and external API applications

autogpt_platform/README.md

@@ -15,66 +15,53 @@ Welcome to the AutoGPT Platform - a powerful system for creating and running AI
 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:
-
    ```
-   cp .env.example .env
+   git submodule update --init --recursive
    ```
-
-   This command will copy the `.env.example` file to `.env`. You can modify the `.env` file to add your own environment variables.
+   This command will initialize and update the submodules in the repository. The `supabase` folder will be cloned to the root directory.
 
 3. Run the following command:
+   ```
+   cp supabase/docker/.env.example .env
+   ```
+   This command will copy the `.env.example` file to `.env` in the `supabase/docker` directory. You can modify the `.env` file to add your own environment variables.
 
+4. Run the following command:
    ```
    docker compose up -d
    ```
-
    This command will start all the necessary backend services defined in the `docker-compose.yml` file in detached mode.
 
-4. Navigate to `frontend` within the `autogpt_platform` directory:
-
+5. Navigate to `frontend` within the `autogpt_platform` directory:
    ```
    cd frontend
    ```
-
    You will need to run your frontend application separately on your local machine.
 
-5. Run the following command:
-
+6. Run the following command: 
    ```
    cp .env.example .env.local
    ```
-
    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.
 
-6. Run the following command:
-
-   Enable corepack and install dependencies by running:
-
+7. Run the following command:
    ```
-   corepack enable
-   pnpm i
+   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
    ```
 
-   Generate the API client (this step is required before running the frontend):
-
-   ```
-   pnpm generate:api-client
-   ```
-
-   Then start the frontend application in development mode:
-
-   ```
-   pnpm dev
-   ```
-
-7. Open your browser and navigate to `http://localhost:3000` to access the AutoGPT Platform frontend.
+8. Open your browser and navigate to `http://localhost:3000` to access the AutoGPT Platform frontend.
 
 ### Docker Compose Commands
 
@@ -87,52 +74,43 @@ Here are some useful Docker Compose commands for managing your AutoGPT Platform:
 - `docker compose down`: Stop and remove containers, networks, and volumes.
 - `docker compose watch`: Watch for changes in your services and automatically update them.
 
+
 ### Sample Scenarios
 
 Here are some common scenarios where you might use multiple Docker Compose commands:
 
 1. Updating and restarting a specific service:
-
    ```
    docker compose build api_srv
    docker compose up -d --no-deps api_srv
    ```
-
    This rebuilds the `api_srv` service and restarts it without affecting other services.
 
 2. Viewing logs for troubleshooting:
-
    ```
    docker compose logs -f api_srv ws_srv
    ```
-
    This shows and follows the logs for both `api_srv` and `ws_srv` services.
 
 3. Scaling a service for increased load:
-
    ```
    docker compose up -d --scale executor=3
    ```
-
    This scales the `executor` service to 3 instances to handle increased load.
 
 4. Stopping the entire system for maintenance:
-
    ```
    docker compose stop
    docker compose rm -f
    docker compose pull
    docker compose up -d
    ```
-
    This stops all services, removes containers, pulls the latest images, and restarts the system.
 
 5. Developing with live updates:
-
    ```
    docker compose watch
    ```
-
    This watches for changes in your code and automatically updates the relevant services.
 
 6. Checking the status of services:
@@ -143,6 +121,7 @@ Here are some common scenarios where you might use multiple Docker Compose comma
 
 These scenarios demonstrate how to use Docker Compose commands in combination to manage your AutoGPT Platform effectively.
 
+
 ### Persisting Data
 
 To persist data for PostgreSQL and Redis, you can modify the `docker-compose.yml` file to add volumes. Here's how:
@@ -170,27 +149,3 @@ 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.
-
-### API Client Generation
-
-The platform includes scripts for generating and managing the API client:
-
-- `pnpm fetch:openapi`: Fetches the OpenAPI specification from the backend service (requires backend to be running on port 8006)
-- `pnpm generate:api-client`: Generates the TypeScript API client from the OpenAPI specification using Orval
-- `pnpm generate:api-all`: Runs both fetch and generate commands in sequence
-
-#### Manual API Client Updates
-
-If you need to update the API client after making changes to the backend API:
-
-1. Ensure the backend services are running:
-   ```
-   docker compose up -d
-   ```
-
-2. Generate the updated API client:
-   ```
-   pnpm generate:api-all
-   ```
-
-This will fetch the latest OpenAPI specification and regenerate the TypeScript client code.

autogpt_platform/autogpt_libs/README.md

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

autogpt_platform/autogpt_libs/autogpt_libs/api_key/key_manager.py

@@ -1,35 +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
-        provided_hash = hashlib.sha256(provided_key.encode()).hexdigest()
-        return secrets.compare_digest(provided_hash, stored_hash)

autogpt_platform/autogpt_libs/autogpt_libs/auth/__init__.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/config.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/depends.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/middleware.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/models.py

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

autogpt_platform/autogpt_libs/autogpt_libs/feature_flag/client.py

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

autogpt_platform/autogpt_libs/autogpt_libs/feature_flag/client_test.py

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

autogpt_platform/autogpt_libs/autogpt_libs/feature_flag/config.py

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

autogpt_platform/autogpt_libs/autogpt_libs/logging/config.py

@@ -6,9 +6,8 @@ from pathlib import Path
 
 from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
-
 from .filters import BelowLevelFilter
-from .formatters import AGPTFormatter
+from .formatters import AGPTFormatter, StructuredLoggingFormatter
 
 LOG_DIR = Path(__file__).parent.parent.parent.parent / "logs"
 LOG_FILE = "activity.log"
@@ -18,11 +17,12 @@ ERROR_LOG_FILE = "error.log"
 SIMPLE_LOG_FORMAT = "%(asctime)s %(levelname)s  %(title)s%(message)s"
 
 DEBUG_LOG_FORMAT = (
-    "%(asctime)s %(levelname)s %(filename)s:%(lineno)d  %(title)s%(message)s"
+    "%(asctime)s %(levelname)s %(filename)s:%(lineno)d" "  %(title)s%(message)s"
 )
 
 
 class LoggingConfig(BaseSettings):
+
     level: str = Field(
         default="INFO",
         description="Logging level",
@@ -81,26 +81,9 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
     """
 
     config = LoggingConfig()
+
     log_handlers: list[logging.Handler] = []
 
-    # Console output handlers
-    stdout = logging.StreamHandler(stream=sys.stdout)
-    stdout.setLevel(config.level)
-    stdout.addFilter(BelowLevelFilter(logging.WARNING))
-    if config.level == logging.DEBUG:
-        stdout.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
-    else:
-        stdout.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
-
-    stderr = logging.StreamHandler()
-    stderr.setLevel(logging.WARNING)
-    if config.level == logging.DEBUG:
-        stderr.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
-    else:
-        stderr.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
-
-    log_handlers += [stdout, stderr]
-
     # Cloud logging setup
     if config.enable_cloud_logging or force_cloud_logging:
         import google.cloud.logging
@@ -114,7 +97,28 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
             transport=SyncTransport,
         )
         cloud_handler.setLevel(config.level)
+        cloud_handler.setFormatter(StructuredLoggingFormatter())
         log_handlers.append(cloud_handler)
+        print("Cloud logging enabled")
+    else:
+        # Console output handlers
+        stdout = logging.StreamHandler(stream=sys.stdout)
+        stdout.setLevel(config.level)
+        stdout.addFilter(BelowLevelFilter(logging.WARNING))
+        if config.level == logging.DEBUG:
+            stdout.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
+        else:
+            stdout.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
+
+        stderr = logging.StreamHandler()
+        stderr.setLevel(logging.WARNING)
+        if config.level == logging.DEBUG:
+            stderr.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
+        else:
+            stderr.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
+
+        log_handlers += [stdout, stderr]
+        print("Console logging enabled")
 
     # File logging setup
     if config.enable_file_logging:
@@ -152,6 +156,7 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
         error_log_handler.setLevel(logging.ERROR)
         error_log_handler.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT, no_color=True))
         log_handlers.append(error_log_handler)
+        print("File logging enabled")
 
     # Configure the root logger
     logging.basicConfig(

autogpt_platform/autogpt_libs/autogpt_libs/logging/formatters.py

@@ -1,6 +1,7 @@
 import logging
 
 from colorama import Fore, Style
+from google.cloud.logging_v2.handlers import CloudLoggingFilter, StructuredLogHandler
 
 from .utils import remove_color_codes
 
@@ -79,3 +80,16 @@ class AGPTFormatter(FancyConsoleFormatter):
             return remove_color_codes(super().format(record))
         else:
             return super().format(record)
+
+
+class StructuredLoggingFormatter(StructuredLogHandler, logging.Formatter):
+    def __init__(self):
+        # Set up CloudLoggingFilter to add diagnostic info to the log records
+        self.cloud_logging_filter = CloudLoggingFilter()
+
+        # Init StructuredLogHandler
+        super().__init__()
+
+    def format(self, record: logging.LogRecord) -> str:
+        self.cloud_logging_filter.filter(record)
+        return super().format(record)

autogpt_platform/autogpt_libs/autogpt_libs/logging/test_utils.py

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

autogpt_platform/autogpt_libs/autogpt_libs/logging/utils.py

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

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/config.py

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

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/limiter.py

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

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/middleware.py

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

autogpt_platform/autogpt_libs/autogpt_libs/supabase_integration_credentials_store/__init__.py

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

autogpt_platform/autogpt_libs/autogpt_libs/supabase_integration_credentials_store/store.py

@@ -0,0 +1,278 @@
+import secrets
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING
+
+from pydantic import SecretStr
+
+if TYPE_CHECKING:
+    from redis import Redis
+    from backend.executor.database import DatabaseManager
+
+from autogpt_libs.utils.cache import thread_cached
+from autogpt_libs.utils.synchronize import RedisKeyedMutex
+
+from .types import (
+    APIKeyCredentials,
+    Credentials,
+    OAuth2Credentials,
+    OAuthState,
+    UserIntegrations,
+)
+
+from backend.util.settings import Settings
+
+settings = Settings()
+
+revid_credentials = APIKeyCredentials(
+    id="fdb7f412-f519-48d1-9b5f-d2f73d0e01fe",
+    provider="revid",
+    api_key=SecretStr(settings.secrets.revid_api_key),
+    title="Use Credits for Revid",
+    expires_at=None,
+)
+ideogram_credentials = APIKeyCredentials(
+    id="760f84fc-b270-42de-91f6-08efe1b512d0",
+    provider="ideogram",
+    api_key=SecretStr(settings.secrets.ideogram_api_key),
+    title="Use Credits for Ideogram",
+    expires_at=None,
+)
+replicate_credentials = APIKeyCredentials(
+    id="6b9fc200-4726-4973-86c9-cd526f5ce5db",
+    provider="replicate",
+    api_key=SecretStr(settings.secrets.replicate_api_key),
+    title="Use Credits for Replicate",
+    expires_at=None,
+)
+openai_credentials = APIKeyCredentials(
+    id="53c25cb8-e3ee-465c-a4d1-e75a4c899c2a",
+    provider="llm",
+    api_key=SecretStr(settings.secrets.openai_api_key),
+    title="Use Credits for OpenAI",
+    expires_at=None,
+)
+anthropic_credentials = APIKeyCredentials(
+    id="24e5d942-d9e3-4798-8151-90143ee55629",
+    provider="llm",
+    api_key=SecretStr(settings.secrets.anthropic_api_key),
+    title="Use Credits for Anthropic",
+    expires_at=None,
+)
+groq_credentials = APIKeyCredentials(
+    id="4ec22295-8f97-4dd1-b42b-2c6957a02545",
+    provider="llm",
+    api_key=SecretStr(settings.secrets.groq_api_key),
+    title="Use Credits for Groq",
+    expires_at=None,
+)
+did_credentials = APIKeyCredentials(
+    id="7f7b0654-c36b-4565-8fa7-9a52575dfae2",
+    provider="d_id",
+    api_key=SecretStr(settings.secrets.did_api_key),
+    title="Use Credits for D-ID",
+    expires_at=None,
+)
+
+DEFAULT_CREDENTIALS = [
+    revid_credentials,
+    ideogram_credentials,
+    replicate_credentials,
+    openai_credentials,
+    anthropic_credentials,
+    groq_credentials,
+    did_credentials,
+]
+
+
+class SupabaseIntegrationCredentialsStore:
+    def __init__(self, redis: "Redis"):
+        self.locks = RedisKeyedMutex(redis)
+
+    @property
+    @thread_cached
+    def db_manager(self) -> "DatabaseManager":
+        from backend.executor.database import DatabaseManager
+        from backend.util.service import get_service_client
+
+        return get_service_client(DatabaseManager)
+
+    def add_creds(self, user_id: str, credentials: Credentials) -> None:
+        with self.locked_user_integrations(user_id):
+            if self.get_creds_by_id(user_id, credentials.id):
+                raise ValueError(
+                    f"Can not re-create existing credentials #{credentials.id} "
+                    f"for user #{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]:
+        users_credentials = self._get_user_integrations(user_id).credentials
+        all_credentials = users_credentials
+        if settings.secrets.revid_api_key:
+            all_credentials.append(revid_credentials)
+        if settings.secrets.ideogram_api_key:
+            all_credentials.append(ideogram_credentials)
+        if settings.secrets.groq_api_key:
+            all_credentials.append(groq_credentials)
+        if settings.secrets.replicate_api_key:
+            all_credentials.append(replicate_credentials)
+        if settings.secrets.openai_api_key:
+            all_credentials.append(openai_credentials)
+        if settings.secrets.anthropic_api_key:
+            all_credentials.append(anthropic_credentials)
+        if settings.secrets.did_api_key:
+            all_credentials.append(did_credentials)
+        return all_credentials
+
+    def get_creds_by_id(self, user_id: str, credentials_id: str) -> Credentials | None:
+        all_credentials = self.get_all_creds(user_id)
+        return next((c for c in all_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:
+        with self.locked_user_integrations(user_id):
+            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:
+        with self.locked_user_integrations(user_id):
+            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)
+
+    def store_state_token(self, user_id: str, provider: str, scopes: list[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()),
+            scopes=scopes,
+        )
+
+        with self.locked_user_integrations(user_id):
+            user_integrations = self._get_user_integrations(user_id)
+            oauth_states = user_integrations.oauth_states
+            oauth_states.append(state)
+            user_integrations.oauth_states = oauth_states
+
+            self.db_manager.update_user_integrations(
+                user_id=user_id, data=user_integrations
+            )
+
+        return token
+
+    def get_any_valid_scopes_from_state_token(
+        self, user_id: str, token: str, provider: str
+    ) -> list[str]:
+        """
+        Get the valid scopes from the OAuth state token. This will return any valid scopes
+        from any OAuth state token for the given provider. If no valid scopes are found,
+        an empty list is returned. DO NOT RELY ON THIS TOKEN TO AUTHENTICATE A USER, AS IT
+        IS TO CHECK IF THE USER HAS GIVEN PERMISSIONS TO THE APPLICATION BEFORE EXCHANGING
+        THE CODE FOR TOKENS.
+        """
+        user_integrations = self._get_user_integrations(user_id)
+        oauth_states = user_integrations.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:
+            return valid_state.scopes
+
+        return []
+
+    def verify_state_token(self, user_id: str, token: str, provider: str) -> bool:
+        with self.locked_user_integrations(user_id):
+            user_integrations = self._get_user_integrations(user_id)
+            oauth_states = user_integrations.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_integrations.oauth_states = oauth_states
+                self.db_manager.update_user_integrations(user_id, user_integrations)
+                return True
+
+        return False
+
+    def _set_user_integration_creds(
+        self, user_id: str, credentials: list[Credentials]
+    ) -> None:
+        integrations = self._get_user_integrations(user_id)
+        # Remove default credentials from the list
+        credentials = [c for c in credentials if c not in DEFAULT_CREDENTIALS]
+        integrations.credentials = credentials
+        self.db_manager.update_user_integrations(user_id, integrations)
+
+    def _get_user_integrations(self, user_id: str) -> UserIntegrations:
+        integrations: UserIntegrations = self.db_manager.get_user_integrations(
+            user_id=user_id
+        )
+        return integrations
+
+    def locked_user_integrations(self, user_id: str):
+        key = (self.db_manager, f"user:{user_id}", "integrations")
+        return self.locks.locked(key)

autogpt_platform/autogpt_libs/autogpt_libs/supabase_integration_credentials_store/types.py

@@ -56,7 +56,6 @@ class OAuthState(BaseModel):
     token: str
     provider: str
     expires_at: int
-    code_verifier: Optional[str] = None
     scopes: list[str]
     """Unix timestamp (seconds) indicating when this OAuth state expires"""
 

autogpt_platform/autogpt_libs/autogpt_libs/utils/cache.py

@@ -1,59 +1,20 @@
-import inspect
+from typing import Callable, TypeVar, ParamSpec
 import threading
-from typing import Awaitable, Callable, ParamSpec, TypeVar, cast, overload
 
 P = ParamSpec("P")
 R = TypeVar("R")
 
 
-@overload
-def thread_cached(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]: ...
-
-
-@overload
-def thread_cached(func: Callable[P, R]) -> Callable[P, R]: ...
-
-
-def thread_cached(
-    func: Callable[P, R] | Callable[P, Awaitable[R]],
-) -> Callable[P, R] | Callable[P, Awaitable[R]]:
+def thread_cached(func: Callable[P, R]) -> Callable[P, R]:
     thread_local = threading.local()
 
-    def _clear():
-        if hasattr(thread_local, "cache"):
-            del thread_local.cache
+    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]
 
-    if inspect.iscoroutinefunction(func):
-
-        async def async_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] = await cast(Callable[P, Awaitable[R]], func)(
-                    *args, **kwargs
-                )
-            return cache[key]
-
-        setattr(async_wrapper, "clear_cache", _clear)
-        return async_wrapper
-
-    else:
-
-        def sync_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]
-
-        setattr(sync_wrapper, "clear_cache", _clear)
-        return sync_wrapper
-
-
-def clear_thread_cache(func: Callable) -> None:
-    if clear := getattr(func, "clear_cache", None):
-        clear()
+    return wrapper

autogpt_platform/autogpt_libs/autogpt_libs/utils/synchronize.py

@@ -1,15 +1,15 @@
-import asyncio
-from contextlib import asynccontextmanager
+from contextlib import contextmanager
+from threading import Lock
 from typing import TYPE_CHECKING, Any
 
 from expiringdict import ExpiringDict
 
 if TYPE_CHECKING:
-    from redis.asyncio import Redis as AsyncRedis
-    from redis.asyncio.lock import Lock as AsyncRedisLock
+    from redis import Redis
+    from redis.lock import Lock as RedisLock
 
 
-class AsyncRedisKeyedMutex:
+class RedisKeyedMutex:
     """
     This class provides a mutex that can be locked and unlocked by a specific key,
     using Redis as a distributed locking provider.
@@ -17,45 +17,40 @@ class AsyncRedisKeyedMutex:
     in case the key is not unlocked for a specified duration, to prevent memory leaks.
     """
 
-    def __init__(self, redis: "AsyncRedis", timeout: int | None = 60):
+    def __init__(self, redis: "Redis", timeout: int | None = 60):
         self.redis = redis
         self.timeout = timeout
-        self.locks: dict[Any, "AsyncRedisLock"] = ExpiringDict(
+        self.locks: dict[Any, "RedisLock"] = ExpiringDict(
             max_len=6000, max_age_seconds=self.timeout
         )
-        self.locks_lock = asyncio.Lock()
+        self.locks_lock = Lock()
 
-    @asynccontextmanager
-    async def locked(self, key: Any):
-        lock = await self.acquire(key)
+    @contextmanager
+    def locked(self, key: Any):
+        lock = self.acquire(key)
         try:
             yield
         finally:
-            if (await lock.locked()) and (await lock.owned()):
-                await lock.release()
+            lock.release()
 
-    async def acquire(self, key: Any) -> "AsyncRedisLock":
+    def acquire(self, key: Any) -> "RedisLock":
         """Acquires and returns a lock with the given key"""
-        async with self.locks_lock:
+        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]
-        await lock.acquire()
+        lock.acquire()
         return lock
 
-    async def release(self, key: Any):
-        if (
-            (lock := self.locks.get(key))
-            and (await lock.locked())
-            and (await lock.owned())
-        ):
-            await lock.release()
+    def release(self, key: Any):
+        if lock := self.locks.get(key):
+            lock.release()
 
-    async def release_all_locks(self):
+    def release_all_locks(self):
         """Call this on process termination to ensure all locks are released"""
-        async with self.locks_lock:
-            for lock in self.locks.values():
-                if (await lock.locked()) and (await lock.owned()):
-                    await lock.release()
+        self.locks_lock.acquire(blocking=False)
+        for lock in self.locks.values():
+            if lock.locked() and lock.owned():
+                lock.release()

autogpt_platform/autogpt_libs/pyproject.toml

@@ -7,30 +7,19 @@ readme = "README.md"
 packages = [{ include = "autogpt_libs" }]
 
 [tool.poetry.dependencies]
-python = ">=3.10,<4.0"
 colorama = "^0.4.6"
 expiringdict = "^1.2.2"
-google-cloud-logging = "^3.12.1"
-pydantic = "^2.11.4"
-pydantic-settings = "^2.9.1"
-pyjwt = "^2.10.1"
-pytest-asyncio = "^0.26.0"
-pytest-mock = "^3.14.0"
-supabase = "^2.15.1"
-launchdarkly-server-sdk = "^9.11.1"
-fastapi = "^0.115.12"
-uvicorn = "^0.34.3"
+google-cloud-logging = "^3.11.3"
+pydantic = "^2.9.2"
+pydantic-settings = "^2.6.1"
+pyjwt = "^2.8.0"
+python = ">=3.10,<4.0"
+python-dotenv = "^1.0.1"
+supabase = "^2.9.1"
 
 [tool.poetry.group.dev.dependencies]
-redis = "^5.2.1"
-ruff = "^0.12.2"
+redis = "^5.2.0"
 
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
-
-[tool.ruff]
-line-length = 88
-
-[tool.ruff.lint]
-extend-select = ["I"]  # sort dependencies

autogpt_platform/backend/.env.example

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

autogpt_platform/backend/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 libpq5 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,8 +71,8 @@ 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
 
 CMD ["poetry", "run", "rest"]

autogpt_platform/backend/README.advanced.md

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

autogpt_platform/backend/README.md

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

autogpt_platform/backend/TESTING.md

@@ -1,237 +0,0 @@
-# Backend Testing Guide
-
-This guide covers testing practices for the AutoGPT Platform backend, with a focus on snapshot testing for API endpoints.
-
-## Table of Contents
-- [Overview](#overview)
-- [Running Tests](#running-tests)
-- [Snapshot Testing](#snapshot-testing)
-- [Writing Tests for API Routes](#writing-tests-for-api-routes)
-- [Best Practices](#best-practices)
-
-## Overview
-
-The backend uses pytest for testing with the following key libraries:
-- `pytest` - Test framework
-- `pytest-asyncio` - Async test support
-- `pytest-mock` - Mocking support
-- `pytest-snapshot` - Snapshot testing for API responses
-
-## Running Tests
-
-### Run all tests
-```bash
-poetry run test
-```
-
-### Run specific test file
-```bash
-poetry run pytest path/to/test_file.py
-```
-
-### Run with verbose output
-```bash
-poetry run pytest -v
-```
-
-### Run with coverage
-```bash
-poetry run pytest --cov=backend
-```
-
-## Snapshot Testing
-
-Snapshot testing captures the output of your code and compares it against previously saved snapshots. This is particularly useful for testing API responses.
-
-### How Snapshot Testing Works
-
-1. First run: Creates snapshot files in `snapshots/` directories
-2. Subsequent runs: Compares output against saved snapshots
-3. Changes detected: Test fails if output differs from snapshot
-
-### Creating/Updating Snapshots
-
-When you first write a test or when the expected output changes:
-
-```bash
-poetry run pytest path/to/test.py --snapshot-update
-```
-
-⚠️ **Important**: Always review snapshot changes before committing! Use `git diff` to verify the changes are expected.
-
-### Snapshot Test Example
-
-```python
-import json
-from pytest_snapshot.plugin import Snapshot
-
-def test_api_endpoint(snapshot: Snapshot):
-    response = client.get("/api/endpoint")
-    
-    # Snapshot the response
-    snapshot.snapshot_dir = "snapshots"
-snapshot.assert_match(
-        json.dumps(response.json(), indent=2, sort_keys=True),
-        "endpoint_response"
-    )
-```
-
-### Best Practices for Snapshots
-
-1. **Use descriptive names**: `"user_list_response"` not `"response1"`
-2. **Sort JSON keys**: Ensures consistent snapshots
-3. **Format JSON**: Use `indent=2` for readable diffs
-4. **Exclude dynamic data**: Remove timestamps, IDs, etc. that change between runs
-
-Example of excluding dynamic data:
-```python
-response_data = response.json()
-# Remove dynamic fields for snapshot
-response_data.pop("created_at", None)
-response_data.pop("id", None)
-
-snapshot.snapshot_dir = "snapshots"
-snapshot.assert_match(
-    json.dumps(response_data, indent=2, sort_keys=True),
-    "static_response_data"
-)
-```
-
-## Writing Tests for API Routes
-
-### Basic Structure
-
-```python
-import json
-import fastapi
-import fastapi.testclient
-import pytest
-from pytest_snapshot.plugin import Snapshot
-
-from backend.server.v2.myroute import router
-
-app = fastapi.FastAPI()
-app.include_router(router)
-client = fastapi.testclient.TestClient(app)
-
-def test_endpoint_success(snapshot: Snapshot):
-    response = client.get("/endpoint")
-    assert response.status_code == 200
-    
-    # Test specific fields
-    data = response.json()
-    assert data["status"] == "success"
-    
-    # Snapshot the full response
-    snapshot.snapshot_dir = "snapshots"
-    snapshot.assert_match(
-        json.dumps(data, indent=2, sort_keys=True),
-        "endpoint_success_response"
-    )
-```
-
-### Testing with Authentication
-
-```python
-def override_auth_middleware():
-    return {"sub": "test-user-id"}
-
-def override_get_user_id():
-    return "test-user-id"
-
-app.dependency_overrides[auth_middleware] = override_auth_middleware
-app.dependency_overrides[get_user_id] = override_get_user_id
-```
-
-### Mocking External Services
-
-```python
-def test_external_api_call(mocker, snapshot):
-    # Mock external service
-    mock_response = {"external": "data"}
-    mocker.patch(
-        "backend.services.external_api.call",
-        return_value=mock_response
-    )
-    
-    response = client.post("/api/process")
-    assert response.status_code == 200
-    
-    snapshot.snapshot_dir = "snapshots"
-    snapshot.assert_match(
-        json.dumps(response.json(), indent=2, sort_keys=True),
-        "process_with_external_response"
-    )
-```
-
-## Best Practices
-
-### 1. Test Organization
-- Place tests next to the code: `routes.py` → `routes_test.py`
-- Use descriptive test names: `test_create_user_with_invalid_email`
-- Group related tests in classes when appropriate
-
-### 2. Test Coverage
-- Test happy path and error cases
-- Test edge cases (empty data, invalid formats)
-- Test authentication and authorization
-
-### 3. Snapshot Testing Guidelines
-- Review all snapshot changes carefully
-- Don't snapshot sensitive data
-- Keep snapshots focused and minimal
-- Update snapshots intentionally, not accidentally
-
-### 4. Async Testing
-- Use regular `def` for FastAPI TestClient tests
-- Use `async def` with `@pytest.mark.asyncio` for testing async functions directly
-
-### 5. Fixtures
-Create reusable fixtures for common test data:
-
-```python
-@pytest.fixture
-def sample_user():
-    return {
-        "email": "test@example.com",
-        "name": "Test User"
-    }
-
-def test_create_user(sample_user, snapshot):
-    response = client.post("/users", json=sample_user)
-    # ... test implementation
-```
-
-## CI/CD Integration
-
-The GitHub Actions workflow automatically runs tests on:
-- Pull requests
-- Pushes to main branch
-
-Snapshot tests work in CI by:
-1. Committing snapshot files to the repository
-2. CI compares against committed snapshots
-3. Fails if snapshots don't match
-
-## Troubleshooting
-
-### Snapshot Mismatches
-- Review the diff carefully
-- If changes are expected: `poetry run pytest --snapshot-update`
-- If changes are unexpected: Fix the code causing the difference
-
-### Async Test Issues
-- Ensure async functions use `@pytest.mark.asyncio`
-- Use `AsyncMock` for mocking async functions
-- FastAPI TestClient handles async automatically
-
-### Import Errors
-- Check that all dependencies are in `pyproject.toml`
-- Run `poetry install` to ensure dependencies are installed
-- Verify import paths are correct
-
-## Summary
-
-Snapshot testing provides a powerful way to ensure API responses remain consistent. Combined with traditional assertions, it creates a robust test suite that catches regressions while remaining maintainable.
-
-Remember: Good tests are as important as good code!

autogpt_platform/backend/backend/app.py

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

autogpt_platform/backend/backend/blocks/__init__.py

@@ -1,99 +1,96 @@
-import functools
 import importlib
 import os
 import re
 from pathlib import Path
-from typing import TYPE_CHECKING, TypeVar
+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
+modules = [
+    str(f.relative_to(current_dir))[:-3].replace(os.path.sep, ".")
+    for f in current_dir.rglob("*.py")
+    if f.is_file() and f.name != "__init__.py"
+]
+for module in modules:
+    if not re.match("^[a-z_.]+$", module):
+        raise ValueError(
+            f"Block module {module} error: module name must be lowercase, "
+            "separated by underscores, and contain only alphabet characters"
+        )
+
+    importlib.import_module(f".{module}", package=__name__)
+    AVAILABLE_MODULES.append(module)
+
+# Load all Block instances from the available modules
+AVAILABLE_BLOCKS: dict[str, Type[Block]] = {}
 
-if TYPE_CHECKING:
-    from backend.data.block import Block
 
 T = TypeVar("T")
 
 
-@functools.cache
-def load_all_blocks() -> dict[str, type["Block"]]:
-    from backend.data.block import Block
-
-    # Dynamically load all modules under backend.blocks
-    current_dir = Path(__file__).parent
-    modules = [
-        str(f.relative_to(current_dir))[:-3].replace(os.path.sep, ".")
-        for f in current_dir.rglob("*.py")
-        if f.is_file() and f.name != "__init__.py" and not f.name.startswith("test_")
-    ]
-    for module in modules:
-        if not re.match("^[a-z0-9_.]+$", module):
-            raise ValueError(
-                f"Block module {module} error: module name must be lowercase, "
-                "and contain only alphanumeric characters and underscores."
-            )
-
-        importlib.import_module(f".{module}", package=__name__)
-
-    # Load all Block instances from the available modules
-    available_blocks: dict[str, type["Block"]] = {}
-    for block_cls in all_subclasses(Block):
-        class_name = block_cls.__name__
-
-        if class_name.endswith("Base"):
-            continue
-
-        if not class_name.endswith("Block"):
-            raise ValueError(
-                f"Block class {class_name} does not end with 'Block'. "
-                "If you are creating an abstract class, "
-                "please name the class with 'Base' at the end"
-            )
-
-        block = block_cls.create()
-
-        if not isinstance(block.id, str) or len(block.id) != 36:
-            raise ValueError(
-                f"Block ID {block.name} error: {block.id} is not a valid UUID"
-            )
-
-        if block.id in available_blocks:
-            raise ValueError(
-                f"Block ID {block.name} error: {block.id} is already in use"
-            )
-
-        input_schema = block.input_schema.model_fields
-        output_schema = block.output_schema.model_fields
-
-        # Make sure `error` field is a string in the output schema
-        if "error" in output_schema and output_schema["error"].annotation is not str:
-            raise ValueError(
-                f"{block.name} `error` field in output_schema must be a string"
-            )
-
-        # Ensure all fields in input_schema and output_schema are annotated SchemaFields
-        for field_name, field in [*input_schema.items(), *output_schema.items()]:
-            if field.annotation is None:
-                raise ValueError(
-                    f"{block.name} has a field {field_name} that is not annotated"
-                )
-            if field.json_schema_extra is None:
-                raise ValueError(
-                    f"{block.name} has a field {field_name} not defined as SchemaField"
-                )
-
-        for field in block.input_schema.model_fields.values():
-            if field.annotation is bool and field.default not in (True, False):
-                raise ValueError(
-                    f"{block.name} has a boolean field with no default value"
-                )
-
-        available_blocks[block.id] = block_cls
-
-    return available_blocks
-
-
-__all__ = ["load_all_blocks"]
-
-
-def all_subclasses(cls: type[T]) -> list[type[T]]:
+def all_subclasses(cls: Type[T]) -> list[Type[T]]:
     subclasses = cls.__subclasses__()
     for subclass in subclasses:
         subclasses += all_subclasses(subclass)
     return subclasses
+
+
+for block_cls in all_subclasses(Block):
+    name = block_cls.__name__
+
+    if block_cls.__name__.endswith("Base"):
+        continue
+
+    if not block_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"
+        )
+
+    block = block_cls.create()
+
+    if not isinstance(block.id, str) or len(block.id) != 36:
+        raise ValueError(f"Block ID {block.name} error: {block.id} is not a valid UUID")
+
+    if block.id in AVAILABLE_BLOCKS:
+        raise ValueError(f"Block ID {block.name} error: {block.id} is already in use")
+
+    input_schema = block.input_schema.model_fields
+    output_schema = block.output_schema.model_fields
+
+    # Prevent duplicate field name in input_schema and output_schema
+    duplicate_field_names = set(input_schema.keys()) & set(output_schema.keys())
+    if duplicate_field_names:
+        raise ValueError(
+            f"{block.name} has duplicate field names in input_schema and output_schema: {duplicate_field_names}"
+        )
+
+    # Make sure `error` field is a string in the output schema
+    if "error" in output_schema and output_schema["error"].annotation is not str:
+        raise ValueError(
+            f"{block.name} `error` field in output_schema must be a string"
+        )
+
+    # 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")
+
+    if block.disabled:
+        continue
+
+    AVAILABLE_BLOCKS[block.id] = block_cls
+
+__all__ = ["AVAILABLE_MODULES", "AVAILABLE_BLOCKS"]

autogpt_platform/backend/backend/blocks/agent.py

@@ -1,199 +0,0 @@
-import asyncio
-import logging
-from typing import Any, Optional
-
-from pydantic import JsonValue
-
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockInput,
-    BlockOutput,
-    BlockSchema,
-    BlockType,
-    get_block,
-)
-from backend.data.execution import ExecutionStatus
-from backend.data.model import SchemaField
-from backend.util import json, retry
-
-_logger = logging.getLogger(__name__)
-
-
-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")
-
-        inputs: 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")
-
-        nodes_input_masks: Optional[dict[str, dict[str, JsonValue]]] = SchemaField(
-            default=None, hidden=True
-        )
-
-        @classmethod
-        def get_input_schema(cls, data: BlockInput) -> dict[str, Any]:
-            return data.get("input_schema", {})
-
-        @classmethod
-        def get_input_defaults(cls, data: BlockInput) -> BlockInput:
-            return data.get("inputs", {})
-
-        @classmethod
-        def get_missing_input(cls, data: BlockInput) -> set[str]:
-            required_fields = cls.get_input_schema(data).get("required", [])
-            return set(required_fields) - set(data)
-
-        @classmethod
-        def get_mismatch_error(cls, data: BlockInput) -> str | None:
-            return json.validate_with_jsonschema(cls.get_input_schema(data), data)
-
-    class Output(BlockSchema):
-        pass
-
-    def __init__(self):
-        super().__init__(
-            id="e189baac-8c20-45a1-94a7-55177ea42565",
-            description="Executes an existing agent inside your agent",
-            input_schema=AgentExecutorBlock.Input,
-            output_schema=AgentExecutorBlock.Output,
-            block_type=BlockType.AGENT,
-            categories={BlockCategory.AGENT},
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-
-        from backend.executor import utils as execution_utils
-
-        graph_exec = await execution_utils.add_graph_execution(
-            graph_id=input_data.graph_id,
-            graph_version=input_data.graph_version,
-            user_id=input_data.user_id,
-            inputs=input_data.inputs,
-            nodes_input_masks=input_data.nodes_input_masks,
-            use_db_query=False,
-        )
-
-        logger = execution_utils.LogMetadata(
-            logger=_logger,
-            user_id=input_data.user_id,
-            graph_eid=graph_exec.id,
-            graph_id=input_data.graph_id,
-            node_eid="*",
-            node_id="*",
-            block_name=self.name,
-        )
-
-        try:
-            async for name, data in self._run(
-                graph_id=input_data.graph_id,
-                graph_version=input_data.graph_version,
-                graph_exec_id=graph_exec.id,
-                user_id=input_data.user_id,
-                logger=logger,
-            ):
-                yield name, data
-        except asyncio.CancelledError:
-            await self._stop(
-                graph_exec_id=graph_exec.id,
-                user_id=input_data.user_id,
-                logger=logger,
-            )
-            logger.warning(
-                f"Execution of graph {input_data.graph_id}v{input_data.graph_version} was cancelled."
-            )
-        except Exception as e:
-            await self._stop(
-                graph_exec_id=graph_exec.id,
-                user_id=input_data.user_id,
-                logger=logger,
-            )
-            logger.error(
-                f"Execution of graph {input_data.graph_id}v{input_data.graph_version} failed: {e}, execution is stopped."
-            )
-            raise
-
-    async def _run(
-        self,
-        graph_id: str,
-        graph_version: int,
-        graph_exec_id: str,
-        user_id: str,
-        logger,
-    ) -> BlockOutput:
-
-        from backend.data.execution import ExecutionEventType
-        from backend.executor import utils as execution_utils
-
-        event_bus = execution_utils.get_async_execution_event_bus()
-
-        log_id = f"Graph #{graph_id}-V{graph_version}, exec-id: {graph_exec_id}"
-        logger.info(f"Starting execution of {log_id}")
-
-        async for event in event_bus.listen(
-            user_id=user_id,
-            graph_id=graph_id,
-            graph_exec_id=graph_exec_id,
-        ):
-            if event.status not in [
-                ExecutionStatus.COMPLETED,
-                ExecutionStatus.TERMINATED,
-                ExecutionStatus.FAILED,
-            ]:
-                logger.debug(
-                    f"Execution {log_id} received event {event.event_type} with status {event.status}"
-                )
-                continue
-
-            if event.event_type == ExecutionEventType.GRAPH_EXEC_UPDATE:
-                # If the graph execution is COMPLETED, TERMINATED, or FAILED,
-                # we can stop listening for further events.
-                break
-
-            logger.debug(
-                f"Execution {log_id} produced input {event.input_data} output {event.output_data}"
-            )
-
-            if not event.block_id:
-                logger.warning(f"{log_id} received event without block_id {event}")
-                continue
-
-            block = get_block(event.block_id)
-            if not block or block.block_type != BlockType.OUTPUT:
-                continue
-
-            output_name = event.input_data.get("name")
-            if not output_name:
-                logger.warning(f"{log_id} produced an output with no name {event}")
-                continue
-
-            for output_data in event.output_data.get("output", []):
-                logger.debug(
-                    f"Execution {log_id} produced {output_name}: {output_data}"
-                )
-                yield output_name, output_data
-
-    @retry.func_retry
-    async def _stop(
-        self,
-        graph_exec_id: str,
-        user_id: str,
-        logger,
-    ) -> None:
-        from backend.executor import utils as execution_utils
-
-        log_id = f"Graph exec-id: {graph_exec_id}"
-        logger.info(f"Stopping execution of {log_id}")
-
-        try:
-            await execution_utils.stop_graph_execution(
-                graph_exec_id=graph_exec_id,
-                user_id=user_id,
-                use_db_query=False,
-            )
-            logger.info(f"Execution {log_id} stopped successfully.")
-        except Exception as e:
-            logger.error(f"Failed to stop execution {log_id}: {e}")

autogpt_platform/backend/backend/blocks/ai_image_generator_block.py

@@ -1,325 +0,0 @@
-from enum import Enum
-from typing import Literal
-
-from pydantic import SecretStr
-from replicate.client import Client as ReplicateClient
-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"
-            },
-        )
-
-    async def _run_client(
-        self, credentials: APIKeyCredentials, model_name: str, input_params: dict
-    ):
-        try:
-            # Initialize Replicate client
-            client = ReplicateClient(api_token=credentials.api_key.get_secret_value())
-
-            # Run the model with input parameters
-            output = await client.async_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}")
-
-    async 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 = await 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 = await 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 = await 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 = await 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 ""
-
-    async def run(self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs):
-        try:
-            url = await 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 asyncio
-import logging
-from enum import Enum
-from typing import Literal
-
-from pydantic import SecretStr
-from replicate.client import Client as ReplicateClient
-
-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,
-        )
-
-    async 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 = await 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:
-                    await asyncio.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}"
-
-    async 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 = ReplicateClient(api_token=api_key.get_secret_value())
-
-        # Run the model with parameters
-        output = await client.async_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,20 +1,14 @@
-import asyncio
 import logging
 import time
 from enum import Enum
 from typing import Literal
 
+from autogpt_libs.supabase_integration_credentials_store.types import APIKeyCredentials
 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
+from backend.data.model import CredentialsField, CredentialsMetaInput, SchemaField
+from backend.util.request import requests
 
 TEST_CREDENTIALS = APIKeyCredentials(
     id="01234567-89ab-cdef-0123-456789abcdef",
@@ -53,7 +47,6 @@ class AudioTrack(str, Enum):
     REFRESHER = ("Refresher",)
     TOURIST = ("Tourist",)
     TWIN_TYCHES = ("Twin Tyches",)
-    DONT_STOP_ME_ABSTRACT_FUTURE_BASS = ("Dont Stop Me Abstract Future Bass",)
 
     @property
     def audio_url(self):
@@ -79,7 +72,6 @@ class AudioTrack(str, Enum):
             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",
-            AudioTrack.DONT_STOP_ME_ABSTRACT_FUTURE_BASS: "https://cdn.revid.ai/audio/_dont-stop-me-abstract-future-bass.mp3",
         }
         return audio_urls[self]
 
@@ -107,7 +99,6 @@ class GenerationPreset(str, Enum):
     MOVIE = ("Movie",)
     STYLIZED_ILLUSTRATION = ("Stylized Illustration",)
     MANGA = ("Manga",)
-    DEFAULT = ("DEFAULT",)
 
 
 class Voice(str, Enum):
@@ -117,7 +108,6 @@ class Voice(str, Enum):
     JESSICA = "Jessica"
     CHARLOTTE = "Charlotte"
     CALLUM = "Callum"
-    EVA = "Eva"
 
     @property
     def voice_id(self):
@@ -128,7 +118,6 @@ class Voice(str, Enum):
             Voice.JESSICA: "cgSgspJ2msm6clMCkdW9",
             Voice.CHARLOTTE: "XB0fDUnXU5powFXDhCwa",
             Voice.CALLUM: "N2lVS1w4EtoT3dr4eOWO",
-            Voice.EVA: "FGY2WhTYpPnrIDTdsKH5",
         }
         return voice_id_map[self]
 
@@ -146,14 +135,14 @@ logger = logging.getLogger(__name__)
 
 
 class AIShortformVideoCreatorBlock(Block):
-    """Creates a short‑form text‑to‑video clip using stock or AI imagery."""
-
     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.",
+        credentials: CredentialsMetaInput[Literal["revid"], Literal["api_key"]] = (
+            CredentialsField(
+                provider="revid",
+                supported_credential_types={"api_key"},
+                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.""",
@@ -191,58 +180,6 @@ class AIShortformVideoCreatorBlock(Block):
         video_url: str = SchemaField(description="The URL of the created video")
         error: str = SchemaField(description="Error message if the request failed")
 
-    async def create_webhook(self) -> tuple[str, str]:
-        """Create a new webhook URL for receiving notifications."""
-        url = "https://webhook.site/token"
-        headers = {"Accept": "application/json", "Content-Type": "application/json"}
-        response = await Requests().post(url, headers=headers)
-        webhook_data = response.json()
-        return webhook_data["uuid"], f"https://webhook.site/{webhook_data['uuid']}"
-
-    async def create_video(self, api_key: SecretStr, payload: dict) -> dict:
-        """Create a video using the Revid API."""
-        url = "https://www.revid.ai/api/public/v2/render"
-        headers = {"key": api_key.get_secret_value()}
-        response = await Requests().post(url, json=payload, headers=headers)
-        logger.debug(
-            f"API Response Status Code: {response.status}, Content: {response.text}"
-        )
-        return response.json()
-
-    async def check_video_status(self, api_key: SecretStr, pid: str) -> dict:
-        """Check the status of a video creation job."""
-        url = f"https://www.revid.ai/api/public/v2/status?pid={pid}"
-        headers = {"key": api_key.get_secret_value()}
-        response = await Requests().get(url, headers=headers)
-        return response.json()
-
-    async def wait_for_video(
-        self,
-        api_key: SecretStr,
-        pid: str,
-        max_wait_time: int = 1000,
-    ) -> str:
-        """Wait for video creation to complete and return the video URL."""
-        start_time = time.time()
-        while time.time() - start_time < max_wait_time:
-            status = await 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')}")
-
-            await asyncio.sleep(10)
-
-        logger.error("Video creation timed out")
-        raise TimeoutError("Video creation timed out")
-
     def __init__(self):
         super().__init__(
             id="361697fb-0c4f-4feb-aed3-8320c88c771b",
@@ -261,41 +198,91 @@ class AIShortformVideoCreatorBlock(Block):
                 "voice": Voice.LILY,
                 "video_style": VisualMediaType.STOCK_VIDEOS,
             },
-            test_output=("video_url", "https://example.com/video.mp4"),
+            test_output=(
+                "video_url",
+                "https://example.com/video.mp4",
+            ),
             test_mock={
-                "create_webhook": lambda *args, **kwargs: (
+                "create_webhook": lambda: (
                     "test_uuid",
                     "https://webhook.site/test_uuid",
                 ),
-                "create_video": lambda *args, **kwargs: {"pid": "test_pid"},
-                "check_video_status": lambda *args, **kwargs: {
-                    "status": "ready",
-                    "videoUrl": "https://example.com/video.mp4",
-                },
-                "wait_for_video": lambda *args, **kwargs: "https://example.com/video.mp4",
+                "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,
         )
 
-    async def run(
+    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 = await self.create_webhook()
+        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": None,
+            "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.value,
+                "selectedAudio": input_data.background_music,
                 "origin": "/create",
                 "inputText": input_data.script,
                 "flowType": "text-to-video",
@@ -311,12 +298,12 @@ class AIShortformVideoCreatorBlock(Block):
                 "selectedStoryStyle": {"value": "custom", "label": "Custom"},
                 "hasToGenerateVideos": input_data.video_style
                 != VisualMediaType.STOCK_VIDEOS,
-                "audioUrl": input_data.background_music.audio_url,
+                "audioUrl": audio_url,
             },
         }
 
         logger.debug("Creating video...")
-        response = await self.create_video(credentials.api_key, payload)
+        response = self.create_video(credentials.api_key, payload)
         pid = response.get("pid")
 
         if not pid:
@@ -328,370 +315,6 @@ class AIShortformVideoCreatorBlock(Block):
             logger.debug(
                 f"Video created with project ID: {pid}. Waiting for completion..."
             )
-            video_url = await self.wait_for_video(credentials.api_key, pid)
+            video_url = self.wait_for_video(credentials.api_key, pid, webhook_token)
             logger.debug(f"Video ready: {video_url}")
             yield "video_url", video_url
-
-
-class AIAdMakerVideoCreatorBlock(Block):
-    """Generates a 30‑second vertical AI advert using optional user‑supplied imagery."""
-
-    class Input(BlockSchema):
-        credentials: CredentialsMetaInput[
-            Literal[ProviderName.REVID], Literal["api_key"]
-        ] = CredentialsField(
-            description="Credentials for Revid.ai API access.",
-        )
-        script: str = SchemaField(
-            description="Short advertising copy. Line breaks create new scenes.",
-            placeholder="Introducing Foobar – [show product photo] the gadget that does it all.",
-        )
-        ratio: str = SchemaField(description="Aspect ratio", default="9 / 16")
-        target_duration: int = SchemaField(
-            description="Desired length of the ad in seconds.", default=30
-        )
-        voice: Voice = SchemaField(
-            description="Narration voice", default=Voice.EVA, placeholder=Voice.EVA
-        )
-        background_music: AudioTrack = SchemaField(
-            description="Background track",
-            default=AudioTrack.DONT_STOP_ME_ABSTRACT_FUTURE_BASS,
-        )
-        input_media_urls: list[str] = SchemaField(
-            description="List of image URLs to feature in the advert.", default=[]
-        )
-        use_only_provided_media: bool = SchemaField(
-            description="Restrict visuals to supplied images only.", default=True
-        )
-
-    class Output(BlockSchema):
-        video_url: str = SchemaField(description="URL of the finished advert")
-        error: str = SchemaField(description="Error message on failure")
-
-    async def create_webhook(self) -> tuple[str, str]:
-        """Create a new webhook URL for receiving notifications."""
-        url = "https://webhook.site/token"
-        headers = {"Accept": "application/json", "Content-Type": "application/json"}
-        response = await Requests().post(url, headers=headers)
-        webhook_data = response.json()
-        return webhook_data["uuid"], f"https://webhook.site/{webhook_data['uuid']}"
-
-    async def create_video(self, api_key: SecretStr, payload: dict) -> dict:
-        """Create a video using the Revid API."""
-        url = "https://www.revid.ai/api/public/v2/render"
-        headers = {"key": api_key.get_secret_value()}
-        response = await Requests().post(url, json=payload, headers=headers)
-        logger.debug(
-            f"API Response Status Code: {response.status}, Content: {response.text}"
-        )
-        return response.json()
-
-    async def check_video_status(self, api_key: SecretStr, pid: str) -> dict:
-        """Check the status of a video creation job."""
-        url = f"https://www.revid.ai/api/public/v2/status?pid={pid}"
-        headers = {"key": api_key.get_secret_value()}
-        response = await Requests().get(url, headers=headers)
-        return response.json()
-
-    async def wait_for_video(
-        self,
-        api_key: SecretStr,
-        pid: str,
-        max_wait_time: int = 1000,
-    ) -> str:
-        """Wait for video creation to complete and return the video URL."""
-        start_time = time.time()
-        while time.time() - start_time < max_wait_time:
-            status = await 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')}")
-
-            await asyncio.sleep(10)
-
-        logger.error("Video creation timed out")
-        raise TimeoutError("Video creation timed out")
-
-    def __init__(self):
-        super().__init__(
-            id="58bd2a19-115d-4fd1-8ca4-13b9e37fa6a0",
-            description="Creates an AI‑generated 30‑second advert (text + images)",
-            categories={BlockCategory.MARKETING, BlockCategory.AI},
-            input_schema=AIAdMakerVideoCreatorBlock.Input,
-            output_schema=AIAdMakerVideoCreatorBlock.Output,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "script": "Test product launch!",
-                "input_media_urls": [
-                    "https://cdn.revid.ai/uploads/1747076315114-image.png",
-                ],
-            },
-            test_output=("video_url", "https://example.com/ad.mp4"),
-            test_mock={
-                "create_webhook": lambda *args, **kwargs: (
-                    "test_uuid",
-                    "https://webhook.site/test_uuid",
-                ),
-                "create_video": lambda *args, **kwargs: {"pid": "test_pid"},
-                "check_video_status": lambda *args, **kwargs: {
-                    "status": "ready",
-                    "videoUrl": "https://example.com/ad.mp4",
-                },
-                "wait_for_video": lambda *args, **kwargs: "https://example.com/ad.mp4",
-            },
-            test_credentials=TEST_CREDENTIALS,
-        )
-
-    async def run(self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs):
-        webhook_token, webhook_url = await self.create_webhook()
-
-        payload = {
-            "webhook": webhook_url,
-            "creationParams": {
-                "targetDuration": input_data.target_duration,
-                "ratio": input_data.ratio,
-                "mediaType": "aiVideo",
-                "inputText": input_data.script,
-                "flowType": "text-to-video",
-                "slug": "ai-ad-generator",
-                "slugNew": "",
-                "isCopiedFrom": False,
-                "hasToGenerateVoice": True,
-                "hasToTranscript": False,
-                "hasToSearchMedia": True,
-                "hasAvatar": False,
-                "hasWebsiteRecorder": False,
-                "hasTextSmallAtBottom": False,
-                "selectedAudio": input_data.background_music.value,
-                "selectedVoice": input_data.voice.voice_id,
-                "selectedAvatar": "https://cdn.revid.ai/avatars/young-woman.mp4",
-                "selectedAvatarType": "video/mp4",
-                "websiteToRecord": "",
-                "hasToGenerateCover": True,
-                "nbGenerations": 1,
-                "disableCaptions": False,
-                "mediaMultiplier": "medium",
-                "characters": [],
-                "captionPresetName": "Revid",
-                "sourceType": "contentScraping",
-                "selectedStoryStyle": {"value": "custom", "label": "General"},
-                "generationPreset": "DEFAULT",
-                "hasToGenerateMusic": False,
-                "isOptimizedForChinese": False,
-                "generationUserPrompt": "",
-                "enableNsfwFilter": False,
-                "addStickers": False,
-                "typeMovingImageAnim": "dynamic",
-                "hasToGenerateSoundEffects": False,
-                "forceModelType": "gpt-image-1",
-                "selectedCharacters": [],
-                "lang": "",
-                "voiceSpeed": 1,
-                "disableAudio": False,
-                "disableVoice": False,
-                "useOnlyProvidedMedia": input_data.use_only_provided_media,
-                "imageGenerationModel": "ultra",
-                "videoGenerationModel": "pro",
-                "hasEnhancedGeneration": True,
-                "hasEnhancedGenerationPro": True,
-                "inputMedias": [
-                    {"url": url, "title": "", "type": "image"}
-                    for url in input_data.input_media_urls
-                ],
-                "hasToGenerateVideos": True,
-                "audioUrl": input_data.background_music.audio_url,
-                "watermark": None,
-            },
-        }
-
-        response = await self.create_video(credentials.api_key, payload)
-        pid = response.get("pid")
-        if not pid:
-            raise RuntimeError("Failed to create video: No project ID returned")
-
-        video_url = await self.wait_for_video(credentials.api_key, pid)
-        yield "video_url", video_url
-
-
-class AIScreenshotToVideoAdBlock(Block):
-    """Creates an advert where the supplied screenshot is narrated by an AI avatar."""
-
-    class Input(BlockSchema):
-        credentials: CredentialsMetaInput[
-            Literal[ProviderName.REVID], Literal["api_key"]
-        ] = CredentialsField(description="Revid.ai API key")
-        script: str = SchemaField(
-            description="Narration that will accompany the screenshot.",
-            placeholder="Check out these amazing stats!",
-        )
-        screenshot_url: str = SchemaField(
-            description="Screenshot or image URL to showcase."
-        )
-        ratio: str = SchemaField(default="9 / 16")
-        target_duration: int = SchemaField(default=30)
-        voice: Voice = SchemaField(default=Voice.EVA)
-        background_music: AudioTrack = SchemaField(
-            default=AudioTrack.DONT_STOP_ME_ABSTRACT_FUTURE_BASS
-        )
-
-    class Output(BlockSchema):
-        video_url: str = SchemaField(description="Rendered video URL")
-        error: str = SchemaField(description="Error, if encountered")
-
-    async def create_webhook(self) -> tuple[str, str]:
-        """Create a new webhook URL for receiving notifications."""
-        url = "https://webhook.site/token"
-        headers = {"Accept": "application/json", "Content-Type": "application/json"}
-        response = await Requests().post(url, headers=headers)
-        webhook_data = response.json()
-        return webhook_data["uuid"], f"https://webhook.site/{webhook_data['uuid']}"
-
-    async def create_video(self, api_key: SecretStr, payload: dict) -> dict:
-        """Create a video using the Revid API."""
-        url = "https://www.revid.ai/api/public/v2/render"
-        headers = {"key": api_key.get_secret_value()}
-        response = await Requests().post(url, json=payload, headers=headers)
-        logger.debug(
-            f"API Response Status Code: {response.status}, Content: {response.text}"
-        )
-        return response.json()
-
-    async def check_video_status(self, api_key: SecretStr, pid: str) -> dict:
-        """Check the status of a video creation job."""
-        url = f"https://www.revid.ai/api/public/v2/status?pid={pid}"
-        headers = {"key": api_key.get_secret_value()}
-        response = await Requests().get(url, headers=headers)
-        return response.json()
-
-    async def wait_for_video(
-        self,
-        api_key: SecretStr,
-        pid: str,
-        max_wait_time: int = 1000,
-    ) -> str:
-        """Wait for video creation to complete and return the video URL."""
-        start_time = time.time()
-        while time.time() - start_time < max_wait_time:
-            status = await 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')}")
-
-            await asyncio.sleep(10)
-
-        logger.error("Video creation timed out")
-        raise TimeoutError("Video creation timed out")
-
-    def __init__(self):
-        super().__init__(
-            id="0f3e4635-e810-43d9-9e81-49e6f4e83b7c",
-            description="Turns a screenshot into an engaging, avatar‑narrated video advert.",
-            categories={BlockCategory.AI, BlockCategory.MARKETING},
-            input_schema=AIScreenshotToVideoAdBlock.Input,
-            output_schema=AIScreenshotToVideoAdBlock.Output,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "script": "Amazing numbers!",
-                "screenshot_url": "https://cdn.revid.ai/uploads/1747080376028-image.png",
-            },
-            test_output=("video_url", "https://example.com/screenshot.mp4"),
-            test_mock={
-                "create_webhook": lambda *args, **kwargs: (
-                    "test_uuid",
-                    "https://webhook.site/test_uuid",
-                ),
-                "create_video": lambda *args, **kwargs: {"pid": "test_pid"},
-                "check_video_status": lambda *args, **kwargs: {
-                    "status": "ready",
-                    "videoUrl": "https://example.com/screenshot.mp4",
-                },
-                "wait_for_video": lambda *args, **kwargs: "https://example.com/screenshot.mp4",
-            },
-            test_credentials=TEST_CREDENTIALS,
-        )
-
-    async def run(self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs):
-        webhook_token, webhook_url = await self.create_webhook()
-
-        payload = {
-            "webhook": webhook_url,
-            "creationParams": {
-                "targetDuration": input_data.target_duration,
-                "ratio": input_data.ratio,
-                "mediaType": "aiVideo",
-                "hasAvatar": True,
-                "removeAvatarBackground": True,
-                "inputText": input_data.script,
-                "flowType": "text-to-video",
-                "slug": "ai-ad-generator",
-                "slugNew": "screenshot-to-video-ad",
-                "isCopiedFrom": "ai-ad-generator",
-                "hasToGenerateVoice": True,
-                "hasToTranscript": False,
-                "hasToSearchMedia": True,
-                "hasWebsiteRecorder": False,
-                "hasTextSmallAtBottom": False,
-                "selectedAudio": input_data.background_music.value,
-                "selectedVoice": input_data.voice.voice_id,
-                "selectedAvatar": "https://cdn.revid.ai/avatars/young-woman.mp4",
-                "selectedAvatarType": "video/mp4",
-                "websiteToRecord": "",
-                "hasToGenerateCover": True,
-                "nbGenerations": 1,
-                "disableCaptions": False,
-                "mediaMultiplier": "medium",
-                "characters": [],
-                "captionPresetName": "Revid",
-                "sourceType": "contentScraping",
-                "selectedStoryStyle": {"value": "custom", "label": "General"},
-                "generationPreset": "DEFAULT",
-                "hasToGenerateMusic": False,
-                "isOptimizedForChinese": False,
-                "generationUserPrompt": "",
-                "enableNsfwFilter": False,
-                "addStickers": False,
-                "typeMovingImageAnim": "dynamic",
-                "hasToGenerateSoundEffects": False,
-                "forceModelType": "gpt-image-1",
-                "selectedCharacters": [],
-                "lang": "",
-                "voiceSpeed": 1,
-                "disableAudio": False,
-                "disableVoice": False,
-                "useOnlyProvidedMedia": True,
-                "imageGenerationModel": "ultra",
-                "videoGenerationModel": "ultra",
-                "hasEnhancedGeneration": True,
-                "hasEnhancedGenerationPro": True,
-                "inputMedias": [
-                    {"url": input_data.screenshot_url, "title": "", "type": "image"}
-                ],
-                "hasToGenerateVideos": True,
-                "audioUrl": input_data.background_music.audio_url,
-                "watermark": None,
-            },
-        }
-
-        response = await self.create_video(credentials.api_key, payload)
-        pid = response.get("pid")
-        if not pid:
-            raise RuntimeError("Failed to create video: No project ID returned")
-
-        video_url = await self.wait_for_video(credentials.api_key, pid)
-        yield "video_url", video_url

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

@@ -1,131 +0,0 @@
-import logging
-from typing import List
-
-from backend.blocks.apollo._auth import ApolloCredentials
-from backend.blocks.apollo.models import (
-    Contact,
-    EnrichPersonRequest,
-    Organization,
-    SearchOrganizationsRequest,
-    SearchOrganizationsResponse,
-    SearchPeopleRequest,
-    SearchPeopleResponse,
-)
-from backend.util.request import Requests
-
-logger = logging.getLogger(name=__name__)
-
-
-class ApolloClient:
-    """Client for the Apollo API"""
-
-    API_URL = "https://api.apollo.io/api/v1"
-
-    def __init__(self, credentials: ApolloCredentials):
-        self.credentials = credentials
-        self.requests = Requests()
-
-    def _get_headers(self) -> dict[str, str]:
-        return {"x-api-key": self.credentials.api_key.get_secret_value()}
-
-    async def search_people(self, query: SearchPeopleRequest) -> List[Contact]:
-        """Search for people in Apollo"""
-        response = await self.requests.post(
-            f"{self.API_URL}/mixed_people/search",
-            headers=self._get_headers(),
-            json=query.model_dump(exclude={"max_results"}),
-        )
-        data = response.json()
-        parsed_response = SearchPeopleResponse(**data)
-        if parsed_response.pagination.total_entries == 0:
-            return []
-
-        people = parsed_response.people
-
-        # handle pagination
-        if (
-            query.max_results is not None
-            and query.max_results < parsed_response.pagination.total_entries
-            and len(people) < query.max_results
-        ):
-            while (
-                len(people) < query.max_results
-                and query.page < parsed_response.pagination.total_pages
-                and len(parsed_response.people) > 0
-            ):
-                query.page += 1
-                response = await self.requests.post(
-                    f"{self.API_URL}/mixed_people/search",
-                    headers=self._get_headers(),
-                    json=query.model_dump(exclude={"max_results"}),
-                )
-                data = response.json()
-                parsed_response = SearchPeopleResponse(**data)
-                people.extend(parsed_response.people[: query.max_results - len(people)])
-
-        logger.info(f"Found {len(people)} people")
-        return people[: query.max_results] if query.max_results else people
-
-    async def search_organizations(
-        self, query: SearchOrganizationsRequest
-    ) -> List[Organization]:
-        """Search for organizations in Apollo"""
-        response = await self.requests.post(
-            f"{self.API_URL}/mixed_companies/search",
-            headers=self._get_headers(),
-            json=query.model_dump(exclude={"max_results"}),
-        )
-        data = response.json()
-        parsed_response = SearchOrganizationsResponse(**data)
-        if parsed_response.pagination.total_entries == 0:
-            return []
-
-        organizations = parsed_response.organizations
-
-        # handle pagination
-        if (
-            query.max_results is not None
-            and query.max_results < parsed_response.pagination.total_entries
-            and len(organizations) < query.max_results
-        ):
-            while (
-                len(organizations) < query.max_results
-                and query.page < parsed_response.pagination.total_pages
-                and len(parsed_response.organizations) > 0
-            ):
-                query.page += 1
-                response = await self.requests.post(
-                    f"{self.API_URL}/mixed_companies/search",
-                    headers=self._get_headers(),
-                    json=query.model_dump(exclude={"max_results"}),
-                )
-                data = response.json()
-                parsed_response = SearchOrganizationsResponse(**data)
-                organizations.extend(
-                    parsed_response.organizations[
-                        : query.max_results - len(organizations)
-                    ]
-                )
-
-        logger.info(f"Found {len(organizations)} organizations")
-        return (
-            organizations[: query.max_results] if query.max_results else organizations
-        )
-
-    async def enrich_person(self, query: EnrichPersonRequest) -> Contact:
-        """Enrich a person's data including email & phone reveal"""
-        response = await self.requests.post(
-            f"{self.API_URL}/people/match",
-            headers=self._get_headers(),
-            json=query.model_dump(),
-            params={
-                "reveal_personal_emails": "true",
-            },
-        )
-        data = response.json()
-        if "person" not in data:
-            raise ValueError(f"Person not found or enrichment failed: {data}")
-
-        contact = Contact(**data["person"])
-        contact.email = contact.email or "-"
-        return contact

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

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

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

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

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

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

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

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

autogpt_platform/backend/backend/blocks/apollo/person.py

@@ -1,138 +0,0 @@
-from backend.blocks.apollo._api import ApolloClient
-from backend.blocks.apollo._auth import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    ApolloCredentials,
-    ApolloCredentialsInput,
-)
-from backend.blocks.apollo.models import Contact, EnrichPersonRequest
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import CredentialsField, SchemaField
-
-
-class GetPersonDetailBlock(Block):
-    """Get detailed person data with Apollo API, including email reveal"""
-
-    class Input(BlockSchema):
-        person_id: str = SchemaField(
-            description="Apollo person ID to enrich (most accurate method)",
-            default="",
-            advanced=False,
-        )
-        first_name: str = SchemaField(
-            description="First name of the person to enrich",
-            default="",
-            advanced=False,
-        )
-        last_name: str = SchemaField(
-            description="Last name of the person to enrich",
-            default="",
-            advanced=False,
-        )
-        name: str = SchemaField(
-            description="Full name of the person to enrich (alternative to first_name + last_name)",
-            default="",
-            advanced=False,
-        )
-        email: str = SchemaField(
-            description="Known email address of the person (helps with matching)",
-            default="",
-            advanced=False,
-        )
-        domain: str = SchemaField(
-            description="Company domain of the person (e.g., 'google.com')",
-            default="",
-            advanced=False,
-        )
-        company: str = SchemaField(
-            description="Company name of the person",
-            default="",
-            advanced=False,
-        )
-        linkedin_url: str = SchemaField(
-            description="LinkedIn URL of the person",
-            default="",
-            advanced=False,
-        )
-        organization_id: str = SchemaField(
-            description="Apollo organization ID of the person's company",
-            default="",
-            advanced=True,
-        )
-        title: str = SchemaField(
-            description="Job title of the person to enrich",
-            default="",
-            advanced=True,
-        )
-        credentials: ApolloCredentialsInput = CredentialsField(
-            description="Apollo credentials",
-        )
-
-    class Output(BlockSchema):
-        contact: Contact = SchemaField(
-            description="Enriched contact information",
-        )
-        error: str = SchemaField(
-            description="Error message if enrichment failed",
-            default="",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="3b18d46c-3db6-42ae-a228-0ba441bdd176",
-            description="Get detailed person data with Apollo API, including email reveal",
-            categories={BlockCategory.SEARCH},
-            input_schema=GetPersonDetailBlock.Input,
-            output_schema=GetPersonDetailBlock.Output,
-            test_credentials=TEST_CREDENTIALS,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "first_name": "John",
-                "last_name": "Doe",
-                "company": "Google",
-            },
-            test_output=[
-                (
-                    "contact",
-                    Contact(
-                        id="1",
-                        name="John Doe",
-                        first_name="John",
-                        last_name="Doe",
-                        email="john.doe@gmail.com",
-                        title="Software Engineer",
-                        organization_name="Google",
-                        linkedin_url="https://www.linkedin.com/in/johndoe",
-                    ),
-                ),
-            ],
-            test_mock={
-                "enrich_person": lambda query, credentials: Contact(
-                    id="1",
-                    name="John Doe",
-                    first_name="John",
-                    last_name="Doe",
-                    email="john.doe@gmail.com",
-                    title="Software Engineer",
-                    organization_name="Google",
-                    linkedin_url="https://www.linkedin.com/in/johndoe",
-                )
-            },
-        )
-
-    @staticmethod
-    async def enrich_person(
-        query: EnrichPersonRequest, credentials: ApolloCredentials
-    ) -> Contact:
-        client = ApolloClient(credentials)
-        return await client.enrich_person(query)
-
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: ApolloCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        query = EnrichPersonRequest(**input_data.model_dump())
-        yield "contact", await self.enrich_person(query, credentials)

autogpt_platform/backend/backend/blocks/basic.py

@@ -1,51 +1,13 @@
-import enum
-from typing import Any
+import re
+from typing import Any, List
+
+from jinja2 import BaseLoader, Environment
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema, BlockType
 from backend.data.model import SchemaField
-from backend.util.file import store_media_file
-from backend.util.type import MediaFileType, convert
+from backend.util.mock import MockObject
 
-
-class FileStoreBlock(Block):
-    class Input(BlockSchema):
-        file_in: MediaFileType = SchemaField(
-            description="The file to store in the temporary directory, it can be a URL, data URI, or local path."
-        )
-        base_64: bool = SchemaField(
-            description="Whether produce an output in base64 format (not recommended, you can pass the string path just fine accross blocks).",
-            default=False,
-            advanced=True,
-            title="Produce Base64 Output",
-        )
-
-    class Output(BlockSchema):
-        file_out: MediaFileType = SchemaField(
-            description="The relative path to the stored file in the temporary directory."
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="cbb50872-625b-42f0-8203-a2ae78242d8a",
-            description="Stores the input file in the temporary directory.",
-            categories={BlockCategory.BASIC, BlockCategory.MULTIMEDIA},
-            input_schema=FileStoreBlock.Input,
-            output_schema=FileStoreBlock.Output,
-            static_output=True,
-        )
-
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        graph_exec_id: str,
-        **kwargs,
-    ) -> BlockOutput:
-        yield "file_out", await store_media_file(
-            graph_exec_id=graph_exec_id,
-            file=input_data.file_in,
-            return_content=input_data.base_64,
-        )
+jinja = Environment(loader=BaseLoader())
 
 
 class StoreValueBlock(Block):
@@ -87,16 +49,15 @@ class StoreValueBlock(Block):
             static_output=True,
         )
 
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
         yield "output", input_data.data or input_data.input
 
 
 class PrintToConsoleBlock(Block):
     class Input(BlockSchema):
-        text: Any = SchemaField(description="The data to print to the console.")
+        text: str = SchemaField(description="The text to print to the console.")
 
     class Output(BlockSchema):
-        output: Any = SchemaField(description="The data printed to the console.")
         status: str = SchemaField(description="The status of the print operation.")
 
     def __init__(self):
@@ -107,15 +68,376 @@ class PrintToConsoleBlock(Block):
             input_schema=PrintToConsoleBlock.Input,
             output_schema=PrintToConsoleBlock.Output,
             test_input={"text": "Hello, World!"},
+            test_output=("status", "printed"),
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        print(">>>>> Print: ", input_data.text)
+        yield "status", "printed"
+
+
+class FindInDictionaryBlock(Block):
+    class Input(BlockSchema):
+        input: Any = SchemaField(description="Dictionary to lookup from")
+        key: str | int = SchemaField(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"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="0e50422c-6dee-4145-83d6-3a5a392f65de",
+            description="Lookup the given key in the input dictionary/object/list and return the value.",
+            input_schema=FindInDictionaryBlock.Input,
+            output_schema=FindInDictionaryBlock.Output,
+            test_input=[
+                {"input": {"apple": 1, "banana": 2, "cherry": 3}, "key": "banana"},
+                {"input": {"x": 10, "y": 20, "z": 30}, "key": "w"},
+                {"input": [1, 2, 3], "key": 1},
+                {"input": [1, 2, 3], "key": 3},
+                {"input": MockObject(value="!!", key="key"), "key": "key"},
+                {"input": [{"k1": "v1"}, {"k2": "v2"}, {"k1": "v3"}], "key": "k1"},
+            ],
             test_output=[
-                ("output", "Hello, World!"),
-                ("status", "printed"),
+                ("output", 2),
+                ("missing", {"x": 10, "y": 20, "z": 30}),
+                ("output", 2),
+                ("missing", [1, 2, 3]),
+                ("output", "key"),
+                ("output", ["v1", "v3"]),
+            ],
+            categories={BlockCategory.BASIC},
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        obj = input_data.input
+        key = input_data.key
+
+        if isinstance(obj, dict) and key in obj:
+            yield "output", obj[key]
+        elif isinstance(obj, list) and isinstance(key, int) and 0 <= key < len(obj):
+            yield "output", obj[key]
+        elif isinstance(obj, list) and isinstance(key, str):
+            if len(obj) == 0:
+                yield "output", []
+            elif isinstance(obj[0], dict) and key in obj[0]:
+                yield "output", [item[key] for item in obj if key in item]
+            else:
+                yield "output", [getattr(val, key) for val in obj if hasattr(val, key)]
+        elif isinstance(obj, object) and isinstance(key, str) and hasattr(obj, key):
+            yield "output", getattr(obj, key)
+        else:
+            yield "missing", input_data.input
+
+
+class AgentInputBlock(Block):
+    """
+    This block is used to provide input to the graph.
+
+    It takes in a value, name, description, default values list and bool to limit selection to default values.
+
+    It Outputs the value passed as input.
+    """
+
+    class Input(BlockSchema):
+        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="The description of the input.",
+            default=None,
+            advanced=True,
+        )
+        placeholder_values: List[Any] = SchemaField(
+            description="The placeholder values to be passed as input.",
+            default=[],
+            advanced=True,
+        )
+        limit_to_placeholder_values: bool = SchemaField(
+            description="Whether to limit the selection to placeholder values.",
+            default=False,
+            advanced=True,
+        )
+        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.")
+
+    def __init__(self):
+        super().__init__(
+            id="c0a8e994-ebf1-4a9c-a4d8-89d09c86741b",
+            description="This block is used to provide input to the graph.",
+            input_schema=AgentInputBlock.Input,
+            output_schema=AgentInputBlock.Output,
+            test_input=[
+                {
+                    "value": "Hello, World!",
+                    "name": "input_1",
+                    "description": "This is a test input.",
+                    "placeholder_values": [],
+                    "limit_to_placeholder_values": False,
+                },
+                {
+                    "value": "Hello, World!",
+                    "name": "input_2",
+                    "description": "This is a test input.",
+                    "placeholder_values": ["Hello, World!"],
+                    "limit_to_placeholder_values": True,
+                },
+            ],
+            test_output=[
+                ("result", "Hello, World!"),
+                ("result", "Hello, World!"),
+            ],
+            categories={BlockCategory.INPUT, BlockCategory.BASIC},
+            block_type=BlockType.INPUT,
+            static_output=True,
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        yield "result", input_data.value
+
+
+class AgentOutputBlock(Block):
+    """
+    Records the output of the graph for users to see.
+
+    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.
+    """
+
+    class Input(BlockSchema):
+        value: Any = SchemaField(
+            description="The value to be recorded as output.",
+            default=None,
+            advanced=False,
+        )
+        name: str = SchemaField(description="The name of the output.")
+        title: str | None = SchemaField(
+            description="The title of the input.", default=None, advanced=True
+        )
+        description: str | None = 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.",
+            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,
+            advanced=True,
+        )
+
+    class Output(BlockSchema):
+        output: Any = SchemaField(description="The value recorded as output.")
+
+    def __init__(self):
+        super().__init__(
+            id="363ae599-353e-4804-937e-b2ee3cef3da4",
+            description=("Stores the output of the graph for users to see."),
+            input_schema=AgentOutputBlock.Input,
+            output_schema=AgentOutputBlock.Output,
+            test_input=[
+                {
+                    "value": "Hello, World!",
+                    "name": "output_1",
+                    "description": "This is a test output.",
+                    "format": "{{ output_1 }}!!",
+                },
+                {
+                    "value": "42",
+                    "name": "output_2",
+                    "description": "This is another test output.",
+                    "format": "{{ output_2 }}",
+                },
+                {
+                    "value": MockObject(value="!!", key="key"),
+                    "name": "output_3",
+                    "description": "This is a test output with a mock object.",
+                    "format": "{{ output_3 }}",
+                },
+            ],
+            test_output=[
+                ("output", "Hello, World!!!"),
+                ("output", "42"),
+                ("output", MockObject(value="!!", key="key")),
+            ],
+            categories={BlockCategory.OUTPUT, BlockCategory.BASIC},
+            block_type=BlockType.OUTPUT,
+            static_output=True,
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        """
+        Attempts to format the recorded_value using the fmt_string if provided.
+        If formatting fails or no fmt_string is given, returns the original recorded_value.
+        """
+        if input_data.format:
+            try:
+                fmt = re.sub(r"(?<!{){[ a-zA-Z0-9_]+}", r"{\g<0>}", input_data.format)
+                template = jinja.from_string(fmt)
+                yield "output", template.render({input_data.name: input_data.value})
+            except Exception as e:
+                yield "output", f"Error: {e}, {input_data.value}"
+        else:
+            yield "output", input_data.value
+
+
+class AddToDictionaryBlock(Block):
+    class Input(BlockSchema):
+        dictionary: dict | None = SchemaField(
+            default=None,
+            description="The dictionary to add the entry to. If not provided, a new dictionary will be created.",
+            placeholder='{"key1": "value1", "key2": "value2"}',
+        )
+        key: str = SchemaField(
+            description="The key for the new entry.", placeholder="new_key"
+        )
+        value: Any = SchemaField(
+            description="The value for the new entry.", placeholder="new_value"
+        )
+
+    class Output(BlockSchema):
+        updated_dictionary: dict = SchemaField(
+            description="The dictionary with the new entry added."
+        )
+        error: str = SchemaField(description="Error message if the operation failed.")
+
+    def __init__(self):
+        super().__init__(
+            id="31d1064e-7446-4693-a7d4-65e5ca1180d1",
+            description="Adds a new key-value pair to a dictionary. If no dictionary is provided, a new one is created.",
+            categories={BlockCategory.BASIC},
+            input_schema=AddToDictionaryBlock.Input,
+            output_schema=AddToDictionaryBlock.Output,
+            test_input=[
+                {
+                    "dictionary": {"existing_key": "existing_value"},
+                    "key": "new_key",
+                    "value": "new_value",
+                },
+                {"key": "first_key", "value": "first_value"},
+            ],
+            test_output=[
+                (
+                    "updated_dictionary",
+                    {"existing_key": "existing_value", "new_key": "new_value"},
+                ),
+                ("updated_dictionary", {"first_key": "first_value"}),
             ],
         )
 
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        yield "output", input_data.text
-        yield "status", "printed"
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        # If no dictionary is provided, create a new one
+        if input_data.dictionary is None:
+            updated_dict = {}
+        else:
+            # Create a copy of the input dictionary to avoid modifying the original
+            updated_dict = input_data.dictionary.copy()
+
+        # Add the new key-value pair
+        updated_dict[input_data.key] = input_data.value
+
+        yield "updated_dictionary", updated_dict
+
+
+class AddToListBlock(Block):
+    class Input(BlockSchema):
+        list: List[Any] | None = SchemaField(
+            default=None,
+            description="The list to add the entry to. If not provided, a new list will be created.",
+            placeholder='[1, "string", {"key": "value"}]',
+        )
+        entry: Any = SchemaField(
+            description="The entry to add to the list. Can be of any type (string, int, dict, etc.).",
+            placeholder='{"new_key": "new_value"}',
+        )
+        position: int | None = SchemaField(
+            default=None,
+            description="The position to insert the new entry. If not provided, the entry will be appended to the end of the list.",
+            placeholder="0",
+        )
+
+    class Output(BlockSchema):
+        updated_list: List[Any] = SchemaField(
+            description="The list with the new entry added."
+        )
+        error: str = SchemaField(description="Error message if the operation failed.")
+
+    def __init__(self):
+        super().__init__(
+            id="aeb08fc1-2fc1-4141-bc8e-f758f183a822",
+            description="Adds a new entry to a list. The entry can be of any type. If no list is provided, a new one is created.",
+            categories={BlockCategory.BASIC},
+            input_schema=AddToListBlock.Input,
+            output_schema=AddToListBlock.Output,
+            test_input=[
+                {
+                    "list": [1, "string", {"existing_key": "existing_value"}],
+                    "entry": {"new_key": "new_value"},
+                    "position": 1,
+                },
+                {"entry": "first_entry"},
+                {"list": ["a", "b", "c"], "entry": "d"},
+            ],
+            test_output=[
+                (
+                    "updated_list",
+                    [
+                        1,
+                        {"new_key": "new_value"},
+                        "string",
+                        {"existing_key": "existing_value"},
+                    ],
+                ),
+                ("updated_list", ["first_entry"]),
+                ("updated_list", ["a", "b", "c", "d"]),
+            ],
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        # If no list is provided, create a new one
+        if input_data.list is None:
+            updated_list = []
+        else:
+            # Create a copy of the input list to avoid modifying the original
+            updated_list = input_data.list.copy()
+
+        # Add the new entry
+        if input_data.position is None:
+            updated_list.append(input_data.entry)
+        else:
+            updated_list.insert(input_data.position, input_data.entry)
+
+        yield "updated_list", updated_list
 
 
 class NoteBlock(Block):
@@ -139,50 +461,5 @@ class NoteBlock(Block):
             block_type=BlockType.NOTE,
         )
 
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
         yield "output", input_data.text
-
-
-class TypeOptions(enum.Enum):
-    STRING = "string"
-    NUMBER = "number"
-    BOOLEAN = "boolean"
-    LIST = "list"
-    DICTIONARY = "dictionary"
-
-
-class UniversalTypeConverterBlock(Block):
-    class Input(BlockSchema):
-        value: Any = SchemaField(
-            description="The value to convert to a universal type."
-        )
-        type: TypeOptions = SchemaField(description="The type to convert the value to.")
-
-    class Output(BlockSchema):
-        value: Any = SchemaField(description="The converted value.")
-        error: str = SchemaField(description="Error message if conversion failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="95d1b990-ce13-4d88-9737-ba5c2070c97b",
-            description="This block is used to convert a value to a universal type.",
-            categories={BlockCategory.BASIC},
-            input_schema=UniversalTypeConverterBlock.Input,
-            output_schema=UniversalTypeConverterBlock.Output,
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        try:
-            converted_value = convert(
-                input_data.value,
-                {
-                    TypeOptions.STRING: str,
-                    TypeOptions.NUMBER: float,
-                    TypeOptions.BOOLEAN: bool,
-                    TypeOptions.LIST: list,
-                    TypeOptions.DICTIONARY: dict,
-                }[input_data.type],
-            )
-            yield "value", converted_value
-        except Exception as e:
-            yield "error", f"Failed to convert value: {str(e)}"

autogpt_platform/backend/backend/blocks/block.py

@@ -38,7 +38,7 @@ class BlockInstallationBlock(Block):
             disabled=True,
         )
 
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
         code = input_data.code
 
         if search := re.search(r"class (\w+)\(Block\):", code):
@@ -64,7 +64,7 @@ class BlockInstallationBlock(Block):
 
             from backend.util.test import execute_block_test
 
-            await execute_block_test(block)
+            execute_block_test(block)
             yield "success", "Block installed successfully."
         except Exception as e:
             os.remove(file_path)

autogpt_platform/backend/backend/blocks/branching.py

@@ -3,7 +3,6 @@ from typing import Any
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
-from backend.util.type import convert
 
 
 class ComparisonOperator(Enum):
@@ -71,22 +70,16 @@ class ConditionBlock(Block):
             ],
         )
 
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
         operator = input_data.operator
 
         value1 = input_data.value1
         if isinstance(value1, str):
-            try:
-                value1 = float(value1.strip())
-            except ValueError:
-                value1 = value1.strip()
+            value1 = float(value1.strip())
 
         value2 = input_data.value2
         if isinstance(value2, str):
-            try:
-                value2 = float(value2.strip())
-            except ValueError:
-                value2 = value2.strip()
+            value2 = float(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
@@ -108,99 +101,3 @@ class ConditionBlock(Block):
             yield "yes_output", yes_value
         else:
             yield "no_output", no_value
-
-
-class IfInputMatchesBlock(Block):
-    class Input(BlockSchema):
-        input: Any = SchemaField(
-            description="The input to match against",
-            placeholder="For example: 10 or 'hello' or True",
-        )
-        value: Any = SchemaField(
-            description="The value to output if the input matches",
-            placeholder="For example: 'Greater' or 20 or False",
-        )
-        yes_value: Any = SchemaField(
-            description="The value to output if the input matches",
-            placeholder="For example: 'Greater' or 20 or False",
-            default=None,
-        )
-        no_value: Any = SchemaField(
-            description="The value to output if the input does not match",
-            placeholder="For example: 'Greater' or 20 or False",
-            default=None,
-        )
-
-    class Output(BlockSchema):
-        result: bool = SchemaField(
-            description="The result of the condition evaluation (True or False)"
-        )
-        yes_output: Any = SchemaField(
-            description="The output value if the condition is true"
-        )
-        no_output: Any = SchemaField(
-            description="The output value if the condition is false"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="6dbbc4b3-ca6c-42b6-b508-da52d23e13f2",
-            input_schema=IfInputMatchesBlock.Input,
-            output_schema=IfInputMatchesBlock.Output,
-            description="Handles conditional logic based on comparison operators",
-            categories={BlockCategory.LOGIC},
-            test_input=[
-                {
-                    "input": 10,
-                    "value": 10,
-                    "yes_value": "Greater",
-                    "no_value": "Not greater",
-                },
-                {
-                    "input": 10,
-                    "value": 20,
-                    "yes_value": "Greater",
-                    "no_value": "Not greater",
-                },
-                {
-                    "input": 10,
-                    "value": "None",
-                    "yes_value": "Yes",
-                    "no_value": "No",
-                },
-            ],
-            test_output=[
-                ("result", True),
-                ("yes_output", "Greater"),
-                ("result", False),
-                ("no_output", "Not greater"),
-                ("result", False),
-                ("no_output", "No"),
-                # ("result", True),
-                # ("yes_output", "Yes"),
-            ],
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-
-        # If input_data.value is not matching input_data.input, convert value to type of input
-        if (
-            input_data.input != input_data.value
-            and input_data.input is not input_data.value
-        ):
-            try:
-                # Only attempt conversion if input is not None and value is not None
-                if input_data.input is not None and input_data.value is not None:
-                    input_type = type(input_data.input)
-                    # Avoid converting if input_type is Any or object
-                    if input_type not in (Any, object):
-                        input_data.value = convert(input_data.value, input_type)
-            except Exception:
-                pass  # If conversion fails, just leave value as is
-
-        if input_data.input == input_data.value:
-            yield "result", True
-            yield "yes_output", input_data.yes_value
-        else:
-            yield "result", False
-            yield "no_output", input_data.no_value

autogpt_platform/backend/backend/blocks/code_executor.py

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

autogpt_platform/backend/backend/blocks/code_extraction_block.py

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

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

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

@@ -34,7 +34,7 @@ class ReadCsvBlock(Block):
         )
         skip_columns: list[str] = SchemaField(
             description="The columns to skip from the start of the row",
-            default_factory=list,
+            default=[],
         )
 
     class Output(BlockSchema):
@@ -69,7 +69,7 @@ class ReadCsvBlock(Block):
             ],
         )
 
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
         import csv
         from io import StringIO
 

autogpt_platform/backend/backend/blocks/data_manipulation.py

@@ -1,683 +0,0 @@
-from typing import Any, List
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-from backend.util.json import loads
-from backend.util.mock import MockObject
-from backend.util.prompt import estimate_token_count_str
-
-# =============================================================================
-# Dictionary Manipulation Blocks
-# =============================================================================
-
-
-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},
-                ),
-            ],
-        )
-
-    async 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 AddToDictionaryBlock(Block):
-    class Input(BlockSchema):
-        dictionary: dict[Any, Any] = SchemaField(
-            default_factory=dict,
-            description="The dictionary to add the entry to. If not provided, a new dictionary will be created.",
-        )
-        key: str = SchemaField(
-            default="",
-            description="The key for the new entry.",
-            placeholder="new_key",
-            advanced=False,
-        )
-        value: Any = SchemaField(
-            default=None,
-            description="The value for the new entry.",
-            placeholder="new_value",
-            advanced=False,
-        )
-        entries: dict[Any, Any] = SchemaField(
-            default_factory=dict,
-            description="The entries to add to the dictionary. This is the batch version of the `key` and `value` fields.",
-            advanced=True,
-        )
-
-    class Output(BlockSchema):
-        updated_dictionary: dict = SchemaField(
-            description="The dictionary with the new entry added."
-        )
-        error: str = SchemaField(description="Error message if the operation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="31d1064e-7446-4693-a7d4-65e5ca1180d1",
-            description="Adds a new key-value pair to a dictionary. If no dictionary is provided, a new one is created.",
-            categories={BlockCategory.BASIC},
-            input_schema=AddToDictionaryBlock.Input,
-            output_schema=AddToDictionaryBlock.Output,
-            test_input=[
-                {
-                    "dictionary": {"existing_key": "existing_value"},
-                    "key": "new_key",
-                    "value": "new_value",
-                },
-                {"key": "first_key", "value": "first_value"},
-                {
-                    "dictionary": {"existing_key": "existing_value"},
-                    "entries": {"new_key": "new_value", "first_key": "first_value"},
-                },
-            ],
-            test_output=[
-                (
-                    "updated_dictionary",
-                    {"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",
-                    },
-                ),
-            ],
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        updated_dict = input_data.dictionary.copy()
-
-        if input_data.value is not None and input_data.key:
-            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
-
-
-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")
-
-    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"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="0e50422c-6dee-4145-83d6-3a5a392f65de",
-            description="Lookup the given key in the input dictionary/object/list and return the value.",
-            input_schema=FindInDictionaryBlock.Input,
-            output_schema=FindInDictionaryBlock.Output,
-            test_input=[
-                {"input": {"apple": 1, "banana": 2, "cherry": 3}, "key": "banana"},
-                {"input": {"x": 10, "y": 20, "z": 30}, "key": "w"},
-                {"input": [1, 2, 3], "key": 1},
-                {"input": [1, 2, 3], "key": 3},
-                {"input": MockObject(value="!!", key="key"), "key": "key"},
-                {"input": [{"k1": "v1"}, {"k2": "v2"}, {"k1": "v3"}], "key": "k1"},
-            ],
-            test_output=[
-                ("output", 2),
-                ("missing", {"x": 10, "y": 20, "z": 30}),
-                ("output", 2),
-                ("missing", [1, 2, 3]),
-                ("output", "key"),
-                ("output", ["v1", "v3"]),
-            ],
-            categories={BlockCategory.BASIC},
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        obj = input_data.input
-        key = input_data.key
-
-        if isinstance(obj, str):
-            obj = loads(obj)
-
-        if isinstance(obj, dict) and key in obj:
-            yield "output", obj[key]
-        elif isinstance(obj, list) and isinstance(key, int) and 0 <= key < len(obj):
-            yield "output", obj[key]
-        elif isinstance(obj, list) and isinstance(key, str):
-            if len(obj) == 0:
-                yield "output", []
-            elif isinstance(obj[0], dict) and key in obj[0]:
-                yield "output", [item[key] for item in obj if key in item]
-            else:
-                yield "output", [getattr(val, key) for val in obj if hasattr(val, key)]
-        elif isinstance(obj, object) and isinstance(key, str) and hasattr(obj, key):
-            yield "output", getattr(obj, key)
-        else:
-            yield "missing", input_data.input
-
-
-class RemoveFromDictionaryBlock(Block):
-    class Input(BlockSchema):
-        dictionary: dict[Any, Any] = SchemaField(
-            description="The dictionary to modify."
-        )
-        key: str | int = SchemaField(description="Key to remove from the dictionary.")
-        return_value: bool = SchemaField(
-            default=False, description="Whether to return the removed value."
-        )
-
-    class Output(BlockSchema):
-        updated_dictionary: dict[Any, Any] = SchemaField(
-            description="The dictionary after removal."
-        )
-        removed_value: Any = SchemaField(description="The removed value if requested.")
-        error: str = SchemaField(description="Error message if the operation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="46afe2ea-c613-43f8-95ff-6692c3ef6876",
-            description="Removes a key-value pair from a dictionary.",
-            categories={BlockCategory.BASIC},
-            input_schema=RemoveFromDictionaryBlock.Input,
-            output_schema=RemoveFromDictionaryBlock.Output,
-            test_input=[
-                {
-                    "dictionary": {"a": 1, "b": 2, "c": 3},
-                    "key": "b",
-                    "return_value": True,
-                },
-                {"dictionary": {"x": "hello", "y": "world"}, "key": "x"},
-            ],
-            test_output=[
-                ("updated_dictionary", {"a": 1, "c": 3}),
-                ("removed_value", 2),
-                ("updated_dictionary", {"y": "world"}),
-            ],
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        updated_dict = input_data.dictionary.copy()
-        try:
-            removed_value = updated_dict.pop(input_data.key)
-            yield "updated_dictionary", updated_dict
-            if input_data.return_value:
-                yield "removed_value", removed_value
-        except KeyError:
-            yield "error", f"Key '{input_data.key}' not found in dictionary"
-
-
-class ReplaceDictionaryValueBlock(Block):
-    class Input(BlockSchema):
-        dictionary: dict[Any, Any] = SchemaField(
-            description="The dictionary to modify."
-        )
-        key: str | int = SchemaField(description="Key to replace the value for.")
-        value: Any = SchemaField(description="The new value for the given key.")
-
-    class Output(BlockSchema):
-        updated_dictionary: dict[Any, Any] = SchemaField(
-            description="The dictionary after replacement."
-        )
-        old_value: Any = SchemaField(description="The value that was replaced.")
-        error: str = SchemaField(description="Error message if the operation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="27e31876-18b6-44f3-ab97-f6226d8b3889",
-            description="Replaces the value for a specified key in a dictionary.",
-            categories={BlockCategory.BASIC},
-            input_schema=ReplaceDictionaryValueBlock.Input,
-            output_schema=ReplaceDictionaryValueBlock.Output,
-            test_input=[
-                {"dictionary": {"a": 1, "b": 2, "c": 3}, "key": "b", "value": 99},
-                {
-                    "dictionary": {"x": "hello", "y": "world"},
-                    "key": "y",
-                    "value": "universe",
-                },
-            ],
-            test_output=[
-                ("updated_dictionary", {"a": 1, "b": 99, "c": 3}),
-                ("old_value", 2),
-                ("updated_dictionary", {"x": "hello", "y": "universe"}),
-                ("old_value", "world"),
-            ],
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        updated_dict = input_data.dictionary.copy()
-        try:
-            old_value = updated_dict[input_data.key]
-            updated_dict[input_data.key] = input_data.value
-            yield "updated_dictionary", updated_dict
-            yield "old_value", old_value
-        except KeyError:
-            yield "error", f"Key '{input_data.key}' not found in dictionary"
-
-
-class DictionaryIsEmptyBlock(Block):
-    class Input(BlockSchema):
-        dictionary: dict[Any, Any] = SchemaField(description="The dictionary to check.")
-
-    class Output(BlockSchema):
-        is_empty: bool = SchemaField(description="True if the dictionary is empty.")
-
-    def __init__(self):
-        super().__init__(
-            id="a3cf3f64-6bb9-4cc6-9900-608a0b3359b0",
-            description="Checks if a dictionary is empty.",
-            categories={BlockCategory.BASIC},
-            input_schema=DictionaryIsEmptyBlock.Input,
-            output_schema=DictionaryIsEmptyBlock.Output,
-            test_input=[{"dictionary": {}}, {"dictionary": {"a": 1}}],
-            test_output=[("is_empty", True), ("is_empty", False)],
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        yield "is_empty", len(input_data.dictionary) == 0
-
-
-# =============================================================================
-# List Manipulation Blocks
-# =============================================================================
-
-
-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]",
-        )
-        max_size: int | None = SchemaField(
-            default=None,
-            description="Maximum size of the list. If provided, the list will be yielded in chunks of this size.",
-            advanced=True,
-        )
-        max_tokens: int | None = SchemaField(
-            default=None,
-            description="Maximum tokens for the list. If provided, the list will be yielded in chunks that fit within this token limit.",
-            advanced=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. This block can also yield the list in batches based on a maximum size or token limit.",
-            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"}],
-                ),
-            ],
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        chunk = []
-        cur_tokens, max_tokens = 0, input_data.max_tokens
-        cur_size, max_size = 0, input_data.max_size
-
-        for value in input_data.values:
-            if max_tokens:
-                tokens = estimate_token_count_str(value)
-            else:
-                tokens = 0
-
-            # Check if adding this value would exceed either limit
-            if (max_tokens and (cur_tokens + tokens > max_tokens)) or (
-                max_size and (cur_size + 1 > max_size)
-            ):
-                yield "list", chunk
-                chunk = [value]
-                cur_size, cur_tokens = 1, tokens
-            else:
-                chunk.append(value)
-                cur_size, cur_tokens = cur_size + 1, cur_tokens + tokens
-
-        # Yield final chunk if any
-        if chunk or not input_data.values:
-            yield "list", chunk
-
-
-class AddToListBlock(Block):
-    class Input(BlockSchema):
-        list: List[Any] = SchemaField(
-            default_factory=list,
-            advanced=False,
-            description="The list to add the entry to. If not provided, a new list will be created.",
-        )
-        entry: Any = SchemaField(
-            description="The entry to add to the list. Can be of any type (string, int, dict, etc.).",
-            advanced=False,
-            default=None,
-        )
-        entries: List[Any] = SchemaField(
-            default_factory=lambda: list(),
-            description="The entries to add to the list. This is the batch version of the `entry` field.",
-            advanced=True,
-        )
-        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.",
-        )
-
-    class Output(BlockSchema):
-        updated_list: List[Any] = SchemaField(
-            description="The list with the new entry added."
-        )
-        error: str = SchemaField(description="Error message if the operation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="aeb08fc1-2fc1-4141-bc8e-f758f183a822",
-            description="Adds a new entry to a list. The entry can be of any type. If no list is provided, a new one is created.",
-            categories={BlockCategory.BASIC},
-            input_schema=AddToListBlock.Input,
-            output_schema=AddToListBlock.Output,
-            test_input=[
-                {
-                    "list": [1, "string", {"existing_key": "existing_value"}],
-                    "entry": {"new_key": "new_value"},
-                    "position": 1,
-                },
-                {"entry": "first_entry"},
-                {"list": ["a", "b", "c"], "entry": "d"},
-                {
-                    "entry": "e",
-                    "entries": ["f", "g"],
-                    "list": ["a", "b"],
-                    "position": 1,
-                },
-            ],
-            test_output=[
-                (
-                    "updated_list",
-                    [
-                        1,
-                        {"new_key": "new_value"},
-                        "string",
-                        {"existing_key": "existing_value"},
-                    ],
-                ),
-                ("updated_list", ["first_entry"]),
-                ("updated_list", ["a", "b", "c", "d"]),
-                ("updated_list", ["a", "f", "g", "e", "b"]),
-            ],
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        entries_added = input_data.entries.copy()
-        if input_data.entry:
-            entries_added.append(input_data.entry)
-
-        updated_list = input_data.list.copy()
-        if (pos := input_data.position) is not None:
-            updated_list = updated_list[:pos] + entries_added + updated_list[pos:]
-        else:
-            updated_list += entries_added
-
-        yield "updated_list", updated_list
-
-
-class FindInListBlock(Block):
-    class Input(BlockSchema):
-        list: List[Any] = SchemaField(description="The list to search in.")
-        value: Any = SchemaField(description="The value to search for.")
-
-    class Output(BlockSchema):
-        index: int = SchemaField(description="The index of the value in the list.")
-        found: bool = SchemaField(
-            description="Whether the value was found in the list."
-        )
-        not_found_value: Any = SchemaField(
-            description="The value that was not found in the list."
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="5e2c6d0a-1e37-489f-b1d0-8e1812b23333",
-            description="Finds the index of the value in the list.",
-            categories={BlockCategory.BASIC},
-            input_schema=FindInListBlock.Input,
-            output_schema=FindInListBlock.Output,
-            test_input=[
-                {"list": [1, 2, 3, 4, 5], "value": 3},
-                {"list": [1, 2, 3, 4, 5], "value": 6},
-            ],
-            test_output=[
-                ("index", 2),
-                ("found", True),
-                ("found", False),
-                ("not_found_value", 6),
-            ],
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        try:
-            yield "index", input_data.list.index(input_data.value)
-            yield "found", True
-        except ValueError:
-            yield "found", False
-            yield "not_found_value", input_data.value
-
-
-class GetListItemBlock(Block):
-    class Input(BlockSchema):
-        list: List[Any] = SchemaField(description="The list to get the item from.")
-        index: int = SchemaField(
-            description="The 0-based index of the item (supports negative indices)."
-        )
-
-    class Output(BlockSchema):
-        item: Any = SchemaField(description="The item at the specified index.")
-        error: str = SchemaField(description="Error message if the operation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="262ca24c-1025-43cf-a578-534e23234e97",
-            description="Returns the element at the given index.",
-            categories={BlockCategory.BASIC},
-            input_schema=GetListItemBlock.Input,
-            output_schema=GetListItemBlock.Output,
-            test_input=[
-                {"list": [1, 2, 3], "index": 1},
-                {"list": [1, 2, 3], "index": -1},
-            ],
-            test_output=[
-                ("item", 2),
-                ("item", 3),
-            ],
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        try:
-            yield "item", input_data.list[input_data.index]
-        except IndexError:
-            yield "error", "Index out of range"
-
-
-class RemoveFromListBlock(Block):
-    class Input(BlockSchema):
-        list: List[Any] = SchemaField(description="The list to modify.")
-        value: Any = SchemaField(
-            default=None, description="Value to remove from the list."
-        )
-        index: int | None = SchemaField(
-            default=None,
-            description="Index of the item to pop (supports negative indices).",
-        )
-        return_item: bool = SchemaField(
-            default=False, description="Whether to return the removed item."
-        )
-
-    class Output(BlockSchema):
-        updated_list: List[Any] = SchemaField(description="The list after removal.")
-        removed_item: Any = SchemaField(description="The removed item if requested.")
-        error: str = SchemaField(description="Error message if the operation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="d93c5a93-ac7e-41c1-ae5c-ef67e6e9b826",
-            description="Removes an item from a list by value or index.",
-            categories={BlockCategory.BASIC},
-            input_schema=RemoveFromListBlock.Input,
-            output_schema=RemoveFromListBlock.Output,
-            test_input=[
-                {"list": [1, 2, 3], "index": 1, "return_item": True},
-                {"list": ["a", "b", "c"], "value": "b"},
-            ],
-            test_output=[
-                ("updated_list", [1, 3]),
-                ("removed_item", 2),
-                ("updated_list", ["a", "c"]),
-            ],
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        lst = input_data.list.copy()
-        removed = None
-        try:
-            if input_data.index is not None:
-                removed = lst.pop(input_data.index)
-            elif input_data.value is not None:
-                lst.remove(input_data.value)
-                removed = input_data.value
-            else:
-                raise ValueError("No index or value provided for removal")
-        except (IndexError, ValueError):
-            yield "error", "Index or value not found"
-            return
-
-        yield "updated_list", lst
-        if input_data.return_item:
-            yield "removed_item", removed
-
-
-class ReplaceListItemBlock(Block):
-    class Input(BlockSchema):
-        list: List[Any] = SchemaField(description="The list to modify.")
-        index: int = SchemaField(
-            description="Index of the item to replace (supports negative indices)."
-        )
-        value: Any = SchemaField(description="The new value for the given index.")
-
-    class Output(BlockSchema):
-        updated_list: List[Any] = SchemaField(description="The list after replacement.")
-        old_item: Any = SchemaField(description="The item that was replaced.")
-        error: str = SchemaField(description="Error message if the operation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="fbf62922-bea1-4a3d-8bac-23587f810b38",
-            description="Replaces an item at the specified index.",
-            categories={BlockCategory.BASIC},
-            input_schema=ReplaceListItemBlock.Input,
-            output_schema=ReplaceListItemBlock.Output,
-            test_input=[
-                {"list": [1, 2, 3], "index": 1, "value": 99},
-                {"list": ["a", "b"], "index": -1, "value": "c"},
-            ],
-            test_output=[
-                ("updated_list", [1, 99, 3]),
-                ("old_item", 2),
-                ("updated_list", ["a", "c"]),
-                ("old_item", "b"),
-            ],
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        lst = input_data.list.copy()
-        try:
-            old = lst[input_data.index]
-            lst[input_data.index] = input_data.value
-        except IndexError:
-            yield "error", "Index out of range"
-            return
-
-        yield "updated_list", lst
-        yield "old_item", old
-
-
-class ListIsEmptyBlock(Block):
-    class Input(BlockSchema):
-        list: List[Any] = SchemaField(description="The list to check.")
-
-    class Output(BlockSchema):
-        is_empty: bool = SchemaField(description="True if the list is empty.")
-
-    def __init__(self):
-        super().__init__(
-            id="896ed73b-27d0-41be-813c-c1c1dc856c03",
-            description="Checks if a list is empty.",
-            categories={BlockCategory.BASIC},
-            input_schema=ListIsEmptyBlock.Input,
-            output_schema=ListIsEmptyBlock.Output,
-            test_input=[{"list": []}, {"list": [1]}],
-            test_output=[("is_empty", True), ("is_empty", False)],
-        )
-
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        yield "is_empty", len(input_data.list) == 0

autogpt_platform/backend/backend/blocks/decoder_block.py

@@ -34,6 +34,6 @@ This is a "quoted" string.""",
             ],
         )
 
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    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,25 +1,23 @@
+import asyncio
 from typing import Literal
 
 import aiohttp
 import discord
+from autogpt_libs.supabase_integration_credentials_store.types import APIKeyCredentials
 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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 
-DiscordCredentials = CredentialsMetaInput[
-    Literal[ProviderName.DISCORD], Literal["api_key"]
-]
+DiscordCredentials = CredentialsMetaInput[Literal["discord"], Literal["api_key"]]
 
 
 def DiscordCredentialsField() -> DiscordCredentials:
-    return CredentialsField(description="Discord bot token")
+    return CredentialsField(
+        description="Discord bot token",
+        provider="discord",
+        supported_credential_types={"api_key"},
+    )
 
 
 TEST_CREDENTIALS = APIKeyCredentials(
@@ -73,11 +71,7 @@ class ReadDiscordMessagesBlock(Block):
                 ("username", "test_user"),
             ],
             test_mock={
-                "run_bot": lambda token: {
-                    "output_data": "Hello!\n\nFile from user: example.txt\nContent: This is the content of the file.",
-                    "channel_name": "general",
-                    "username": "test_user",
-                }
+                "run_bot": lambda token: asyncio.Future()  # Create a Future object for mocking
             },
         )
 
@@ -109,24 +103,37 @@ class ReadDiscordMessagesBlock(Block):
                 if attachment.filename.endswith((".txt", ".py")):
                     async with aiohttp.ClientSession() as session:
                         async with session.get(attachment.url) as response:
-                            file_content = response.text()
+                            file_content = await response.text()
                             self.output_data += f"\n\nFile from user: {attachment.filename}\nContent: {file_content}"
 
             await client.close()
 
         await client.start(token.get_secret_value())
 
-    async def run(
+    def run(
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
-        async for output_name, output_value in self.__run(input_data, credentials):
-            yield output_name, output_value
+        while True:
+            for output_name, output_value in self.__run(input_data, credentials):
+                yield output_name, output_value
+            break
 
-    async def __run(
-        self, input_data: Input, credentials: APIKeyCredentials
-    ) -> BlockOutput:
+    def __run(self, input_data: Input, credentials: APIKeyCredentials) -> BlockOutput:
         try:
-            result = await self.run_bot(credentials.api_key)
+            loop = asyncio.get_event_loop()
+            future = self.run_bot(credentials.api_key)
+
+            # If it's a Future (mock), set the result
+            if isinstance(future, asyncio.Future):
+                future.set_result(
+                    {
+                        "output_data": "Hello!\n\nFile from user: example.txt\nContent: This is the content of the file.",
+                        "channel_name": "general",
+                        "username": "test_user",
+                    }
+                )
+
+            result = loop.run_until_complete(future)
 
             # For testing purposes, use the mocked result
             if isinstance(result, dict):
@@ -180,7 +187,7 @@ class SendDiscordMessageBlock(Block):
             },
             test_output=[("status", "Message sent")],
             test_mock={
-                "send_message": lambda token, channel_name, message_content: "Message sent"
+                "send_message": lambda token, channel_name, message_content: asyncio.Future()
             },
             test_credentials=TEST_CREDENTIALS,
         )
@@ -212,16 +219,23 @@ 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)]
 
-    async def run(
+    def run(
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
         try:
-            result = await self.send_message(
+            loop = asyncio.get_event_loop()
+            future = self.send_message(
                 credentials.api_key.get_secret_value(),
                 input_data.channel_name,
                 input_data.message_content,
             )
 
+            # If it's a Future (mock), set the result
+            if isinstance(future, asyncio.Future):
+                future.set_result("Message sent")
+
+            result = loop.run_until_complete(future)
+
             # For testing purposes, use the mocked result
             if isinstance(result, str):
                 self.output_data = result

autogpt_platform/backend/backend/blocks/email_block.py

@@ -1,53 +1,22 @@
 import smtplib
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
-from typing import Literal
 
-from pydantic import BaseModel, ConfigDict, SecretStr
+from pydantic import BaseModel, ConfigDict
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import (
-    CredentialsField,
-    CredentialsMetaInput,
-    SchemaField,
-    UserPasswordCredentials,
-)
-from backend.integrations.providers import ProviderName
-
-TEST_CREDENTIALS = UserPasswordCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="smtp",
-    username=SecretStr("mock-smtp-username"),
-    password=SecretStr("mock-smtp-password"),
-    title="Mock SMTP credentials",
-)
-
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.title,
-}
-SMTPCredentials = UserPasswordCredentials
-SMTPCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.SMTP],
-    Literal["user_password"],
-]
+from backend.data.model import BlockSecret, SchemaField, SecretField
 
 
-def SMTPCredentialsField() -> SMTPCredentialsInput:
-    return CredentialsField(
-        description="The SMTP integration requires a username and password.",
-    )
-
-
-class SMTPConfig(BaseModel):
+class EmailCredentials(BaseModel):
     smtp_server: str = SchemaField(
-        default="smtp.example.com", description="SMTP server address"
+        default="smtp.gmail.com", description="SMTP server address"
     )
     smtp_port: int = SchemaField(default=25, description="SMTP port number")
+    smtp_username: BlockSecret = SecretField(key="smtp_username")
+    smtp_password: BlockSecret = SecretField(key="smtp_password")
 
-    model_config = ConfigDict(title="SMTP Config")
+    model_config = ConfigDict(title="Email Credentials")
 
 
 class SendEmailBlock(Block):
@@ -61,11 +30,10 @@ class SendEmailBlock(Block):
         body: str = SchemaField(
             description="Body of the email", placeholder="Enter the email body"
         )
-        config: SMTPConfig = SchemaField(
-            description="SMTP Config",
-            default=SMTPConfig(),
+        creds: EmailCredentials = SchemaField(
+            description="SMTP credentials",
+            default=EmailCredentials(),
         )
-        credentials: SMTPCredentialsInput = SMTPCredentialsField()
 
     class Output(BlockSchema):
         status: str = SchemaField(description="Status of the email sending operation")
@@ -75,6 +43,7 @@ class SendEmailBlock(Block):
 
     def __init__(self):
         super().__init__(
+            disabled=True,
             id="4335878a-394e-4e67-adf2-919877ff49ae",
             description="This block sends an email using the provided SMTP credentials.",
             categories={BlockCategory.OUTPUT},
@@ -84,29 +53,25 @@ class SendEmailBlock(Block):
                 "to_email": "recipient@example.com",
                 "subject": "Test Email",
                 "body": "This is a test email.",
-                "config": {
+                "creds": {
                     "smtp_server": "smtp.gmail.com",
                     "smtp_port": 25,
+                    "smtp_username": "your-email@gmail.com",
+                    "smtp_password": "your-gmail-password",
                 },
-                "credentials": TEST_CREDENTIALS_INPUT,
             },
-            test_credentials=TEST_CREDENTIALS,
             test_output=[("status", "Email sent successfully")],
             test_mock={"send_email": lambda *args, **kwargs: "Email sent successfully"},
         )
 
     @staticmethod
     def send_email(
-        config: SMTPConfig,
-        to_email: str,
-        subject: str,
-        body: str,
-        credentials: SMTPCredentials,
+        creds: EmailCredentials, to_email: str, subject: str, body: str
     ) -> str:
-        smtp_server = config.smtp_server
-        smtp_port = config.smtp_port
-        smtp_username = credentials.username.get_secret_value()
-        smtp_password = credentials.password.get_secret_value()
+        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
@@ -121,13 +86,10 @@ class SendEmailBlock(Block):
 
         return "Email sent successfully"
 
-    async def run(
-        self, input_data: Input, *, credentials: SMTPCredentials, **kwargs
-    ) -> BlockOutput:
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
         yield "status", self.send_email(
-            config=input_data.config,
-            to_email=input_data.to_email,
-            subject=input_data.subject,
-            body=input_data.body,
-            credentials=credentials,
+            input_data.creds,
+            input_data.to_email,
+            input_data.subject,
+            input_data.body,
         )

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

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,144 +0,0 @@
-from datetime import datetime
-from typing import List
-
-from backend.blocks.exa._auth import (
-    ExaCredentials,
-    ExaCredentialsField,
-    ExaCredentialsInput,
-)
-from backend.blocks.exa.helpers import ContentSettings
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-from backend.util.request import Requests
-
-
-class ExaSearchBlock(Block):
-    class Input(BlockSchema):
-        credentials: ExaCredentialsInput = ExaCredentialsField()
-        query: str = SchemaField(description="The search query")
-        use_auto_prompt: bool = SchemaField(
-            description="Whether to use autoprompt",
-            default=True,
-            advanced=True,
-        )
-        type: str = SchemaField(
-            description="Type of search",
-            default="",
-            advanced=True,
-        )
-        category: str = SchemaField(
-            description="Category to search within",
-            default="",
-            advanced=True,
-        )
-        number_of_results: int = SchemaField(
-            description="Number of results to return",
-            default=10,
-            advanced=True,
-        )
-        include_domains: List[str] = SchemaField(
-            description="Domains to include in search",
-            default_factory=list,
-        )
-        exclude_domains: List[str] = SchemaField(
-            description="Domains to exclude from search",
-            default_factory=list,
-            advanced=True,
-        )
-        start_crawl_date: datetime = SchemaField(
-            description="Start date for crawled content",
-        )
-        end_crawl_date: datetime = SchemaField(
-            description="End date for crawled content",
-        )
-        start_published_date: datetime = SchemaField(
-            description="Start date for published content",
-        )
-        end_published_date: datetime = SchemaField(
-            description="End date for published content",
-        )
-        include_text: List[str] = SchemaField(
-            description="Text patterns to include",
-            default_factory=list,
-            advanced=True,
-        )
-        exclude_text: List[str] = SchemaField(
-            description="Text patterns to exclude",
-            default_factory=list,
-            advanced=True,
-        )
-        contents: ContentSettings = SchemaField(
-            description="Content retrieval settings",
-            default=ContentSettings(),
-            advanced=True,
-        )
-
-    class Output(BlockSchema):
-        results: list = SchemaField(
-            description="List of search results",
-            default_factory=list,
-        )
-        error: str = SchemaField(
-            description="Error message if the request failed",
-        )
-
-    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,
-        )
-
-    async 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 = await Requests().post(url, headers=headers, json=payload)
-            data = response.json()
-            # Extract just the results array from the response
-            yield "results", data.get("results", [])
-        except Exception as e:
-            yield "error", str(e)

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

@@ -1,127 +0,0 @@
-from datetime import datetime
-from typing import Any, List
-
-from backend.blocks.exa._auth import (
-    ExaCredentials,
-    ExaCredentialsField,
-    ExaCredentialsInput,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-from backend.util.request import Requests
-
-from .helpers import ContentSettings
-
-
-class ExaFindSimilarBlock(Block):
-    class Input(BlockSchema):
-        credentials: ExaCredentialsInput = ExaCredentialsField()
-        url: str = SchemaField(
-            description="The url for which you would like to find similar links"
-        )
-        number_of_results: int = SchemaField(
-            description="Number of results to return",
-            default=10,
-            advanced=True,
-        )
-        include_domains: List[str] = SchemaField(
-            description="Domains to include in search",
-            default_factory=list,
-            advanced=True,
-        )
-        exclude_domains: List[str] = SchemaField(
-            description="Domains to exclude from search",
-            default_factory=list,
-            advanced=True,
-        )
-        start_crawl_date: datetime = SchemaField(
-            description="Start date for crawled content",
-        )
-        end_crawl_date: datetime = SchemaField(
-            description="End date for crawled content",
-        )
-        start_published_date: datetime = SchemaField(
-            description="Start date for published content",
-        )
-        end_published_date: datetime = SchemaField(
-            description="End date for published content",
-        )
-        include_text: List[str] = SchemaField(
-            description="Text patterns to include (max 1 string, up to 5 words)",
-            default_factory=list,
-            advanced=True,
-        )
-        exclude_text: List[str] = SchemaField(
-            description="Text patterns to exclude (max 1 string, up to 5 words)",
-            default_factory=list,
-            advanced=True,
-        )
-        contents: ContentSettings = SchemaField(
-            description="Content retrieval settings",
-            default=ContentSettings(),
-            advanced=True,
-        )
-
-    class Output(BlockSchema):
-        results: List[Any] = SchemaField(
-            description="List of similar documents with title, URL, published date, author, and score",
-            default_factory=list,
-        )
-        error: str = SchemaField(description="Error message if the request failed")
-
-    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,
-        )
-
-    async 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 = await Requests().post(url, headers=headers, json=payload)
-            data = response.json()
-            yield "results", data.get("results", [])
-        except Exception as e:
-            yield "error", str(e)

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,212 +0,0 @@
-import asyncio
-import logging
-from enum import Enum
-from typing import Any
-
-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
-from backend.util.request import ClientResponseError, Requests
-
-logger = logging.getLogger(__name__)
-
-
-class FalModel(str, Enum):
-    MOCHI = "fal-ai/mochi-v1"
-    LUMA = "fal-ai/luma-dream-machine"
-    VEO3 = "fal-ai/veo3"
-
-
-class AIVideoGeneratorBlock(Block):
-    class Input(BlockSchema):
-        prompt: str = SchemaField(
-            description="Description of the video to generate.",
-            placeholder="A dog running in a field.",
-        )
-        model: FalModel = SchemaField(
-            title="FAL Model",
-            default=FalModel.MOCHI,
-            description="The FAL model to use for video generation.",
-        )
-        credentials: FalCredentialsInput = FalCredentialsField()
-
-    class Output(BlockSchema):
-        video_url: str = SchemaField(description="The URL of the generated video.")
-        error: str = SchemaField(
-            description="Error message if video generation failed."
-        )
-        logs: list[str] = SchemaField(
-            description="Generation progress logs.",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="530cf046-2ce0-4854-ae2c-659db17c7a46",
-            description="Generate videos using FAL AI models.",
-            categories={BlockCategory.AI},
-            input_schema=self.Input,
-            output_schema=self.Output,
-            test_input={
-                "prompt": "A dog running in a field.",
-                "model": FalModel.MOCHI,
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[("video_url", "https://fal.media/files/example/video.mp4")],
-            test_mock={
-                "generate_video": lambda *args, **kwargs: "https://fal.media/files/example/video.mp4"
-            },
-        )
-
-    def _get_headers(self, api_key: str) -> dict[str, str]:
-        """Get headers for FAL API Requests."""
-        return {
-            "Authorization": f"Key {api_key}",
-            "Content-Type": "application/json",
-        }
-
-    async 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 = await Requests().post(url, headers=headers, json=data)
-            return response.json()
-        except ClientResponseError as e:
-            logger.error(f"FAL API request failed: {str(e)}")
-            raise RuntimeError(f"Failed to submit request: {str(e)}")
-
-    async def _poll_status(
-        self, status_url: str, headers: dict[str, str]
-    ) -> dict[str, Any]:
-        """Poll the status endpoint until completion or failure."""
-        try:
-            response = await Requests().get(status_url, headers=headers)
-            return response.json()
-        except ClientResponseError as e:
-            logger.error(f"Failed to get status: {str(e)}")
-            raise RuntimeError(f"Failed to get status: {str(e)}")
-
-    async 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}
-        if input_data.model == FalModel.VEO3:
-            submit_data["generate_audio"] = True  # type: ignore
-
-        seen_logs = set()
-
-        try:
-            # Submit request to queue
-            submit_response = await Requests().post(
-                submit_url, headers=headers, json=submit_data
-            )
-            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")
-
-            # Ensure status_url is a string
-            if not isinstance(status_url, str):
-                raise ValueError("Invalid status URL format")
-
-            # Ensure result_url is a string
-            if not isinstance(result_url, str):
-                raise ValueError("Invalid result URL format")
-
-            # Poll for status with exponential backoff
-            max_attempts = 30
-            attempt = 0
-            base_wait_time = 5
-
-            while attempt < max_attempts:
-                status_response = await Requests().get(
-                    f"{status_url}?logs=1", headers=headers
-                )
-                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 = await Requests().get(result_url, headers=headers)
-                    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 or not isinstance(video_url, str):
-                        raise ValueError("No valid 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
-                await asyncio.sleep(wait_time)
-                attempt += 1
-
-            raise RuntimeError("Maximum polling attempts reached")
-
-        except ClientResponseError as e:
-            raise RuntimeError(f"API request failed: {str(e)}")
-
-    async def run(
-        self, input_data: Input, *, credentials: FalCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            video_url = await self.generate_video(input_data, credentials)
-            yield "video_url", video_url
-        except Exception as e:
-            error_message = str(e)
-            yield "error", error_message