Remove replicated code

.dockerignore

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

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,38 +1,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,9 +7,6 @@ updates:
       interval: "weekly"
     open-pull-requests-limit: 10
     target-branch: "dev"
-    commit-message:
-      prefix: "chore(libs/deps)"
-      prefix-development: "chore(libs/deps-dev)"
     groups:
       production-dependencies:
         dependency-type: "production"
@@ -29,9 +26,6 @@ updates:
       interval: "weekly"
     open-pull-requests-limit: 10
     target-branch: "dev"
-    commit-message:
-      prefix: "chore(backend/deps)"
-      prefix-development: "chore(backend/deps-dev)"
     groups:
       production-dependencies:
         dependency-type: "production"
@@ -44,6 +38,7 @@ updates:
         - "minor"
         - "patch"
 
+
   # frontend (Next.js project)
   - package-ecosystem: "npm"
     directory: "autogpt_platform/frontend"
@@ -51,9 +46,6 @@ 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"
@@ -66,6 +58,7 @@ updates:
         - "minor"
         - "patch"
 
+
   # infra (Terraform)
   - package-ecosystem: "terraform"
     directory: "autogpt_platform/infra"
@@ -73,10 +66,26 @@ 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"
+      development-dependencies:
+        dependency-type: "development"
+        update-types:
+        - "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"
@@ -137,9 +146,6 @@ updates:
       interval: "weekly"
     open-pull-requests-limit: 1
     target-branch: "dev"
-    commit-message:
-      prefix: "chore(platform/deps)"
-      prefix-development: "chore(platform/deps-dev)"
     groups:
       production-dependencies:
         dependency-type: "production"
@@ -160,8 +166,6 @@ updates:
       interval: "weekly"
     open-pull-requests-limit: 1
     target-branch: "dev"
-    commit-message:
-      prefix: "chore(docs/deps)"
     groups:
       production-dependencies:
         dependency-type: "production"

.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

@@ -102,7 +102,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        agent-name: [forge]
+        agent-name: [ forge ]
       fail-fast: false
     timeout-minutes: 20
     steps:
@@ -146,23 +146,23 @@ jobs:
           echo "Running the following command: poetry run agbenchmark --mock --category=coding"
           poetry run agbenchmark --mock --category=coding
 
-          # echo "Running the following command: poetry run agbenchmark --test=WriteFile"
-          # poetry run agbenchmark --test=WriteFile
+          echo "Running the following command: poetry run agbenchmark --test=WriteFile"
+          poetry run agbenchmark --test=WriteFile
           cd ../benchmark
           poetry install
           echo "Adding the BUILD_SKILL_TREE environment variable. This will attempt to add new elements in the skill tree. If new elements are added, the CI fails because they should have been pushed"
           export BUILD_SKILL_TREE=true
 
-          # poetry run agbenchmark --mock
+          poetry run agbenchmark --mock
 
-          # CHANGED=$(git diff --name-only | grep -E '(agbenchmark/challenges)|(../classic/frontend/assets)') || echo "No diffs"
-          # if [ ! -z "$CHANGED" ]; then
-          #   echo "There are unstaged changes please run agbenchmark and commit those changes since they are needed."
-          #   echo "$CHANGED"
-          #   exit 1
-          # else
-          #   echo "No unstaged changes."
-          # fi
+          CHANGED=$(git diff --name-only | grep -E '(agbenchmark/challenges)|(../classic/frontend/assets)') || echo "No diffs"
+          if [ ! -z "$CHANGED" ]; then
+            echo "There are unstaged changes please run agbenchmark and commit those changes since they are needed."
+            echo "$CHANGED"
+            exit 1
+          else
+            echo "No unstaged changes."
+          fi
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
           TELEMETRY_ENVIRONMENT: autogpt-benchmark-ci

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

.github/workflows/platform-autogpt-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) }}
@@ -79,17 +76,6 @@ jobs:
             echo "$HOME/.local/bin" >> $GITHUB_PATH
           fi
 
-      - name: Check poetry.lock
-        run: |
-          poetry lock
-
-          if ! git diff --quiet 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
 

.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:
@@ -23,7 +22,6 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
-
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
@@ -39,12 +37,24 @@ jobs:
 
   test:
     runs-on: ubuntu-latest
-    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:
@@ -55,20 +65,10 @@ jobs:
         with:
           node-version: "21"
 
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
-        with:
-          large-packages: false  # slow
-          docker-images: false  # limited benefit
-
       - name: Copy default supabase .env
         run: |
           cp ../supabase/docker/.env.example ../.env
 
-      - name: Copy backend .env
-        run: |
-          cp ../backend/.env.example ../backend/.env
-
       - name: Run docker compose
         run: |
           docker compose -f ../docker-compose.yml up -d
@@ -81,21 +81,16 @@ jobs:
         run: |
           cp .env.example .env
 
-      - name: Install Browser '${{ matrix.browser }}'
-        run: yarn playwright install --with-deps ${{ matrix.browser }}
+      - name: Install Playwright Browsers
+        run: yarn playwright install --with-deps
 
       - name: Run tests
         run: |
-          yarn test --project=${{ matrix.browser }}
-
-      - name: Print Docker Compose logs in debug mode
-        if: runner.debug
-        run: |
-          docker compose -f ../docker-compose.yml logs
+          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-workflow-checker.yml

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

.github/workflows/scripts/check_actions_status.py

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

.gitignore

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

.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:
@@ -19,122 +19,27 @@ repos:
         files: ^autogpt_platform/
         stages: [push]
 
-  - repo: local
-    # For proper type checking, all dependencies need to be up-to-date.
-    # It's also a good idea to check that poetry.lock is consistent with pyproject.toml.
-    hooks:
-      - id: poetry-install
-        name: Check & Install dependencies - AutoGPT Platform - Backend
-        alias: poetry-install-platform-backend
-        entry: poetry -C autogpt_platform/backend install
-        # include autogpt_libs source (since it's a path dependency)
-        files: ^autogpt_platform/(backend|autogpt_libs)/poetry\.lock$
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: poetry-install
-        name: Check & Install dependencies - AutoGPT Platform - Libs
-        alias: poetry-install-platform-libs
-        entry: poetry -C autogpt_platform/autogpt_libs install
-        files: ^autogpt_platform/autogpt_libs/poetry\.lock$
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: poetry-install
-        name: Check & Install dependencies - Classic - AutoGPT
-        alias: poetry-install-classic-autogpt
-        entry: poetry -C classic/original_autogpt install
-        # include forge source (since it's a path dependency)
-        files: ^classic/(original_autogpt|forge)/poetry\.lock$
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: poetry-install
-        name: Check & Install dependencies - Classic - Forge
-        alias: poetry-install-classic-forge
-        entry: poetry -C classic/forge install
-        files: ^classic/forge/poetry\.lock$
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: poetry-install
-        name: Check & Install dependencies - Classic - Benchmark
-        alias: poetry-install-classic-benchmark
-        entry: poetry -C classic/benchmark install
-        files: ^classic/benchmark/poetry\.lock$
-        types: [file]
-        language: system
-        pass_filenames: false
-
-  - repo: local
-    # For proper type checking, Prisma client must be up-to-date.
-    hooks:
-      - id: prisma-generate
-        name: Prisma Generate - AutoGPT Platform - Backend
-        alias: prisma-generate-platform-backend
-        entry: bash -c 'cd autogpt_platform/backend && poetry run prisma generate'
-        # include everything that triggers poetry install + the prisma schema
-        files: ^autogpt_platform/((backend|autogpt_libs)/poetry\.lock|backend/schema.prisma)$
-        types: [file]
-        language: system
-        pass_filenames: false
-
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.2
-    hooks:
-      - id: ruff
-        name: Lint (Ruff) - AutoGPT Platform - Backend
-        alias: ruff-lint-platform-backend
-        files: ^autogpt_platform/backend/
-        args: [--fix]
-
-      - id: ruff
-        name: Lint (Ruff) - AutoGPT Platform - Libs
-        alias: ruff-lint-platform-libs
-        files: ^autogpt_platform/autogpt_libs/
-        args: [--fix]
-
-      - id: ruff-format
-        name: Format (Ruff) - AutoGPT Platform - Libs
-        alias: ruff-lint-platform-libs
-        files: ^autogpt_platform/autogpt_libs/
-
   - repo: local
     # isort needs the context of which packages are installed to function, so we
     # can't use a vendored isort pre-commit hook (which runs in its own isolated venv).
     hooks:
-      - id: isort
-        name: Lint (isort) - AutoGPT Platform - Backend
-        alias: isort-platform-backend
-        entry: poetry -P autogpt_platform/backend run isort -p backend
-        files: ^autogpt_platform/backend/
-        types: [file, python]
-        language: system
-
-      - id: isort
-        name: Lint (isort) - Classic - AutoGPT
-        alias: isort-classic-autogpt
-        entry: poetry -P classic/original_autogpt run isort -p autogpt
+      - id: isort-autogpt
+        name: Lint (isort) - AutoGPT
+        entry: poetry -C classic/original_autogpt run isort
         files: ^classic/original_autogpt/
         types: [file, python]
         language: system
 
-      - id: isort
-        name: Lint (isort) - Classic - Forge
-        alias: isort-classic-forge
-        entry: poetry -P classic/forge run isort -p forge
+      - id: isort-forge
+        name: Lint (isort) - Forge
+        entry: poetry -C classic/forge run isort
         files: ^classic/forge/
         types: [file, python]
         language: system
 
-      - id: isort
-        name: Lint (isort) - Classic - Benchmark
-        alias: isort-classic-benchmark
-        entry: poetry -P classic/benchmark run isort -p agbenchmark
+      - id: isort-benchmark
+        name: Lint (isort) - Benchmark
+        entry: poetry -C classic/benchmark run isort
         files: ^classic/benchmark/
         types: [file, python]
         language: system
@@ -145,7 +50,8 @@ repos:
     # everything in .gitignore, so it works fine without any config or arguments.
     hooks:
       - id: black
-        name: Format (Black)
+        name: Lint (Black)
+        language_version: python3.12
 
   - repo: https://github.com/PyCQA/flake8
     rev: 7.0.0
@@ -153,20 +59,20 @@ repos:
     # them separately.
     hooks:
       - id: flake8
-        name: Lint (Flake8) - Classic - AutoGPT
-        alias: flake8-classic-autogpt
+        name: Lint (Flake8) - AutoGPT
+        alias: flake8-autogpt
         files: ^classic/original_autogpt/(autogpt|scripts|tests)/
         args: [--config=classic/original_autogpt/.flake8]
 
       - id: flake8
-        name: Lint (Flake8) - Classic - Forge
-        alias: flake8-classic-forge
+        name: Lint (Flake8) - Forge
+        alias: flake8-forge
         files: ^classic/forge/(forge|tests)/
         args: [--config=classic/forge/.flake8]
 
       - id: flake8
-        name: Lint (Flake8) - Classic - Benchmark
-        alias: flake8-classic-benchmark
+        name: Lint (Flake8) - Benchmark
+        alias: flake8-benchmark
         files: ^classic/benchmark/(agbenchmark|tests)/((?!reports).)*[/.]
         args: [--config=classic/benchmark/.flake8]
 
@@ -175,47 +81,31 @@ repos:
     # project. To trigger on poetry.lock we also reset the file `types` filter.
     hooks:
       - id: pyright
-        name: Typecheck - AutoGPT Platform - Backend
-        alias: pyright-platform-backend
-        entry: poetry -C autogpt_platform/backend run pyright
-        # include forge source (since it's a path dependency) but exclude *_test.py files:
-        files: ^autogpt_platform/(backend/((backend|test)/|(\w+\.py|poetry\.lock)$)|autogpt_libs/(autogpt_libs/.*(?<!_test)\.py|poetry\.lock)$)
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: pyright
-        name: Typecheck - AutoGPT Platform - Libs
-        alias: pyright-platform-libs
-        entry: poetry -C autogpt_platform/autogpt_libs run pyright
-        files: ^autogpt_platform/autogpt_libs/(autogpt_libs/|poetry\.lock$)
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: pyright
-        name: Typecheck - Classic - AutoGPT
-        alias: pyright-classic-autogpt
+        name: Typecheck - AutoGPT
+        alias: pyright-autogpt
         entry: poetry -C classic/original_autogpt run pyright
+        args: [-p, autogpt, autogpt]
         # include forge source (since it's a path dependency) but exclude *_test.py files:
-        files: ^(classic/original_autogpt/((autogpt|scripts|tests)/|poetry\.lock$)|classic/forge/(forge/.*(?<!_test)\.py|poetry\.lock)$)
+        files: ^(classic/original_autogpt/((autogpt|scripts|tests)/|poetry\.lock$)|classic/forge/(classic/forge/.*(?<!_test)\.py|poetry\.lock)$)
         types: [file]
         language: system
         pass_filenames: false
 
       - id: pyright
-        name: Typecheck - Classic - Forge
-        alias: pyright-classic-forge
+        name: Typecheck - Forge
+        alias: pyright-forge
         entry: poetry -C classic/forge run pyright
-        files: ^classic/forge/(forge/|poetry\.lock$)
+        args: [-p, forge, forge]
+        files: ^classic/forge/(classic/forge/|poetry\.lock$)
         types: [file]
         language: system
         pass_filenames: false
 
       - id: pyright
-        name: Typecheck - Classic - Benchmark
-        alias: pyright-classic-benchmark
+        name: Typecheck - Benchmark
+        alias: pyright-benchmark
         entry: poetry -C classic/benchmark run pyright
+        args: [-p, benchmark, benchmark]
         files: ^classic/benchmark/(agbenchmark/|tests/|poetry\.lock$)
         types: [file]
         language: system
@@ -223,35 +113,23 @@ repos:
 
   - repo: local
     hooks:
-      - id: pytest
-        name: Run tests - AutoGPT Platform - Backend
-        alias: pytest-platform-backend
-        entry: bash -c 'cd autogpt_platform/backend && poetry run pytest'
-        # include autogpt_libs source (since it's a path dependency) but exclude *_test.py files:
-        files: ^autogpt_platform/(backend/((backend|test)/|poetry\.lock$)|autogpt_libs/(autogpt_libs/.*(?<!_test)\.py|poetry\.lock)$)
-        language: system
-        pass_filenames: false
-
-      - id: pytest
-        name: Run tests - Classic - AutoGPT (excl. slow tests)
-        alias: pytest-classic-autogpt
+      - id: pytest-autogpt
+        name: Run tests - AutoGPT (excl. slow tests)
         entry: bash -c 'cd classic/original_autogpt && poetry run pytest --cov=autogpt -m "not slow" tests/unit tests/integration'
         # include forge source (since it's a path dependency) but exclude *_test.py files:
-        files: ^(classic/original_autogpt/((autogpt|tests)/|poetry\.lock$)|classic/forge/(forge/.*(?<!_test)\.py|poetry\.lock)$)
+        files: ^(classic/original_autogpt/((autogpt|tests)/|poetry\.lock$)|classic/forge/(classic/forge/.*(?<!_test)\.py|poetry\.lock)$)
         language: system
         pass_filenames: false
 
-      - id: pytest
-        name: Run tests - Classic - Forge (excl. slow tests)
-        alias: pytest-classic-forge
+      - id: pytest-forge
+        name: Run tests - Forge (excl. slow tests)
         entry: bash -c 'cd classic/forge && poetry run pytest --cov=forge -m "not slow"'
-        files: ^classic/forge/(forge/|tests/|poetry\.lock$)
+        files: ^classic/forge/(classic/forge/|tests/|poetry\.lock$)
         language: system
         pass_filenames: false
 
-      - id: pytest
-        name: Run tests - Classic - Benchmark
-        alias: pytest-classic-benchmark
+      - id: pytest-benchmark
+        name: Run tests - Benchmark
         entry: bash -c 'cd classic/benchmark && poetry run pytest --cov=benchmark'
         files: ^classic/benchmark/(agbenchmark/|tests/|poetry\.lock$)
         language: system

.vscode/launch.json

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

README.md

@@ -35,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
 

SECURITY.md

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

autogpt_platform/autogpt_libs/autogpt_libs/api_key/key_manager.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/depends.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/models.py

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

autogpt_platform/autogpt_libs/autogpt_libs/feature_flag/client.py

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

autogpt_platform/autogpt_libs/autogpt_libs/feature_flag/client_test.py

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

autogpt_platform/autogpt_libs/autogpt_libs/feature_flag/config.py

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

autogpt_platform/autogpt_libs/autogpt_libs/logging/config.py

@@ -6,7 +6,6 @@ from pathlib import Path
 
 from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
-
 from .filters import BelowLevelFilter
 from .formatters import AGPTFormatter, StructuredLoggingFormatter
 
@@ -23,6 +22,7 @@ DEBUG_LOG_FORMAT = (
 
 
 class LoggingConfig(BaseSettings):
+
     level: str = Field(
         default="INFO",
         description="Logging level",

autogpt_platform/autogpt_libs/autogpt_libs/logging/test_utils.py

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

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/config.py

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

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/limiter.py

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

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/middleware.py

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

autogpt_platform/autogpt_libs/autogpt_libs/supabase_integration_credentials_store/__init__.py

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

@@ -1,24 +1,24 @@
-import base64
-import hashlib
 import secrets
 from datetime import datetime, timedelta, timezone
-from typing import TYPE_CHECKING, Optional
+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 backend.data.model import (
+from .types import (
     APIKeyCredentials,
     Credentials,
     OAuth2Credentials,
     OAuthState,
     UserIntegrations,
 )
+
 from backend.util.settings import Settings
 
 settings = Settings()
@@ -46,21 +46,21 @@ replicate_credentials = APIKeyCredentials(
 )
 openai_credentials = APIKeyCredentials(
     id="53c25cb8-e3ee-465c-a4d1-e75a4c899c2a",
-    provider="openai",
+    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="anthropic",
+    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="groq",
+    provider="llm",
     api_key=SecretStr(settings.secrets.groq_api_key),
     title="Use Credits for Groq",
     expires_at=None,
@@ -72,56 +72,6 @@ did_credentials = APIKeyCredentials(
     title="Use Credits for D-ID",
     expires_at=None,
 )
-jina_credentials = APIKeyCredentials(
-    id="7f26de70-ba0d-494e-ba76-238e65e7b45f",
-    provider="jina",
-    api_key=SecretStr(settings.secrets.jina_api_key),
-    title="Use Credits for Jina",
-    expires_at=None,
-)
-unreal_credentials = APIKeyCredentials(
-    id="66f20754-1b81-48e4-91d0-f4f0dd82145f",
-    provider="unreal",
-    api_key=SecretStr(settings.secrets.unreal_speech_api_key),
-    title="Use Credits for Unreal",
-    expires_at=None,
-)
-open_router_credentials = APIKeyCredentials(
-    id="b5a0e27d-0c98-4df3-a4b9-10193e1f3c40",
-    provider="open_router",
-    api_key=SecretStr(settings.secrets.open_router_api_key),
-    title="Use Credits for Open Router",
-    expires_at=None,
-)
-fal_credentials = APIKeyCredentials(
-    id="6c0f5bd0-9008-4638-9d79-4b40b631803e",
-    provider="fal",
-    api_key=SecretStr(settings.secrets.fal_api_key),
-    title="Use Credits for FAL",
-    expires_at=None,
-)
-exa_credentials = APIKeyCredentials(
-    id="96153e04-9c6c-4486-895f-5bb683b1ecec",
-    provider="exa",
-    api_key=SecretStr(settings.secrets.exa_api_key),
-    title="Use Credits for Exa search",
-    expires_at=None,
-)
-e2b_credentials = APIKeyCredentials(
-    id="78d19fd7-4d59-4a16-8277-3ce310acf2b7",
-    provider="e2b",
-    api_key=SecretStr(settings.secrets.e2b_api_key),
-    title="Use Credits for E2B",
-    expires_at=None,
-)
-nvidia_credentials = APIKeyCredentials(
-    id="96b83908-2789-4dec-9968-18f0ece4ceb3",
-    provider="nvidia",
-    api_key=SecretStr(settings.secrets.nvidia_api_key),
-    title="Use Credits for Nvidia",
-    expires_at=None,
-)
-
 
 DEFAULT_CREDENTIALS = [
     revid_credentials,
@@ -131,21 +81,12 @@ DEFAULT_CREDENTIALS = [
     anthropic_credentials,
     groq_credentials,
     did_credentials,
-    jina_credentials,
-    unreal_credentials,
-    open_router_credentials,
-    fal_credentials,
-    exa_credentials,
-    e2b_credentials,
-    nvidia_credentials,
 ]
 
 
-class IntegrationCredentialsStore:
-    def __init__(self):
-        from backend.data.redis import get_redis
-
-        self.locks = RedisKeyedMutex(get_redis())
+class SupabaseIntegrationCredentialsStore:
+    def __init__(self, redis: "Redis"):
+        self.locks = RedisKeyedMutex(redis)
 
     @property
     @thread_cached
@@ -183,20 +124,6 @@ class IntegrationCredentialsStore:
             all_credentials.append(anthropic_credentials)
         if settings.secrets.did_api_key:
             all_credentials.append(did_credentials)
-        if settings.secrets.jina_api_key:
-            all_credentials.append(jina_credentials)
-        if settings.secrets.unreal_speech_api_key:
-            all_credentials.append(unreal_credentials)
-        if settings.secrets.open_router_api_key:
-            all_credentials.append(open_router_credentials)
-        if settings.secrets.fal_api_key:
-            all_credentials.append(fal_credentials)
-        if settings.secrets.exa_api_key:
-            all_credentials.append(exa_credentials)
-        if settings.secrets.e2b_api_key:
-            all_credentials.append(e2b_credentials)
-        if settings.secrets.nvidia_api_key:
-            all_credentials.append(nvidia_credentials)
         return all_credentials
 
     def get_creds_by_id(self, user_id: str, credentials_id: str) -> Credentials | None:
@@ -252,24 +179,18 @@ class IntegrationCredentialsStore:
             ]
             self._set_user_integration_creds(user_id, filtered_credentials)
 
-    def store_state_token(
-        self, user_id: str, provider: str, scopes: list[str], use_pkce: bool = False
-    ) -> tuple[str, str]:
+    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)
 
-        (code_challenge, code_verifier) = self._generate_code_challenge()
-
         state = OAuthState(
             token=token,
             provider=provider,
-            code_verifier=code_verifier,
             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)
@@ -279,21 +200,39 @@ class IntegrationCredentialsStore:
                 user_id=user_id, data=user_integrations
             )
 
-        return token, code_challenge
+        return token
 
-    def _generate_code_challenge(self) -> tuple[str, str]:
-        """
-        Generate code challenge using SHA256 from the code verifier.
-        Currently only SHA256 is supported.(In future if we want to support more methods we can add them here)
-        """
-        code_verifier = secrets.token_urlsafe(128)
-        sha256_hash = hashlib.sha256(code_verifier.encode("utf-8")).digest()
-        code_challenge = base64.urlsafe_b64encode(sha256_hash).decode("utf-8")
-        return code_challenge.replace("=", ""), code_verifier
-
-    def verify_state_token(
+    def get_any_valid_scopes_from_state_token(
         self, user_id: str, token: str, provider: str
-    ) -> Optional[OAuthState]:
+    ) -> 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
@@ -315,9 +254,9 @@ class IntegrationCredentialsStore:
                 oauth_states.remove(valid_state)
                 user_integrations.oauth_states = oauth_states
                 self.db_manager.update_user_integrations(user_id, user_integrations)
-                return valid_state
+                return True
 
-        return None
+        return False
 
     def _set_user_integration_creds(
         self, user_id: str, credentials: list[Credentials]
@@ -335,5 +274,5 @@ class IntegrationCredentialsStore:
         return integrations
 
     def locked_user_integrations(self, user_id: str):
-        key = (f"user:{user_id}", "integrations")
+        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,5 +1,5 @@
+from typing import Callable, TypeVar, ParamSpec
 import threading
-from typing import Callable, ParamSpec, TypeVar
 
 P = ParamSpec("P")
 R = TypeVar("R")

autogpt_platform/autogpt_libs/autogpt_libs/utils/synchronize.py

@@ -31,8 +31,7 @@ class RedisKeyedMutex:
         try:
             yield
         finally:
-            if lock.locked():
-                lock.release()
+            lock.release()
 
     def acquire(self, key: Any) -> "RedisLock":
         """Acquires and returns a lock with the given key"""
@@ -46,7 +45,7 @@ class RedisKeyedMutex:
         return lock
 
     def release(self, key: Any):
-        if (lock := self.locks.get(key)) and lock.locked() and lock.owned():
+        if lock := self.locks.get(key):
             lock.release()
 
     def release_all_locks(self):

autogpt_platform/autogpt_libs/poetry.lock

@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 1.8.5 and should not be changed by hand.
+# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand.
 
 [[package]]
 name = "aiohappyeyeballs"
@@ -626,13 +626,13 @@ grpc = ["grpcio (>=1.44.0,<2.0.0.dev0)"]
 
 [[package]]
 name = "gotrue"
-version = "2.10.0"
+version = "2.9.3"
 description = "Python Client Library for Supabase Auth"
 optional = false
 python-versions = "<4.0,>=3.9"
 files = [
-    {file = "gotrue-2.10.0-py3-none-any.whl", hash = "sha256:768e58207488e5184ffbdc4351b7280d913daf97962f4e9f2cca05c80004b042"},
-    {file = "gotrue-2.10.0.tar.gz", hash = "sha256:4edf4c251da3535f2b044e23deba221e848ca1210c17d0c7a9b19f79a1e3f3c0"},
+    {file = "gotrue-2.9.3-py3-none-any.whl", hash = "sha256:9d2e9c74405d879f4828e0a7b94daf167a6e109c10ae6e5c59a0e21446f6e423"},
+    {file = "gotrue-2.9.3.tar.gz", hash = "sha256:051551d80e642bdd2ab42cac78207745d89a2a08f429a1512d82624e675d8255"},
 ]
 
 [package.dependencies]
@@ -854,17 +854,6 @@ doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linke
 perf = ["ipython"]
 test = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-perf (>=0.9.2)", "pytest-ruff (>=0.2.1)"]
 
-[[package]]
-name = "iniconfig"
-version = "2.0.0"
-description = "brain-dead simple config-ini parsing"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"},
-    {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},
-]
-
 [[package]]
 name = "multidict"
 version = "6.1.0"
@@ -995,30 +984,15 @@ files = [
     {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"},
 ]
 
-[[package]]
-name = "pluggy"
-version = "1.5.0"
-description = "plugin and hook calling mechanisms for python"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
-    {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
-]
-
-[package.extras]
-dev = ["pre-commit", "tox"]
-testing = ["pytest", "pytest-benchmark"]
-
 [[package]]
 name = "postgrest"
-version = "0.18.0"
+version = "0.17.2"
 description = "PostgREST client for Python. This library provides an ORM interface to PostgREST."
 optional = false
 python-versions = "<4.0,>=3.9"
 files = [
-    {file = "postgrest-0.18.0-py3-none-any.whl", hash = "sha256:200baad0d23fee986b3a0ffd3e07bfe0cdd40e09760f11e8e13a6c0c2376d5fa"},
-    {file = "postgrest-0.18.0.tar.gz", hash = "sha256:29c1a94801a17eb9ad590189993fe5a7a6d8c1bfc11a3c9d0ce7ba146454ebb3"},
+    {file = "postgrest-0.17.2-py3-none-any.whl", hash = "sha256:f7c4f448e5a5e2d4c1dcf192edae9d1007c4261e9a6fb5116783a0046846ece2"},
+    {file = "postgrest-0.17.2.tar.gz", hash = "sha256:445cd4e4a191e279492549df0c4e827d32f9d01d0852599bb8a6efb0f07fcf78"},
 ]
 
 [package.dependencies]
@@ -1091,19 +1065,22 @@ pyasn1 = ">=0.4.6,<0.7.0"
 
 [[package]]
 name = "pydantic"
-version = "2.10.3"
+version = "2.9.2"
 description = "Data validation using Python type hints"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pydantic-2.10.3-py3-none-any.whl", hash = "sha256:be04d85bbc7b65651c5f8e6b9976ed9c6f41782a55524cef079a34a0bb82144d"},
-    {file = "pydantic-2.10.3.tar.gz", hash = "sha256:cb5ac360ce894ceacd69c403187900a02c4b20b693a9dd1d643e1effab9eadf9"},
+    {file = "pydantic-2.9.2-py3-none-any.whl", hash = "sha256:f048cec7b26778210e28a0459867920654d48e5e62db0958433636cde4254f12"},
+    {file = "pydantic-2.9.2.tar.gz", hash = "sha256:d155cef71265d1e9807ed1c32b4c8deec042a44a50a4188b25ac67ecd81a9c0f"},
 ]
 
 [package.dependencies]
 annotated-types = ">=0.6.0"
-pydantic-core = "2.27.1"
-typing-extensions = ">=4.12.2"
+pydantic-core = "2.23.4"
+typing-extensions = [
+    {version = ">=4.12.2", markers = "python_version >= \"3.13\""},
+    {version = ">=4.6.1", markers = "python_version < \"3.13\""},
+]
 
 [package.extras]
 email = ["email-validator (>=2.0.0)"]
@@ -1111,111 +1088,100 @@ timezone = ["tzdata"]
 
 [[package]]
 name = "pydantic-core"
-version = "2.27.1"
+version = "2.23.4"
 description = "Core functionality for Pydantic validation and serialization"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pydantic_core-2.27.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:71a5e35c75c021aaf400ac048dacc855f000bdfed91614b4a726f7432f1f3d6a"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f82d068a2d6ecfc6e054726080af69a6764a10015467d7d7b9f66d6ed5afa23b"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:121ceb0e822f79163dd4699e4c54f5ad38b157084d97b34de8b232bcaad70278"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4603137322c18eaf2e06a4495f426aa8d8388940f3c457e7548145011bb68e05"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a33cd6ad9017bbeaa9ed78a2e0752c5e250eafb9534f308e7a5f7849b0b1bfb4"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:15cc53a3179ba0fcefe1e3ae50beb2784dede4003ad2dfd24f81bba4b23a454f"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45d9c5eb9273aa50999ad6adc6be5e0ecea7e09dbd0d31bd0c65a55a2592ca08"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8bf7b66ce12a2ac52d16f776b31d16d91033150266eb796967a7e4621707e4f6"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:655d7dd86f26cb15ce8a431036f66ce0318648f8853d709b4167786ec2fa4807"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:5556470f1a2157031e676f776c2bc20acd34c1990ca5f7e56f1ebf938b9ab57c"},
-    {file = "pydantic_core-2.27.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:f69ed81ab24d5a3bd93861c8c4436f54afdf8e8cc421562b0c7504cf3be58206"},
-    {file = "pydantic_core-2.27.1-cp310-none-win32.whl", hash = "sha256:f5a823165e6d04ccea61a9f0576f345f8ce40ed533013580e087bd4d7442b52c"},
-    {file = "pydantic_core-2.27.1-cp310-none-win_amd64.whl", hash = "sha256:57866a76e0b3823e0b56692d1a0bf722bffb324839bb5b7226a7dbd6c9a40b17"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:ac3b20653bdbe160febbea8aa6c079d3df19310d50ac314911ed8cc4eb7f8cb8"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a5a8e19d7c707c4cadb8c18f5f60c843052ae83c20fa7d44f41594c644a1d330"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f7059ca8d64fea7f238994c97d91f75965216bcbe5f695bb44f354893f11d52"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bed0f8a0eeea9fb72937ba118f9db0cb7e90773462af7962d382445f3005e5a4"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a3cb37038123447cf0f3ea4c74751f6a9d7afef0eb71aa07bf5f652b5e6a132c"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:84286494f6c5d05243456e04223d5a9417d7f443c3b76065e75001beb26f88de"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acc07b2cfc5b835444b44a9956846b578d27beeacd4b52e45489e93276241025"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4fefee876e07a6e9aad7a8c8c9f85b0cdbe7df52b8a9552307b09050f7512c7e"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:258c57abf1188926c774a4c94dd29237e77eda19462e5bb901d88adcab6af919"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:35c14ac45fcfdf7167ca76cc80b2001205a8d5d16d80524e13508371fb8cdd9c"},
-    {file = "pydantic_core-2.27.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d1b26e1dff225c31897696cab7d4f0a315d4c0d9e8666dbffdb28216f3b17fdc"},
-    {file = "pydantic_core-2.27.1-cp311-none-win32.whl", hash = "sha256:2cdf7d86886bc6982354862204ae3b2f7f96f21a3eb0ba5ca0ac42c7b38598b9"},
-    {file = "pydantic_core-2.27.1-cp311-none-win_amd64.whl", hash = "sha256:3af385b0cee8df3746c3f406f38bcbfdc9041b5c2d5ce3e5fc6637256e60bbc5"},
-    {file = "pydantic_core-2.27.1-cp311-none-win_arm64.whl", hash = "sha256:81f2ec23ddc1b476ff96563f2e8d723830b06dceae348ce02914a37cb4e74b89"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9cbd94fc661d2bab2bc702cddd2d3370bbdcc4cd0f8f57488a81bcce90c7a54f"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5f8c4718cd44ec1580e180cb739713ecda2bdee1341084c1467802a417fe0f02"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:15aae984e46de8d376df515f00450d1522077254ef6b7ce189b38ecee7c9677c"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1ba5e3963344ff25fc8c40da90f44b0afca8cfd89d12964feb79ac1411a260ac"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:992cea5f4f3b29d6b4f7f1726ed8ee46c8331c6b4eed6db5b40134c6fe1768bb"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0325336f348dbee6550d129b1627cb8f5351a9dc91aad141ffb96d4937bd9529"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7597c07fbd11515f654d6ece3d0e4e5093edc30a436c63142d9a4b8e22f19c35"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3bbd5d8cc692616d5ef6fbbbd50dbec142c7e6ad9beb66b78a96e9c16729b089"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:dc61505e73298a84a2f317255fcc72b710b72980f3a1f670447a21efc88f8381"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:e1f735dc43da318cad19b4173dd1ffce1d84aafd6c9b782b3abc04a0d5a6f5bb"},
-    {file = "pydantic_core-2.27.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:f4e5658dbffe8843a0f12366a4c2d1c316dbe09bb4dfbdc9d2d9cd6031de8aae"},
-    {file = "pydantic_core-2.27.1-cp312-none-win32.whl", hash = "sha256:672ebbe820bb37988c4d136eca2652ee114992d5d41c7e4858cdd90ea94ffe5c"},
-    {file = "pydantic_core-2.27.1-cp312-none-win_amd64.whl", hash = "sha256:66ff044fd0bb1768688aecbe28b6190f6e799349221fb0de0e6f4048eca14c16"},
-    {file = "pydantic_core-2.27.1-cp312-none-win_arm64.whl", hash = "sha256:9a3b0793b1bbfd4146304e23d90045f2a9b5fd5823aa682665fbdaf2a6c28f3e"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f216dbce0e60e4d03e0c4353c7023b202d95cbaeff12e5fd2e82ea0a66905073"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a2e02889071850bbfd36b56fd6bc98945e23670773bc7a76657e90e6b6603c08"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42b0e23f119b2b456d07ca91b307ae167cc3f6c846a7b169fca5326e32fdc6cf"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:764be71193f87d460a03f1f7385a82e226639732214b402f9aa61f0d025f0737"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1c00666a3bd2f84920a4e94434f5974d7bbc57e461318d6bb34ce9cdbbc1f6b2"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3ccaa88b24eebc0f849ce0a4d09e8a408ec5a94afff395eb69baf868f5183107"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c65af9088ac534313e1963443d0ec360bb2b9cba6c2909478d22c2e363d98a51"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:206b5cf6f0c513baffaeae7bd817717140770c74528f3e4c3e1cec7871ddd61a"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:062f60e512fc7fff8b8a9d680ff0ddaaef0193dba9fa83e679c0c5f5fbd018bc"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:a0697803ed7d4af5e4c1adf1670af078f8fcab7a86350e969f454daf598c4960"},
-    {file = "pydantic_core-2.27.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:58ca98a950171f3151c603aeea9303ef6c235f692fe555e883591103da709b23"},
-    {file = "pydantic_core-2.27.1-cp313-none-win32.whl", hash = "sha256:8065914ff79f7eab1599bd80406681f0ad08f8e47c880f17b416c9f8f7a26d05"},
-    {file = "pydantic_core-2.27.1-cp313-none-win_amd64.whl", hash = "sha256:ba630d5e3db74c79300d9a5bdaaf6200172b107f263c98a0539eeecb857b2337"},
-    {file = "pydantic_core-2.27.1-cp313-none-win_arm64.whl", hash = "sha256:45cf8588c066860b623cd11c4ba687f8d7175d5f7ef65f7129df8a394c502de5"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:5897bec80a09b4084aee23f9b73a9477a46c3304ad1d2d07acca19723fb1de62"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:d0165ab2914379bd56908c02294ed8405c252250668ebcb438a55494c69f44ab"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b9af86e1d8e4cfc82c2022bfaa6f459381a50b94a29e95dcdda8442d6d83864"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f6c8a66741c5f5447e047ab0ba7a1c61d1e95580d64bce852e3df1f895c4067"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a42d6a8156ff78981f8aa56eb6394114e0dedb217cf8b729f438f643608cbcd"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:64c65f40b4cd8b0e049a8edde07e38b476da7e3aaebe63287c899d2cff253fa5"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdcf339322a3fae5cbd504edcefddd5a50d9ee00d968696846f089b4432cf78"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bf99c8404f008750c846cb4ac4667b798a9f7de673ff719d705d9b2d6de49c5f"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:8f1edcea27918d748c7e5e4d917297b2a0ab80cad10f86631e488b7cddf76a36"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-musllinux_1_1_armv7l.whl", hash = "sha256:159cac0a3d096f79ab6a44d77a961917219707e2a130739c64d4dd46281f5c2a"},
-    {file = "pydantic_core-2.27.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:029d9757eb621cc6e1848fa0b0310310de7301057f623985698ed7ebb014391b"},
-    {file = "pydantic_core-2.27.1-cp38-none-win32.whl", hash = "sha256:a28af0695a45f7060e6f9b7092558a928a28553366519f64083c63a44f70e618"},
-    {file = "pydantic_core-2.27.1-cp38-none-win_amd64.whl", hash = "sha256:2d4567c850905d5eaaed2f7a404e61012a51caf288292e016360aa2b96ff38d4"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:e9386266798d64eeb19dd3677051f5705bf873e98e15897ddb7d76f477131967"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4228b5b646caa73f119b1ae756216b59cc6e2267201c27d3912b592c5e323b60"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b3dfe500de26c52abe0477dde16192ac39c98f05bf2d80e76102d394bd13854"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:aee66be87825cdf72ac64cb03ad4c15ffef4143dbf5c113f64a5ff4f81477bf9"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3b748c44bb9f53031c8cbc99a8a061bc181c1000c60a30f55393b6e9c45cc5bd"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ca038c7f6a0afd0b2448941b6ef9d5e1949e999f9e5517692eb6da58e9d44be"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e0bd57539da59a3e4671b90a502da9a28c72322a4f17866ba3ac63a82c4498e"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ac6c2c45c847bbf8f91930d88716a0fb924b51e0c6dad329b793d670ec5db792"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b94d4ba43739bbe8b0ce4262bcc3b7b9f31459ad120fb595627eaeb7f9b9ca01"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-musllinux_1_1_armv7l.whl", hash = "sha256:00e6424f4b26fe82d44577b4c842d7df97c20be6439e8e685d0d715feceb9fb9"},
-    {file = "pydantic_core-2.27.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:38de0a70160dd97540335b7ad3a74571b24f1dc3ed33f815f0880682e6880131"},
-    {file = "pydantic_core-2.27.1-cp39-none-win32.whl", hash = "sha256:7ccebf51efc61634f6c2344da73e366c75e735960b5654b63d7e6f69a5885fa3"},
-    {file = "pydantic_core-2.27.1-cp39-none-win_amd64.whl", hash = "sha256:a57847b090d7892f123726202b7daa20df6694cbd583b67a592e856bff603d6c"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3fa80ac2bd5856580e242dbc202db873c60a01b20309c8319b5c5986fbe53ce6"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:d950caa237bb1954f1b8c9227b5065ba6875ac9771bb8ec790d956a699b78676"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e4216e64d203e39c62df627aa882f02a2438d18a5f21d7f721621f7a5d3611d"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:02a3d637bd387c41d46b002f0e49c52642281edacd2740e5a42f7017feea3f2c"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:161c27ccce13b6b0c8689418da3885d3220ed2eae2ea5e9b2f7f3d48f1d52c27"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:19910754e4cc9c63bc1c7f6d73aa1cfee82f42007e407c0f413695c2f7ed777f"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:e173486019cc283dc9778315fa29a363579372fe67045e971e89b6365cc035ed"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:af52d26579b308921b73b956153066481f064875140ccd1dfd4e77db89dbb12f"},
-    {file = "pydantic_core-2.27.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:981fb88516bd1ae8b0cbbd2034678a39dedc98752f264ac9bc5839d3923fa04c"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5fde892e6c697ce3e30c61b239330fc5d569a71fefd4eb6512fc6caec9dd9e2f"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:816f5aa087094099fff7edabb5e01cc370eb21aa1a1d44fe2d2aefdfb5599b31"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c10c309e18e443ddb108f0ef64e8729363adbfd92d6d57beec680f6261556f3"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98476c98b02c8e9b2eec76ac4156fd006628b1b2d0ef27e548ffa978393fd154"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c3027001c28434e7ca5a6e1e527487051136aa81803ac812be51802150d880dd"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:7699b1df36a48169cdebda7ab5a2bac265204003f153b4bd17276153d997670a"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:1c39b07d90be6b48968ddc8c19e7585052088fd7ec8d568bb31ff64c70ae3c97"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:46ccfe3032b3915586e469d4972973f893c0a2bb65669194a5bdea9bacc088c2"},
-    {file = "pydantic_core-2.27.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:62ba45e21cf6571d7f716d903b5b7b6d2617e2d5d67c0923dc47b9d41369f840"},
-    {file = "pydantic_core-2.27.1.tar.gz", hash = "sha256:62a763352879b84aa31058fc931884055fd75089cccbd9d58bb6afd01141b235"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:b10bd51f823d891193d4717448fab065733958bdb6a6b351967bd349d48d5c9b"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4fc714bdbfb534f94034efaa6eadd74e5b93c8fa6315565a222f7b6f42ca1166"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:63e46b3169866bd62849936de036f901a9356e36376079b05efa83caeaa02ceb"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed1a53de42fbe34853ba90513cea21673481cd81ed1be739f7f2efb931b24916"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cfdd16ab5e59fc31b5e906d1a3f666571abc367598e3e02c83403acabc092e07"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:255a8ef062cbf6674450e668482456abac99a5583bbafb73f9ad469540a3a232"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4a7cd62e831afe623fbb7aabbb4fe583212115b3ef38a9f6b71869ba644624a2"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f09e2ff1f17c2b51f2bc76d1cc33da96298f0a036a137f5440ab3ec5360b624f"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e38e63e6f3d1cec5a27e0afe90a085af8b6806ee208b33030e65b6516353f1a3"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0dbd8dbed2085ed23b5c04afa29d8fd2771674223135dc9bc937f3c09284d071"},
+    {file = "pydantic_core-2.23.4-cp310-none-win32.whl", hash = "sha256:6531b7ca5f951d663c339002e91aaebda765ec7d61b7d1e3991051906ddde119"},
+    {file = "pydantic_core-2.23.4-cp310-none-win_amd64.whl", hash = "sha256:7c9129eb40958b3d4500fa2467e6a83356b3b61bfff1b414c7361d9220f9ae8f"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:77733e3892bb0a7fa797826361ce8a9184d25c8dffaec60b7ffe928153680ba8"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b84d168f6c48fabd1f2027a3d1bdfe62f92cade1fb273a5d68e621da0e44e6d"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df49e7a0861a8c36d089c1ed57d308623d60416dab2647a4a17fe050ba85de0e"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ff02b6d461a6de369f07ec15e465a88895f3223eb75073ffea56b84d9331f607"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:996a38a83508c54c78a5f41456b0103c30508fed9abcad0a59b876d7398f25fd"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d97683ddee4723ae8c95d1eddac7c192e8c552da0c73a925a89fa8649bf13eea"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:216f9b2d7713eb98cb83c80b9c794de1f6b7e3145eef40400c62e86cee5f4e1e"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6f783e0ec4803c787bcea93e13e9932edab72068f68ecffdf86a99fd5918878b"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d0776dea117cf5272382634bd2a5c1b6eb16767c223c6a5317cd3e2a757c61a0"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d5f7a395a8cf1621939692dba2a6b6a830efa6b3cee787d82c7de1ad2930de64"},
+    {file = "pydantic_core-2.23.4-cp311-none-win32.whl", hash = "sha256:74b9127ffea03643e998e0c5ad9bd3811d3dac8c676e47db17b0ee7c3c3bf35f"},
+    {file = "pydantic_core-2.23.4-cp311-none-win_amd64.whl", hash = "sha256:98d134c954828488b153d88ba1f34e14259284f256180ce659e8d83e9c05eaa3"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f3e0da4ebaef65158d4dfd7d3678aad692f7666877df0002b8a522cdf088f231"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f69a8e0b033b747bb3e36a44e7732f0c99f7edd5cea723d45bc0d6e95377ffee"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:723314c1d51722ab28bfcd5240d858512ffd3116449c557a1336cbe3919beb87"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bb2802e667b7051a1bebbfe93684841cc9351004e2badbd6411bf357ab8d5ac8"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d18ca8148bebe1b0a382a27a8ee60350091a6ddaf475fa05ef50dc35b5df6327"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:33e3d65a85a2a4a0dc3b092b938a4062b1a05f3a9abde65ea93b233bca0e03f2"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:128585782e5bfa515c590ccee4b727fb76925dd04a98864182b22e89a4e6ed36"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:68665f4c17edcceecc112dfed5dbe6f92261fb9d6054b47d01bf6371a6196126"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:20152074317d9bed6b7a95ade3b7d6054845d70584216160860425f4fbd5ee9e"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:9261d3ce84fa1d38ed649c3638feefeae23d32ba9182963e465d58d62203bd24"},
+    {file = "pydantic_core-2.23.4-cp312-none-win32.whl", hash = "sha256:4ba762ed58e8d68657fc1281e9bb72e1c3e79cc5d464be146e260c541ec12d84"},
+    {file = "pydantic_core-2.23.4-cp312-none-win_amd64.whl", hash = "sha256:97df63000f4fea395b2824da80e169731088656d1818a11b95f3b173747b6cd9"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7530e201d10d7d14abce4fb54cfe5b94a0aefc87da539d0346a484ead376c3cc"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:df933278128ea1cd77772673c73954e53a1c95a4fdf41eef97c2b779271bd0bd"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cb3da3fd1b6a5d0279a01877713dbda118a2a4fc6f0d821a57da2e464793f05"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:42c6dcb030aefb668a2b7009c85b27f90e51e6a3b4d5c9bc4c57631292015b0d"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:696dd8d674d6ce621ab9d45b205df149399e4bb9aa34102c970b721554828510"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2971bb5ffe72cc0f555c13e19b23c85b654dd2a8f7ab493c262071377bfce9f6"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8394d940e5d400d04cad4f75c0598665cbb81aecefaca82ca85bd28264af7f9b"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0dff76e0602ca7d4cdaacc1ac4c005e0ce0dcfe095d5b5259163a80d3a10d327"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7d32706badfe136888bdea71c0def994644e09fff0bfe47441deaed8e96fdbc6"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ed541d70698978a20eb63d8c5d72f2cc6d7079d9d90f6b50bad07826f1320f5f"},
+    {file = "pydantic_core-2.23.4-cp313-none-win32.whl", hash = "sha256:3d5639516376dce1940ea36edf408c554475369f5da2abd45d44621cb616f769"},
+    {file = "pydantic_core-2.23.4-cp313-none-win_amd64.whl", hash = "sha256:5a1504ad17ba4210df3a045132a7baeeba5a200e930f57512ee02909fc5c4cb5"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:d4488a93b071c04dc20f5cecc3631fc78b9789dd72483ba15d423b5b3689b555"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:81965a16b675b35e1d09dd14df53f190f9129c0202356ed44ab2728b1c905658"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ffa2ebd4c8530079140dd2d7f794a9d9a73cbb8e9d59ffe24c63436efa8f271"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:61817945f2fe7d166e75fbfb28004034b48e44878177fc54d81688e7b85a3665"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:29d2c342c4bc01b88402d60189f3df065fb0dda3654744d5a165a5288a657368"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5e11661ce0fd30a6790e8bcdf263b9ec5988e95e63cf901972107efc49218b13"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d18368b137c6295db49ce7218b1a9ba15c5bc254c96d7c9f9e924a9bc7825ad"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ec4e55f79b1c4ffb2eecd8a0cfba9955a2588497d96851f4c8f99aa4a1d39b12"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:374a5e5049eda9e0a44c696c7ade3ff355f06b1fe0bb945ea3cac2bc336478a2"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:5c364564d17da23db1106787675fc7af45f2f7b58b4173bfdd105564e132e6fb"},
+    {file = "pydantic_core-2.23.4-cp38-none-win32.whl", hash = "sha256:d7a80d21d613eec45e3d41eb22f8f94ddc758a6c4720842dc74c0581f54993d6"},
+    {file = "pydantic_core-2.23.4-cp38-none-win_amd64.whl", hash = "sha256:5f5ff8d839f4566a474a969508fe1c5e59c31c80d9e140566f9a37bba7b8d556"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:a4fa4fc04dff799089689f4fd502ce7d59de529fc2f40a2c8836886c03e0175a"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0a7df63886be5e270da67e0966cf4afbae86069501d35c8c1b3b6c168f42cb36"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dcedcd19a557e182628afa1d553c3895a9f825b936415d0dbd3cd0bbcfd29b4b"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f54b118ce5de9ac21c363d9b3caa6c800341e8c47a508787e5868c6b79c9323"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86d2f57d3e1379a9525c5ab067b27dbb8a0642fb5d454e17a9ac434f9ce523e3"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:de6d1d1b9e5101508cb37ab0d972357cac5235f5c6533d1071964c47139257df"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1278e0d324f6908e872730c9102b0112477a7f7cf88b308e4fc36ce1bdb6d58c"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9a6b5099eeec78827553827f4c6b8615978bb4b6a88e5d9b93eddf8bb6790f55"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:e55541f756f9b3ee346b840103f32779c695a19826a4c442b7954550a0972040"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a5c7ba8ffb6d6f8f2ab08743be203654bb1aaa8c9dcb09f82ddd34eadb695605"},
+    {file = "pydantic_core-2.23.4-cp39-none-win32.whl", hash = "sha256:37b0fe330e4a58d3c58b24d91d1eb102aeec675a3db4c292ec3928ecd892a9a6"},
+    {file = "pydantic_core-2.23.4-cp39-none-win_amd64.whl", hash = "sha256:1498bec4c05c9c787bde9125cfdcc63a41004ff167f495063191b863399b1a29"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f455ee30a9d61d3e1a15abd5068827773d6e4dc513e795f380cdd59932c782d5"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1e90d2e3bd2c3863d48525d297cd143fe541be8bbf6f579504b9712cb6b643ec"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e203fdf807ac7e12ab59ca2bfcabb38c7cf0b33c41efeb00f8e5da1d86af480"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e08277a400de01bc72436a0ccd02bdf596631411f592ad985dcee21445bd0068"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f220b0eea5965dec25480b6333c788fb72ce5f9129e8759ef876a1d805d00801"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:d06b0c8da4f16d1d1e352134427cb194a0a6e19ad5db9161bf32b2113409e728"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:ba1a0996f6c2773bd83e63f18914c1de3c9dd26d55f4ac302a7efe93fb8e7433"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:9a5bce9d23aac8f0cf0836ecfc033896aa8443b501c58d0602dbfd5bd5b37753"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:78ddaaa81421a29574a682b3179d4cf9e6d405a09b99d93ddcf7e5239c742e21"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:883a91b5dd7d26492ff2f04f40fbb652de40fcc0afe07e8129e8ae779c2110eb"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88ad334a15b32a791ea935af224b9de1bf99bcd62fabf745d5f3442199d86d59"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:233710f069d251feb12a56da21e14cca67994eab08362207785cf8c598e74577"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:19442362866a753485ba5e4be408964644dd6a09123d9416c54cd49171f50744"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:624e278a7d29b6445e4e813af92af37820fafb6dcc55c012c834f9e26f9aaaef"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f5ef8f42bec47f21d07668a043f077d507e5bf4e668d5c6dfe6aaba89de1a5b8"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:aea443fffa9fbe3af1a9ba721a87f926fe548d32cab71d188a6ede77d0ff244e"},
+    {file = "pydantic_core-2.23.4.tar.gz", hash = "sha256:2584f7cf844ac4d970fba483a717dbe10c1c1c96a969bf65d61ffe94df1b2863"},
 ]
 
 [package.dependencies]
@@ -1223,13 +1189,13 @@ typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0"
 
 [[package]]
 name = "pydantic-settings"
-version = "2.7.0"
+version = "2.6.1"
 description = "Settings management using Pydantic"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pydantic_settings-2.7.0-py3-none-any.whl", hash = "sha256:e00c05d5fa6cbbb227c84bd7487c5c1065084119b750df7c8c1a554aed236eb5"},
-    {file = "pydantic_settings-2.7.0.tar.gz", hash = "sha256:ac4bfd4a36831a48dbf8b2d9325425b549a0a6f18cea118436d728eb4f1c4d66"},
+    {file = "pydantic_settings-2.6.1-py3-none-any.whl", hash = "sha256:7fb0637c786a558d3103436278a7c4f1cfd29ba8973238a50c5bb9a55387da87"},
+    {file = "pydantic_settings-2.6.1.tar.gz", hash = "sha256:e0f92546d8a9923cb8941689abf85d6601a8c19a23e97a34b2964a2e3f813ca0"},
 ]
 
 [package.dependencies]
@@ -1243,13 +1209,13 @@ yaml = ["pyyaml (>=6.0.1)"]
 
 [[package]]
 name = "pyjwt"
-version = "2.10.1"
+version = "2.9.0"
 description = "JSON Web Token implementation in Python"
 optional = false
-python-versions = ">=3.9"
+python-versions = ">=3.8"
 files = [
-    {file = "PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb"},
-    {file = "pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953"},
+    {file = "PyJWT-2.9.0-py3-none-any.whl", hash = "sha256:3b02fb0f44517787776cf48f2ae25d8e14f300e6d7545a4315cee571a415e850"},
+    {file = "pyjwt-2.9.0.tar.gz", hash = "sha256:7e1e5b56cc735432a7369cbfa0efe50fa113ebecdc04ae6922deba8b84582d0c"},
 ]
 
 [package.extras]
@@ -1258,63 +1224,6 @@ dev = ["coverage[toml] (==5.0.4)", "cryptography (>=3.4.0)", "pre-commit", "pyte
 docs = ["sphinx", "sphinx-rtd-theme", "zope.interface"]
 tests = ["coverage[toml] (==5.0.4)", "pytest (>=6.0.0,<7.0.0)"]
 
-[[package]]
-name = "pytest"
-version = "8.3.3"
-description = "pytest: simple powerful testing with Python"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2"},
-    {file = "pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181"},
-]
-
-[package.dependencies]
-colorama = {version = "*", markers = "sys_platform == \"win32\""}
-exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""}
-iniconfig = "*"
-packaging = "*"
-pluggy = ">=1.5,<2"
-tomli = {version = ">=1", markers = "python_version < \"3.11\""}
-
-[package.extras]
-dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
-
-[[package]]
-name = "pytest-asyncio"
-version = "0.25.0"
-description = "Pytest support for asyncio"
-optional = false
-python-versions = ">=3.9"
-files = [
-    {file = "pytest_asyncio-0.25.0-py3-none-any.whl", hash = "sha256:db5432d18eac6b7e28b46dcd9b69921b55c3b1086e85febfe04e70b18d9e81b3"},
-    {file = "pytest_asyncio-0.25.0.tar.gz", hash = "sha256:8c0610303c9e0442a5db8604505fc0f545456ba1528824842b37b4a626cbf609"},
-]
-
-[package.dependencies]
-pytest = ">=8.2,<9"
-
-[package.extras]
-docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1)"]
-testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"]
-
-[[package]]
-name = "pytest-mock"
-version = "3.14.0"
-description = "Thin-wrapper around the mock package for easier use with pytest"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pytest-mock-3.14.0.tar.gz", hash = "sha256:2719255a1efeceadbc056d6bf3df3d1c5015530fb40cf347c0f9afac88410bd0"},
-    {file = "pytest_mock-3.14.0-py3-none-any.whl", hash = "sha256:0b72c38033392a5f4621342fe11e9219ac11ec9d375f8e2a0c164539e0d70f6f"},
-]
-
-[package.dependencies]
-pytest = ">=6.2.5"
-
-[package.extras]
-dev = ["pre-commit", "pytest-asyncio", "tox"]
-
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"
@@ -1362,13 +1271,13 @@ websockets = ">=11,<13"
 
 [[package]]
 name = "redis"
-version = "5.2.1"
+version = "5.2.0"
 description = "Python client for Redis database and key-value store"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "redis-5.2.1-py3-none-any.whl", hash = "sha256:ee7e1056b9aea0f04c6c2ed59452947f34c4940ee025f5dd83e6a6418b6989e4"},
-    {file = "redis-5.2.1.tar.gz", hash = "sha256:16f2e22dff21d5125e8481515e386711a34cbec50f0e44413dd7d9c060a54e0f"},
+    {file = "redis-5.2.0-py3-none-any.whl", hash = "sha256:ae174f2bb3b1bf2b09d54bf3e51fbc1469cf6c10aa03e21141f51969801a7897"},
+    {file = "redis-5.2.0.tar.gz", hash = "sha256:0b1087665a771b1ff2e003aa5bdd354f15a70c9e25d5a7dbf9c722c16528a7b0"},
 ]
 
 [package.dependencies]
@@ -1413,33 +1322,6 @@ files = [
 [package.dependencies]
 pyasn1 = ">=0.1.3"
 
-[[package]]
-name = "ruff"
-version = "0.8.6"
-description = "An extremely fast Python linter and code formatter, written in Rust."
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "ruff-0.8.6-py3-none-linux_armv6l.whl", hash = "sha256:defed167955d42c68b407e8f2e6f56ba52520e790aba4ca707a9c88619e580e3"},
-    {file = "ruff-0.8.6-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:54799ca3d67ae5e0b7a7ac234baa657a9c1784b48ec954a094da7c206e0365b1"},
-    {file = "ruff-0.8.6-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e88b8f6d901477c41559ba540beeb5a671e14cd29ebd5683903572f4b40a9807"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0509e8da430228236a18a677fcdb0c1f102dd26d5520f71f79b094963322ed25"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:91a7ddb221779871cf226100e677b5ea38c2d54e9e2c8ed847450ebbdf99b32d"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:248b1fb3f739d01d528cc50b35ee9c4812aa58cc5935998e776bf8ed5b251e75"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:bc3c083c50390cf69e7e1b5a5a7303898966be973664ec0c4a4acea82c1d4315"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:52d587092ab8df308635762386f45f4638badb0866355b2b86760f6d3c076188"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:61323159cf21bc3897674e5adb27cd9e7700bab6b84de40d7be28c3d46dc67cf"},
-    {file = "ruff-0.8.6-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ae4478b1471fc0c44ed52a6fb787e641a2ac58b1c1f91763bafbc2faddc5117"},
-    {file = "ruff-0.8.6-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:0c000a471d519b3e6cfc9c6680025d923b4ca140ce3e4612d1a2ef58e11f11fe"},
-    {file = "ruff-0.8.6-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:9257aa841e9e8d9b727423086f0fa9a86b6b420fbf4bf9e1465d1250ce8e4d8d"},
-    {file = "ruff-0.8.6-py3-none-musllinux_1_2_i686.whl", hash = "sha256:45a56f61b24682f6f6709636949ae8cc82ae229d8d773b4c76c09ec83964a95a"},
-    {file = "ruff-0.8.6-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:496dd38a53aa173481a7d8866bcd6451bd934d06976a2505028a50583e001b76"},
-    {file = "ruff-0.8.6-py3-none-win32.whl", hash = "sha256:e169ea1b9eae61c99b257dc83b9ee6c76f89042752cb2d83486a7d6e48e8f764"},
-    {file = "ruff-0.8.6-py3-none-win_amd64.whl", hash = "sha256:f1d70bef3d16fdc897ee290d7d20da3cbe4e26349f62e8a0274e7a3f4ce7a905"},
-    {file = "ruff-0.8.6-py3-none-win_arm64.whl", hash = "sha256:7d7fc2377a04b6e04ffe588caad613d0c460eb2ecba4c0ccbbfe2bc973cbc162"},
-    {file = "ruff-0.8.6.tar.gz", hash = "sha256:dcad24b81b62650b0eb8814f576fc65cfee8674772a6e24c9b747911801eeaa5"},
-]
-
 [[package]]
 name = "six"
 version = "1.16.0"
@@ -1464,18 +1346,19 @@ files = [
 
 [[package]]
 name = "storage3"
-version = "0.9.0"
+version = "0.8.2"
 description = "Supabase Storage client for Python."
 optional = false
 python-versions = "<4.0,>=3.9"
 files = [
-    {file = "storage3-0.9.0-py3-none-any.whl", hash = "sha256:8b2fb91f0c61583a2f4eac74a8bae67e00d41ff38095c8a6cd3f2ce5e0ab76e7"},
-    {file = "storage3-0.9.0.tar.gz", hash = "sha256:e16697f60894c94e1d9df0d2e4af783c1b3f7dd08c9013d61978825c624188c4"},
+    {file = "storage3-0.8.2-py3-none-any.whl", hash = "sha256:f2e995b18c77a2a9265d1a33047d43e4d6abb11eb3ca5067959f68281c305de3"},
+    {file = "storage3-0.8.2.tar.gz", hash = "sha256:db05d3fe8fb73bd30c814c4c4749664f37a5dfc78b629e8c058ef558c2b89f5a"},
 ]
 
 [package.dependencies]
 httpx = {version = ">=0.26,<0.28", extras = ["http2"]}
 python-dateutil = ">=2.8.2,<3.0.0"
+typing-extensions = ">=4.2.0,<5.0.0"
 
 [[package]]
 name = "strenum"
@@ -1495,48 +1378,37 @@ test = ["pylint", "pytest", "pytest-black", "pytest-cov", "pytest-pylint"]
 
 [[package]]
 name = "supabase"
-version = "2.10.0"
+version = "2.9.1"
 description = "Supabase client for Python."
 optional = false
 python-versions = "<4.0,>=3.9"
 files = [
-    {file = "supabase-2.10.0-py3-none-any.whl", hash = "sha256:183fb23c04528593f8f81c24ceb8178f3a56bff40fec7ed873b6c55ebc2e420a"},
-    {file = "supabase-2.10.0.tar.gz", hash = "sha256:9ac095f8947bf60780e67c0edcbab53e2db3f6f3f022329397b093500bf2607c"},
+    {file = "supabase-2.9.1-py3-none-any.whl", hash = "sha256:a96f857a465712cb551679c1df66ba772c834f861756ce4aa2aa4cb703f6aeb7"},
+    {file = "supabase-2.9.1.tar.gz", hash = "sha256:51fce39c9eb50573126dabb342541ec5e1f13e7476938768f4b0ccfdb8c522cd"},
 ]
 
 [package.dependencies]
-gotrue = ">=2.10.0,<3.0.0"
+gotrue = ">=2.9.0,<3.0.0"
 httpx = ">=0.26,<0.28"
-postgrest = ">=0.18,<0.19"
+postgrest = ">=0.17.0,<0.18.0"
 realtime = ">=2.0.0,<3.0.0"
-storage3 = ">=0.9.0,<0.10.0"
-supafunc = ">=0.7.0,<0.8.0"
+storage3 = ">=0.8.0,<0.9.0"
+supafunc = ">=0.6.0,<0.7.0"
 
 [[package]]
 name = "supafunc"
-version = "0.7.0"
+version = "0.6.2"
 description = "Library for Supabase Functions"
 optional = false
 python-versions = "<4.0,>=3.9"
 files = [
-    {file = "supafunc-0.7.0-py3-none-any.whl", hash = "sha256:4160260dc02bdd906be1e2ffd7cb3ae8b74ae437c892bb475352b6a99d9ff8eb"},
-    {file = "supafunc-0.7.0.tar.gz", hash = "sha256:5b1c415fba1395740b2b4eedd1d786384bd58b98f6333a11ba7889820a48b6a7"},
+    {file = "supafunc-0.6.2-py3-none-any.whl", hash = "sha256:101b30616b0a1ce8cf938eca1df362fa4cf1deacb0271f53ebbd674190fb0da5"},
+    {file = "supafunc-0.6.2.tar.gz", hash = "sha256:c7dfa20db7182f7fe4ae436e94e05c06cd7ed98d697fed75d68c7b9792822adc"},
 ]
 
 [package.dependencies]
 httpx = {version = ">=0.26,<0.28", extras = ["http2"]}
 
-[[package]]
-name = "tomli"
-version = "2.1.0"
-description = "A lil' TOML parser"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "tomli-2.1.0-py3-none-any.whl", hash = "sha256:a5c57c3d1c56f5ccdf89f6523458f60ef716e210fc47c4cfb188c5ba473e0391"},
-    {file = "tomli-2.1.0.tar.gz", hash = "sha256:3f646cae2aec94e17d04973e4249548320197cfabdf130015d023de4b74d8ab8"},
-]
-
 [[package]]
 name = "typing-extensions"
 version = "4.12.2"
@@ -1852,4 +1724,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.10,<4.0"
-content-hash = "bf1b0125759dadb1369fff05ffba64fea3e82b9b7a43d0068e1c80974a4ebc1c"
+content-hash = "f80654aae542b1f2f3a44a01f197f87ffbaea52f474dd2cc2b72b8d56b155563"

autogpt_platform/autogpt_libs/pyproject.toml

@@ -10,25 +10,16 @@ packages = [{ include = "autogpt_libs" }]
 colorama = "^0.4.6"
 expiringdict = "^1.2.2"
 google-cloud-logging = "^3.11.3"
-pydantic = "^2.10.3"
-pydantic-settings = "^2.7.0"
-pyjwt = "^2.10.1"
-pytest-asyncio = "^0.25.0"
-pytest-mock = "^3.14.0"
+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.10.0"
+supabase = "^2.9.1"
 
 [tool.poetry.group.dev.dependencies]
-redis = "^5.2.1"
-ruff = "^0.8.6"
+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

@@ -28,15 +28,8 @@ SUPABASE_URL=http://localhost:8000
 SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJzZXJ2aWNlX3JvbGUiLAogICAgImlzcyI6ICJzdXBhYmFzZS1kZW1vIiwKICAgICJpYXQiOiAxNjQxNzY5MjAwLAogICAgImV4cCI6IDE3OTk1MzU2MDAKfQ.DaYlNEoUrrEn2Ig7tqibS-PHK5vgusbcbo7X36XVt4Q
 SUPABASE_JWT_SECRET=your-super-secret-jwt-token-with-at-least-32-characters-long
 
-## For local development, you may need to set FRONTEND_BASE_URL for the OAuth flow
-## for integrations to work. Defaults to the value of PLATFORM_BASE_URL if not set.
-# FRONTEND_BASE_URL=http://localhost:3000
-
-## PLATFORM_BASE_URL must be set to a *publicly accessible* URL pointing to your backend
-## to use the platform's webhook-related functionality.
-## If you are developing locally, you can use something like ngrok to get a publc URL
-## and tunnel it to your locally running backend.
-PLATFORM_BASE_URL=https://your-public-url-here
+# 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
@@ -58,28 +51,12 @@ 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=
-
-
 ## ===== OPTIONAL API KEYS ===== ##
 
 # LLM
 OPENAI_API_KEY=
 ANTHROPIC_API_KEY=
 GROQ_API_KEY=
-OPEN_ROUTER_API_KEY=
 
 # Reddit
 REDDIT_CLIENT_ID=
@@ -121,18 +98,6 @@ REPLICATE_API_KEY=
 # Ideogram
 IDEOGRAM_API_KEY=
 
-# Fal
-FAL_API_KEY=
-
-# Exa
-EXA_API_KEY=
-
-# E2B
-E2B_API_KEY=
-
-# Nvidia
-NVIDIA_API_KEY=
-
 # Logging Configuration
 LOG_LEVEL=INFO
 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,7 +71,6 @@ WORKDIR /app/autogpt_platform/backend
 FROM server_dependencies AS server
 
 COPY autogpt_platform/backend /app/autogpt_platform/backend
-RUN poetry install --no-ansi --only-root
 
 ENV DATABASE_URL=""
 ENV PORT=8000

autogpt_platform/backend/README.md

@@ -200,4 +200,4 @@ To add a new agent block, you need to create a new class that inherits from `Blo
 * `run` method: the main logic of the block.
 * `test_input` & `test_output`: the sample input and output data for the block, which will be used to auto-test the block.
 * You can mock the functions declared in the block using the `test_mock` field for your unit tests.
-* Once you finish creating the block, you can test it by running `poetry run pytest -s test/block/test_block.py`.
+* Once you finish creating the block, you can test it by running `pytest -s test/block/test_block.py`.

autogpt_platform/backend/backend/blocks/__init__.py

@@ -15,10 +15,10 @@ modules = [
     if f.is_file() and f.name != "__init__.py"
 ]
 for module in modules:
-    if not re.match("^[a-z0-9_.]+$", module):
+    if not re.match("^[a-z_.]+$", module):
         raise ValueError(
             f"Block module {module} error: module name must be lowercase, "
-            "and contain only alphanumeric characters and underscores."
+            "separated by underscores, and contain only alphabet characters"
         )
 
     importlib.import_module(f".{module}", package=__name__)
@@ -60,6 +60,13 @@ for block_cls in all_subclasses(Block):
     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(

autogpt_platform/backend/backend/blocks/agent.py

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

autogpt_platform/backend/backend/blocks/ai_image_generator_block.py

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

autogpt_platform/backend/backend/blocks/ai_music_generator.py

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

autogpt_platform/backend/backend/blocks/ai_shortform_video_block.py

@@ -3,16 +3,11 @@ 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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 from backend.util.request import requests
 
 TEST_CREDENTIALS = APIKeyCredentials(
@@ -141,11 +136,13 @@ logger = logging.getLogger(__name__)
 
 class AIShortformVideoCreatorBlock(Block):
     class Input(BlockSchema):
-        credentials: CredentialsMetaInput[
-            Literal[ProviderName.REVID], Literal["api_key"]
-        ] = CredentialsField(
-            description="The revid.ai integration can be used with "
-            "any API key with sufficient permissions for the blocks it is used on.",
+        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.""",

autogpt_platform/backend/backend/blocks/basic.py

@@ -1,11 +1,13 @@
+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.mock import MockObject
-from backend.util.text import TextFormatter
 
-formatter = TextFormatter()
+jinja = Environment(loader=BaseLoader())
 
 
 class StoreValueBlock(Block):
@@ -231,9 +233,7 @@ class AgentOutputBlock(Block):
         )
         name: str = SchemaField(description="The name of the output.")
         title: str | None = SchemaField(
-            description="The title of the output.",
-            default=None,
-            advanced=True,
+            description="The title of the input.", default=None, advanced=True
         )
         description: str | None = SchemaField(
             description="The description of the output.",
@@ -241,7 +241,7 @@ class AgentOutputBlock(Block):
             advanced=True,
         )
         format: str = SchemaField(
-            description="The format string to be used to format the recorded_value. Use Jinja2 syntax.",
+            description="The format string to be used to format the recorded_value.",
             default="",
             advanced=True,
         )
@@ -262,7 +262,7 @@ class AgentOutputBlock(Block):
     def __init__(self):
         super().__init__(
             id="363ae599-353e-4804-937e-b2ee3cef3da4",
-            description="Stores the output of the graph for users to see.",
+            description=("Stores the output of the graph for users to see."),
             input_schema=AgentOutputBlock.Input,
             output_schema=AgentOutputBlock.Output,
             test_input=[
@@ -302,9 +302,9 @@ class AgentOutputBlock(Block):
         """
         if input_data.format:
             try:
-                yield "output", formatter.format_string(
-                    input_data.format, {input_data.name: input_data.value}
-                )
+                fmt = re.sub(r"(?<!{){[ a-zA-Z0-9_]+}", r"{\g<0>}", input_data.format)
+                template = jinja.from_string(fmt)
+                yield "output", template.render({input_data.name: input_data.value})
             except Exception as e:
                 yield "output", f"Error: {e}, {input_data.value}"
         else:
@@ -313,26 +313,16 @@ class AgentOutputBlock(Block):
 
 class AddToDictionaryBlock(Block):
     class Input(BlockSchema):
-        dictionary: dict[Any, Any] = SchemaField(
-            default={},
+        dictionary: dict | None = SchemaField(
+            default=None,
             description="The dictionary to add the entry to. If not provided, a new dictionary will be created.",
+            placeholder='{"key1": "value1", "key2": "value2"}',
         )
         key: str = SchemaField(
-            default="",
-            description="The key for the new entry.",
-            placeholder="new_key",
-            advanced=False,
+            description="The key for the new entry.", placeholder="new_key"
         )
         value: Any = SchemaField(
-            default=None,
-            description="The value for the new entry.",
-            placeholder="new_value",
-            advanced=False,
-        )
-        entries: dict[Any, Any] = SchemaField(
-            default={},
-            description="The entries to add to the dictionary. This is the batch version of the `key` and `value` fields.",
-            advanced=True,
+            description="The value for the new entry.", placeholder="new_value"
         )
 
     class Output(BlockSchema):
@@ -355,10 +345,6 @@ class AddToDictionaryBlock(Block):
                     "value": "new_value",
                 },
                 {"key": "first_key", "value": "first_value"},
-                {
-                    "dictionary": {"existing_key": "existing_value"},
-                    "entries": {"new_key": "new_value", "first_key": "first_value"},
-                },
             ],
             test_output=[
                 (
@@ -366,49 +352,38 @@ class AddToDictionaryBlock(Block):
                     {"existing_key": "existing_value", "new_key": "new_value"},
                 ),
                 ("updated_dictionary", {"first_key": "first_value"}),
-                (
-                    "updated_dictionary",
-                    {
-                        "existing_key": "existing_value",
-                        "new_key": "new_value",
-                        "first_key": "first_value",
-                    },
-                ),
             ],
         )
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        updated_dict = input_data.dictionary.copy()
+        # If no dictionary is provided, create a new one
+        if input_data.dictionary is None:
+            updated_dict = {}
+        else:
+            # Create a copy of the input dictionary to avoid modifying the original
+            updated_dict = input_data.dictionary.copy()
 
-        if input_data.value is not None and input_data.key:
-            updated_dict[input_data.key] = input_data.value
-
-        for key, value in input_data.entries.items():
-            updated_dict[key] = value
+        # 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] = SchemaField(
-            default=[],
-            advanced=False,
+        list: List[Any] | None = SchemaField(
+            default=None,
             description="The list to add the entry to. If not provided, a new list will be created.",
+            placeholder='[1, "string", {"key": "value"}]',
         )
         entry: Any = SchemaField(
             description="The entry to add to the list. Can be of any type (string, int, dict, etc.).",
-            advanced=False,
-            default=None,
-        )
-        entries: List[Any] = SchemaField(
-            default=[],
-            description="The entries to add to the list. This is the batch version of the `entry` field.",
-            advanced=True,
+            placeholder='{"new_key": "new_value"}',
         )
         position: int | None = SchemaField(
             default=None,
             description="The position to insert the new entry. If not provided, the entry will be appended to the end of the list.",
+            placeholder="0",
         )
 
     class Output(BlockSchema):
@@ -432,12 +407,6 @@ class AddToListBlock(Block):
                 },
                 {"entry": "first_entry"},
                 {"list": ["a", "b", "c"], "entry": "d"},
-                {
-                    "entry": "e",
-                    "entries": ["f", "g"],
-                    "list": ["a", "b"],
-                    "position": 1,
-                },
             ],
             test_output=[
                 (
@@ -451,20 +420,22 @@ class AddToListBlock(Block):
                 ),
                 ("updated_list", ["first_entry"]),
                 ("updated_list", ["a", "b", "c", "d"]),
-                ("updated_list", ["a", "f", "g", "e", "b"]),
             ],
         )
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        entries_added = input_data.entries.copy()
-        if input_data.entry:
-            entries_added.append(input_data.entry)
-
-        updated_list = input_data.list.copy()
-        if (pos := input_data.position) is not None:
-            updated_list = updated_list[:pos] + entries_added + updated_list[pos:]
+        # If no list is provided, create a new one
+        if input_data.list is None:
+            updated_list = []
         else:
-            updated_list += entries_added
+            # 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
 
@@ -492,101 +463,3 @@ class NoteBlock(Block):
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
         yield "output", input_data.text
-
-
-class CreateDictionaryBlock(Block):
-    class Input(BlockSchema):
-        values: dict[str, Any] = SchemaField(
-            description="Key-value pairs to create the dictionary with",
-            placeholder="e.g., {'name': 'Alice', 'age': 25}",
-        )
-
-    class Output(BlockSchema):
-        dictionary: dict[str, Any] = SchemaField(
-            description="The created dictionary containing the specified key-value pairs"
-        )
-        error: str = SchemaField(
-            description="Error message if dictionary creation failed"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="b924ddf4-de4f-4b56-9a85-358930dcbc91",
-            description="Creates a dictionary with the specified key-value pairs. Use this when you know all the values you want to add upfront.",
-            categories={BlockCategory.DATA},
-            input_schema=CreateDictionaryBlock.Input,
-            output_schema=CreateDictionaryBlock.Output,
-            test_input=[
-                {
-                    "values": {"name": "Alice", "age": 25, "city": "New York"},
-                },
-                {
-                    "values": {"numbers": [1, 2, 3], "active": True, "score": 95.5},
-                },
-            ],
-            test_output=[
-                (
-                    "dictionary",
-                    {"name": "Alice", "age": 25, "city": "New York"},
-                ),
-                (
-                    "dictionary",
-                    {"numbers": [1, 2, 3], "active": True, "score": 95.5},
-                ),
-            ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        try:
-            # The values are already validated by Pydantic schema
-            yield "dictionary", input_data.values
-        except Exception as e:
-            yield "error", f"Failed to create dictionary: {str(e)}"
-
-
-class CreateListBlock(Block):
-    class Input(BlockSchema):
-        values: List[Any] = SchemaField(
-            description="A list of values to be combined into a new list.",
-            placeholder="e.g., ['Alice', 25, True]",
-        )
-
-    class Output(BlockSchema):
-        list: List[Any] = SchemaField(
-            description="The created list containing the specified values."
-        )
-        error: str = SchemaField(description="Error message if list creation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="a912d5c7-6e00-4542-b2a9-8034136930e4",
-            description="Creates a list with the specified values. Use this when you know all the values you want to add upfront.",
-            categories={BlockCategory.DATA},
-            input_schema=CreateListBlock.Input,
-            output_schema=CreateListBlock.Output,
-            test_input=[
-                {
-                    "values": ["Alice", 25, True],
-                },
-                {
-                    "values": [1, 2, 3, "four", {"key": "value"}],
-                },
-            ],
-            test_output=[
-                (
-                    "list",
-                    ["Alice", 25, True],
-                ),
-                (
-                    "list",
-                    [1, 2, 3, "four", {"key": "value"}],
-                ),
-            ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        try:
-            # The values are already validated by Pydantic schema
-            yield "list", input_data.values
-        except Exception as e:
-            yield "error", f"Failed to create list: {str(e)}"

autogpt_platform/backend/backend/blocks/branching.py

@@ -75,17 +75,11 @@ class ConditionBlock(Block):
 
         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

autogpt_platform/backend/backend/blocks/code_executor.py

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

autogpt_platform/backend/backend/blocks/code_extraction_block.py

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

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

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

autogpt_platform/backend/backend/blocks/count_words_and_char_block.py

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

autogpt_platform/backend/backend/blocks/discord.py

@@ -3,24 +3,21 @@ 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(

autogpt_platform/backend/backend/blocks/exa/_auth.py

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -35,9 +35,9 @@ def _get_headers(credentials: GithubCredentials) -> dict[str, str]:
     }
 
 
-def get_api(credentials: GithubCredentials, convert_urls: bool = True) -> Requests:
+def get_api(credentials: GithubCredentials) -> Requests:
     return Requests(
         trusted_origins=["https://api.github.com", "https://github.com"],
-        extra_url_validator=_convert_to_api_url if convert_urls else None,
+        extra_url_validator=_convert_to_api_url,
         extra_headers=_get_headers(credentials),
     )

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

@@ -1,14 +1,12 @@
 from typing import Literal
 
-from pydantic import SecretStr
-
-from backend.data.model import (
+from autogpt_libs.supabase_integration_credentials_store.types import (
     APIKeyCredentials,
-    CredentialsField,
-    CredentialsMetaInput,
     OAuth2Credentials,
 )
-from backend.integrations.providers import ProviderName
+from pydantic import SecretStr
+
+from backend.data.model import CredentialsField, CredentialsMetaInput
 from backend.util.settings import Secrets
 
 secrets = Secrets()
@@ -18,7 +16,7 @@ GITHUB_OAUTH_IS_CONFIGURED = bool(
 
 GithubCredentials = APIKeyCredentials | OAuth2Credentials
 GithubCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.GITHUB],
+    Literal["github"],
     Literal["api_key", "oauth2"] if GITHUB_OAUTH_IS_CONFIGURED else Literal["api_key"],
 ]
 
@@ -31,6 +29,10 @@ def GithubCredentialsField(scope: str) -> GithubCredentialsInput:
         scope: The authorization scope needed for the block to work. ([list of available scopes](https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/scopes-for-oauth-apps#available-scopes))
     """  # noqa
     return CredentialsField(
+        provider="github",
+        supported_credential_types=(
+            {"api_key", "oauth2"} if GITHUB_OAUTH_IS_CONFIGURED else {"api_key"}
+        ),
         required_scopes={scope},
         description="The GitHub integration can be used with OAuth, "
         "or any API key with sufficient permissions for the blocks it is used on.",

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

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

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

@@ -46,27 +46,15 @@ class GithubCommentBlock(Block):
             categories={BlockCategory.DEVELOPER_TOOLS},
             input_schema=GithubCommentBlock.Input,
             output_schema=GithubCommentBlock.Output,
-            test_input=[
-                {
-                    "issue_url": "https://github.com/owner/repo/issues/1",
-                    "comment": "This is a test comment.",
-                    "credentials": TEST_CREDENTIALS_INPUT,
-                },
-                {
-                    "issue_url": "https://github.com/owner/repo/pull/1",
-                    "comment": "This is a test comment.",
-                    "credentials": TEST_CREDENTIALS_INPUT,
-                },
-            ],
+            test_input={
+                "issue_url": "https://github.com/owner/repo/issues/1",
+                "comment": "This is a test comment.",
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
             test_credentials=TEST_CREDENTIALS,
             test_output=[
                 ("id", 1337),
                 ("url", "https://github.com/owner/repo/issues/1#issuecomment-1337"),
-                ("id", 1337),
-                (
-                    "url",
-                    "https://github.com/owner/repo/issues/1#issuecomment-1337",
-                ),
             ],
             test_mock={
                 "post_comment": lambda *args, **kwargs: (
@@ -82,8 +70,6 @@ class GithubCommentBlock(Block):
     ) -> tuple[int, str]:
         api = get_api(credentials)
         data = {"body": body_text}
-        if "pull" in issue_url:
-            issue_url = issue_url.replace("pull", "issues")
         comments_url = issue_url + "/comments"
         response = api.post(comments_url, json=data)
         comment = response.json()
@@ -248,12 +234,9 @@ class GithubReadIssueBlock(Block):
             credentials,
             input_data.issue_url,
         )
-        if title:
-            yield "title", title
-        if body:
-            yield "body", body
-        if user:
-            yield "user", user
+        yield "title", title
+        yield "body", body
+        yield "user", user
 
 
 class GithubListIssuesBlock(Block):

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

@@ -1,5 +1,3 @@
-import re
-
 from typing_extensions import TypedDict
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
@@ -255,7 +253,7 @@ class GithubReadPullRequestBlock(Block):
     @staticmethod
     def read_pr_changes(credentials: GithubCredentials, pr_url: str) -> str:
         api = get_api(credentials)
-        files_url = prepare_pr_api_url(pr_url=pr_url, path="files")
+        files_url = pr_url + "/files"
         response = api.get(files_url)
         files = response.json()
         changes = []
@@ -333,7 +331,7 @@ class GithubAssignPRReviewerBlock(Block):
         credentials: GithubCredentials, pr_url: str, reviewer: str
     ) -> str:
         api = get_api(credentials)
-        reviewers_url = prepare_pr_api_url(pr_url=pr_url, path="requested_reviewers")
+        reviewers_url = pr_url + "/requested_reviewers"
         data = {"reviewers": [reviewer]}
         api.post(reviewers_url, json=data)
         return "Reviewer assigned successfully"
@@ -400,7 +398,7 @@ class GithubUnassignPRReviewerBlock(Block):
         credentials: GithubCredentials, pr_url: str, reviewer: str
     ) -> str:
         api = get_api(credentials)
-        reviewers_url = prepare_pr_api_url(pr_url=pr_url, path="requested_reviewers")
+        reviewers_url = pr_url + "/requested_reviewers"
         data = {"reviewers": [reviewer]}
         api.delete(reviewers_url, json=data)
         return "Reviewer unassigned successfully"
@@ -480,7 +478,7 @@ class GithubListPRReviewersBlock(Block):
         credentials: GithubCredentials, pr_url: str
     ) -> list[Output.ReviewerItem]:
         api = get_api(credentials)
-        reviewers_url = prepare_pr_api_url(pr_url=pr_url, path="requested_reviewers")
+        reviewers_url = pr_url + "/requested_reviewers"
         response = api.get(reviewers_url)
         data = response.json()
         reviewers: list[GithubListPRReviewersBlock.Output.ReviewerItem] = [
@@ -501,14 +499,3 @@ class GithubListPRReviewersBlock(Block):
             input_data.pr_url,
         )
         yield from (("reviewer", reviewer) for reviewer in reviewers)
-
-
-def prepare_pr_api_url(pr_url: str, path: str) -> str:
-    # Pattern to capture the base repository URL and the pull request number
-    pattern = r"^(?:https?://)?([^/]+/[^/]+/[^/]+)/pull/(\d+)"
-    match = re.match(pattern, pr_url)
-    if not match:
-        return pr_url
-
-    base_url, pr_number = match.groups()
-    return f"{base_url}/pulls/{pr_number}/{path}"

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

@@ -699,420 +699,3 @@ class GithubDeleteBranchBlock(Block):
             input_data.branch,
         )
         yield "status", status
-
-
-class GithubCreateFileBlock(Block):
-    class Input(BlockSchema):
-        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
-        repo_url: str = SchemaField(
-            description="URL of the GitHub repository",
-            placeholder="https://github.com/owner/repo",
-        )
-        file_path: str = SchemaField(
-            description="Path where the file should be created",
-            placeholder="path/to/file.txt",
-        )
-        content: str = SchemaField(
-            description="Content to write to the file",
-            placeholder="File content here",
-        )
-        branch: str = SchemaField(
-            description="Branch where the file should be created",
-            default="main",
-        )
-        commit_message: str = SchemaField(
-            description="Message for the commit",
-            default="Create new file",
-        )
-
-    class Output(BlockSchema):
-        url: str = SchemaField(description="URL of the created file")
-        sha: str = SchemaField(description="SHA of the commit")
-        error: str = SchemaField(
-            description="Error message if the file creation failed"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="8fd132ac-b917-428a-8159-d62893e8a3fe",
-            description="This block creates a new file in a GitHub repository.",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=GithubCreateFileBlock.Input,
-            output_schema=GithubCreateFileBlock.Output,
-            test_input={
-                "repo_url": "https://github.com/owner/repo",
-                "file_path": "test/file.txt",
-                "content": "Test content",
-                "branch": "main",
-                "commit_message": "Create test file",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                ("url", "https://github.com/owner/repo/blob/main/test/file.txt"),
-                ("sha", "abc123"),
-            ],
-            test_mock={
-                "create_file": lambda *args, **kwargs: (
-                    "https://github.com/owner/repo/blob/main/test/file.txt",
-                    "abc123",
-                )
-            },
-        )
-
-    @staticmethod
-    def create_file(
-        credentials: GithubCredentials,
-        repo_url: str,
-        file_path: str,
-        content: str,
-        branch: str,
-        commit_message: str,
-    ) -> tuple[str, str]:
-        api = get_api(credentials)
-        # Convert content to base64
-        content_bytes = content.encode("utf-8")
-        content_base64 = base64.b64encode(content_bytes).decode("utf-8")
-
-        # Create the file using the GitHub API
-        contents_url = f"{repo_url}/contents/{file_path}"
-        data = {
-            "message": commit_message,
-            "content": content_base64,
-            "branch": branch,
-        }
-        response = api.put(contents_url, json=data)
-        result = response.json()
-
-        return result["content"]["html_url"], result["commit"]["sha"]
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: GithubCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            url, sha = self.create_file(
-                credentials,
-                input_data.repo_url,
-                input_data.file_path,
-                input_data.content,
-                input_data.branch,
-                input_data.commit_message,
-            )
-            yield "url", url
-            yield "sha", sha
-        except Exception as e:
-            yield "error", str(e)
-
-
-class GithubUpdateFileBlock(Block):
-    class Input(BlockSchema):
-        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
-        repo_url: str = SchemaField(
-            description="URL of the GitHub repository",
-            placeholder="https://github.com/owner/repo",
-        )
-        file_path: str = SchemaField(
-            description="Path to the file to update",
-            placeholder="path/to/file.txt",
-        )
-        content: str = SchemaField(
-            description="New content for the file",
-            placeholder="Updated content here",
-        )
-        branch: str = SchemaField(
-            description="Branch containing the file",
-            default="main",
-        )
-        commit_message: str = SchemaField(
-            description="Message for the commit",
-            default="Update file",
-        )
-
-    class Output(BlockSchema):
-        url: str = SchemaField(description="URL of the updated file")
-        sha: str = SchemaField(description="SHA of the commit")
-        error: str = SchemaField(description="Error message if the file update failed")
-
-    def __init__(self):
-        super().__init__(
-            id="30be12a4-57cb-4aa4-baf5-fcc68d136076",
-            description="This block updates an existing file in a GitHub repository.",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=GithubUpdateFileBlock.Input,
-            output_schema=GithubUpdateFileBlock.Output,
-            test_input={
-                "repo_url": "https://github.com/owner/repo",
-                "file_path": "test/file.txt",
-                "content": "Updated content",
-                "branch": "main",
-                "commit_message": "Update test file",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                ("url", "https://github.com/owner/repo/blob/main/test/file.txt"),
-                ("sha", "def456"),
-            ],
-            test_mock={
-                "update_file": lambda *args, **kwargs: (
-                    "https://github.com/owner/repo/blob/main/test/file.txt",
-                    "def456",
-                )
-            },
-        )
-
-    @staticmethod
-    def update_file(
-        credentials: GithubCredentials,
-        repo_url: str,
-        file_path: str,
-        content: str,
-        branch: str,
-        commit_message: str,
-    ) -> tuple[str, str]:
-        api = get_api(credentials)
-
-        # First get the current file to get its SHA
-        contents_url = f"{repo_url}/contents/{file_path}"
-        params = {"ref": branch}
-        response = api.get(contents_url, params=params)
-        current_file = response.json()
-
-        # Convert new content to base64
-        content_bytes = content.encode("utf-8")
-        content_base64 = base64.b64encode(content_bytes).decode("utf-8")
-
-        # Update the file
-        data = {
-            "message": commit_message,
-            "content": content_base64,
-            "sha": current_file["sha"],
-            "branch": branch,
-        }
-        response = api.put(contents_url, json=data)
-        result = response.json()
-
-        return result["content"]["html_url"], result["commit"]["sha"]
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: GithubCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            url, sha = self.update_file(
-                credentials,
-                input_data.repo_url,
-                input_data.file_path,
-                input_data.content,
-                input_data.branch,
-                input_data.commit_message,
-            )
-            yield "url", url
-            yield "sha", sha
-        except Exception as e:
-            yield "error", str(e)
-
-
-class GithubCreateRepositoryBlock(Block):
-    class Input(BlockSchema):
-        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
-        name: str = SchemaField(
-            description="Name of the repository to create",
-            placeholder="my-new-repo",
-        )
-        description: str = SchemaField(
-            description="Description of the repository",
-            placeholder="A description of the repository",
-            default="",
-        )
-        private: bool = SchemaField(
-            description="Whether the repository should be private",
-            default=False,
-        )
-        auto_init: bool = SchemaField(
-            description="Whether to initialize the repository with a README",
-            default=True,
-        )
-        gitignore_template: str = SchemaField(
-            description="Git ignore template to use (e.g., Python, Node, Java)",
-            default="",
-        )
-
-    class Output(BlockSchema):
-        url: str = SchemaField(description="URL of the created repository")
-        clone_url: str = SchemaField(description="Git clone URL of the repository")
-        error: str = SchemaField(
-            description="Error message if the repository creation failed"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="029ec3b8-1cfd-46d3-b6aa-28e4a706efd1",
-            description="This block creates a new GitHub repository.",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=GithubCreateRepositoryBlock.Input,
-            output_schema=GithubCreateRepositoryBlock.Output,
-            test_input={
-                "name": "test-repo",
-                "description": "A test repository",
-                "private": False,
-                "auto_init": True,
-                "gitignore_template": "Python",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                ("url", "https://github.com/owner/test-repo"),
-                ("clone_url", "https://github.com/owner/test-repo.git"),
-            ],
-            test_mock={
-                "create_repository": lambda *args, **kwargs: (
-                    "https://github.com/owner/test-repo",
-                    "https://github.com/owner/test-repo.git",
-                )
-            },
-        )
-
-    @staticmethod
-    def create_repository(
-        credentials: GithubCredentials,
-        name: str,
-        description: str,
-        private: bool,
-        auto_init: bool,
-        gitignore_template: str,
-    ) -> tuple[str, str]:
-        api = get_api(credentials, convert_urls=False)  # Disable URL conversion
-        data = {
-            "name": name,
-            "description": description,
-            "private": private,
-            "auto_init": auto_init,
-        }
-
-        if gitignore_template:
-            data["gitignore_template"] = gitignore_template
-
-        # Create repository using the user endpoint
-        response = api.post("https://api.github.com/user/repos", json=data)
-        result = response.json()
-
-        return result["html_url"], result["clone_url"]
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: GithubCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            url, clone_url = self.create_repository(
-                credentials,
-                input_data.name,
-                input_data.description,
-                input_data.private,
-                input_data.auto_init,
-                input_data.gitignore_template,
-            )
-            yield "url", url
-            yield "clone_url", clone_url
-        except Exception as e:
-            yield "error", str(e)
-
-
-class GithubListStargazersBlock(Block):
-    class Input(BlockSchema):
-        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
-        repo_url: str = SchemaField(
-            description="URL of the GitHub repository",
-            placeholder="https://github.com/owner/repo",
-        )
-
-    class Output(BlockSchema):
-        class StargazerItem(TypedDict):
-            username: str
-            url: str
-
-        stargazer: StargazerItem = SchemaField(
-            title="Stargazer",
-            description="Stargazers with their username and profile URL",
-        )
-        error: str = SchemaField(
-            description="Error message if listing stargazers failed"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="a4b9c2d1-e5f6-4g7h-8i9j-0k1l2m3n4o5p",  # Generated unique UUID
-            description="This block lists all users who have starred a specified GitHub repository.",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=GithubListStargazersBlock.Input,
-            output_schema=GithubListStargazersBlock.Output,
-            test_input={
-                "repo_url": "https://github.com/owner/repo",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "stargazer",
-                    {
-                        "username": "octocat",
-                        "url": "https://github.com/octocat",
-                    },
-                )
-            ],
-            test_mock={
-                "list_stargazers": lambda *args, **kwargs: [
-                    {
-                        "username": "octocat",
-                        "url": "https://github.com/octocat",
-                    }
-                ]
-            },
-        )
-
-    @staticmethod
-    def list_stargazers(
-        credentials: GithubCredentials, repo_url: str
-    ) -> list[Output.StargazerItem]:
-        api = get_api(credentials)
-        # Add /stargazers to the repo URL to get stargazers endpoint
-        stargazers_url = f"{repo_url}/stargazers"
-        # Set accept header to get starred_at timestamp
-        headers = {"Accept": "application/vnd.github.star+json"}
-        response = api.get(stargazers_url, headers=headers)
-        data = response.json()
-
-        stargazers: list[GithubListStargazersBlock.Output.StargazerItem] = [
-            {
-                "username": stargazer["login"],
-                "url": stargazer["html_url"],
-            }
-            for stargazer in data
-        ]
-        return stargazers
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: GithubCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            stargazers = self.list_stargazers(
-                credentials,
-                input_data.repo_url,
-            )
-            yield from (("stargazer", stargazer) for stargazer in stargazers)
-        except Exception as e:
-            yield "error", str(e)

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

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

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

@@ -1,9 +1,9 @@
 from typing import Literal
 
+from autogpt_libs.supabase_integration_credentials_store.types import OAuth2Credentials
 from pydantic import SecretStr
 
-from backend.data.model import CredentialsField, CredentialsMetaInput, OAuth2Credentials
-from backend.integrations.providers import ProviderName
+from backend.data.model import CredentialsField, CredentialsMetaInput
 from backend.util.settings import Secrets
 
 # --8<-- [start:GoogleOAuthIsConfigured]
@@ -13,9 +13,7 @@ GOOGLE_OAUTH_IS_CONFIGURED = bool(
 )
 # --8<-- [end:GoogleOAuthIsConfigured]
 GoogleCredentials = OAuth2Credentials
-GoogleCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.GOOGLE], Literal["oauth2"]
-]
+GoogleCredentialsInput = CredentialsMetaInput[Literal["google"], Literal["oauth2"]]
 
 
 def GoogleCredentialsField(scopes: list[str]) -> GoogleCredentialsInput:
@@ -26,6 +24,8 @@ def GoogleCredentialsField(scopes: list[str]) -> GoogleCredentialsInput:
         scopes: The authorization scopes needed for the block to work.
     """
     return CredentialsField(
+        provider="google",
+        supported_credential_types={"oauth2"},
         required_scopes=set(scopes),
         description="The Google integration requires OAuth2 authentication.",
     )

autogpt_platform/backend/backend/blocks/google_maps.py

@@ -1,16 +1,11 @@
 from typing import Literal
 
 import googlemaps
+from autogpt_libs.supabase_integration_credentials_store.types import APIKeyCredentials
 from pydantic import BaseModel, SecretStr
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import (
-    APIKeyCredentials,
-    CredentialsField,
-    CredentialsMetaInput,
-    SchemaField,
-)
-from backend.integrations.providers import ProviderName
+from backend.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 
 TEST_CREDENTIALS = APIKeyCredentials(
     id="01234567-89ab-cdef-0123-456789abcdef",
@@ -39,8 +34,12 @@ class Place(BaseModel):
 class GoogleMapsSearchBlock(Block):
     class Input(BlockSchema):
         credentials: CredentialsMetaInput[
-            Literal[ProviderName.GOOGLE_MAPS], Literal["api_key"]
-        ] = CredentialsField(description="Google Maps API Key")
+            Literal["google_maps"], Literal["api_key"]
+        ] = CredentialsField(
+            provider="google_maps",
+            supported_credential_types={"api_key"},
+            description="Google Maps API Key",
+        )
         query: str = SchemaField(
             description="Search query for local businesses",
             placeholder="e.g., 'restaurants in New York'",

autogpt_platform/backend/backend/blocks/http.py

@@ -56,24 +56,15 @@ class SendWebRequestBlock(Block):
         )
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        body = input_data.body
-
-        if input_data.json_format:
-            if isinstance(body, str):
-                try:
-                    # Try to parse as JSON first
-                    body = json.loads(body)
-                except json.JSONDecodeError:
-                    # If it's not valid JSON and just plain text,
-                    # we should send it as plain text instead
-                    input_data.json_format = False
+        if isinstance(input_data.body, str):
+            input_data.body = json.loads(input_data.body)
 
         response = requests.request(
             input_data.method.value,
             input_data.url,
             headers=input_data.headers,
-            json=body if input_data.json_format else None,
-            data=body if not input_data.json_format else None,
+            json=input_data.body if input_data.json_format else None,
+            data=input_data.body if not input_data.json_format else None,
         )
         result = response.json() if input_data.json_format else response.text
 

autogpt_platform/backend/backend/blocks/hubspot/_auth.py

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

autogpt_platform/backend/backend/blocks/hubspot/company.py

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

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

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

autogpt_platform/backend/backend/blocks/hubspot/engagement.py

@@ -1,121 +0,0 @@
-from datetime import datetime, timedelta
-
-from backend.blocks.hubspot._auth import (
-    HubSpotCredentials,
-    HubSpotCredentialsField,
-    HubSpotCredentialsInput,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-from backend.util.request import requests
-
-
-class HubSpotEngagementBlock(Block):
-    class Input(BlockSchema):
-        credentials: HubSpotCredentialsInput = HubSpotCredentialsField()
-        operation: str = SchemaField(
-            description="Operation to perform (send_email, track_engagement)",
-            default="send_email",
-        )
-        email_data: dict = SchemaField(
-            description="Email data including recipient, subject, content",
-            default={},
-        )
-        contact_id: str = SchemaField(
-            description="Contact ID for engagement tracking", default=""
-        )
-        timeframe_days: int = SchemaField(
-            description="Number of days to look back for engagement",
-            default=30,
-            optional=True,
-        )
-
-    class Output(BlockSchema):
-        result: dict = SchemaField(description="Operation result")
-        status: str = SchemaField(description="Operation status")
-
-    def __init__(self):
-        super().__init__(
-            id="c6524385-7d87-49d6-a470-248bd29ca765",
-            description="Manages HubSpot engagements - sends emails and tracks engagement metrics",
-            categories={BlockCategory.CRM, BlockCategory.COMMUNICATION},
-            input_schema=HubSpotEngagementBlock.Input,
-            output_schema=HubSpotEngagementBlock.Output,
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: HubSpotCredentials, **kwargs
-    ) -> BlockOutput:
-        base_url = "https://api.hubapi.com"
-        headers = {
-            "Authorization": f"Bearer {credentials.api_key.get_secret_value()}",
-            "Content-Type": "application/json",
-        }
-
-        if input_data.operation == "send_email":
-            # Using the email send API
-            email_url = f"{base_url}/crm/v3/objects/emails"
-            email_data = {
-                "properties": {
-                    "hs_timestamp": datetime.now().isoformat(),
-                    "hubspot_owner_id": "1",  # This should be configurable
-                    "hs_email_direction": "OUTBOUND",
-                    "hs_email_status": "SEND",
-                    "hs_email_subject": input_data.email_data.get("subject"),
-                    "hs_email_text": input_data.email_data.get("content"),
-                    "hs_email_to_email": input_data.email_data.get("recipient"),
-                }
-            }
-
-            response = requests.post(email_url, headers=headers, json=email_data)
-            result = response.json()
-            yield "result", result
-            yield "status", "email_sent"
-
-        elif input_data.operation == "track_engagement":
-            # Get engagement events for the contact
-            from_date = datetime.now() - timedelta(days=input_data.timeframe_days)
-            engagement_url = (
-                f"{base_url}/crm/v3/objects/contacts/{input_data.contact_id}/engagement"
-            )
-
-            params = {"limit": 100, "after": from_date.isoformat()}
-
-            response = requests.get(engagement_url, headers=headers, params=params)
-            engagements = response.json()
-
-            # Process engagement metrics
-            metrics = {
-                "email_opens": 0,
-                "email_clicks": 0,
-                "email_replies": 0,
-                "last_engagement": None,
-                "engagement_score": 0,
-            }
-
-            for engagement in engagements.get("results", []):
-                eng_type = engagement.get("properties", {}).get("hs_engagement_type")
-                if eng_type == "EMAIL":
-                    metrics["email_opens"] += 1
-                elif eng_type == "EMAIL_CLICK":
-                    metrics["email_clicks"] += 1
-                elif eng_type == "EMAIL_REPLY":
-                    metrics["email_replies"] += 1
-
-                # Update last engagement time
-                eng_time = engagement.get("properties", {}).get("hs_timestamp")
-                if eng_time and (
-                    not metrics["last_engagement"]
-                    or eng_time > metrics["last_engagement"]
-                ):
-                    metrics["last_engagement"] = eng_time
-
-            # Calculate simple engagement score
-            metrics["engagement_score"] = (
-                metrics["email_opens"]
-                + metrics["email_clicks"] * 2
-                + metrics["email_replies"] * 3
-            )
-
-            yield "result", metrics
-            yield "status", "engagement_tracked"

autogpt_platform/backend/backend/blocks/ideogram.py

@@ -1,17 +1,12 @@
 from enum import Enum
 from typing import Any, Dict, Literal, Optional
 
+from autogpt_libs.supabase_integration_credentials_store.types import APIKeyCredentials
 from pydantic import SecretStr
 from requests.exceptions import RequestException
 
 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
 from backend.util.request import requests
 
 TEST_CREDENTIALS = APIKeyCredentials(
@@ -84,10 +79,13 @@ class UpscaleOption(str, Enum):
 
 class IdeogramModelBlock(Block):
     class Input(BlockSchema):
-        credentials: CredentialsMetaInput[
-            Literal[ProviderName.IDEOGRAM], Literal["api_key"]
-        ] = CredentialsField(
-            description="The Ideogram integration can be used with any API key with sufficient permissions for the blocks it is used on.",
+
+        credentials: CredentialsMetaInput[Literal["ideogram"], Literal["api_key"]] = (
+            CredentialsField(
+                provider="ideogram",
+                supported_credential_types={"api_key"},
+                description="The Ideogram integration can be used with any API key with sufficient permissions for the blocks it is used on.",
+            )
         )
         prompt: str = SchemaField(
             description="Text prompt for image generation",

autogpt_platform/backend/backend/blocks/iteration.py

@@ -2,28 +2,13 @@ from typing import Any
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
-from backend.util.json import json
 
 
 class StepThroughItemsBlock(Block):
     class Input(BlockSchema):
-        items: list = SchemaField(
-            advanced=False,
+        items: list | dict = SchemaField(
             description="The list or dictionary of items to iterate over",
             placeholder="[1, 2, 3, 4, 5] or {'key1': 'value1', 'key2': 'value2'}",
-            default=[],
-        )
-        items_object: dict = SchemaField(
-            advanced=False,
-            description="The list or dictionary of items to iterate over",
-            placeholder="[1, 2, 3, 4, 5] or {'key1': 'value1', 'key2': 'value2'}",
-            default={},
-        )
-        items_str: str = SchemaField(
-            advanced=False,
-            description="The list or dictionary of items to iterate over",
-            placeholder="[1, 2, 3, 4, 5] or {'key1': 'value1', 'key2': 'value2'}",
-            default="",
         )
 
     class Output(BlockSchema):
@@ -54,20 +39,14 @@ class StepThroughItemsBlock(Block):
         )
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        for data in [input_data.items, input_data.items_object, input_data.items_str]:
-            if not data:
-                continue
-            if isinstance(data, str):
-                items = json.loads(data)
-            else:
-                items = data
-            if isinstance(items, dict):
-                # If items is a dictionary, iterate over its values
-                for item in items.values():
-                    yield "item", item
-                    yield "key", item
-            else:
-                # If items is a list, iterate over the list
-                for index, item in enumerate(items):
-                    yield "item", item
-                    yield "key", index
+        items = input_data.items
+        if isinstance(items, dict):
+            # If items is a dictionary, iterate over its values
+            for item in items.values():
+                yield "item", item
+                yield "key", item
+        else:
+            # If items is a list, iterate over the list
+            for index, item in enumerate(items):
+                yield "item", item
+                yield "key", index

autogpt_platform/backend/backend/blocks/jina/_auth.py

@@ -1,16 +1,30 @@
 from typing import Literal
 
+from autogpt_libs.supabase_integration_credentials_store.types import APIKeyCredentials
 from pydantic import SecretStr
 
-from backend.data.model import APIKeyCredentials, CredentialsField, CredentialsMetaInput
-from backend.integrations.providers import ProviderName
+from backend.data.model import CredentialsField, CredentialsMetaInput
 
 JinaCredentials = APIKeyCredentials
 JinaCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.JINA],
+    Literal["jina"],
     Literal["api_key"],
 ]
 
+TEST_CREDENTIALS = APIKeyCredentials(
+    id="01234567-89ab-cdef-0123-456789abcdef",
+    provider="jina",
+    api_key=SecretStr("mock-jina-api-key"),
+    title="Mock Jina API key",
+    expires_at=None,
+)
+TEST_CREDENTIALS_INPUT = {
+    "provider": TEST_CREDENTIALS.provider,
+    "id": TEST_CREDENTIALS.id,
+    "type": TEST_CREDENTIALS.type,
+    "title": TEST_CREDENTIALS.type,
+}
+
 
 def JinaCredentialsField() -> JinaCredentialsInput:
     """
@@ -18,6 +32,8 @@ def JinaCredentialsField() -> JinaCredentialsInput:
 
     """
     return CredentialsField(
+        provider="jina",
+        supported_credential_types={"api_key"},
         description="The Jina integration can be used with an API Key.",
     )
 

autogpt_platform/backend/backend/blocks/jina/fact_checker.py

@@ -1,59 +0,0 @@
-from urllib.parse import quote
-
-import requests
-
-from backend.blocks.jina._auth import (
-    JinaCredentials,
-    JinaCredentialsField,
-    JinaCredentialsInput,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-
-class FactCheckerBlock(Block):
-    class Input(BlockSchema):
-        statement: str = SchemaField(
-            description="The statement to check for factuality"
-        )
-        credentials: JinaCredentialsInput = JinaCredentialsField()
-
-    class Output(BlockSchema):
-        factuality: float = SchemaField(
-            description="The factuality score of the statement"
-        )
-        result: bool = SchemaField(description="The result of the factuality check")
-        reason: str = SchemaField(description="The reason for the factuality result")
-        error: str = SchemaField(description="Error message if the check fails")
-
-    def __init__(self):
-        super().__init__(
-            id="d38b6c5e-9968-4271-8423-6cfe60d6e7e6",
-            description="This block checks the factuality of a given statement using Jina AI's Grounding API.",
-            categories={BlockCategory.SEARCH},
-            input_schema=FactCheckerBlock.Input,
-            output_schema=FactCheckerBlock.Output,
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: JinaCredentials, **kwargs
-    ) -> BlockOutput:
-        encoded_statement = quote(input_data.statement)
-        url = f"https://g.jina.ai/{encoded_statement}"
-
-        headers = {
-            "Accept": "application/json",
-            "Authorization": f"Bearer {credentials.api_key.get_secret_value()}",
-        }
-
-        response = requests.get(url, headers=headers)
-        response.raise_for_status()
-        data = response.json()
-
-        if "data" in data:
-            data = data["data"]
-            yield "factuality", data["factuality"]
-            yield "result", data["result"]
-            yield "reason", data["reason"]
-        else:
-            raise RuntimeError(f"Expected 'data' key not found in response: {data}")

autogpt_platform/backend/backend/blocks/jina/search.py

@@ -55,53 +55,3 @@ class SearchTheWebBlock(Block, GetRequest):
 
         # Output the search results
         yield "results", results
-
-
-class ExtractWebsiteContentBlock(Block, GetRequest):
-    class Input(BlockSchema):
-        credentials: JinaCredentialsInput = JinaCredentialsField()
-        url: str = SchemaField(description="The URL to scrape the content from")
-        raw_content: bool = SchemaField(
-            default=False,
-            title="Raw Content",
-            description="Whether to do a raw scrape of the content or use Jina-ai Reader to scrape the content",
-            advanced=True,
-        )
-
-    class Output(BlockSchema):
-        content: str = SchemaField(description="The scraped content from the given URL")
-        error: str = SchemaField(
-            description="Error message if the content cannot be retrieved"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="436c3984-57fd-4b85-8e9a-459b356883bd",
-            description="This block scrapes the content from the given web URL.",
-            categories={BlockCategory.SEARCH},
-            input_schema=ExtractWebsiteContentBlock.Input,
-            output_schema=ExtractWebsiteContentBlock.Output,
-            test_input={
-                "url": "https://en.wikipedia.org/wiki/Artificial_intelligence",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=("content", "scraped content"),
-            test_mock={"get_request": lambda *args, **kwargs: "scraped content"},
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: JinaCredentials, **kwargs
-    ) -> BlockOutput:
-        if input_data.raw_content:
-            url = input_data.url
-            headers = {}
-        else:
-            url = f"https://r.jina.ai/{input_data.url}"
-            headers = {
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {credentials.api_key.get_secret_value()}",
-            }
-
-        content = self.get_request(url, json=False, headers=headers)
-        yield "content", content

autogpt_platform/backend/backend/blocks/llm.py

@@ -5,10 +5,9 @@ from json import JSONDecodeError
 from types import MappingProxyType
 from typing import TYPE_CHECKING, Any, List, Literal, NamedTuple
 
+from autogpt_libs.supabase_integration_credentials_store.types import APIKeyCredentials
 from pydantic import SecretStr
 
-from backend.integrations.providers import ProviderName
-
 if TYPE_CHECKING:
     from enum import _EnumMemberT
 
@@ -18,31 +17,24 @@ import openai
 from groq import Groq
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import (
-    APIKeyCredentials,
-    CredentialsField,
-    CredentialsMetaInput,
-    SchemaField,
-)
+from backend.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 from backend.util import json
 from backend.util.settings import BehaveAs, Settings
-from backend.util.text import TextFormatter
 
 logger = logging.getLogger(__name__)
-fmt = TextFormatter()
 
-LLMProviderName = Literal[
-    ProviderName.ANTHROPIC,
-    ProviderName.GROQ,
-    ProviderName.OLLAMA,
-    ProviderName.OPENAI,
-    ProviderName.OPEN_ROUTER,
-]
-AICredentials = CredentialsMetaInput[LLMProviderName, Literal["api_key"]]
+# LlmApiKeys = {
+#     "openai": BlockSecret("openai_api_key"),
+#     "anthropic": BlockSecret("anthropic_api_key"),
+#     "groq": BlockSecret("groq_api_key"),
+#     "ollama": BlockSecret(value=""),
+# }
+
+AICredentials = CredentialsMetaInput[Literal["llm"], Literal["api_key"]]
 
 TEST_CREDENTIALS = APIKeyCredentials(
     id="ed55ac19-356e-4243-a6cb-bc599e9b716f",
-    provider="openai",
+    provider="llm",
     api_key=SecretStr("mock-openai-api-key"),
     title="Mock OpenAI API key",
     expires_at=None,
@@ -58,16 +50,15 @@ TEST_CREDENTIALS_INPUT = {
 def AICredentialsField() -> AICredentials:
     return CredentialsField(
         description="API key for the LLM provider.",
-        discriminator="model",
-        discriminator_mapping={
-            model.value: model.metadata.provider for model in LlmModel
-        },
+        provider="llm",
+        supported_credential_types={"api_key"},
     )
 
 
 class ModelMetadata(NamedTuple):
     provider: str
     context_window: int
+    cost_factor: int
 
 
 class LlmModelMeta(EnumMeta):
@@ -111,29 +102,8 @@ class LlmModel(str, Enum, metaclass=LlmModelMeta):
     LLAMA3_1_70B = "llama-3.1-70b-versatile"
     LLAMA3_1_8B = "llama-3.1-8b-instant"
     # Ollama models
-    OLLAMA_LLAMA3_2 = "llama3.2"
     OLLAMA_LLAMA3_8B = "llama3"
     OLLAMA_LLAMA3_405B = "llama3.1:405b"
-    OLLAMA_DOLPHIN = "dolphin-mistral:latest"
-    # OpenRouter models
-    GEMINI_FLASH_1_5_8B = "google/gemini-flash-1.5"
-    GROK_BETA = "x-ai/grok-beta"
-    MISTRAL_NEMO = "mistralai/mistral-nemo"
-    COHERE_COMMAND_R_08_2024 = "cohere/command-r-08-2024"
-    COHERE_COMMAND_R_PLUS_08_2024 = "cohere/command-r-plus-08-2024"
-    EVA_QWEN_2_5_32B = "eva-unit-01/eva-qwen-2.5-32b"
-    DEEPSEEK_CHAT = "deepseek/deepseek-chat"
-    PERPLEXITY_LLAMA_3_1_SONAR_LARGE_128K_ONLINE = (
-        "perplexity/llama-3.1-sonar-large-128k-online"
-    )
-    QWEN_QWQ_32B_PREVIEW = "qwen/qwq-32b-preview"
-    NOUSRESEARCH_HERMES_3_LLAMA_3_1_405B = "nousresearch/hermes-3-llama-3.1-405b"
-    NOUSRESEARCH_HERMES_3_LLAMA_3_1_70B = "nousresearch/hermes-3-llama-3.1-70b"
-    AMAZON_NOVA_LITE_V1 = "amazon/nova-lite-v1"
-    AMAZON_NOVA_MICRO_V1 = "amazon/nova-micro-v1"
-    AMAZON_NOVA_PRO_V1 = "amazon/nova-pro-v1"
-    MICROSOFT_WIZARDLM_2_8X22B = "microsoft/wizardlm-2-8x22b"
-    GRYPHE_MYTHOMAX_L2_13B = "gryphe/mythomax-l2-13b"
 
     @property
     def metadata(self) -> ModelMetadata:
@@ -147,47 +117,31 @@ class LlmModel(str, Enum, metaclass=LlmModelMeta):
     def context_window(self) -> int:
         return self.metadata.context_window
 
+    @property
+    def cost_factor(self) -> int:
+        return self.metadata.cost_factor
+
 
 MODEL_METADATA = {
-    LlmModel.O1_PREVIEW: ModelMetadata("openai", 32000),
-    LlmModel.O1_MINI: ModelMetadata("openai", 62000),
-    LlmModel.GPT4O_MINI: ModelMetadata("openai", 128000),
-    LlmModel.GPT4O: ModelMetadata("openai", 128000),
-    LlmModel.GPT4_TURBO: ModelMetadata("openai", 128000),
-    LlmModel.GPT3_5_TURBO: ModelMetadata("openai", 16385),
-    LlmModel.CLAUDE_3_5_SONNET: ModelMetadata("anthropic", 200000),
-    LlmModel.CLAUDE_3_HAIKU: ModelMetadata("anthropic", 200000),
-    LlmModel.LLAMA3_8B: ModelMetadata("groq", 8192),
-    LlmModel.LLAMA3_70B: ModelMetadata("groq", 8192),
-    LlmModel.MIXTRAL_8X7B: ModelMetadata("groq", 32768),
-    LlmModel.GEMMA_7B: ModelMetadata("groq", 8192),
-    LlmModel.GEMMA2_9B: ModelMetadata("groq", 8192),
-    LlmModel.LLAMA3_1_405B: ModelMetadata("groq", 8192),
+    LlmModel.O1_PREVIEW: ModelMetadata("openai", 32000, cost_factor=16),
+    LlmModel.O1_MINI: ModelMetadata("openai", 62000, cost_factor=4),
+    LlmModel.GPT4O_MINI: ModelMetadata("openai", 128000, cost_factor=1),
+    LlmModel.GPT4O: ModelMetadata("openai", 128000, cost_factor=3),
+    LlmModel.GPT4_TURBO: ModelMetadata("openai", 128000, cost_factor=10),
+    LlmModel.GPT3_5_TURBO: ModelMetadata("openai", 16385, cost_factor=1),
+    LlmModel.CLAUDE_3_5_SONNET: ModelMetadata("anthropic", 200000, cost_factor=4),
+    LlmModel.CLAUDE_3_HAIKU: ModelMetadata("anthropic", 200000, cost_factor=1),
+    LlmModel.LLAMA3_8B: ModelMetadata("groq", 8192, cost_factor=1),
+    LlmModel.LLAMA3_70B: ModelMetadata("groq", 8192, cost_factor=1),
+    LlmModel.MIXTRAL_8X7B: ModelMetadata("groq", 32768, cost_factor=1),
+    LlmModel.GEMMA_7B: ModelMetadata("groq", 8192, cost_factor=1),
+    LlmModel.GEMMA2_9B: ModelMetadata("groq", 8192, cost_factor=1),
+    LlmModel.LLAMA3_1_405B: ModelMetadata("groq", 8192, cost_factor=1),
     # Limited to 16k during preview
-    LlmModel.LLAMA3_1_70B: ModelMetadata("groq", 131072),
-    LlmModel.LLAMA3_1_8B: ModelMetadata("groq", 131072),
-    LlmModel.OLLAMA_LLAMA3_2: ModelMetadata("ollama", 8192),
-    LlmModel.OLLAMA_LLAMA3_8B: ModelMetadata("ollama", 8192),
-    LlmModel.OLLAMA_LLAMA3_405B: ModelMetadata("ollama", 8192),
-    LlmModel.OLLAMA_DOLPHIN: ModelMetadata("ollama", 32768),
-    LlmModel.GEMINI_FLASH_1_5_8B: ModelMetadata("open_router", 8192),
-    LlmModel.GROK_BETA: ModelMetadata("open_router", 8192),
-    LlmModel.MISTRAL_NEMO: ModelMetadata("open_router", 4000),
-    LlmModel.COHERE_COMMAND_R_08_2024: ModelMetadata("open_router", 4000),
-    LlmModel.COHERE_COMMAND_R_PLUS_08_2024: ModelMetadata("open_router", 4000),
-    LlmModel.EVA_QWEN_2_5_32B: ModelMetadata("open_router", 4000),
-    LlmModel.DEEPSEEK_CHAT: ModelMetadata("open_router", 8192),
-    LlmModel.PERPLEXITY_LLAMA_3_1_SONAR_LARGE_128K_ONLINE: ModelMetadata(
-        "open_router", 8192
-    ),
-    LlmModel.QWEN_QWQ_32B_PREVIEW: ModelMetadata("open_router", 4000),
-    LlmModel.NOUSRESEARCH_HERMES_3_LLAMA_3_1_405B: ModelMetadata("open_router", 4000),
-    LlmModel.NOUSRESEARCH_HERMES_3_LLAMA_3_1_70B: ModelMetadata("open_router", 4000),
-    LlmModel.AMAZON_NOVA_LITE_V1: ModelMetadata("open_router", 4000),
-    LlmModel.AMAZON_NOVA_MICRO_V1: ModelMetadata("open_router", 4000),
-    LlmModel.AMAZON_NOVA_PRO_V1: ModelMetadata("open_router", 4000),
-    LlmModel.MICROSOFT_WIZARDLM_2_8X22B: ModelMetadata("open_router", 4000),
-    LlmModel.GRYPHE_MYTHOMAX_L2_13B: ModelMetadata("open_router", 4000),
+    LlmModel.LLAMA3_1_70B: ModelMetadata("groq", 131072, cost_factor=1),
+    LlmModel.LLAMA3_1_8B: ModelMetadata("groq", 131072, cost_factor=1),
+    LlmModel.OLLAMA_LLAMA3_8B: ModelMetadata("ollama", 8192, cost_factor=1),
+    LlmModel.OLLAMA_LLAMA3_405B: ModelMetadata("ollama", 8192, cost_factor=1),
 }
 
 for model in LlmModel:
@@ -238,9 +192,7 @@ class AIStructuredResponseGeneratorBlock(Block):
             description="Number of times to retry the LLM call if the response does not match the expected format.",
         )
         prompt_values: dict[str, str] = SchemaField(
-            advanced=False,
-            default={},
-            description="Values used to fill in the prompt. The values can be used in the prompt by putting them in a double curly braces, e.g. {{variable_name}}.",
+            advanced=False, default={}, description="Values used to fill in the prompt."
         )
         max_tokens: int | None = SchemaField(
             advanced=True,
@@ -248,12 +200,6 @@ class AIStructuredResponseGeneratorBlock(Block):
             description="The maximum number of tokens to generate in the chat completion.",
         )
 
-        ollama_host: str = SchemaField(
-            advanced=True,
-            default="localhost:11434",
-            description="Ollama host for local  models",
-        )
-
     class Output(BlockSchema):
         response: dict[str, Any] = SchemaField(
             description="The response object generated by the language model."
@@ -299,7 +245,6 @@ class AIStructuredResponseGeneratorBlock(Block):
         prompt: list[dict],
         json_format: bool,
         max_tokens: int | None = None,
-        ollama_host: str = "localhost:11434",
     ) -> tuple[str, int, int]:
         """
         Args:
@@ -308,7 +253,6 @@ class AIStructuredResponseGeneratorBlock(Block):
             prompt: The prompt to send to the LLM.
             json_format: Whether the response should be in JSON format.
             max_tokens: The maximum number of tokens to generate in the chat completion.
-            ollama_host: The host for ollama to use
 
         Returns:
             The response from the LLM.
@@ -398,10 +342,9 @@ class AIStructuredResponseGeneratorBlock(Block):
                 response.usage.completion_tokens if response.usage else 0,
             )
         elif provider == "ollama":
-            client = ollama.Client(host=ollama_host)
             sys_messages = [p["content"] for p in prompt if p["role"] == "system"]
             usr_messages = [p["content"] for p in prompt if p["role"] != "system"]
-            response = client.generate(
+            response = ollama.generate(
                 model=llm_model.value,
                 prompt=f"{sys_messages}\n\n{usr_messages}",
                 stream=False,
@@ -411,34 +354,6 @@ class AIStructuredResponseGeneratorBlock(Block):
                 response.get("prompt_eval_count") or 0,
                 response.get("eval_count") or 0,
             )
-        elif provider == "open_router":
-            client = openai.OpenAI(
-                base_url="https://openrouter.ai/api/v1",
-                api_key=credentials.api_key.get_secret_value(),
-            )
-
-            response = client.chat.completions.create(
-                extra_headers={
-                    "HTTP-Referer": "https://agpt.co",
-                    "X-Title": "AutoGPT",
-                },
-                model=llm_model.value,
-                messages=prompt,  # type: ignore
-                max_tokens=max_tokens,
-            )
-
-            # If there's no response, raise an error
-            if not response.choices:
-                if response:
-                    raise ValueError(f"OpenRouter error: {response}")
-                else:
-                    raise ValueError("No response from OpenRouter.")
-
-            return (
-                response.choices[0].message.content or "",
-                response.usage.prompt_tokens if response.usage else 0,
-                response.usage.completion_tokens if response.usage else 0,
-            )
         else:
             raise ValueError(f"Unsupported LLM provider: {provider}")
 
@@ -454,8 +369,8 @@ class AIStructuredResponseGeneratorBlock(Block):
 
         values = input_data.prompt_values
         if values:
-            input_data.prompt = fmt.format_string(input_data.prompt, values)
-            input_data.sys_prompt = fmt.format_string(input_data.sys_prompt, values)
+            input_data.prompt = input_data.prompt.format(**values)
+            input_data.sys_prompt = input_data.sys_prompt.format(**values)
 
         if input_data.sys_prompt:
             prompt.append({"role": "system", "content": input_data.sys_prompt})
@@ -501,7 +416,6 @@ class AIStructuredResponseGeneratorBlock(Block):
                     llm_model=llm_model,
                     prompt=prompt,
                     json_format=bool(input_data.expected_format),
-                    ollama_host=input_data.ollama_host,
                     max_tokens=input_data.max_tokens,
                 )
                 self.merge_stats(
@@ -561,7 +475,7 @@ class AIStructuredResponseGeneratorBlock(Block):
 class AITextGeneratorBlock(Block):
     class Input(BlockSchema):
         prompt: str = SchemaField(
-            description="The prompt to send to the language model. You can use any of the {keys} from Prompt Values to fill in the prompt with values from the prompt values dictionary by putting them in curly braces.",
+            description="The prompt to send to the language model.",
             placeholder="Enter your prompt here...",
         )
         model: LlmModel = SchemaField(
@@ -582,14 +496,7 @@ class AITextGeneratorBlock(Block):
             description="Number of times to retry the LLM call if the response does not match the expected format.",
         )
         prompt_values: dict[str, str] = SchemaField(
-            advanced=False,
-            default={},
-            description="Values used to fill in the prompt. The values can be used in the prompt by putting them in a double curly braces, e.g. {{variable_name}}.",
-        )
-        ollama_host: str = SchemaField(
-            advanced=True,
-            default="localhost:11434",
-            description="Ollama host for local  models",
+            advanced=False, default={}, description="Values used to fill in the prompt."
         )
         max_tokens: int | None = SchemaField(
             advanced=True,
@@ -681,11 +588,6 @@ class AITextSummarizerBlock(Block):
             description="The number of overlapping tokens between chunks to maintain context.",
             ge=0,
         )
-        ollama_host: str = SchemaField(
-            advanced=True,
-            default="localhost:11434",
-            description="Ollama host for local  models",
-        )
 
     class Output(BlockSchema):
         summary: str = SchemaField(description="The final summary of the text.")
@@ -824,11 +726,6 @@ class AIConversationBlock(Block):
             default=None,
             description="The maximum number of tokens to generate in the chat completion.",
         )
-        ollama_host: str = SchemaField(
-            advanced=True,
-            default="localhost:11434",
-            description="Ollama host for local  models",
-        )
 
     class Output(BlockSchema):
         response: str = SchemaField(
@@ -926,11 +823,6 @@ class AIListGeneratorBlock(Block):
             default=None,
             description="The maximum number of tokens to generate in the chat completion.",
         )
-        ollama_host: str = SchemaField(
-            advanced=True,
-            default="localhost:11434",
-            description="Ollama host for local  models",
-        )
 
     class Output(BlockSchema):
         generated_list: List[str] = SchemaField(description="The generated list.")
@@ -1082,7 +974,6 @@ class AIListGeneratorBlock(Block):
                         credentials=input_data.credentials,
                         model=input_data.model,
                         expected_format={},  # Do not use structured response
-                        ollama_host=input_data.ollama_host,
                     ),
                     credentials=credentials,
                 )

autogpt_platform/backend/backend/blocks/medium.py

@@ -1,18 +1,17 @@
 from enum import Enum
 from typing import List, 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,
     BlockSecret,
     CredentialsField,
     CredentialsMetaInput,
     SchemaField,
     SecretField,
 )
-from backend.integrations.providers import ProviderName
 from backend.util.request import requests
 
 TEST_CREDENTIALS = APIKeyCredentials(
@@ -78,10 +77,12 @@ class PublishToMediumBlock(Block):
             description="Whether to notify followers that the user has published",
             placeholder="False",
         )
-        credentials: CredentialsMetaInput[
-            Literal[ProviderName.MEDIUM], Literal["api_key"]
-        ] = CredentialsField(
-            description="The Medium integration can be used with any API key with sufficient permissions for the blocks it is used on.",
+        credentials: CredentialsMetaInput[Literal["medium"], Literal["api_key"]] = (
+            CredentialsField(
+                provider="medium",
+                supported_credential_types={"api_key"},
+                description="The Medium integration can be used with any API key with sufficient permissions for the blocks it is used on.",
+            )
         )
 
     class Output(BlockSchema):

autogpt_platform/backend/backend/blocks/nvidia/_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
-
-NvidiaCredentials = APIKeyCredentials
-NvidiaCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.NVIDIA],
-    Literal["api_key"],
-]
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="nvidia",
-    api_key=SecretStr("mock-nvidia-api-key"),
-    title="Mock Nvidia 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 NvidiaCredentialsField() -> NvidiaCredentialsInput:
-    """Creates an Nvidia credentials input on a block."""
-    return CredentialsField(description="The Nvidia integration requires an API Key.")

autogpt_platform/backend/backend/blocks/nvidia/deepfake.py

@@ -1,90 +0,0 @@
-from backend.blocks.nvidia._auth import (
-    NvidiaCredentials,
-    NvidiaCredentialsField,
-    NvidiaCredentialsInput,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-from backend.util.request import requests
-
-
-class NvidiaDeepfakeDetectBlock(Block):
-    class Input(BlockSchema):
-        credentials: NvidiaCredentialsInput = NvidiaCredentialsField()
-        image_base64: str = SchemaField(
-            description="Image to analyze for deepfakes", image_upload=True
-        )
-        return_image: bool = SchemaField(
-            description="Whether to return the processed image with markings",
-            default=False,
-        )
-
-    class Output(BlockSchema):
-        status: str = SchemaField(
-            description="Detection status (SUCCESS, ERROR, CONTENT_FILTERED)",
-            default="",
-        )
-        image: str = SchemaField(
-            description="Processed image with detection markings (if return_image=True)",
-            default="",
-            image_output=True,
-        )
-        is_deepfake: float = SchemaField(
-            description="Probability that the image is a deepfake (0-1)",
-            default=0.0,
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="8c7d0d67-e79c-44f6-92a1-c2600c8aac7f",
-            description="Detects potential deepfakes in images using Nvidia's AI API",
-            categories={BlockCategory.SAFETY},
-            input_schema=NvidiaDeepfakeDetectBlock.Input,
-            output_schema=NvidiaDeepfakeDetectBlock.Output,
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: NvidiaCredentials, **kwargs
-    ) -> BlockOutput:
-        url = "https://ai.api.nvidia.com/v1/cv/hive/deepfake-image-detection"
-
-        headers = {
-            "accept": "application/json",
-            "content-type": "application/json",
-            "Authorization": f"Bearer {credentials.api_key.get_secret_value()}",
-        }
-
-        image_data = f"data:image/jpeg;base64,{input_data.image_base64}"
-
-        payload = {
-            "input": [image_data],
-            "return_image": input_data.return_image,
-        }
-
-        try:
-            response = requests.post(url, headers=headers, json=payload)
-            response.raise_for_status()
-            data = response.json()
-
-            result = data.get("data", [{}])[0]
-
-            # Get deepfake probability from first bounding box if any
-            deepfake_prob = 0.0
-            if result.get("bounding_boxes"):
-                deepfake_prob = result["bounding_boxes"][0].get("is_deepfake", 0.0)
-
-            yield "status", result.get("status", "ERROR")
-            yield "is_deepfake", deepfake_prob
-
-            if input_data.return_image:
-                image_data = result.get("image", "")
-                output_data = f"data:image/jpeg;base64,{image_data}"
-                yield "image", output_data
-            else:
-                yield "image", ""
-
-        except Exception as e:
-            yield "error", str(e)
-            yield "status", "ERROR"
-            yield "is_deepfake", 0.0
-            yield "image", ""

autogpt_platform/backend/backend/blocks/pinecone.py

@@ -1,27 +1,26 @@
-import uuid
-from typing import Any, Literal
+from typing import Literal
 
+from autogpt_libs.supabase_integration_credentials_store import APIKeyCredentials
 from pinecone import Pinecone, ServerlessSpec
 
 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
 
 PineconeCredentials = APIKeyCredentials
 PineconeCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.PINECONE],
+    Literal["pinecone"],
     Literal["api_key"],
 ]
 
 
 def PineconeCredentialsField() -> PineconeCredentialsInput:
-    """Creates a Pinecone credentials input on a block."""
+    """
+    Creates a Pinecone credentials input on a block.
+
+    """
     return CredentialsField(
+        provider="pinecone",
+        supported_credential_types={"api_key"},
         description="The Pinecone integration can be used with an API Key.",
     )
 
@@ -99,14 +98,10 @@ class PineconeQueryBlock(Block):
         include_metadata: bool = SchemaField(
             description="Whether to include metadata in the response", default=True
         )
-        host: str = SchemaField(description="Host for pinecone", default="")
-        idx_name: str = SchemaField(description="Index name for pinecone")
+        host: str = SchemaField(description="Host for pinecone")
 
     class Output(BlockSchema):
-        results: Any = SchemaField(description="Query results from Pinecone")
-        combined_results: Any = SchemaField(
-            description="Combined results from Pinecone"
-        )
+        results: dict = SchemaField(description="Query results from Pinecone")
 
     def __init__(self):
         super().__init__(
@@ -124,105 +119,13 @@ class PineconeQueryBlock(Block):
         credentials: APIKeyCredentials,
         **kwargs,
     ) -> BlockOutput:
-        try:
-            # Create a new client instance
-            pc = Pinecone(api_key=credentials.api_key.get_secret_value())
-
-            # Get the index
-            idx = pc.Index(input_data.idx_name)
-
-            # Ensure query_vector is in correct format
-            query_vector = input_data.query_vector
-            if isinstance(query_vector, list) and len(query_vector) > 0:
-                if isinstance(query_vector[0], list):
-                    query_vector = query_vector[0]
-
-            results = idx.query(
-                namespace=input_data.namespace,
-                vector=query_vector,
-                top_k=input_data.top_k,
-                include_values=input_data.include_values,
-                include_metadata=input_data.include_metadata,
-            ).to_dict()  # type: ignore
-            combined_text = ""
-            if results["matches"]:
-                texts = [
-                    match["metadata"]["text"]
-                    for match in results["matches"]
-                    if match.get("metadata", {}).get("text")
-                ]
-                combined_text = "\n\n".join(texts)
-
-            # Return both the raw matches and combined text
-            yield "results", {
-                "matches": results["matches"],
-                "combined_text": combined_text,
-            }
-            yield "combined_results", combined_text
-
-        except Exception as e:
-            error_msg = f"Error querying Pinecone: {str(e)}"
-            raise RuntimeError(error_msg) from e
-
-
-class PineconeInsertBlock(Block):
-    class Input(BlockSchema):
-        credentials: PineconeCredentialsInput = PineconeCredentialsField()
-        index: str = SchemaField(description="Initialized Pinecone index")
-        chunks: list = SchemaField(description="List of text chunks to ingest")
-        embeddings: list = SchemaField(
-            description="List of embeddings corresponding to the chunks"
+        pc = Pinecone(api_key=credentials.api_key.get_secret_value())
+        idx = pc.Index(host=input_data.host)
+        results = idx.query(
+            namespace=input_data.namespace,
+            vector=input_data.query_vector,
+            top_k=input_data.top_k,
+            include_values=input_data.include_values,
+            include_metadata=input_data.include_metadata,
         )
-        namespace: str = SchemaField(
-            description="Namespace to use in Pinecone", default=""
-        )
-        metadata: dict = SchemaField(
-            description="Additional metadata to store with each vector", default={}
-        )
-
-    class Output(BlockSchema):
-        upsert_response: str = SchemaField(
-            description="Response from Pinecone upsert operation"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="477f2168-cd91-475a-8146-9499a5982434",
-            description="Upload data to a Pinecone index",
-            categories={BlockCategory.LOGIC},
-            input_schema=PineconeInsertBlock.Input,
-            output_schema=PineconeInsertBlock.Output,
-        )
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: APIKeyCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            # Create a new client instance
-            pc = Pinecone(api_key=credentials.api_key.get_secret_value())
-
-            # Get the index
-            idx = pc.Index(input_data.index)
-
-            vectors = []
-            for chunk, embedding in zip(input_data.chunks, input_data.embeddings):
-                vector_metadata = input_data.metadata.copy()
-                vector_metadata["text"] = chunk
-                vectors.append(
-                    {
-                        "id": str(uuid.uuid4()),
-                        "values": embedding,
-                        "metadata": vector_metadata,
-                    }
-                )
-            idx.upsert(vectors=vectors, namespace=input_data.namespace)
-
-            yield "upsert_response", "successfully upserted"
-
-        except Exception as e:
-            error_msg = f"Error uploading to Pinecone: {str(e)}"
-            raise RuntimeError(error_msg) from e
+        yield "results", results

autogpt_platform/backend/backend/blocks/replicate_flux_advanced.py

@@ -3,17 +3,12 @@ from enum import Enum
 from typing import Literal
 
 import replicate
+from autogpt_libs.supabase_integration_credentials_store.types import APIKeyCredentials
 from pydantic import SecretStr
 from replicate.helpers import FileOutput
 
 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
 
 TEST_CREDENTIALS = APIKeyCredentials(
     id="01234567-89ab-cdef-0123-456789abcdef",
@@ -55,11 +50,13 @@ class ImageType(str, Enum):
 
 class ReplicateFluxAdvancedModelBlock(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.",
+        credentials: CredentialsMetaInput[Literal["replicate"], Literal["api_key"]] = (
+            CredentialsField(
+                provider="replicate",
+                supported_credential_types={"api_key"},
+                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="Text prompt for image generation",

autogpt_platform/backend/backend/blocks/search.py

@@ -1,17 +1,12 @@
 from typing import Literal
 from urllib.parse import quote
 
+from autogpt_libs.supabase_integration_credentials_store.types import APIKeyCredentials
 from pydantic import SecretStr
 
 from backend.blocks.helpers.http import GetRequest
 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
 
 
 class GetWikipediaSummaryBlock(Block, GetRequest):
@@ -45,6 +40,44 @@ class GetWikipediaSummaryBlock(Block, GetRequest):
         yield "summary", response["extract"]
 
 
+class ExtractWebsiteContentBlock(Block, GetRequest):
+    class Input(BlockSchema):
+        url: str = SchemaField(description="The URL to scrape the content from")
+        raw_content: bool = SchemaField(
+            default=False,
+            title="Raw Content",
+            description="Whether to do a raw scrape of the content or use Jina-ai Reader to scrape the content",
+            advanced=True,
+        )
+
+    class Output(BlockSchema):
+        content: str = SchemaField(description="The scraped content from the given URL")
+        error: str = SchemaField(
+            description="Error message if the content cannot be retrieved"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="436c3984-57fd-4b85-8e9a-459b356883bd",
+            description="This block scrapes the content from the given web URL.",
+            categories={BlockCategory.SEARCH},
+            input_schema=ExtractWebsiteContentBlock.Input,
+            output_schema=ExtractWebsiteContentBlock.Output,
+            test_input={"url": "https://en.wikipedia.org/wiki/Artificial_intelligence"},
+            test_output=("content", "scraped content"),
+            test_mock={"get_request": lambda url, json: "scraped content"},
+        )
+
+    def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        if input_data.raw_content:
+            url = input_data.url
+        else:
+            url = f"https://r.jina.ai/{input_data.url}"
+
+        content = self.get_request(url, json=False)
+        yield "content", content
+
+
 TEST_CREDENTIALS = APIKeyCredentials(
     id="01234567-89ab-cdef-0123-456789abcdef",
     provider="openweathermap",
@@ -66,8 +99,10 @@ class GetWeatherInformationBlock(Block, GetRequest):
             description="Location to get weather information for"
         )
         credentials: CredentialsMetaInput[
-            Literal[ProviderName.OPENWEATHERMAP], Literal["api_key"]
+            Literal["openweathermap"], Literal["api_key"]
         ] = CredentialsField(
+            provider="openweathermap",
+            supported_credential_types={"api_key"},
             description="The OpenWeatherMap integration can be used with "
             "any API key with sufficient permissions for the blocks it is used on.",
         )

autogpt_platform/backend/backend/blocks/slant3d/_api.py

@@ -1,70 +0,0 @@
-from enum import Enum
-from typing import Literal
-
-from pydantic import BaseModel, SecretStr
-
-from backend.data.model import APIKeyCredentials, CredentialsField, CredentialsMetaInput
-from backend.integrations.providers import ProviderName
-
-Slant3DCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.SLANT3D], Literal["api_key"]
-]
-
-
-def Slant3DCredentialsField() -> Slant3DCredentialsInput:
-    return CredentialsField(description="Slant3D API key for authentication")
-
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="slant3d",
-    api_key=SecretStr("mock-slant3d-api-key"),
-    title="Mock Slant3D API key",
-    expires_at=None,
-)
-
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.title,
-}
-
-
-class CustomerDetails(BaseModel):
-    name: str
-    email: str
-    phone: str
-    address: str
-    city: str
-    state: str
-    zip: str
-    country_iso: str = "US"
-    is_residential: bool = True
-
-
-class Color(Enum):
-    WHITE = "white"
-    BLACK = "black"
-
-
-class Profile(Enum):
-    PLA = "PLA"
-    PETG = "PETG"
-
-
-class OrderItem(BaseModel):
-    # filename: str
-    file_url: str
-    quantity: str  # String as per API spec
-    color: Color = Color.WHITE
-    profile: Profile = Profile.PLA
-    # image_url: str = ""
-    # sku: str = ""
-
-
-class Filament(BaseModel):
-    filament: str
-    hexColor: str
-    colorTag: str
-    profile: str

autogpt_platform/backend/backend/blocks/slant3d/base.py

@@ -1,94 +0,0 @@
-from typing import Any, Dict
-
-from backend.data.block import Block
-from backend.util.request import requests
-
-from ._api import Color, CustomerDetails, OrderItem, Profile
-
-
-class Slant3DBlockBase(Block):
-    """Base block class for Slant3D API interactions"""
-
-    BASE_URL = "https://www.slant3dapi.com/api"
-
-    def _get_headers(self, api_key: str) -> Dict[str, str]:
-        return {"api-key": api_key, "Content-Type": "application/json"}
-
-    def _make_request(self, method: str, endpoint: str, api_key: str, **kwargs) -> Dict:
-        url = f"{self.BASE_URL}/{endpoint}"
-        response = requests.request(
-            method=method, url=url, headers=self._get_headers(api_key), **kwargs
-        )
-
-        if not response.ok:
-            error_msg = response.json().get("error", "Unknown error")
-            raise RuntimeError(f"API request failed: {error_msg}")
-
-        return response.json()
-
-    def _check_valid_color(self, profile: Profile, color: Color, api_key: str) -> str:
-        response = self._make_request(
-            "GET",
-            "filament",
-            api_key,
-            params={"profile": profile.value, "color": color.value},
-        )
-        if profile == Profile.PLA:
-            color_tag = color.value
-        else:
-            color_tag = f"{profile.value.lower()}{color.value.capitalize()}"
-        valid_tags = [filament["colorTag"] for filament in response["filaments"]]
-
-        if color_tag not in valid_tags:
-            raise ValueError(
-                f"""Invalid color profile combination {color_tag}.
-Valid colors for {profile.value} are:
-{','.join([filament['colorTag'].replace(profile.value.lower(), '') for filament in response['filaments'] if filament['profile'] == profile.value])}
-"""
-            )
-        return color_tag
-
-    def _convert_to_color(self, profile: Profile, color: Color, api_key: str) -> str:
-        return self._check_valid_color(profile, color, api_key)
-
-    def _format_order_data(
-        self,
-        customer: CustomerDetails,
-        order_number: str,
-        items: list[OrderItem],
-        api_key: str,
-    ) -> list[dict[str, Any]]:
-        """Helper function to format order data for API requests"""
-        orders = []
-        for item in items:
-            order_data = {
-                "email": customer.email,
-                "phone": customer.phone,
-                "name": customer.name,
-                "orderNumber": order_number,
-                "filename": item.file_url,
-                "fileURL": item.file_url,
-                "bill_to_street_1": customer.address,
-                "bill_to_city": customer.city,
-                "bill_to_state": customer.state,
-                "bill_to_zip": customer.zip,
-                "bill_to_country_as_iso": customer.country_iso,
-                "bill_to_is_US_residential": str(customer.is_residential).lower(),
-                "ship_to_name": customer.name,
-                "ship_to_street_1": customer.address,
-                "ship_to_city": customer.city,
-                "ship_to_state": customer.state,
-                "ship_to_zip": customer.zip,
-                "ship_to_country_as_iso": customer.country_iso,
-                "ship_to_is_US_residential": str(customer.is_residential).lower(),
-                "order_item_name": item.file_url,
-                "order_quantity": item.quantity,
-                "order_image_url": "",
-                "order_sku": "NOT_USED",
-                "order_item_color": self._convert_to_color(
-                    item.profile, item.color, api_key
-                ),
-                "profile": item.profile.value,
-            }
-            orders.append(order_data)
-        return orders

autogpt_platform/backend/backend/blocks/slant3d/filament.py

@@ -1,85 +0,0 @@
-from typing import List
-
-from backend.data.block import BlockOutput, BlockSchema
-from backend.data.model import APIKeyCredentials, SchemaField
-
-from ._api import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    Filament,
-    Slant3DCredentialsField,
-    Slant3DCredentialsInput,
-)
-from .base import Slant3DBlockBase
-
-
-class Slant3DFilamentBlock(Slant3DBlockBase):
-    """Block for retrieving available filaments"""
-
-    class Input(BlockSchema):
-        credentials: Slant3DCredentialsInput = Slant3DCredentialsField()
-
-    class Output(BlockSchema):
-        filaments: List[Filament] = SchemaField(
-            description="List of available filaments"
-        )
-        error: str = SchemaField(description="Error message if request failed")
-
-    def __init__(self):
-        super().__init__(
-            id="7cc416f4-f305-4606-9b3b-452b8a81031c",
-            description="Get list of available filaments",
-            input_schema=self.Input,
-            output_schema=self.Output,
-            test_input={"credentials": TEST_CREDENTIALS_INPUT},
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "filaments",
-                    [
-                        {
-                            "filament": "PLA BLACK",
-                            "hexColor": "000000",
-                            "colorTag": "black",
-                            "profile": "PLA",
-                        },
-                        {
-                            "filament": "PLA WHITE",
-                            "hexColor": "ffffff",
-                            "colorTag": "white",
-                            "profile": "PLA",
-                        },
-                    ],
-                )
-            ],
-            test_mock={
-                "_make_request": lambda *args, **kwargs: {
-                    "filaments": [
-                        {
-                            "filament": "PLA BLACK",
-                            "hexColor": "000000",
-                            "colorTag": "black",
-                            "profile": "PLA",
-                        },
-                        {
-                            "filament": "PLA WHITE",
-                            "hexColor": "ffffff",
-                            "colorTag": "white",
-                            "profile": "PLA",
-                        },
-                    ]
-                }
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            result = self._make_request(
-                "GET", "filament", credentials.api_key.get_secret_value()
-            )
-            yield "filaments", result["filaments"]
-        except Exception as e:
-            yield "error", str(e)
-            raise

autogpt_platform/backend/backend/blocks/slant3d/order.py

@@ -1,418 +0,0 @@
-import uuid
-from typing import List
-
-import requests as baserequests
-
-from backend.data.block import BlockOutput, BlockSchema
-from backend.data.model import APIKeyCredentials, SchemaField
-from backend.util import settings
-from backend.util.settings import BehaveAs
-
-from ._api import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    CustomerDetails,
-    OrderItem,
-    Slant3DCredentialsField,
-    Slant3DCredentialsInput,
-)
-from .base import Slant3DBlockBase
-
-
-class Slant3DCreateOrderBlock(Slant3DBlockBase):
-    """Block for creating new orders"""
-
-    class Input(BlockSchema):
-        credentials: Slant3DCredentialsInput = Slant3DCredentialsField()
-        order_number: str = SchemaField(
-            description="Your custom order number (or leave blank for a random one)",
-            default_factory=lambda: str(uuid.uuid4()),
-        )
-        customer: CustomerDetails = SchemaField(
-            description="Customer details for where to ship the item",
-            advanced=False,
-        )
-        items: List[OrderItem] = SchemaField(
-            description="List of items to print",
-            advanced=False,
-        )
-
-    class Output(BlockSchema):
-        order_id: str = SchemaField(description="Slant3D order ID")
-        error: str = SchemaField(description="Error message if order failed")
-
-    def __init__(self):
-        super().__init__(
-            id="f73007d6-f48f-4aaf-9e6b-6883998a09b4",
-            description="Create a new print order",
-            input_schema=self.Input,
-            output_schema=self.Output,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "order_number": "TEST-001",
-                "customer": {
-                    "name": "John Doe",
-                    "email": "john@example.com",
-                    "phone": "123-456-7890",
-                    "address": "123 Test St",
-                    "city": "Test City",
-                    "state": "TS",
-                    "zip": "12345",
-                },
-                "items": [
-                    {
-                        "file_url": "https://example.com/model.stl",
-                        "quantity": "1",
-                        "color": "black",
-                        "profile": "PLA",
-                    }
-                ],
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[("order_id", "314144241")],
-            test_mock={
-                "_make_request": lambda *args, **kwargs: {"orderId": "314144241"},
-                "_convert_to_color": lambda *args, **kwargs: "black",
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            order_data = self._format_order_data(
-                input_data.customer,
-                input_data.order_number,
-                input_data.items,
-                credentials.api_key.get_secret_value(),
-            )
-            result = self._make_request(
-                "POST", "order", credentials.api_key.get_secret_value(), json=order_data
-            )
-            yield "order_id", result["orderId"]
-        except Exception as e:
-            yield "error", str(e)
-            raise
-
-
-class Slant3DEstimateOrderBlock(Slant3DBlockBase):
-    """Block for getting order cost estimates"""
-
-    class Input(BlockSchema):
-        credentials: Slant3DCredentialsInput = Slant3DCredentialsField()
-        order_number: str = SchemaField(
-            description="Your custom order number (or leave blank for a random one)",
-            default_factory=lambda: str(uuid.uuid4()),
-        )
-        customer: CustomerDetails = SchemaField(
-            description="Customer details for where to ship the item",
-            advanced=False,
-        )
-        items: List[OrderItem] = SchemaField(
-            description="List of items to print",
-            advanced=False,
-        )
-
-    class Output(BlockSchema):
-        total_price: float = SchemaField(description="Total price in USD")
-        shipping_cost: float = SchemaField(description="Shipping cost")
-        printing_cost: float = SchemaField(description="Printing cost")
-        error: str = SchemaField(description="Error message if estimation failed")
-
-    def __init__(self):
-        super().__init__(
-            id="bf8823d6-b42a-48c7-b558-d7c117f2ae85",
-            description="Get order cost estimate",
-            input_schema=self.Input,
-            output_schema=self.Output,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "order_number": "TEST-001",
-                "customer": {
-                    "name": "John Doe",
-                    "email": "john@example.com",
-                    "phone": "123-456-7890",
-                    "address": "123 Test St",
-                    "city": "Test City",
-                    "state": "TS",
-                    "zip": "12345",
-                },
-                "items": [
-                    {
-                        "file_url": "https://example.com/model.stl",
-                        "quantity": "1",
-                        "color": "black",
-                        "profile": "PLA",
-                    }
-                ],
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                ("total_price", 9.31),
-                ("shipping_cost", 5.56),
-                ("printing_cost", 3.75),
-            ],
-            test_mock={
-                "_make_request": lambda *args, **kwargs: {
-                    "totalPrice": 9.31,
-                    "shippingCost": 5.56,
-                    "printingCost": 3.75,
-                },
-                "_convert_to_color": lambda *args, **kwargs: "black",
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        order_data = self._format_order_data(
-            input_data.customer,
-            input_data.order_number,
-            input_data.items,
-            credentials.api_key.get_secret_value(),
-        )
-        try:
-            result = self._make_request(
-                "POST",
-                "order/estimate",
-                credentials.api_key.get_secret_value(),
-                json=order_data,
-            )
-            yield "total_price", result["totalPrice"]
-            yield "shipping_cost", result["shippingCost"]
-            yield "printing_cost", result["printingCost"]
-        except baserequests.HTTPError as e:
-            yield "error", str(f"Error estimating order: {e} {e.response.text}")
-            raise
-
-
-class Slant3DEstimateShippingBlock(Slant3DBlockBase):
-    """Block for getting shipping cost estimates"""
-
-    class Input(BlockSchema):
-        credentials: Slant3DCredentialsInput = Slant3DCredentialsField()
-        order_number: str = SchemaField(
-            description="Your custom order number (or leave blank for a random one)",
-            default_factory=lambda: str(uuid.uuid4()),
-        )
-        customer: CustomerDetails = SchemaField(
-            description="Customer details for where to ship the item"
-        )
-        items: List[OrderItem] = SchemaField(
-            description="List of items to print",
-            advanced=False,
-        )
-
-    class Output(BlockSchema):
-        shipping_cost: float = SchemaField(description="Estimated shipping cost")
-        currency_code: str = SchemaField(description="Currency code (e.g., 'usd')")
-        error: str = SchemaField(description="Error message if estimation failed")
-
-    def __init__(self):
-        super().__init__(
-            id="00aae2a1-caf6-4a74-8175-39a0615d44e1",
-            description="Get shipping cost estimate",
-            input_schema=self.Input,
-            output_schema=self.Output,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "order_number": "TEST-001",
-                "customer": {
-                    "name": "John Doe",
-                    "email": "john@example.com",
-                    "phone": "123-456-7890",
-                    "address": "123 Test St",
-                    "city": "Test City",
-                    "state": "TS",
-                    "zip": "12345",
-                },
-                "items": [
-                    {
-                        "file_url": "https://example.com/model.stl",
-                        "quantity": "1",
-                        "color": "black",
-                        "profile": "PLA",
-                    }
-                ],
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[("shipping_cost", 4.81), ("currency_code", "usd")],
-            test_mock={
-                "_make_request": lambda *args, **kwargs: {
-                    "shippingCost": 4.81,
-                    "currencyCode": "usd",
-                },
-                "_convert_to_color": lambda *args, **kwargs: "black",
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            order_data = self._format_order_data(
-                input_data.customer,
-                input_data.order_number,
-                input_data.items,
-                credentials.api_key.get_secret_value(),
-            )
-            result = self._make_request(
-                "POST",
-                "order/estimateShipping",
-                credentials.api_key.get_secret_value(),
-                json=order_data,
-            )
-            yield "shipping_cost", result["shippingCost"]
-            yield "currency_code", result["currencyCode"]
-        except Exception as e:
-            yield "error", str(e)
-            raise
-
-
-class Slant3DGetOrdersBlock(Slant3DBlockBase):
-    """Block for retrieving all orders"""
-
-    class Input(BlockSchema):
-        credentials: Slant3DCredentialsInput = Slant3DCredentialsField()
-
-    class Output(BlockSchema):
-        orders: List[str] = SchemaField(description="List of orders with their details")
-        error: str = SchemaField(description="Error message if request failed")
-
-    def __init__(self):
-        super().__init__(
-            id="42283bf5-8a32-4fb4-92a2-60a9ea48e105",
-            description="Get all orders for the account",
-            input_schema=self.Input,
-            output_schema=self.Output,
-            # This block is disabled for cloud hosted because it allows access to all orders for the account
-            disabled=settings.Settings().config.behave_as == BehaveAs.CLOUD,
-            test_input={"credentials": TEST_CREDENTIALS_INPUT},
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "orders",
-                    [
-                        "1234567890",
-                    ],
-                )
-            ],
-            test_mock={
-                "_make_request": lambda *args, **kwargs: {
-                    "ordersData": [
-                        {
-                            "orderId": 1234567890,
-                            "orderTimestamp": {
-                                "_seconds": 1719510986,
-                                "_nanoseconds": 710000000,
-                            },
-                        }
-                    ]
-                }
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            result = self._make_request(
-                "GET", "order", credentials.api_key.get_secret_value()
-            )
-            yield "orders", [str(order["orderId"]) for order in result["ordersData"]]
-        except Exception as e:
-            yield "error", str(e)
-            raise
-
-
-class Slant3DTrackingBlock(Slant3DBlockBase):
-    """Block for tracking order status and shipping"""
-
-    class Input(BlockSchema):
-        credentials: Slant3DCredentialsInput = Slant3DCredentialsField()
-        order_id: str = SchemaField(description="Slant3D order ID to track")
-
-    class Output(BlockSchema):
-        status: str = SchemaField(description="Order status")
-        tracking_numbers: List[str] = SchemaField(
-            description="List of tracking numbers"
-        )
-        error: str = SchemaField(description="Error message if tracking failed")
-
-    def __init__(self):
-        super().__init__(
-            id="dd7c0293-c5af-4551-ba3e-fc162fb1fb89",
-            description="Track order status and shipping",
-            input_schema=self.Input,
-            output_schema=self.Output,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "order_id": "314144241",
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[("status", "awaiting_shipment"), ("tracking_numbers", [])],
-            test_mock={
-                "_make_request": lambda *args, **kwargs: {
-                    "status": "awaiting_shipment",
-                    "trackingNumbers": [],
-                }
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            result = self._make_request(
-                "GET",
-                f"order/{input_data.order_id}/get-tracking",
-                credentials.api_key.get_secret_value(),
-            )
-            yield "status", result["status"]
-            yield "tracking_numbers", result["trackingNumbers"]
-        except Exception as e:
-            yield "error", str(e)
-            raise
-
-
-class Slant3DCancelOrderBlock(Slant3DBlockBase):
-    """Block for canceling orders"""
-
-    class Input(BlockSchema):
-        credentials: Slant3DCredentialsInput = Slant3DCredentialsField()
-        order_id: str = SchemaField(description="Slant3D order ID to cancel")
-
-    class Output(BlockSchema):
-        status: str = SchemaField(description="Cancellation status message")
-        error: str = SchemaField(description="Error message if cancellation failed")
-
-    def __init__(self):
-        super().__init__(
-            id="54de35e1-407f-450b-b5fa-3b5e2eba8185",
-            description="Cancel an existing order",
-            input_schema=self.Input,
-            output_schema=self.Output,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "order_id": "314144241",
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[("status", "Order cancelled")],
-            test_mock={
-                "_make_request": lambda *args, **kwargs: {"status": "Order cancelled"}
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            result = self._make_request(
-                "DELETE",
-                f"order/{input_data.order_id}",
-                credentials.api_key.get_secret_value(),
-            )
-            yield "status", result["status"]
-        except Exception as e:
-            yield "error", str(e)
-            raise

autogpt_platform/backend/backend/blocks/slant3d/slicing.py

@@ -1,61 +0,0 @@
-from backend.data.block import BlockOutput, BlockSchema
-from backend.data.model import APIKeyCredentials, SchemaField
-
-from ._api import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    Slant3DCredentialsField,
-    Slant3DCredentialsInput,
-)
-from .base import Slant3DBlockBase
-
-
-class Slant3DSlicerBlock(Slant3DBlockBase):
-    """Block for slicing 3D model files"""
-
-    class Input(BlockSchema):
-        credentials: Slant3DCredentialsInput = Slant3DCredentialsField()
-        file_url: str = SchemaField(
-            description="URL of the 3D model file to slice (STL)"
-        )
-
-    class Output(BlockSchema):
-        message: str = SchemaField(description="Response message")
-        price: float = SchemaField(description="Calculated price for printing")
-        error: str = SchemaField(description="Error message if slicing failed")
-
-    def __init__(self):
-        super().__init__(
-            id="f8a12c8d-3e4b-4d5f-b6a7-8c9d0e1f2g3h",
-            description="Slice a 3D model file and get pricing information",
-            input_schema=self.Input,
-            output_schema=self.Output,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "file_url": "https://example.com/model.stl",
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[("message", "Slicing successful"), ("price", 8.23)],
-            test_mock={
-                "_make_request": lambda *args, **kwargs: {
-                    "message": "Slicing successful",
-                    "data": {"price": 8.23},
-                }
-            },
-        )
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            result = self._make_request(
-                "POST",
-                "slicer",
-                credentials.api_key.get_secret_value(),
-                json={"fileURL": input_data.file_url},
-            )
-            yield "message", result["message"]
-            yield "price", result["data"]["price"]
-        except Exception as e:
-            yield "error", str(e)
-            raise

autogpt_platform/backend/backend/blocks/slant3d/webhook.py

@@ -1,125 +0,0 @@
-from pydantic import BaseModel
-
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchema,
-    BlockWebhookConfig,
-)
-from backend.data.model import SchemaField
-from backend.util import settings
-from backend.util.settings import AppEnvironment, BehaveAs
-
-from ._api import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    Slant3DCredentialsField,
-    Slant3DCredentialsInput,
-)
-
-
-class Slant3DTriggerBase:
-    """Base class for Slant3D webhook triggers"""
-
-    class Input(BlockSchema):
-        credentials: Slant3DCredentialsInput = Slant3DCredentialsField()
-        # Webhook URL is handled by the webhook system
-        payload: dict = SchemaField(hidden=True, default={})
-
-    class Output(BlockSchema):
-        payload: dict = SchemaField(
-            description="The complete webhook payload received from Slant3D"
-        )
-        order_id: str = SchemaField(description="The ID of the affected order")
-        error: str = SchemaField(
-            description="Error message if payload processing failed"
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        yield "payload", input_data.payload
-        yield "order_id", input_data.payload["orderId"]
-
-
-class Slant3DOrderWebhookBlock(Slant3DTriggerBase, Block):
-    """Block for handling Slant3D order webhooks"""
-
-    class Input(Slant3DTriggerBase.Input):
-        class EventsFilter(BaseModel):
-            """
-            Currently Slant3D only supports 'SHIPPED' status updates
-            Could be expanded in the future with more status types
-            """
-
-            shipped: bool = True
-
-        events: EventsFilter = SchemaField(
-            title="Events",
-            description="Order status events to subscribe to",
-            default=EventsFilter(shipped=True),
-        )
-
-    class Output(Slant3DTriggerBase.Output):
-        status: str = SchemaField(description="The new status of the order")
-        tracking_number: str = SchemaField(
-            description="The tracking number for the shipment"
-        )
-        carrier_code: str = SchemaField(description="The carrier code (e.g., 'usps')")
-
-    def __init__(self):
-        super().__init__(
-            id="8a74c2ad-0104-4640-962f-26c6b69e58cd",
-            description=(
-                "This block triggers on Slant3D order status updates and outputs "
-                "the event details, including tracking information when orders are shipped."
-            ),
-            # All webhooks are currently subscribed to for all orders. This works for self hosted, but not for cloud hosted prod
-            disabled=(
-                settings.Settings().config.behave_as == BehaveAs.CLOUD
-                and settings.Settings().config.app_env != AppEnvironment.LOCAL
-            ),
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=self.Input,
-            output_schema=self.Output,
-            webhook_config=BlockWebhookConfig(
-                provider="slant3d",
-                webhook_type="orders",  # Only one type for now
-                resource_format="",  # No resource format needed
-                event_filter_input="events",
-                event_format="order.{event}",
-            ),
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "events": {"shipped": True},
-                "payload": {
-                    "orderId": "1234567890",
-                    "status": "SHIPPED",
-                    "trackingNumber": "ABCDEF123456",
-                    "carrierCode": "usps",
-                },
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "payload",
-                    {
-                        "orderId": "1234567890",
-                        "status": "SHIPPED",
-                        "trackingNumber": "ABCDEF123456",
-                        "carrierCode": "usps",
-                    },
-                ),
-                ("order_id", "1234567890"),
-                ("status", "SHIPPED"),
-                ("tracking_number", "ABCDEF123456"),
-                ("carrier_code", "usps"),
-            ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:  # type: ignore
-        yield from super().run(input_data, **kwargs)
-
-        # Extract and normalize values from the payload
-        yield "status", input_data.payload["status"]
-        yield "tracking_number", input_data.payload["trackingNumber"]
-        yield "carrier_code", input_data.payload["carrierCode"]

autogpt_platform/backend/backend/blocks/talking_head.py

@@ -1,16 +1,11 @@
 import time
 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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 from backend.util.request import requests
 
 TEST_CREDENTIALS = APIKeyCredentials(
@@ -30,11 +25,13 @@ TEST_CREDENTIALS_INPUT = {
 
 class CreateTalkingAvatarVideoBlock(Block):
     class Input(BlockSchema):
-        credentials: CredentialsMetaInput[
-            Literal[ProviderName.D_ID], Literal["api_key"]
-        ] = CredentialsField(
-            description="The D-ID integration can be used with "
-            "any API key with sufficient permissions for the blocks it is used on.",
+        credentials: CredentialsMetaInput[Literal["d_id"], Literal["api_key"]] = (
+            CredentialsField(
+                provider="d_id",
+                supported_credential_types={"api_key"},
+                description="The D-ID integration can be used with "
+                "any API key with sufficient permissions for the blocks it is used on.",
+            )
         )
         script_input: str = SchemaField(
             description="The text input for the script",

autogpt_platform/backend/backend/blocks/text.py

@@ -1,11 +1,13 @@
 import re
 from typing import Any
 
+from jinja2 import BaseLoader, Environment
+
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
-from backend.util import json, text
+from backend.util import json
 
-formatter = text.TextFormatter()
+jinja = Environment(loader=BaseLoader())
 
 
 class MatchTextPatternBlock(Block):
@@ -71,7 +73,6 @@ class ExtractTextInformationBlock(Block):
             description="Case sensitive match", default=True
         )
         dot_all: bool = SchemaField(description="Dot matches all", default=True)
-        find_all: bool = SchemaField(description="Find all matches", default=False)
 
     class Output(BlockSchema):
         positive: str = SchemaField(description="Extracted text")
@@ -89,27 +90,12 @@ class ExtractTextInformationBlock(Block):
                 {"text": "Hello, World!", "pattern": "Hello, (.+)", "group": 0},
                 {"text": "Hello, World!", "pattern": "Hello, (.+)", "group": 2},
                 {"text": "Hello, World!", "pattern": "hello,", "case_sensitive": False},
-                {
-                    "text": "Hello, World!! Hello, Earth!!",
-                    "pattern": "Hello, (\\S+)",
-                    "group": 1,
-                    "find_all": False,
-                },
-                {
-                    "text": "Hello, World!! Hello, Earth!!",
-                    "pattern": "Hello, (\\S+)",
-                    "group": 1,
-                    "find_all": True,
-                },
             ],
             test_output=[
                 ("positive", "World!"),
                 ("positive", "Hello, World!"),
                 ("negative", "Hello, World!"),
                 ("positive", "Hello,"),
-                ("positive", "World!!"),
-                ("positive", "World!!"),
-                ("positive", "Earth!!"),
             ],
         )
 
@@ -121,30 +107,24 @@ class ExtractTextInformationBlock(Block):
             flags = flags | re.DOTALL
 
         if isinstance(input_data.text, str):
-            txt = input_data.text
+            text = input_data.text
         else:
-            txt = json.dumps(input_data.text)
+            text = json.dumps(input_data.text)
 
-        matches = [
-            match.group(input_data.group)
-            for match in re.finditer(input_data.pattern, txt, flags)
-            if input_data.group <= len(match.groups())
-        ]
-        for match in matches:
-            yield "positive", match
-            if not input_data.find_all:
-                return
-        if not matches:
-            yield "negative", input_data.text
+        match = re.search(input_data.pattern, text, flags)
+        if match and input_data.group <= len(match.groups()):
+            yield "positive", match.group(input_data.group)
+        else:
+            yield "negative", text
 
 
 class FillTextTemplateBlock(Block):
     class Input(BlockSchema):
         values: dict[str, Any] = SchemaField(
-            description="Values (dict) to be used in format. These values can be used by putting them in double curly braces in the format template. e.g. {{value_name}}.",
+            description="Values (dict) to be used in format"
         )
         format: str = SchemaField(
-            description="Template to format the text using `values`. Use Jinja2 syntax."
+            description="Template to format the text using `values`"
         )
 
     class Output(BlockSchema):
@@ -160,26 +140,25 @@ class FillTextTemplateBlock(Block):
             test_input=[
                 {
                     "values": {"name": "Alice", "hello": "Hello", "world": "World!"},
-                    "format": "{{hello}}, {{ world }} {{name}}",
+                    "format": "{hello}, {world} {{name}}",
                 },
                 {
                     "values": {"list": ["Hello", " World!"]},
                     "format": "{% for item in list %}{{ item }}{% endfor %}",
                 },
-                {
-                    "values": {},
-                    "format": "{% set name = 'Alice' %}Hello, World! {{ name }}",
-                },
             ],
             test_output=[
                 ("output", "Hello, World! Alice"),
                 ("output", "Hello World!"),
-                ("output", "Hello, World! Alice"),
             ],
         )
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        yield "output", formatter.format_string(input_data.format, input_data.values)
+        # For python.format compatibility: replace all {...} with {{..}}.
+        # But avoid replacing {{...}} to {{{...}}}.
+        fmt = re.sub(r"(?<!{){[ a-zA-Z0-9_]+}", r"{\g<0>}", input_data.format)
+        template = jinja.from_string(fmt)
+        yield "output", template.render(**input_data.values)
 
 
 class CombineTextsBlock(Block):

autogpt_platform/backend/backend/blocks/text_to_speech_block.py

@@ -1,15 +1,10 @@
 from typing import Any, 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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 from backend.util.request import requests
 
 TEST_CREDENTIALS = APIKeyCredentials(
@@ -39,8 +34,10 @@ class UnrealTextToSpeechBlock(Block):
             default="Scarlett",
         )
         credentials: CredentialsMetaInput[
-            Literal[ProviderName.UNREAL_SPEECH], Literal["api_key"]
+            Literal["unreal_speech"], Literal["api_key"]
         ] = CredentialsField(
+            provider="unreal_speech",
+            supported_credential_types={"api_key"},
             description="The Unreal Speech integration can be used with "
             "any API key with sufficient permissions for the blocks it is used on.",
         )

autogpt_platform/backend/backend/blocks/time_blocks.py

@@ -140,25 +140,20 @@ class GetCurrentDateAndTimeBlock(Block):
 class CountdownTimerBlock(Block):
     class Input(BlockSchema):
         input_message: Any = SchemaField(
-            advanced=False,
             description="Message to output after the timer finishes",
             default="timer finished",
         )
         seconds: Union[int, str] = SchemaField(
-            advanced=False, description="Duration in seconds", default=0
+            description="Duration in seconds", default=0
         )
         minutes: Union[int, str] = SchemaField(
-            advanced=False, description="Duration in minutes", default=0
-        )
-        hours: Union[int, str] = SchemaField(
-            advanced=False, description="Duration in hours", default=0
-        )
-        days: Union[int, str] = SchemaField(
-            advanced=False, description="Duration in days", default=0
+            description="Duration in minutes", default=0
         )
+        hours: Union[int, str] = SchemaField(description="Duration in hours", default=0)
+        days: Union[int, str] = SchemaField(description="Duration in days", default=0)
 
     class Output(BlockSchema):
-        output_message: Any = SchemaField(
+        output_message: str = SchemaField(
             description="Message after the timer finishes"
         )