Remove replicated code

.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/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
@@ -42,14 +48,135 @@ jobs:
         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,57 +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 }}
-
-      - 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
-    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

@@ -11,7 +11,6 @@ on:
     paths:
       - ".github/workflows/platform-backend-ci.yml"
       - "autogpt_platform/backend/**"
-  merge_group:
 
 concurrency:
   group: ${{ format('backend-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}

.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:
@@ -70,10 +69,6 @@ jobs:
         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

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

@@ -11,7 +11,6 @@ on:
     paths:
       - ".github/workflows/platform-market-ci.yml"
       - "autogpt_platform/market/**"
-  merge_group:
 
 concurrency:
   group: ${{ format('backend-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}

.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,5 +171,3 @@ ig*
 .github_access_token
 LICENSE.rtf
 autogpt_platform/backend/settings.py
-/.auth
-/autogpt_platform/frontend/.auth

.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,117 +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]
-
   - 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 -C 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 -C 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 -C 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 -C 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
@@ -141,6 +51,7 @@ repos:
     hooks:
       - id: black
         name: Lint (Black)
+        language_version: python3.12
 
   - repo: https://github.com/PyCQA/flake8
     rev: 7.0.0
@@ -148,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]
 
@@ -170,52 +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
-        args: [-p, autogpt_platform/backend, autogpt_platform/backend]
-        # 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
-        args: [-p, autogpt_platform/autogpt_libs, autogpt_platform/autogpt_libs]
-        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, classic/original_autogpt, classic/original_autogpt]
+        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
-        args: [-p, classic/forge, classic/forge]
-        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, classic/benchmark, classic/benchmark]
+        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")
 

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,44 +0,0 @@
-import pytest
-from autogpt_libs.feature_flag.client import feature_flag, mock_flag_variation
-from ldclient import LDClient
-
-
-@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
 

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

@@ -5,18 +5,20 @@ 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()
@@ -44,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,
@@ -70,28 +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,
-)
-
 
 DEFAULT_CREDENTIALS = [
     revid_credentials,
@@ -101,17 +81,12 @@ DEFAULT_CREDENTIALS = [
     anthropic_credentials,
     groq_credentials,
     did_credentials,
-    jina_credentials,
-    unreal_credentials,
-    open_router_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
@@ -149,12 +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)
         return all_credentials
 
     def get_creds_by_id(self, user_id: str, credentials_id: str) -> Credentials | None:
@@ -305,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

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

autogpt_platform/autogpt_libs/autogpt_libs/utils/cache.py

@@ -1,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/poetry.lock

@@ -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.2"
+version = "2.9.2"
 description = "Data validation using Python type hints"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pydantic-2.10.2-py3-none-any.whl", hash = "sha256:cfb96e45951117c3024e6b67b25cdc33a3cb7b2fa62e239f7af1378358a1d99e"},
-    {file = "pydantic-2.10.2.tar.gz", hash = "sha256:2bc2d7f17232e0841cbba4641e65ba1eb6fafb3a08de3a091ff3ce14a197c4fa"},
+    {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]
@@ -1243,13 +1209,13 @@ yaml = ["pyyaml (>=6.0.1)"]
 
 [[package]]
 name = "pyjwt"
-version = "2.10.0"
+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.0-py3-none-any.whl", hash = "sha256:543b77207db656de204372350926bed5a86201c4cbff159f623f79c7bb487a15"},
-    {file = "pyjwt-2.10.0.tar.gz", hash = "sha256:7628a7eb7938959ac1b26e819a1df0fd3259505627b575e4bad6d08f76db695c"},
+    {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.24.0"
-description = "Pytest support for asyncio"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pytest_asyncio-0.24.0-py3-none-any.whl", hash = "sha256:a811296ed596b69bf0b6f3dc40f83bcaf341b155a269052d82efa2b25ac7037b"},
-    {file = "pytest_asyncio-0.24.0.tar.gz", hash = "sha256:d081d828e576d85f875399194281e92bf8a68d60d72d1a2faf2feddb6c46b276"},
-]
-
-[package.dependencies]
-pytest = ">=8.2,<9"
-
-[package.extras]
-docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1.0)"]
-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"
@@ -1413,33 +1322,6 @@ files = [
 [package.dependencies]
 pyasn1 = ">=0.1.3"
 
-[[package]]
-name = "ruff"
-version = "0.8.0"
-description = "An extremely fast Python linter and code formatter, written in Rust."
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "ruff-0.8.0-py3-none-linux_armv6l.whl", hash = "sha256:fcb1bf2cc6706adae9d79c8d86478677e3bbd4ced796ccad106fd4776d395fea"},
-    {file = "ruff-0.8.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:295bb4c02d58ff2ef4378a1870c20af30723013f441c9d1637a008baaf928c8b"},
-    {file = "ruff-0.8.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:7b1f1c76b47c18fa92ee78b60d2d20d7e866c55ee603e7d19c1e991fad933a9a"},
-    {file = "ruff-0.8.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eb0d4f250a7711b67ad513fde67e8870109e5ce590a801c3722580fe98c33a99"},
-    {file = "ruff-0.8.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0e55cce9aa93c5d0d4e3937e47b169035c7e91c8655b0974e61bb79cf398d49c"},
-    {file = "ruff-0.8.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3f4cd64916d8e732ce6b87f3f5296a8942d285bbbc161acee7fe561134af64f9"},
-    {file = "ruff-0.8.0-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:c5c1466be2a2ebdf7c5450dd5d980cc87c8ba6976fb82582fea18823da6fa362"},
-    {file = "ruff-0.8.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2dabfd05b96b7b8f2da00d53c514eea842bff83e41e1cceb08ae1966254a51df"},
-    {file = "ruff-0.8.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:facebdfe5a5af6b1588a1d26d170635ead6892d0e314477e80256ef4a8470cf3"},
-    {file = "ruff-0.8.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87a8e86bae0dbd749c815211ca11e3a7bd559b9710746c559ed63106d382bd9c"},
-    {file = "ruff-0.8.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:85e654f0ded7befe2d61eeaf3d3b1e4ef3894469cd664ffa85006c7720f1e4a2"},
-    {file = "ruff-0.8.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:83a55679c4cb449fa527b8497cadf54f076603cc36779b2170b24f704171ce70"},
-    {file = "ruff-0.8.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:812e2052121634cf13cd6fddf0c1871d0ead1aad40a1a258753c04c18bb71bbd"},
-    {file = "ruff-0.8.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:780d5d8523c04202184405e60c98d7595bdb498c3c6abba3b6d4cdf2ca2af426"},
-    {file = "ruff-0.8.0-py3-none-win32.whl", hash = "sha256:5fdb6efecc3eb60bba5819679466471fd7d13c53487df7248d6e27146e985468"},
-    {file = "ruff-0.8.0-py3-none-win_amd64.whl", hash = "sha256:582891c57b96228d146725975fbb942e1f30a0c4ba19722e692ca3eb25cc9b4f"},
-    {file = "ruff-0.8.0-py3-none-win_arm64.whl", hash = "sha256:ba93e6294e9a737cd726b74b09a6972e36bb511f9a102f1d9a7e1ce94dd206a6"},
-    {file = "ruff-0.8.0.tar.gz", hash = "sha256:a7ccfe6331bf8c8dad715753e157457faf7351c2b69f62f32c165c2dbcbacd44"},
-]
-
 [[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 = "54bf6e076ec4d09be2307f07240018459dd6594efdc55a2dc2dc1d673184587e"
+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.2"
+pydantic = "^2.9.2"
 pydantic-settings = "^2.6.1"
-pyjwt = "^2.10.0"
-pytest-asyncio = "^0.24.0"
-pytest-mock = "^3.14.0"
+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.0"
-ruff = "^0.8.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
@@ -64,7 +57,6 @@ GOOGLE_CLIENT_SECRET=
 OPENAI_API_KEY=
 ANTHROPIC_API_KEY=
 GROQ_API_KEY=
-OPEN_ROUTER_API_KEY=
 
 # Reddit
 REDDIT_CLIENT_ID=

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
@@ -35,7 +35,7 @@ COPY autogpt_platform/backend/schema.prisma ./
 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
 

autogpt_platform/backend/backend/blocks/__init__.py

@@ -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,100 +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.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,326 +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,
-)
-
-
-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["replicate"], Literal["api_key"]] = (
-            CredentialsField(
-                provider="replicate",
-                supported_credential_types={"api_key"},
-                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,228 +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,
-)
-
-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["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="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,15 +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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 from backend.util.request import requests
 
 TEST_CREDENTIALS = APIKeyCredentials(

autogpt_platform/backend/backend/blocks/basic.py

@@ -233,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.",
@@ -264,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=[
@@ -315,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):
@@ -357,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=[
                 (
@@ -368,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):
@@ -434,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=[
                 (
@@ -453,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
 

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/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,15 +3,11 @@ 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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 
 DiscordCredentials = CredentialsMetaInput[Literal["discord"], Literal["api_key"]]
 

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

@@ -1,36 +0,0 @@
-from typing import Literal
-
-from pydantic import SecretStr
-
-from backend.data.model import APIKeyCredentials, CredentialsField, CredentialsMetaInput
-
-FalCredentials = APIKeyCredentials
-FalCredentialsInput = CredentialsMetaInput[
-    Literal["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(
-        provider="fal",
-        supported_credential_types={"api_key"},
-        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, Dict
-
-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,13 +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 pydantic import SecretStr
+
+from backend.data.model import CredentialsField, CredentialsMetaInput
 from backend.util.settings import Secrets
 
 secrets = Secrets()

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/triggers.py

@@ -1,156 +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())
-
-        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,8 +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.data.model import CredentialsField, CredentialsMetaInput
 from backend.util.settings import Secrets
 
 # --8<-- [start:GoogleOAuthIsConfigured]

autogpt_platform/backend/backend/blocks/google_maps.py

@@ -1,15 +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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 
 TEST_CREDENTIALS = APIKeyCredentials(
     id="01234567-89ab-cdef-0123-456789abcdef",

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

@@ -1,36 +0,0 @@
-from typing import Literal
-
-from pydantic import SecretStr
-
-from backend.data.model import APIKeyCredentials, CredentialsField, CredentialsMetaInput
-
-HubSpotCredentials = APIKeyCredentials
-HubSpotCredentialsInput = CredentialsMetaInput[
-    Literal["hubspot"],
-    Literal["api_key"],
-]
-
-
-def HubSpotCredentialsField() -> HubSpotCredentialsInput:
-    """Creates a HubSpot credentials input on a block."""
-    return CredentialsField(
-        provider="hubspot",
-        supported_credential_types={"api_key"},
-        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,16 +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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 from backend.util.request import requests
 
 TEST_CREDENTIALS = APIKeyCredentials(

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,8 +1,9 @@
 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.data.model import CredentialsField, CredentialsMetaInput
 
 JinaCredentials = APIKeyCredentials
 JinaCredentialsInput = CredentialsMetaInput[

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,6 +5,7 @@ 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
 
 if TYPE_CHECKING:
@@ -16,23 +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
 
 logger = logging.getLogger(__name__)
 
-LLMProviderName = Literal["anthropic", "groq", "openai", "ollama", "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,
@@ -48,18 +50,15 @@ TEST_CREDENTIALS_INPUT = {
 def AICredentialsField() -> AICredentials:
     return CredentialsField(
         description="API key for the LLM provider.",
-        provider=["anthropic", "groq", "openai", "ollama", "open_router"],
+        provider="llm",
         supported_credential_types={"api_key"},
-        discriminator="model",
-        discriminator_mapping={
-            model.value: model.metadata.provider for model in LlmModel
-        },
     )
 
 
 class ModelMetadata(NamedTuple):
     provider: str
     context_window: int
+    cost_factor: int
 
 
 class LlmModelMeta(EnumMeta):
@@ -105,18 +104,6 @@ class LlmModel(str, Enum, metaclass=LlmModelMeta):
     # Ollama models
     OLLAMA_LLAMA3_8B = "llama3"
     OLLAMA_LLAMA3_405B = "llama3.1:405b"
-    # OpenRouter models
-    GEMINI_FLASH_1_5_8B = "google/gemini-flash-1.5"
-    GEMINI_FLASH_1_5_EXP = "google/gemini-flash-1.5-exp"
-    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"
-    )
 
     @property
     def metadata(self) -> ModelMetadata:
@@ -130,38 +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_8B: ModelMetadata("ollama", 8192),
-    LlmModel.OLLAMA_LLAMA3_405B: ModelMetadata("ollama", 8192),
-    LlmModel.GEMINI_FLASH_1_5_8B: ModelMetadata("open_router", 8192),
-    LlmModel.GEMINI_FLASH_1_5_EXP: 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.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:
@@ -374,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}")
 
@@ -523,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(

autogpt_platform/backend/backend/blocks/medium.py

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

autogpt_platform/backend/backend/blocks/pinecone.py

@@ -1,15 +1,10 @@
-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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 
 PineconeCredentials = APIKeyCredentials
 PineconeCredentialsInput = CredentialsMetaInput[
@@ -103,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__(
@@ -128,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()
-            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,16 +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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 
 TEST_CREDENTIALS = APIKeyCredentials(
     id="01234567-89ab-cdef-0123-456789abcdef",

autogpt_platform/backend/backend/blocks/search.py

@@ -1,16 +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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 
 
 class GetWikipediaSummaryBlock(Block, GetRequest):
@@ -44,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",

autogpt_platform/backend/backend/blocks/talking_head.py

@@ -1,15 +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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 from backend.util.request import requests
 
 TEST_CREDENTIALS = APIKeyCredentials(

autogpt_platform/backend/backend/blocks/text_to_speech_block.py

@@ -1,14 +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.data.model import CredentialsField, CredentialsMetaInput, SchemaField
 from backend.util.request import requests
 
 TEST_CREDENTIALS = APIKeyCredentials(

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"
         )
 

autogpt_platform/backend/backend/blocks/youtube.py

@@ -62,22 +62,7 @@ class TranscribeYoutubeVideoBlock(Block):
 
     @staticmethod
     def get_transcript(video_id: str):
-        try:
-            transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
-
-            if not transcript_list:
-                raise ValueError(f"No transcripts found for the video: {video_id}")
-
-            for transcript in transcript_list:
-                first_transcript = transcript_list.find_transcript(
-                    [transcript.language_code]
-                )
-                return YouTubeTranscriptApi.get_transcript(
-                    video_id, languages=[first_transcript.language_code]
-                )
-
-        except Exception:
-            raise ValueError(f"No transcripts found for the video: {video_id}")
+        return YouTubeTranscriptApi.get_transcript(video_id)
 
     def run(self, input_data: Input, **kwargs) -> BlockOutput:
         video_id = self.extract_video_id(input_data.youtube_url)

autogpt_platform/backend/backend/cli.py

@@ -93,16 +93,6 @@ def stop():
     print("Server Stopped")
 
 
-@main.command()
-def gen_encrypt_key():
-    """
-    Generate a new encryption key
-    """
-    from cryptography.fernet import Fernet
-
-    print(Fernet.generate_key().decode())
-
-
 @click.group()
 def test():
     """

autogpt_platform/backend/backend/data/api_key.py

@@ -1,325 +0,0 @@
-import logging
-import uuid
-from datetime import datetime, timezone
-from typing import List, Optional
-
-from autogpt_libs.api_key.key_manager import APIKeyManager
-from prisma.enums import APIKeyPermission, APIKeyStatus
-from prisma.errors import PrismaError
-from prisma.models import APIKey as PrismaAPIKey
-from prisma.types import (
-    APIKeyCreateInput,
-    APIKeyUpdateInput,
-    APIKeyWhereInput,
-    APIKeyWhereUniqueInput,
-)
-from pydantic import BaseModel
-
-from backend.data.db import BaseDbModel
-
-logger = logging.getLogger(__name__)
-
-
-# Some basic exceptions
-class APIKeyError(Exception):
-    """Base exception for API key operations"""
-
-    pass
-
-
-class APIKeyNotFoundError(APIKeyError):
-    """Raised when an API key is not found"""
-
-    pass
-
-
-class APIKeyPermissionError(APIKeyError):
-    """Raised when there are permission issues with API key operations"""
-
-    pass
-
-
-class APIKeyValidationError(APIKeyError):
-    """Raised when API key validation fails"""
-
-    pass
-
-
-class APIKey(BaseDbModel):
-    name: str
-    prefix: str
-    key: str
-    status: APIKeyStatus = APIKeyStatus.ACTIVE
-    permissions: List[APIKeyPermission]
-    postfix: str
-    created_at: datetime
-    last_used_at: Optional[datetime] = None
-    revoked_at: Optional[datetime] = None
-    description: Optional[str] = None
-    user_id: str
-
-    @staticmethod
-    def from_db(api_key: PrismaAPIKey):
-        try:
-            return APIKey(
-                id=api_key.id,
-                name=api_key.name,
-                prefix=api_key.prefix,
-                postfix=api_key.postfix,
-                key=api_key.key,
-                status=APIKeyStatus(api_key.status),
-                permissions=[APIKeyPermission(p) for p in api_key.permissions],
-                created_at=api_key.createdAt,
-                last_used_at=api_key.lastUsedAt,
-                revoked_at=api_key.revokedAt,
-                description=api_key.description,
-                user_id=api_key.userId,
-            )
-        except Exception as e:
-            logger.error(f"Error creating APIKey from db: {str(e)}")
-            raise APIKeyError(f"Failed to create API key object: {str(e)}")
-
-
-class APIKeyWithoutHash(BaseModel):
-    id: str
-    name: str
-    prefix: str
-    postfix: str
-    status: APIKeyStatus
-    permissions: List[APIKeyPermission]
-    created_at: datetime
-    last_used_at: Optional[datetime]
-    revoked_at: Optional[datetime]
-    description: Optional[str]
-    user_id: str
-
-    @staticmethod
-    def from_db(api_key: PrismaAPIKey):
-        try:
-            return APIKeyWithoutHash(
-                id=api_key.id,
-                name=api_key.name,
-                prefix=api_key.prefix,
-                postfix=api_key.postfix,
-                status=APIKeyStatus(api_key.status),
-                permissions=[APIKeyPermission(p) for p in api_key.permissions],
-                created_at=api_key.createdAt,
-                last_used_at=api_key.lastUsedAt,
-                revoked_at=api_key.revokedAt,
-                description=api_key.description,
-                user_id=api_key.userId,
-            )
-        except Exception as e:
-            logger.error(f"Error creating APIKeyWithoutHash from db: {str(e)}")
-            raise APIKeyError(f"Failed to create API key object: {str(e)}")
-
-
-async def generate_api_key(
-    name: str,
-    user_id: str,
-    permissions: List[APIKeyPermission],
-    description: Optional[str] = None,
-) -> tuple[APIKeyWithoutHash, str]:
-    """
-    Generate a new API key and store it in the database.
-    Returns the API key object (without hash) and the plain text key.
-    """
-    try:
-        api_manager = APIKeyManager()
-        key = api_manager.generate_api_key()
-
-        api_key = await PrismaAPIKey.prisma().create(
-            data=APIKeyCreateInput(
-                id=str(uuid.uuid4()),
-                name=name,
-                prefix=key.prefix,
-                postfix=key.postfix,
-                key=key.hash,
-                permissions=[p for p in permissions],
-                description=description,
-                userId=user_id,
-            )
-        )
-
-        api_key_without_hash = APIKeyWithoutHash.from_db(api_key)
-        return api_key_without_hash, key.raw
-    except PrismaError as e:
-        logger.error(f"Database error while generating API key: {str(e)}")
-        raise APIKeyError(f"Failed to generate API key: {str(e)}")
-    except Exception as e:
-        logger.error(f"Unexpected error while generating API key: {str(e)}")
-        raise APIKeyError(f"Failed to generate API key: {str(e)}")
-
-
-async def validate_api_key(plain_text_key: str) -> Optional[APIKey]:
-    """
-    Validate an API key and return the API key object if valid.
-    """
-    try:
-        if not plain_text_key.startswith(APIKeyManager.PREFIX):
-            logger.warning("Invalid API key format")
-            return None
-
-        prefix = plain_text_key[: APIKeyManager.PREFIX_LENGTH]
-        api_manager = APIKeyManager()
-
-        api_key = await PrismaAPIKey.prisma().find_first(
-            where=APIKeyWhereInput(prefix=prefix, status=(APIKeyStatus.ACTIVE))
-        )
-
-        if not api_key:
-            logger.warning(f"No active API key found with prefix {prefix}")
-            return None
-
-        is_valid = api_manager.verify_api_key(plain_text_key, api_key.key)
-        if not is_valid:
-            logger.warning("API key verification failed")
-            return None
-
-        return APIKey.from_db(api_key)
-    except Exception as e:
-        logger.error(f"Error validating API key: {str(e)}")
-        raise APIKeyValidationError(f"Failed to validate API key: {str(e)}")
-
-
-async def revoke_api_key(key_id: str, user_id: str) -> Optional[APIKeyWithoutHash]:
-    try:
-        api_key = await PrismaAPIKey.prisma().find_unique(where={"id": key_id})
-
-        if not api_key:
-            raise APIKeyNotFoundError(f"API key with id {key_id} not found")
-
-        if api_key.userId != user_id:
-            raise APIKeyPermissionError(
-                "You do not have permission to revoke this API key."
-            )
-
-        where_clause: APIKeyWhereUniqueInput = {"id": key_id}
-        updated_api_key = await PrismaAPIKey.prisma().update(
-            where=where_clause,
-            data=APIKeyUpdateInput(
-                status=APIKeyStatus.REVOKED, revokedAt=datetime.now(timezone.utc)
-            ),
-        )
-
-        if updated_api_key:
-            return APIKeyWithoutHash.from_db(updated_api_key)
-        return None
-    except (APIKeyNotFoundError, APIKeyPermissionError) as e:
-        raise e
-    except PrismaError as e:
-        logger.error(f"Database error while revoking API key: {str(e)}")
-        raise APIKeyError(f"Failed to revoke API key: {str(e)}")
-    except Exception as e:
-        logger.error(f"Unexpected error while revoking API key: {str(e)}")
-        raise APIKeyError(f"Failed to revoke API key: {str(e)}")
-
-
-async def list_user_api_keys(user_id: str) -> List[APIKeyWithoutHash]:
-    try:
-        where_clause: APIKeyWhereInput = {"userId": user_id}
-
-        api_keys = await PrismaAPIKey.prisma().find_many(
-            where=where_clause, order={"createdAt": "desc"}
-        )
-
-        return [APIKeyWithoutHash.from_db(key) for key in api_keys]
-    except PrismaError as e:
-        logger.error(f"Database error while listing API keys: {str(e)}")
-        raise APIKeyError(f"Failed to list API keys: {str(e)}")
-    except Exception as e:
-        logger.error(f"Unexpected error while listing API keys: {str(e)}")
-        raise APIKeyError(f"Failed to list API keys: {str(e)}")
-
-
-async def suspend_api_key(key_id: str, user_id: str) -> Optional[APIKeyWithoutHash]:
-    try:
-        api_key = await PrismaAPIKey.prisma().find_unique(where={"id": key_id})
-
-        if not api_key:
-            raise APIKeyNotFoundError(f"API key with id {key_id} not found")
-
-        if api_key.userId != user_id:
-            raise APIKeyPermissionError(
-                "You do not have permission to suspend this API key."
-            )
-
-        where_clause: APIKeyWhereUniqueInput = {"id": key_id}
-        updated_api_key = await PrismaAPIKey.prisma().update(
-            where=where_clause,
-            data=APIKeyUpdateInput(status=APIKeyStatus.SUSPENDED),
-        )
-
-        if updated_api_key:
-            return APIKeyWithoutHash.from_db(updated_api_key)
-        return None
-    except (APIKeyNotFoundError, APIKeyPermissionError) as e:
-        raise e
-    except PrismaError as e:
-        logger.error(f"Database error while suspending API key: {str(e)}")
-        raise APIKeyError(f"Failed to suspend API key: {str(e)}")
-    except Exception as e:
-        logger.error(f"Unexpected error while suspending API key: {str(e)}")
-        raise APIKeyError(f"Failed to suspend API key: {str(e)}")
-
-
-def has_permission(api_key: APIKey, required_permission: APIKeyPermission) -> bool:
-    try:
-        return required_permission in api_key.permissions
-    except Exception as e:
-        logger.error(f"Error checking API key permissions: {str(e)}")
-        return False
-
-
-async def get_api_key_by_id(key_id: str, user_id: str) -> Optional[APIKeyWithoutHash]:
-    try:
-        api_key = await PrismaAPIKey.prisma().find_first(
-            where=APIKeyWhereInput(id=key_id, userId=user_id)
-        )
-
-        if not api_key:
-            return None
-
-        return APIKeyWithoutHash.from_db(api_key)
-    except PrismaError as e:
-        logger.error(f"Database error while getting API key: {str(e)}")
-        raise APIKeyError(f"Failed to get API key: {str(e)}")
-    except Exception as e:
-        logger.error(f"Unexpected error while getting API key: {str(e)}")
-        raise APIKeyError(f"Failed to get API key: {str(e)}")
-
-
-async def update_api_key_permissions(
-    key_id: str, user_id: str, permissions: List[APIKeyPermission]
-) -> Optional[APIKeyWithoutHash]:
-    """
-    Update the permissions of an API key.
-    """
-    try:
-        api_key = await PrismaAPIKey.prisma().find_unique(where={"id": key_id})
-
-        if api_key is None:
-            raise APIKeyNotFoundError("No such API key found.")
-
-        if api_key.userId != user_id:
-            raise APIKeyPermissionError(
-                "You do not have permission to update this API key."
-            )
-
-        where_clause: APIKeyWhereUniqueInput = {"id": key_id}
-        updated_api_key = await PrismaAPIKey.prisma().update(
-            where=where_clause,
-            data=APIKeyUpdateInput(permissions=permissions),
-        )
-
-        if updated_api_key:
-            return APIKeyWithoutHash.from_db(updated_api_key)
-        return None
-    except (APIKeyNotFoundError, APIKeyPermissionError) as e:
-        raise e
-    except PrismaError as e:
-        logger.error(f"Database error while updating API key permissions: {str(e)}")
-        raise APIKeyError(f"Failed to update API key permissions: {str(e)}")
-    except Exception as e:
-        logger.error(f"Unexpected error while updating API key permissions: {str(e)}")
-        raise APIKeyError(f"Failed to update API key permissions: {str(e)}")

autogpt_platform/backend/backend/data/block.py

@@ -15,20 +15,13 @@ from typing import (
 
 import jsonref
 import jsonschema
+from autogpt_libs.supabase_integration_credentials_store.types import Credentials
 from prisma.models import AgentBlock
 from pydantic import BaseModel
 
 from backend.util import json
-from backend.util.settings import Config
 
-from .model import (
-    CREDENTIALS_FIELD_NAME,
-    ContributorDetails,
-    Credentials,
-    CredentialsMetaInput,
-)
-
-app_config = Config()
+from .model import CREDENTIALS_FIELD_NAME, ContributorDetails, CredentialsMetaInput
 
 BlockData = tuple[str, Any]  # Input & Output data should be a tuple of (name, data).
 BlockInput = dict[str, Any]  # Input: 1 input pin consumes 1 data.
@@ -41,8 +34,6 @@ class BlockType(Enum):
     INPUT = "Input"
     OUTPUT = "Output"
     NOTE = "Note"
-    WEBHOOK = "Webhook"
-    AGENT = "Agent"
 
 
 class BlockCategory(Enum):
@@ -57,8 +48,6 @@ class BlockCategory(Enum):
     COMMUNICATION = "Block that interacts with communication platforms."
     DEVELOPER_TOOLS = "Developer tools such as GitHub blocks."
     DATA = "Block that interacts with structured data."
-    AGENT = "Block that interacts with other agents."
-    CRM = "Block that interacts with CRM services."
 
     def dict(self) -> dict[str, str]:
         return {"category": self.name, "description": self.value}
@@ -103,7 +92,15 @@ class BlockSchema(BaseModel):
 
     @classmethod
     def validate_data(cls, data: BlockInput) -> str | None:
-        return json.validate_with_jsonschema(schema=cls.jsonschema(), data=data)
+        """
+        Validate the data against the schema.
+        Returns the validation error message if the data does not match the schema.
+        """
+        try:
+            jsonschema.validate(data, cls.jsonschema())
+            return None
+        except jsonschema.ValidationError as e:
+            return str(e)
 
     @classmethod
     def validate_field(cls, field_name: str, data: BlockInput) -> str | None:
@@ -186,41 +183,6 @@ class EmptySchema(BlockSchema):
     pass
 
 
-# --8<-- [start:BlockWebhookConfig]
-class BlockWebhookConfig(BaseModel):
-    provider: str
-    """The service provider that the webhook connects to"""
-
-    webhook_type: str
-    """
-    Identifier for the webhook type. E.g. GitHub has repo and organization level hooks.
-
-    Only for use in the corresponding `WebhooksManager`.
-    """
-
-    resource_format: str
-    """
-    Template string for the resource that a block instance subscribes to.
-    Fields will be filled from the block's inputs (except `payload`).
-
-    Example: `f"{repo}/pull_requests"` (note: not how it's actually implemented)
-
-    Only for use in the corresponding `WebhooksManager`.
-    """
-
-    event_filter_input: str
-    """Name of the block's event filter input."""
-
-    event_format: str = "{event}"
-    """
-    Template string for the event(s) that a block instance subscribes to.
-    Applied individually to each event selected in the event filter input.
-
-    Example: `"pull_request.{event}"` -> `"pull_request.opened"`
-    """
-    # --8<-- [end:BlockWebhookConfig]
-
-
 class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
     def __init__(
         self,
@@ -237,7 +199,6 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         disabled: bool = False,
         static_output: bool = False,
         block_type: BlockType = BlockType.STANDARD,
-        webhook_config: Optional[BlockWebhookConfig] = None,
     ):
         """
         Initialize the block with the given schema.
@@ -268,38 +229,9 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         self.contributors = contributors or set()
         self.disabled = disabled
         self.static_output = static_output
-        self.block_type = block_type if not webhook_config else BlockType.WEBHOOK
-        self.webhook_config = webhook_config
+        self.block_type = block_type
         self.execution_stats = {}
 
-        if self.webhook_config:
-            # Enforce shape of webhook event filter
-            event_filter_field = self.input_schema.model_fields[
-                self.webhook_config.event_filter_input
-            ]
-            if not (
-                isinstance(event_filter_field.annotation, type)
-                and issubclass(event_filter_field.annotation, BaseModel)
-                and all(
-                    field.annotation is bool
-                    for field in event_filter_field.annotation.model_fields.values()
-                )
-            ):
-                raise NotImplementedError(
-                    f"{self.name} has an invalid webhook event selector: "
-                    "field must be a BaseModel and all its fields must be boolean"
-                )
-
-            # Enforce presence of 'payload' input
-            if "payload" not in self.input_schema.model_fields:
-                raise TypeError(
-                    f"{self.name} is webhook-triggered but has no 'payload' input"
-                )
-
-            # Disable webhook-triggered block if webhook functionality not available
-            if not app_config.platform_base_url:
-                self.disabled = True
-
     @classmethod
     def create(cls: Type["Block"]) -> "Block":
         return cls()
@@ -367,9 +299,7 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         ):
             if output_name == "error":
                 raise RuntimeError(output_data)
-            if self.block_type == BlockType.STANDARD and (
-                error := self.output_schema.validate_field(output_name, output_data)
-            ):
+            if error := self.output_schema.validate_field(output_name, output_data):
                 raise ValueError(f"Block produced an invalid output data: {error}")
             yield output_name, output_data
 

autogpt_platform/backend/backend/data/block_cost_config.py

@@ -1,256 +0,0 @@
-from typing import Type
-
-from backend.blocks.ai_music_generator import AIMusicGeneratorBlock
-from backend.blocks.ai_shortform_video_block import AIShortformVideoCreatorBlock
-from backend.blocks.ideogram import IdeogramModelBlock
-from backend.blocks.jina.embeddings import JinaEmbeddingBlock
-from backend.blocks.jina.search import ExtractWebsiteContentBlock, SearchTheWebBlock
-from backend.blocks.llm import (
-    MODEL_METADATA,
-    AIConversationBlock,
-    AIListGeneratorBlock,
-    AIStructuredResponseGeneratorBlock,
-    AITextGeneratorBlock,
-    AITextSummarizerBlock,
-    LlmModel,
-)
-from backend.blocks.replicate_flux_advanced import ReplicateFluxAdvancedModelBlock
-from backend.blocks.talking_head import CreateTalkingAvatarVideoBlock
-from backend.blocks.text_to_speech_block import UnrealTextToSpeechBlock
-from backend.data.block import Block
-from backend.data.cost import BlockCost, BlockCostType
-from backend.integrations.credentials_store import (
-    anthropic_credentials,
-    did_credentials,
-    groq_credentials,
-    ideogram_credentials,
-    jina_credentials,
-    open_router_credentials,
-    openai_credentials,
-    replicate_credentials,
-    revid_credentials,
-    unreal_credentials,
-)
-
-# =============== Configure the cost for each LLM Model call =============== #
-
-MODEL_COST: dict[LlmModel, int] = {
-    LlmModel.O1_PREVIEW: 16,
-    LlmModel.O1_MINI: 4,
-    LlmModel.GPT4O_MINI: 1,
-    LlmModel.GPT4O: 3,
-    LlmModel.GPT4_TURBO: 10,
-    LlmModel.GPT3_5_TURBO: 1,
-    LlmModel.CLAUDE_3_5_SONNET: 4,
-    LlmModel.CLAUDE_3_HAIKU: 1,
-    LlmModel.LLAMA3_8B: 1,
-    LlmModel.LLAMA3_70B: 1,
-    LlmModel.MIXTRAL_8X7B: 1,
-    LlmModel.GEMMA_7B: 1,
-    LlmModel.GEMMA2_9B: 1,
-    LlmModel.LLAMA3_1_405B: 1,
-    LlmModel.LLAMA3_1_70B: 1,
-    LlmModel.LLAMA3_1_8B: 1,
-    LlmModel.OLLAMA_LLAMA3_8B: 1,
-    LlmModel.OLLAMA_LLAMA3_405B: 1,
-    LlmModel.GEMINI_FLASH_1_5_8B: 1,
-    LlmModel.GEMINI_FLASH_1_5_EXP: 1,
-    LlmModel.GROK_BETA: 5,
-    LlmModel.MISTRAL_NEMO: 1,
-    LlmModel.COHERE_COMMAND_R_08_2024: 1,
-    LlmModel.COHERE_COMMAND_R_PLUS_08_2024: 3,
-    LlmModel.EVA_QWEN_2_5_32B: 1,
-    LlmModel.DEEPSEEK_CHAT: 2,
-    LlmModel.PERPLEXITY_LLAMA_3_1_SONAR_LARGE_128K_ONLINE: 1,
-}
-
-for model in LlmModel:
-    if model not in MODEL_COST:
-        raise ValueError(f"Missing MODEL_COST for model: {model}")
-
-
-LLM_COST = (
-    # Anthropic Models
-    [
-        BlockCost(
-            cost_type=BlockCostType.RUN,
-            cost_filter={
-                "model": model,
-                "credentials": {
-                    "id": anthropic_credentials.id,
-                    "provider": anthropic_credentials.provider,
-                    "type": anthropic_credentials.type,
-                },
-            },
-            cost_amount=cost,
-        )
-        for model, cost in MODEL_COST.items()
-        if MODEL_METADATA[model].provider == "anthropic"
-    ]
-    # OpenAI Models
-    + [
-        BlockCost(
-            cost_type=BlockCostType.RUN,
-            cost_filter={
-                "model": model,
-                "credentials": {
-                    "id": openai_credentials.id,
-                    "provider": openai_credentials.provider,
-                    "type": openai_credentials.type,
-                },
-            },
-            cost_amount=cost,
-        )
-        for model, cost in MODEL_COST.items()
-        if MODEL_METADATA[model].provider == "openai"
-    ]
-    # Groq Models
-    + [
-        BlockCost(
-            cost_type=BlockCostType.RUN,
-            cost_filter={
-                "model": model,
-                "credentials": {"id": groq_credentials.id},
-            },
-            cost_amount=cost,
-        )
-        for model, cost in MODEL_COST.items()
-        if MODEL_METADATA[model].provider == "groq"
-    ]
-    # Open Router Models
-    + [
-        BlockCost(
-            cost_type=BlockCostType.RUN,
-            cost_filter={
-                "model": model,
-                "credentials": {
-                    "id": open_router_credentials.id,
-                    "provider": open_router_credentials.provider,
-                    "type": open_router_credentials.type,
-                },
-            },
-            cost_amount=cost,
-        )
-        for model, cost in MODEL_COST.items()
-        if MODEL_METADATA[model].provider == "open_router"
-    ]
-)
-
-# =============== This is the exhaustive list of cost for each Block =============== #
-
-BLOCK_COSTS: dict[Type[Block], list[BlockCost]] = {
-    AIConversationBlock: LLM_COST,
-    AITextGeneratorBlock: LLM_COST,
-    AIStructuredResponseGeneratorBlock: LLM_COST,
-    AITextSummarizerBlock: LLM_COST,
-    AIListGeneratorBlock: LLM_COST,
-    CreateTalkingAvatarVideoBlock: [
-        BlockCost(
-            cost_amount=15,
-            cost_filter={
-                "credentials": {
-                    "id": did_credentials.id,
-                    "provider": did_credentials.provider,
-                    "type": did_credentials.type,
-                }
-            },
-        )
-    ],
-    SearchTheWebBlock: [
-        BlockCost(
-            cost_amount=1,
-            cost_filter={
-                "credentials": {
-                    "id": jina_credentials.id,
-                    "provider": jina_credentials.provider,
-                    "type": jina_credentials.type,
-                }
-            },
-        )
-    ],
-    ExtractWebsiteContentBlock: [
-        BlockCost(
-            cost_amount=1,
-            cost_filter={
-                "raw_content": False,
-                "credentials": {
-                    "id": jina_credentials.id,
-                    "provider": jina_credentials.provider,
-                    "type": jina_credentials.type,
-                },
-            },
-        )
-    ],
-    IdeogramModelBlock: [
-        BlockCost(
-            cost_amount=16,
-            cost_filter={
-                "credentials": {
-                    "id": ideogram_credentials.id,
-                    "provider": ideogram_credentials.provider,
-                    "type": ideogram_credentials.type,
-                }
-            },
-        )
-    ],
-    AIShortformVideoCreatorBlock: [
-        BlockCost(
-            cost_amount=50,
-            cost_filter={
-                "credentials": {
-                    "id": revid_credentials.id,
-                    "provider": revid_credentials.provider,
-                    "type": revid_credentials.type,
-                }
-            },
-        )
-    ],
-    ReplicateFluxAdvancedModelBlock: [
-        BlockCost(
-            cost_amount=10,
-            cost_filter={
-                "credentials": {
-                    "id": replicate_credentials.id,
-                    "provider": replicate_credentials.provider,
-                    "type": replicate_credentials.type,
-                }
-            },
-        )
-    ],
-    AIMusicGeneratorBlock: [
-        BlockCost(
-            cost_amount=11,
-            cost_filter={
-                "credentials": {
-                    "id": replicate_credentials.id,
-                    "provider": replicate_credentials.provider,
-                    "type": replicate_credentials.type,
-                }
-            },
-        )
-    ],
-    JinaEmbeddingBlock: [
-        BlockCost(
-            cost_amount=12,
-            cost_filter={
-                "credentials": {
-                    "id": jina_credentials.id,
-                    "provider": jina_credentials.provider,
-                    "type": jina_credentials.type,
-                }
-            },
-        )
-    ],
-    UnrealTextToSpeechBlock: [
-        BlockCost(
-            cost_amount=5,
-            cost_filter={
-                "credentials": {
-                    "id": unreal_credentials.id,
-                    "provider": unreal_credentials.provider,
-                    "type": unreal_credentials.type,
-                }
-            },
-        )
-    ],
-}

autogpt_platform/backend/backend/data/cost.py

@@ -1,32 +0,0 @@
-from enum import Enum
-from typing import Any, Optional
-
-from pydantic import BaseModel
-
-from backend.data.block import BlockInput
-
-
-class BlockCostType(str, Enum):
-    RUN = "run"  # cost X credits per run
-    BYTE = "byte"  # cost X credits per byte
-    SECOND = "second"  # cost X credits per second
-
-
-class BlockCost(BaseModel):
-    cost_amount: int
-    cost_filter: BlockInput
-    cost_type: BlockCostType
-
-    def __init__(
-        self,
-        cost_amount: int,
-        cost_type: BlockCostType = BlockCostType.RUN,
-        cost_filter: Optional[BlockInput] = None,
-        **data: Any,
-    ) -> None:
-        super().__init__(
-            cost_amount=cost_amount,
-            cost_filter=cost_filter or {},
-            cost_type=cost_type,
-            **data,
-        )

autogpt_platform/backend/backend/data/credit.py

@@ -1,17 +1,190 @@
 from abc import ABC, abstractmethod
 from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Optional, Type
 
+import prisma.errors
+from autogpt_libs.supabase_integration_credentials_store.store import (
+    anthropic_credentials,
+    did_credentials,
+    groq_credentials,
+    ideogram_credentials,
+    openai_credentials,
+    replicate_credentials,
+    revid_credentials,
+)
 from prisma import Json
 from prisma.enums import UserBlockCreditType
-from prisma.errors import UniqueViolationError
 from prisma.models import UserBlockCredit
+from pydantic import BaseModel
 
+from backend.blocks.ai_shortform_video_block import AIShortformVideoCreatorBlock
+from backend.blocks.ideogram import IdeogramModelBlock
+from backend.blocks.jina.search import SearchTheWebBlock
+from backend.blocks.llm import (
+    MODEL_METADATA,
+    AIConversationBlock,
+    AIStructuredResponseGeneratorBlock,
+    AITextGeneratorBlock,
+    AITextSummarizerBlock,
+    LlmModel,
+)
+from backend.blocks.replicate_flux_advanced import ReplicateFluxAdvancedModelBlock
+from backend.blocks.search import ExtractWebsiteContentBlock
+from backend.blocks.talking_head import CreateTalkingAvatarVideoBlock
 from backend.data.block import Block, BlockInput, get_block
-from backend.data.block_cost_config import BLOCK_COSTS
-from backend.data.cost import BlockCost, BlockCostType
 from backend.util.settings import Config
 
-config = Config()
+
+class BlockCostType(str, Enum):
+    RUN = "run"  # cost X credits per run
+    BYTE = "byte"  # cost X credits per byte
+    SECOND = "second"  # cost X credits per second
+
+
+class BlockCost(BaseModel):
+    cost_amount: int
+    cost_filter: BlockInput
+    cost_type: BlockCostType
+
+    def __init__(
+        self,
+        cost_amount: int,
+        cost_type: BlockCostType = BlockCostType.RUN,
+        cost_filter: Optional[BlockInput] = None,
+        **data: Any,
+    ) -> None:
+        super().__init__(
+            cost_amount=cost_amount,
+            cost_filter=cost_filter or {},
+            cost_type=cost_type,
+            **data,
+        )
+
+
+llm_cost = (
+    [
+        BlockCost(
+            cost_type=BlockCostType.RUN,
+            cost_filter={
+                "model": model,
+                "api_key": None,  # Running LLM with user own API key is free.
+            },
+            cost_amount=metadata.cost_factor,
+        )
+        for model, metadata in MODEL_METADATA.items()
+    ]
+    + [
+        BlockCost(
+            cost_type=BlockCostType.RUN,
+            cost_filter={
+                "model": model,
+                "credentials": {
+                    "id": anthropic_credentials.id,
+                    "provider": anthropic_credentials.provider,
+                    "type": anthropic_credentials.type,
+                },
+            },
+            cost_amount=metadata.cost_factor,
+        )
+        for model, metadata in MODEL_METADATA.items()
+        if metadata.provider == "anthropic"
+    ]
+    + [
+        BlockCost(
+            cost_type=BlockCostType.RUN,
+            cost_filter={
+                "model": model,
+                "credentials": {
+                    "id": openai_credentials.id,
+                    "provider": openai_credentials.provider,
+                    "type": openai_credentials.type,
+                },
+            },
+            cost_amount=metadata.cost_factor,
+        )
+        for model, metadata in MODEL_METADATA.items()
+        if metadata.provider == "openai"
+    ]
+    + [
+        BlockCost(
+            cost_type=BlockCostType.RUN,
+            cost_filter={
+                "model": model,
+                "credentials": {"id": groq_credentials.id},
+            },
+            cost_amount=metadata.cost_factor,
+        )
+        for model, metadata in MODEL_METADATA.items()
+        if metadata.provider == "groq"
+    ]
+    + [
+        BlockCost(
+            # Default cost is running LlmModel.GPT4O.
+            cost_amount=MODEL_METADATA[LlmModel.GPT4O].cost_factor,
+            cost_filter={"api_key": None},
+        ),
+    ]
+)
+
+BLOCK_COSTS: dict[Type[Block], list[BlockCost]] = {
+    AIConversationBlock: llm_cost,
+    AITextGeneratorBlock: llm_cost,
+    AIStructuredResponseGeneratorBlock: llm_cost,
+    AITextSummarizerBlock: llm_cost,
+    CreateTalkingAvatarVideoBlock: [
+        BlockCost(
+            cost_amount=15,
+            cost_filter={
+                "credentials": {
+                    "id": did_credentials.id,
+                    "provider": did_credentials.provider,
+                    "type": did_credentials.type,
+                }
+            },
+        )
+    ],
+    SearchTheWebBlock: [BlockCost(cost_amount=1)],
+    ExtractWebsiteContentBlock: [
+        BlockCost(cost_amount=1, cost_filter={"raw_content": False})
+    ],
+    IdeogramModelBlock: [
+        BlockCost(
+            cost_amount=1,
+            cost_filter={
+                "credentials": {
+                    "id": ideogram_credentials.id,
+                    "provider": ideogram_credentials.provider,
+                    "type": ideogram_credentials.type,
+                }
+            },
+        )
+    ],
+    AIShortformVideoCreatorBlock: [
+        BlockCost(
+            cost_amount=10,
+            cost_filter={
+                "credentials": {
+                    "id": revid_credentials.id,
+                    "provider": revid_credentials.provider,
+                    "type": revid_credentials.type,
+                }
+            },
+        )
+    ],
+    ReplicateFluxAdvancedModelBlock: [
+        BlockCost(
+            cost_amount=10,
+            cost_filter={
+                "credentials": {
+                    "id": replicate_credentials.id,
+                    "provider": replicate_credentials.provider,
+                    "type": replicate_credentials.type,
+                }
+            },
+        )
+    ],
+}
 
 
 class UserCreditBase(ABC):
@@ -70,11 +243,7 @@ class UserCredit(UserCreditBase):
     async def get_or_refill_credit(self, user_id: str) -> int:
         cur_time = self.time_now()
         cur_month = cur_time.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
-        nxt_month = (
-            cur_month.replace(month=cur_month.month + 1)
-            if cur_month.month < 12
-            else cur_month.replace(year=cur_month.year + 1, month=1)
-        )
+        nxt_month = cur_month.replace(month=cur_month.month + 1)
 
         user_credit = await UserBlockCredit.prisma().group_by(
             by=["userId"],
@@ -102,7 +271,7 @@ class UserCredit(UserCreditBase):
                     "createdAt": self.time_now(),
                 }
             )
-        except UniqueViolationError:
+        except prisma.errors.UniqueViolationError:
             pass  # Already refilled this month
 
         return self.num_user_credits_refill
@@ -111,8 +280,8 @@ class UserCredit(UserCreditBase):
     def time_now():
         return datetime.now(timezone.utc)
 
+    @staticmethod
     def _block_usage_cost(
-        self,
         block: Block,
         input_data: BlockInput,
         data_size: float,
@@ -123,44 +292,28 @@ class UserCredit(UserCreditBase):
             return 0, {}
 
         for block_cost in block_costs:
-            if not self._is_cost_filter_match(block_cost.cost_filter, input_data):
-                continue
+            if all(
+                # None, [], {}, "", are considered the same value.
+                input_data.get(k) == b or (not input_data.get(k) and not b)
+                for k, b in block_cost.cost_filter.items()
+            ):
+                if block_cost.cost_type == BlockCostType.RUN:
+                    return block_cost.cost_amount, block_cost.cost_filter
 
-            if block_cost.cost_type == BlockCostType.RUN:
-                return block_cost.cost_amount, block_cost.cost_filter
+                if block_cost.cost_type == BlockCostType.SECOND:
+                    return (
+                        int(run_time * block_cost.cost_amount),
+                        block_cost.cost_filter,
+                    )
 
-            if block_cost.cost_type == BlockCostType.SECOND:
-                return (
-                    int(run_time * block_cost.cost_amount),
-                    block_cost.cost_filter,
-                )
-
-            if block_cost.cost_type == BlockCostType.BYTE:
-                return (
-                    int(data_size * block_cost.cost_amount),
-                    block_cost.cost_filter,
-                )
+                if block_cost.cost_type == BlockCostType.BYTE:
+                    return (
+                        int(data_size * block_cost.cost_amount),
+                        block_cost.cost_filter,
+                    )
 
         return 0, {}
 
-    def _is_cost_filter_match(
-        self, cost_filter: BlockInput, input_data: BlockInput
-    ) -> bool:
-        """
-        Filter rules:
-          - If costFilter is an object, then check if costFilter is the subset of inputValues
-          - Otherwise, check if costFilter is equal to inputValues.
-          - Undefined, null, and empty string are considered as equal.
-        """
-        if not isinstance(cost_filter, dict) or not isinstance(input_data, dict):
-            return cost_filter == input_data
-
-        return all(
-            (not input_data.get(k) and not v)
-            or (input_data.get(k) and self._is_cost_filter_match(v, input_data[k]))
-            for k, v in cost_filter.items()
-        )
-
     async def spend_credits(
         self,
         user_id: str,
@@ -224,6 +377,7 @@ class DisabledUserCredit(UserCreditBase):
 
 
 def get_user_credit_model() -> UserCreditBase:
+    config = Config()
     if config.enable_credit.lower() == "true":
         return UserCredit(config.num_user_credits_refill)
     else:

autogpt_platform/backend/backend/data/db.py

@@ -23,23 +23,15 @@ logger = logging.getLogger(__name__)
 async def connect():
     if prisma.is_connected():
         return
-
     await prisma.connect()
 
-    if not prisma.is_connected():
-        raise ConnectionError("Failed to connect to Prisma.")
-
 
 @conn_retry("Prisma", "Releasing connection")
 async def disconnect():
     if not prisma.is_connected():
         return
-
     await prisma.disconnect()
 
-    if prisma.is_connected():
-        raise ConnectionError("Failed to disconnect from Prisma.")
-
 
 @asynccontextmanager
 async def transaction():

autogpt_platform/backend/backend/data/execution.py

@@ -1,7 +1,7 @@
 from collections import defaultdict
 from datetime import datetime, timezone
 from multiprocessing import Manager
-from typing import Any, AsyncGenerator, Generator, Generic, TypeVar
+from typing import Any, Generic, TypeVar
 
 from prisma.enums import AgentExecutionStatus
 from prisma.models import (
@@ -14,9 +14,7 @@ from pydantic import BaseModel
 
 from backend.data.block import BlockData, BlockInput, CompletedBlockOutput
 from backend.data.includes import EXECUTION_RESULT_INCLUDE, GRAPH_EXECUTION_INCLUDE
-from backend.data.queue import AsyncRedisEventBus, RedisEventBus
 from backend.util import json, mock
-from backend.util.settings import Config
 
 
 class GraphExecution(BaseModel):
@@ -66,7 +64,6 @@ class ExecutionResult(BaseModel):
     graph_exec_id: str
     node_exec_id: str
     node_id: str
-    block_id: str
     status: ExecutionStatus
     input_data: BlockInput
     output_data: CompletedBlockOutput
@@ -75,31 +72,11 @@ class ExecutionResult(BaseModel):
     start_time: datetime | None
     end_time: datetime | None
 
-    @staticmethod
-    def from_graph(graph: AgentGraphExecution):
-        return ExecutionResult(
-            graph_id=graph.agentGraphId,
-            graph_version=graph.agentGraphVersion,
-            graph_exec_id=graph.id,
-            node_exec_id="",
-            node_id="",
-            block_id="",
-            status=graph.executionStatus,
-            # TODO: Populate input_data & output_data from AgentNodeExecutions
-            #       Input & Output comes AgentInputBlock & AgentOutputBlock.
-            input_data={},
-            output_data={},
-            add_time=graph.createdAt,
-            queue_time=graph.createdAt,
-            start_time=graph.startedAt,
-            end_time=graph.updatedAt,
-        )
-
     @staticmethod
     def from_db(execution: AgentNodeExecution):
         if execution.executionData:
             # Execution that has been queued for execution will persist its data.
-            input_data = json.loads(execution.executionData, target_type=dict[str, Any])
+            input_data = json.loads(execution.executionData)
         else:
             # For incomplete execution, executionData will not be yet available.
             input_data: BlockInput = defaultdict()
@@ -116,10 +93,9 @@ class ExecutionResult(BaseModel):
             graph_id=graph_execution.agentGraphId if graph_execution else "",
             graph_version=graph_execution.agentGraphVersion if graph_execution else 0,
             graph_exec_id=execution.agentGraphExecutionId,
-            block_id=execution.AgentNode.agentBlockId if execution.AgentNode else "",
             node_exec_id=execution.id,
             node_id=execution.agentNodeId,
-            status=execution.executionStatus,
+            status=ExecutionStatus(execution.executionStatus),
             input_data=input_data,
             output_data=output_data,
             add_time=execution.addedTime,
@@ -272,19 +248,15 @@ async def update_graph_execution_start_time(graph_exec_id: str):
 async def update_graph_execution_stats(
     graph_exec_id: str,
     stats: dict[str, Any],
-) -> ExecutionResult:
+):
     status = ExecutionStatus.FAILED if stats.get("error") else ExecutionStatus.COMPLETED
-    res = await AgentGraphExecution.prisma().update(
+    await AgentGraphExecution.prisma().update(
         where={"id": graph_exec_id},
         data={
             "executionStatus": status,
             "stats": json.dumps(stats),
         },
     )
-    if not res:
-        raise ValueError(f"Execution {graph_exec_id} not found.")
-
-    return ExecutionResult.from_graph(res)
 
 
 async def update_node_execution_stats(node_exec_id: str, stats: dict[str, Any]):
@@ -472,42 +444,3 @@ async def get_incomplete_executions(
         include=EXECUTION_RESULT_INCLUDE,
     )
     return [ExecutionResult.from_db(execution) for execution in executions]
-
-
-# --------------------- Event Bus --------------------- #
-
-config = Config()
-
-
-class RedisExecutionEventBus(RedisEventBus[ExecutionResult]):
-    Model = ExecutionResult
-
-    @property
-    def event_bus_name(self) -> str:
-        return config.execution_event_bus_name
-
-    def publish(self, res: ExecutionResult):
-        self.publish_event(res, f"{res.graph_id}/{res.graph_exec_id}")
-
-    def listen(
-        self, graph_id: str = "*", graph_exec_id: str = "*"
-    ) -> Generator[ExecutionResult, None, None]:
-        for execution_result in self.listen_events(f"{graph_id}/{graph_exec_id}"):
-            yield execution_result
-
-
-class AsyncRedisExecutionEventBus(AsyncRedisEventBus[ExecutionResult]):
-    Model = ExecutionResult
-
-    @property
-    def event_bus_name(self) -> str:
-        return config.execution_event_bus_name
-
-    async def publish(self, res: ExecutionResult):
-        await self.publish_event(res, f"{res.graph_id}/{res.graph_exec_id}")
-
-    async def listen(
-        self, graph_id: str = "*", graph_exec_id: str = "*"
-    ) -> AsyncGenerator[ExecutionResult, None]:
-        async for execution_result in self.listen_events(f"{graph_id}/{graph_exec_id}"):
-            yield execution_result

autogpt_platform/backend/backend/data/graph.py

@@ -3,23 +3,19 @@ import logging
 import uuid
 from collections import defaultdict
 from datetime import datetime, timezone
-from typing import Any, Literal, Optional, Type
+from typing import Any, Literal, Type
 
-import prisma
 from prisma.models import AgentGraph, AgentGraphExecution, AgentNode, AgentNodeLink
 from prisma.types import AgentGraphWhereInput
 from pydantic.fields import computed_field
 
-from backend.blocks.agent import AgentExecutorBlock
 from backend.blocks.basic import AgentInputBlock, AgentOutputBlock
+from backend.data.block import BlockInput, BlockType, get_block, get_blocks
+from backend.data.db import BaseDbModel, transaction
+from backend.data.execution import ExecutionStatus
+from backend.data.includes import AGENT_GRAPH_INCLUDE, AGENT_NODE_INCLUDE
 from backend.util import json
 
-from .block import BlockInput, BlockType, get_block, get_blocks
-from .db import BaseDbModel, transaction
-from .execution import ExecutionStatus
-from .includes import AGENT_GRAPH_INCLUDE, AGENT_NODE_INCLUDE
-from .integrations import Webhook
-
 logger = logging.getLogger(__name__)
 
 
@@ -52,51 +48,20 @@ class Node(BaseDbModel):
     input_links: list[Link] = []
     output_links: list[Link] = []
 
-    webhook_id: Optional[str] = None
-
-
-class NodeModel(Node):
-    graph_id: str
-    graph_version: int
-
-    webhook: Optional[Webhook] = None
-
     @staticmethod
     def from_db(node: AgentNode):
         if not node.AgentBlock:
             raise ValueError(f"Invalid node {node.id}, invalid AgentBlock.")
-        obj = NodeModel(
+        obj = Node(
             id=node.id,
             block_id=node.AgentBlock.id,
-            input_default=json.loads(node.constantInput, target_type=dict[str, Any]),
-            metadata=json.loads(node.metadata, target_type=dict[str, Any]),
-            graph_id=node.agentGraphId,
-            graph_version=node.agentGraphVersion,
-            webhook_id=node.webhookId,
-            webhook=Webhook.from_db(node.Webhook) if node.Webhook else None,
+            input_default=json.loads(node.constantInput),
+            metadata=json.loads(node.metadata),
         )
         obj.input_links = [Link.from_db(link) for link in node.Input or []]
         obj.output_links = [Link.from_db(link) for link in node.Output or []]
         return obj
 
-    def is_triggered_by_event_type(self, event_type: str) -> bool:
-        if not (block := get_block(self.block_id)):
-            raise ValueError(f"Block #{self.block_id} not found for node #{self.id}")
-        if not block.webhook_config:
-            raise TypeError("This method can't be used on non-webhook blocks")
-        event_filter = self.input_default.get(block.webhook_config.event_filter_input)
-        if not event_filter:
-            raise ValueError(f"Event filter is not configured on node #{self.id}")
-        return event_type in [
-            block.webhook_config.event_format.format(event=k)
-            for k in event_filter
-            if event_filter[k] is True
-        ]
-
-
-# Fix 2-way reference Node <-> Webhook
-Webhook.model_rebuild()
-
 
 class GraphExecution(BaseDbModel):
     execution_id: str
@@ -114,13 +79,10 @@ class GraphExecution(BaseDbModel):
         duration = (end_time - start_time).total_seconds()
         total_run_time = duration
 
-        try:
-            stats = json.loads(execution.stats or "{}", target_type=dict[str, Any])
-        except ValueError:
-            stats = {}
-
-        duration = stats.get("walltime", duration)
-        total_run_time = stats.get("nodes_walltime", total_run_time)
+        if execution.stats:
+            stats = json.loads(execution.stats)
+            duration = stats.get("walltime", duration)
+            total_run_time = stats.get("nodes_walltime", total_run_time)
 
         return GraphExecution(
             id=execution.id,
@@ -143,6 +105,33 @@ class Graph(BaseDbModel):
     nodes: list[Node] = []
     links: list[Link] = []
 
+    @staticmethod
+    def _generate_schema(
+        type_class: Type[AgentInputBlock.Input] | Type[AgentOutputBlock.Input],
+        data: list[dict],
+    ) -> dict[str, Any]:
+        props = []
+        for p in data:
+            try:
+                props.append(type_class(**p))
+            except Exception as e:
+                logger.warning(f"Invalid {type_class}: {p}, {e}")
+
+        return {
+            "type": "object",
+            "properties": {
+                p.name: {
+                    "secret": p.secret,
+                    "advanced": p.advanced,
+                    "title": p.title or p.name,
+                    **({"description": p.description} if p.description else {}),
+                    **({"default": p.value} if p.value is not None else {}),
+                }
+                for p in props
+            },
+            "required": [p.name for p in props if p.value is None],
+        }
+
     @computed_field
     @property
     def input_schema(self) -> dict[str, Any]:
@@ -171,38 +160,6 @@ class Graph(BaseDbModel):
             ],
         )
 
-    @staticmethod
-    def _generate_schema(
-        type_class: Type[AgentInputBlock.Input] | Type[AgentOutputBlock.Input],
-        data: list[dict],
-    ) -> dict[str, Any]:
-        props = []
-        for p in data:
-            try:
-                props.append(type_class(**p))
-            except Exception as e:
-                logger.warning(f"Invalid {type_class}: {p}, {e}")
-
-        return {
-            "type": "object",
-            "properties": {
-                p.name: {
-                    "secret": p.secret,
-                    "advanced": p.advanced,
-                    "title": p.title or p.name,
-                    **({"description": p.description} if p.description else {}),
-                    **({"default": p.value} if p.value is not None else {}),
-                }
-                for p in props
-            },
-            "required": [p.name for p in props if p.value is None],
-        }
-
-
-class GraphModel(Graph):
-    user_id: str
-    nodes: list[NodeModel] = []  # type: ignore
-
     @property
     def starting_nodes(self) -> list[Node]:
         outbound_nodes = {link.sink_id for link in self.links}
@@ -217,35 +174,24 @@ class GraphModel(Graph):
             if node.id not in outbound_nodes or node.id in input_nodes
         ]
 
-    def reassign_ids(self, user_id: str, reassign_graph_id: bool = False):
+    def reassign_ids(self, reassign_graph_id: bool = False):
         """
         Reassigns all IDs in the graph to new UUIDs.
         This method can be used before storing a new graph to the database.
         """
+        self.validate_graph()
 
-        # Reassign Graph ID
         id_map = {node.id: str(uuid.uuid4()) for node in self.nodes}
         if reassign_graph_id:
             self.id = str(uuid.uuid4())
 
-        # Reassign Node IDs
         for node in self.nodes:
             node.id = id_map[node.id]
 
-        # Reassign Link IDs
         for link in self.links:
             link.source_id = id_map[link.source_id]
             link.sink_id = id_map[link.sink_id]
 
-        # Reassign User IDs for agent blocks
-        for node in self.nodes:
-            if node.block_id != AgentExecutorBlock().id:
-                continue
-            node.input_default["user_id"] = user_id
-            node.input_default.setdefault("data", {})
-
-        self.validate_graph()
-
     def validate_graph(self, for_run: bool = False):
         def sanitize(name):
             return name.split("_#_")[0].split("_@_")[0].split("_$_")[0]
@@ -254,7 +200,7 @@ class GraphModel(Graph):
         for link in self.links:
             input_links[link.sink_id].append(link)
 
-        # Nodes: required fields are filled or connected and dependencies are satisfied
+        # Nodes: required fields are filled or connected
         for node in self.nodes:
             block = get_block(node.block_id)
             if block is None:
@@ -269,44 +215,11 @@ class GraphModel(Graph):
                     for_run  # Skip input completion validation, unless when executing.
                     or block.block_type == BlockType.INPUT
                     or block.block_type == BlockType.OUTPUT
-                    or block.block_type == BlockType.AGENT
                 ):
                     raise ValueError(
                         f"Node {block.name} #{node.id} required input missing: `{name}`"
                     )
 
-            # Get input schema properties and check dependencies
-            input_schema = block.input_schema.model_fields
-            required_fields = block.input_schema.get_required_fields()
-
-            def has_value(name):
-                return (
-                    node is not None
-                    and name in node.input_default
-                    and node.input_default[name] is not None
-                    and str(node.input_default[name]).strip() != ""
-                ) or (name in input_schema and input_schema[name].default is not None)
-
-            # Validate dependencies between fields
-            for field_name, field_info in input_schema.items():
-
-                # Apply input dependency validation only on run & field with depends_on
-                json_schema_extra = field_info.json_schema_extra or {}
-                dependencies = json_schema_extra.get("depends_on", [])
-                if not for_run or not dependencies:
-                    continue
-
-                # Check if dependent field has value in input_default
-                field_has_value = has_value(field_name)
-                field_is_required = field_name in required_fields
-
-                # Check for missing dependencies when dependent field is present
-                missing_deps = [dep for dep in dependencies if not has_value(dep)]
-                if missing_deps and (field_has_value or field_is_required):
-                    raise ValueError(
-                        f"Node {block.name} #{node.id}: Field `{field_name}` requires [{', '.join(missing_deps)}] to be set"
-                    )
-
         node_map = {v.id: v for v in self.nodes}
 
         def is_static_output_block(nid: str) -> bool:
@@ -335,65 +248,52 @@ class GraphModel(Graph):
                     )
 
                 sanitized_name = sanitize(name)
-                vals = node.input_default
                 if i == 0:
-                    fields = (
-                        block.output_schema.get_fields()
-                        if block.block_type != BlockType.AGENT
-                        else vals.get("output_schema", {}).get("properties", {}).keys()
-                    )
+                    fields = f"Valid output fields: {block.output_schema.get_fields()}"
                 else:
-                    fields = (
-                        block.input_schema.get_fields()
-                        if block.block_type != BlockType.AGENT
-                        else vals.get("input_schema", {}).get("properties", {}).keys()
-                    )
+                    fields = f"Valid input fields: {block.input_schema.get_fields()}"
                 if sanitized_name not in fields:
-                    fields_msg = f"Allowed fields: {fields}"
-                    raise ValueError(f"{suffix}, `{name}` invalid, {fields_msg}")
+                    raise ValueError(f"{suffix}, `{name}` invalid, {fields}")
 
             if is_static_output_block(link.source_id):
                 link.is_static = True  # Each value block output should be static.
 
+            # TODO: Add type compatibility check here.
+
     @staticmethod
     def from_db(graph: AgentGraph, hide_credentials: bool = False):
         executions = [
             GraphExecution.from_db(execution)
             for execution in graph.AgentGraphExecution or []
         ]
+        nodes = graph.AgentNodes or []
 
-        return GraphModel(
+        return Graph(
             id=graph.id,
-            user_id=graph.userId,
             version=graph.version,
             is_active=graph.isActive,
             is_template=graph.isTemplate,
             name=graph.name or "",
             description=graph.description or "",
             executions=executions,
-            nodes=[
-                GraphModel._process_node(node, hide_credentials)
-                for node in graph.AgentNodes or []
-            ],
+            nodes=[Graph._process_node(node, hide_credentials) for node in nodes],
             links=list(
                 {
                     Link.from_db(link)
-                    for node in graph.AgentNodes or []
+                    for node in nodes
                     for link in (node.Input or []) + (node.Output or [])
                 }
             ),
         )
 
     @staticmethod
-    def _process_node(node: AgentNode, hide_credentials: bool) -> NodeModel:
-        node_dict = {field: getattr(node, field) for field in node.model_fields}
+    def _process_node(node: AgentNode, hide_credentials: bool) -> Node:
+        node_dict = node.model_dump()
         if hide_credentials and "constantInput" in node_dict:
-            constant_input = json.loads(
-                node_dict["constantInput"], target_type=dict[str, Any]
-            )
-            constant_input = GraphModel._hide_credentials_in_input(constant_input)
+            constant_input = json.loads(node_dict["constantInput"])
+            constant_input = Graph._hide_credentials_in_input(constant_input)
             node_dict["constantInput"] = json.dumps(constant_input)
-        return NodeModel.from_db(AgentNode(**node_dict))
+        return Node.from_db(AgentNode(**node_dict))
 
     @staticmethod
     def _hide_credentials_in_input(input_data: dict[str, Any]) -> dict[str, Any]:
@@ -401,7 +301,7 @@ class GraphModel(Graph):
         result = {}
         for key, value in input_data.items():
             if isinstance(value, dict):
-                result[key] = GraphModel._hide_credentials_in_input(value)
+                result[key] = Graph._hide_credentials_in_input(value)
             elif isinstance(value, str) and any(
                 sensitive_key in key.lower() for sensitive_key in sensitive_keys
             ):
@@ -412,37 +312,22 @@ class GraphModel(Graph):
         return result
 
 
-# --------------------- CRUD functions --------------------- #
+# --------------------- Model functions --------------------- #
 
 
-async def get_node(node_id: str) -> NodeModel:
+async def get_node(node_id: str) -> Node:
     node = await AgentNode.prisma().find_unique_or_raise(
         where={"id": node_id},
         include=AGENT_NODE_INCLUDE,
     )
-    return NodeModel.from_db(node)
-
-
-async def set_node_webhook(node_id: str, webhook_id: str | None) -> NodeModel:
-    node = await AgentNode.prisma().update(
-        where={"id": node_id},
-        data=(
-            {"Webhook": {"connect": {"id": webhook_id}}}
-            if webhook_id
-            else {"Webhook": {"disconnect": True}}
-        ),
-        include=AGENT_NODE_INCLUDE,
-    )
-    if not node:
-        raise ValueError(f"Node #{node_id} not found")
-    return NodeModel.from_db(node)
+    return Node.from_db(node)
 
 
 async def get_graphs(
     user_id: str,
     include_executions: bool = False,
     filter_by: Literal["active", "template"] | None = "active",
-) -> list[GraphModel]:
+) -> list[Graph]:
     """
     Retrieves graph metadata objects.
     Default behaviour is to get all currently active graphs.
@@ -453,7 +338,7 @@ async def get_graphs(
         user_id: The ID of the user that owns the graph.
 
     Returns:
-        list[GraphModel]: A list of objects representing the retrieved graphs.
+        list[Graph]: A list of objects representing the retrieved graph metadata.
     """
     where_clause: AgentGraphWhereInput = {}
 
@@ -474,7 +359,7 @@ async def get_graphs(
         include=graph_include,
     )
 
-    return [GraphModel.from_db(graph) for graph in graphs]
+    return [Graph.from_db(graph) for graph in graphs]
 
 
 async def get_graph(
@@ -483,7 +368,7 @@ async def get_graph(
     template: bool = False,
     user_id: str | None = None,
     hide_credentials: bool = False,
-) -> GraphModel | None:
+) -> Graph | None:
     """
     Retrieves a graph from the DB.
     Defaults to the version with `is_active` if `version` is not passed,
@@ -508,35 +393,38 @@ async def get_graph(
         include=AGENT_GRAPH_INCLUDE,
         order={"version": "desc"},
     )
-    return GraphModel.from_db(graph, hide_credentials) if graph else None
+    return Graph.from_db(graph, hide_credentials) if graph else None
 
 
 async def set_graph_active_version(graph_id: str, version: int, user_id: str) -> None:
-    # Activate the requested version if it exists and is owned by the user.
-    updated_count = await AgentGraph.prisma().update_many(
-        data={"isActive": True},
+    # Check if the graph belongs to the user
+    graph = await AgentGraph.prisma().find_first(
         where={
             "id": graph_id,
             "version": version,
             "userId": user_id,
-        },
+        }
     )
-    if updated_count == 0:
+    if not graph:
         raise Exception(f"Graph #{graph_id} v{version} not found or not owned by user")
 
-    # Deactivate all other versions.
+    updated_graph = await AgentGraph.prisma().update(
+        data={"isActive": True},
+        where={
+            "graphVersionId": {"id": graph_id, "version": version},
+        },
+    )
+    if not updated_graph:
+        raise Exception(f"Graph #{graph_id} v{version} not found")
+
+    # Deactivate all other versions
     await AgentGraph.prisma().update_many(
         data={"isActive": False},
-        where={
-            "id": graph_id,
-            "version": {"not": version},
-            "userId": user_id,
-            "isActive": True,
-        },
+        where={"id": graph_id, "version": {"not": version}, "userId": user_id},
     )
 
 
-async def get_graph_all_versions(graph_id: str, user_id: str) -> list[GraphModel]:
+async def get_graph_all_versions(graph_id: str, user_id: str) -> list[Graph]:
     graph_versions = await AgentGraph.prisma().find_many(
         where={"id": graph_id, "userId": user_id},
         order={"version": "desc"},
@@ -546,7 +434,7 @@ async def get_graph_all_versions(graph_id: str, user_id: str) -> list[GraphModel
     if not graph_versions:
         return []
 
-    return [GraphModel.from_db(graph) for graph in graph_versions]
+    return [Graph.from_db(graph) for graph in graph_versions]
 
 
 async def delete_graph(graph_id: str, user_id: str) -> int:
@@ -558,7 +446,7 @@ async def delete_graph(graph_id: str, user_id: str) -> int:
     return entries_count
 
 
-async def create_graph(graph: Graph, user_id: str) -> GraphModel:
+async def create_graph(graph: Graph, user_id: str) -> Graph:
     async with transaction() as tx:
         await __create_graph(tx, graph, user_id)
 
@@ -614,105 +502,3 @@ async def __create_graph(tx, graph: Graph, user_id: str):
             for link in graph.links
         ]
     )
-
-
-# ------------------------ UTILITIES ------------------------ #
-
-
-def make_graph_model(creatable_graph: Graph, user_id: str) -> GraphModel:
-    """
-    Convert a Graph to a GraphModel, setting graph_id and graph_version on all nodes.
-
-    Args:
-        creatable_graph (Graph): The creatable graph to convert.
-        user_id (str): The ID of the user creating the graph.
-
-    Returns:
-        GraphModel: The converted Graph object.
-    """
-    # Create a new Graph object, inheriting properties from CreatableGraph
-    return GraphModel(
-        **creatable_graph.model_dump(exclude={"nodes"}),
-        user_id=user_id,
-        nodes=[
-            NodeModel(
-                **creatable_node.model_dump(),
-                graph_id=creatable_graph.id,
-                graph_version=creatable_graph.version,
-            )
-            for creatable_node in creatable_graph.nodes
-        ],
-    )
-
-
-async def fix_llm_provider_credentials():
-    """Fix node credentials with provider `llm`"""
-    from backend.integrations.credentials_store import IntegrationCredentialsStore
-
-    from .user import get_user_integrations
-
-    store = IntegrationCredentialsStore()
-
-    broken_nodes = await prisma.get_client().query_raw(
-        """
-        SELECT    graph."userId"       user_id,
-                  node.id              node_id,
-                  node."constantInput" node_preset_input
-        FROM      platform."AgentNode"  node
-        LEFT JOIN platform."AgentGraph" graph
-        ON        node."agentGraphId" = graph.id
-        WHERE     node."constantInput"::jsonb->'credentials'->>'provider' = 'llm'
-        ORDER BY  graph."userId";
-        """
-    )
-    logger.info(f"Fixing LLM credential inputs on {len(broken_nodes)} nodes")
-
-    user_id: str = ""
-    user_integrations = None
-    for node in broken_nodes:
-        if node["user_id"] != user_id:
-            # Save queries by only fetching once per user
-            user_id = node["user_id"]
-            user_integrations = await get_user_integrations(user_id)
-        elif not user_integrations:
-            raise RuntimeError(f"Impossible state while processing node {node}")
-
-        node_id: str = node["node_id"]
-        node_preset_input: dict = json.loads(node["node_preset_input"])
-        credentials_meta: dict = node_preset_input["credentials"]
-
-        credentials = next(
-            (
-                c
-                for c in user_integrations.credentials
-                if c.id == credentials_meta["id"]
-            ),
-            None,
-        )
-        if not credentials:
-            continue
-        if credentials.type != "api_key":
-            logger.warning(
-                f"User {user_id} credentials {credentials.id} with provider 'llm' "
-                f"has invalid type '{credentials.type}'"
-            )
-            continue
-
-        api_key = credentials.api_key.get_secret_value()
-        if api_key.startswith("sk-ant-api03-"):
-            credentials.provider = credentials_meta["provider"] = "anthropic"
-        elif api_key.startswith("sk-"):
-            credentials.provider = credentials_meta["provider"] = "openai"
-        elif api_key.startswith("gsk_"):
-            credentials.provider = credentials_meta["provider"] = "groq"
-        else:
-            logger.warning(
-                f"Could not identify provider from key prefix {api_key[:13]}*****"
-            )
-            continue
-
-        store.update_creds(user_id, credentials)
-        await AgentNode.prisma().update(
-            where={"id": node_id},
-            data={"constantInput": json.dumps(node_preset_input)},
-        )

autogpt_platform/backend/backend/data/includes.py

@@ -3,7 +3,6 @@ import prisma
 AGENT_NODE_INCLUDE: prisma.types.AgentNodeInclude = {
     "Input": True,
     "Output": True,
-    "Webhook": True,
     "AgentBlock": True,
 }
 
@@ -28,7 +27,3 @@ GRAPH_EXECUTION_INCLUDE: prisma.types.AgentGraphExecutionInclude = {
         }
     }
 }
-
-INTEGRATION_WEBHOOK_INCLUDE: prisma.types.IntegrationWebhookInclude = {
-    "AgentNodes": {"include": AGENT_NODE_INCLUDE}  # type: ignore
-}

autogpt_platform/backend/backend/data/integrations.py

@@ -1,168 +0,0 @@
-import logging
-from typing import TYPE_CHECKING, AsyncGenerator, Optional
-
-from prisma import Json
-from prisma.models import IntegrationWebhook
-from pydantic import Field
-
-from backend.data.includes import INTEGRATION_WEBHOOK_INCLUDE
-from backend.data.queue import AsyncRedisEventBus
-
-from .db import BaseDbModel
-
-if TYPE_CHECKING:
-    from .graph import NodeModel
-
-logger = logging.getLogger(__name__)
-
-
-class Webhook(BaseDbModel):
-    user_id: str
-    provider: str
-    credentials_id: str
-    webhook_type: str
-    resource: str
-    events: list[str]
-    config: dict = Field(default_factory=dict)
-    secret: str
-
-    provider_webhook_id: str
-
-    attached_nodes: Optional[list["NodeModel"]] = None
-
-    @staticmethod
-    def from_db(webhook: IntegrationWebhook):
-        from .graph import NodeModel
-
-        return Webhook(
-            id=webhook.id,
-            user_id=webhook.userId,
-            provider=webhook.provider,
-            credentials_id=webhook.credentialsId,
-            webhook_type=webhook.webhookType,
-            resource=webhook.resource,
-            events=webhook.events,
-            config=dict(webhook.config),
-            secret=webhook.secret,
-            provider_webhook_id=webhook.providerWebhookId,
-            attached_nodes=(
-                [NodeModel.from_db(node) for node in webhook.AgentNodes]
-                if webhook.AgentNodes is not None
-                else None
-            ),
-        )
-
-
-# --------------------- CRUD functions --------------------- #
-
-
-async def create_webhook(webhook: Webhook) -> Webhook:
-    created_webhook = await IntegrationWebhook.prisma().create(
-        data={
-            "id": webhook.id,
-            "userId": webhook.user_id,
-            "provider": webhook.provider,
-            "credentialsId": webhook.credentials_id,
-            "webhookType": webhook.webhook_type,
-            "resource": webhook.resource,
-            "events": webhook.events,
-            "config": Json(webhook.config),
-            "secret": webhook.secret,
-            "providerWebhookId": webhook.provider_webhook_id,
-        }
-    )
-    return Webhook.from_db(created_webhook)
-
-
-async def get_webhook(webhook_id: str) -> Webhook:
-    """⚠️ No `user_id` check: DO NOT USE without check in user-facing endpoints."""
-    webhook = await IntegrationWebhook.prisma().find_unique_or_raise(
-        where={"id": webhook_id},
-        include=INTEGRATION_WEBHOOK_INCLUDE,
-    )
-    return Webhook.from_db(webhook)
-
-
-async def get_all_webhooks(credentials_id: str) -> list[Webhook]:
-    """⚠️ No `user_id` check: DO NOT USE without check in user-facing endpoints."""
-    webhooks = await IntegrationWebhook.prisma().find_many(
-        where={"credentialsId": credentials_id},
-        include=INTEGRATION_WEBHOOK_INCLUDE,
-    )
-    return [Webhook.from_db(webhook) for webhook in webhooks]
-
-
-async def find_webhook(
-    credentials_id: str, webhook_type: str, resource: str, events: list[str]
-) -> Webhook | None:
-    """⚠️ No `user_id` check: DO NOT USE without check in user-facing endpoints."""
-    webhook = await IntegrationWebhook.prisma().find_first(
-        where={
-            "credentialsId": credentials_id,
-            "webhookType": webhook_type,
-            "resource": resource,
-            "events": {"has_every": events},
-        },
-        include=INTEGRATION_WEBHOOK_INCLUDE,
-    )
-    return Webhook.from_db(webhook) if webhook else None
-
-
-async def update_webhook_config(webhook_id: str, updated_config: dict) -> Webhook:
-    """⚠️ No `user_id` check: DO NOT USE without check in user-facing endpoints."""
-    _updated_webhook = await IntegrationWebhook.prisma().update(
-        where={"id": webhook_id},
-        data={"config": Json(updated_config)},
-        include=INTEGRATION_WEBHOOK_INCLUDE,
-    )
-    if _updated_webhook is None:
-        raise ValueError(f"Webhook #{webhook_id} not found")
-    return Webhook.from_db(_updated_webhook)
-
-
-async def delete_webhook(webhook_id: str) -> None:
-    """⚠️ No `user_id` check: DO NOT USE without check in user-facing endpoints."""
-    deleted = await IntegrationWebhook.prisma().delete(where={"id": webhook_id})
-    if not deleted:
-        raise ValueError(f"Webhook #{webhook_id} not found")
-
-
-# --------------------- WEBHOOK EVENTS --------------------- #
-
-
-class WebhookEvent(BaseDbModel):
-    provider: str
-    webhook_id: str
-    event_type: str
-    payload: dict
-
-
-class WebhookEventBus(AsyncRedisEventBus[WebhookEvent]):
-    Model = WebhookEvent
-
-    @property
-    def event_bus_name(self) -> str:
-        return "webhooks"
-
-    async def publish(self, event: WebhookEvent):
-        await self.publish_event(event, f"{event.webhook_id}/{event.event_type}")
-
-    async def listen(
-        self, webhook_id: str, event_type: Optional[str] = None
-    ) -> AsyncGenerator[WebhookEvent, None]:
-        async for event in self.listen_events(f"{webhook_id}/{event_type or '*'}"):
-            yield event
-
-
-event_bus = WebhookEventBus()
-
-
-async def publish_webhook_event(event: WebhookEvent):
-    await event_bus.publish(event)
-
-
-async def listen_for_webhook_event(
-    webhook_id: str, event_type: Optional[str] = None
-) -> WebhookEvent | None:
-    async for event in event_bus.listen(webhook_id, event_type):
-        return event  # Only one event is expected

autogpt_platform/backend/backend/data/model.py

@@ -1,20 +1,10 @@
 from __future__ import annotations
 
 import logging
-from typing import (
-    Annotated,
-    Any,
-    Callable,
-    ClassVar,
-    Generic,
-    Literal,
-    Optional,
-    TypedDict,
-    TypeVar,
-)
-from uuid import uuid4
+from typing import Any, Callable, ClassVar, Generic, Optional, TypeVar
 
-from pydantic import BaseModel, Field, GetCoreSchemaHandler, SecretStr, field_serializer
+from autogpt_libs.supabase_integration_credentials_store.types import CredentialsType
+from pydantic import BaseModel, Field, GetCoreSchemaHandler
 from pydantic_core import (
     CoreSchema,
     PydanticUndefined,
@@ -123,8 +113,6 @@ def SchemaField(
     advanced: Optional[bool] = None,
     secret: bool = False,
     exclude: bool = False,
-    hidden: Optional[bool] = None,
-    depends_on: list[str] | None = None,
     **kwargs,
 ) -> T:
     json_extra = {
@@ -133,8 +121,6 @@ def SchemaField(
             "placeholder": placeholder,
             "secret": secret,
             "advanced": advanced,
-            "hidden": hidden,
-            "depends_on": depends_on,
         }.items()
         if v is not None
     }
@@ -151,77 +137,6 @@ def SchemaField(
     )
 
 
-class _BaseCredentials(BaseModel):
-    id: str = Field(default_factory=lambda: str(uuid4()))
-    provider: str
-    title: Optional[str]
-
-    @field_serializer("*")
-    def dump_secret_strings(value: Any, _info):
-        if isinstance(value, SecretStr):
-            return value.get_secret_value()
-        return value
-
-
-class OAuth2Credentials(_BaseCredentials):
-    type: Literal["oauth2"] = "oauth2"
-    username: Optional[str]
-    """Username of the third-party service user that these credentials belong to"""
-    access_token: SecretStr
-    access_token_expires_at: Optional[int]
-    """Unix timestamp (seconds) indicating when the access token expires (if at all)"""
-    refresh_token: Optional[SecretStr]
-    refresh_token_expires_at: Optional[int]
-    """Unix timestamp (seconds) indicating when the refresh token expires (if at all)"""
-    scopes: list[str]
-    metadata: dict[str, Any] = Field(default_factory=dict)
-
-    def bearer(self) -> str:
-        return f"Bearer {self.access_token.get_secret_value()}"
-
-
-class APIKeyCredentials(_BaseCredentials):
-    type: Literal["api_key"] = "api_key"
-    api_key: SecretStr
-    expires_at: Optional[int]
-    """Unix timestamp (seconds) indicating when the API key expires (if at all)"""
-
-    def bearer(self) -> str:
-        return f"Bearer {self.api_key.get_secret_value()}"
-
-
-Credentials = Annotated[
-    OAuth2Credentials | APIKeyCredentials,
-    Field(discriminator="type"),
-]
-
-
-CredentialsType = Literal["api_key", "oauth2"]
-
-
-class OAuthState(BaseModel):
-    token: str
-    provider: str
-    expires_at: int
-    """Unix timestamp (seconds) indicating when this OAuth state expires"""
-    scopes: list[str]
-
-
-class UserMetadata(BaseModel):
-    integration_credentials: list[Credentials] = Field(default_factory=list)
-    integration_oauth_states: list[OAuthState] = Field(default_factory=list)
-
-
-class UserMetadataRaw(TypedDict, total=False):
-    integration_credentials: list[dict]
-    integration_oauth_states: list[dict]
-
-
-class UserIntegrations(BaseModel):
-    credentials: list[Credentials] = Field(default_factory=list)
-    oauth_states: list[OAuthState] = Field(default_factory=list)
-
-
 CP = TypeVar("CP", bound=str)
 CT = TypeVar("CT", bound=CredentialsType)
 
@@ -236,22 +151,11 @@ class CredentialsMetaInput(BaseModel, Generic[CP, CT]):
     type: CT
 
 
-class CredentialsFieldSchemaExtra(BaseModel, Generic[CP, CT]):
-    # TODO: move discrimination mechanism out of CredentialsField (frontend + backend)
-    credentials_provider: list[CP]
-    credentials_scopes: Optional[list[str]]
-    credentials_types: list[CT]
-    discriminator: Optional[str] = None
-    discriminator_mapping: Optional[dict[str, CP]] = None
-
-
 def CredentialsField(
-    provider: CP | list[CP],
+    provider: CP,
     supported_credential_types: set[CT],
     required_scopes: set[str] = set(),
     *,
-    discriminator: Optional[str] = None,
-    discriminator_mapping: Optional[dict[str, Any]] = None,
     title: Optional[str] = None,
     description: Optional[str] = None,
     **kwargs,
@@ -260,21 +164,20 @@ def CredentialsField(
     `CredentialsField` must and can only be used on fields named `credentials`.
     This is enforced by the `BlockSchema` base class.
     """
-    if not isinstance(provider, str) and len(provider) > 1 and not discriminator:
-        raise TypeError("Multi-provider CredentialsField requires discriminator!")
-
-    field_schema_extra = CredentialsFieldSchemaExtra[CP, CT](
-        credentials_provider=[provider] if isinstance(provider, str) else provider,
-        credentials_scopes=list(required_scopes) or None,  # omit if empty
-        credentials_types=list(supported_credential_types),
-        discriminator=discriminator,
-        discriminator_mapping=discriminator_mapping,
-    )
+    json_extra = {
+        k: v
+        for k, v in {
+            "credentials_provider": provider,
+            "credentials_scopes": list(required_scopes) or None,  # omit if empty
+            "credentials_types": list(supported_credential_types),
+        }.items()
+        if v is not None
+    }
 
     return Field(
         title=title,
         description=description,
-        json_schema_extra=field_schema_extra.model_dump(exclude_none=True),
+        json_schema_extra=json_extra,
         **kwargs,
     )
 

autogpt_platform/backend/backend/data/queue.py

@@ -9,8 +9,11 @@ from redis.asyncio.client import PubSub as AsyncPubSub
 from redis.client import PubSub
 
 from backend.data import redis
+from backend.data.execution import ExecutionResult
+from backend.util.settings import Config
 
 logger = logging.getLogger(__name__)
+config = Config()
 
 
 class DateTimeEncoder(json.JSONEncoder):
@@ -33,7 +36,7 @@ class BaseRedisEventBus(Generic[M], ABC):
 
     def _serialize_message(self, item: M, channel_key: str) -> tuple[str, str]:
         message = json.dumps(item.model_dump(), cls=DateTimeEncoder)
-        channel_name = f"{self.event_bus_name}/{channel_key}"
+        channel_name = f"{self.event_bus_name}-{channel_key}"
         logger.info(f"[{channel_name}] Publishing an event to Redis {message}")
         return message, channel_name
 
@@ -51,7 +54,7 @@ class BaseRedisEventBus(Generic[M], ABC):
     def _subscribe(
         self, connection: redis.Redis | redis.AsyncRedis, channel_key: str
     ) -> tuple[PubSub | AsyncPubSub, str]:
-        channel_name = f"{self.event_bus_name}/{channel_key}"
+        channel_name = f"{self.event_bus_name}-{channel_key}"
         pubsub = connection.pubsub()
         return pubsub, channel_name
 
@@ -105,3 +108,37 @@ class AsyncRedisEventBus(BaseRedisEventBus[M], ABC):
         async for message in pubsub.listen():
             if event := self._deserialize_message(message, channel_key):
                 yield event
+
+
+class RedisExecutionEventBus(RedisEventBus[ExecutionResult]):
+    Model = ExecutionResult
+
+    @property
+    def event_bus_name(self) -> str:
+        return config.execution_event_bus_name
+
+    def publish(self, res: ExecutionResult):
+        self.publish_event(res, f"{res.graph_id}-{res.graph_exec_id}")
+
+    def listen(
+        self, graph_id: str = "*", graph_exec_id: str = "*"
+    ) -> Generator[ExecutionResult, None, None]:
+        for execution_result in self.listen_events(f"{graph_id}-{graph_exec_id}"):
+            yield execution_result
+
+
+class AsyncRedisExecutionEventBus(AsyncRedisEventBus[ExecutionResult]):
+    Model = ExecutionResult
+
+    @property
+    def event_bus_name(self) -> str:
+        return config.execution_event_bus_name
+
+    async def publish(self, res: ExecutionResult):
+        await self.publish_event(res, f"{res.graph_id}-{res.graph_exec_id}")
+
+    async def listen(
+        self, graph_id: str = "*", graph_exec_id: str = "*"
+    ) -> AsyncGenerator[ExecutionResult, None]:
+        async for execution_result in self.listen_events(f"{graph_id}-{graph_exec_id}"):
+            yield execution_result

autogpt_platform/backend/backend/data/schedule.py

@@ -0,0 +1,81 @@
+from datetime import datetime
+from typing import Optional
+
+from prisma.models import AgentGraphExecutionSchedule
+
+from backend.data.block import BlockInput
+from backend.data.db import BaseDbModel
+from backend.util import json
+
+
+class ExecutionSchedule(BaseDbModel):
+    graph_id: str
+    user_id: str
+    graph_version: int
+    schedule: str
+    is_enabled: bool
+    input_data: BlockInput
+    last_updated: Optional[datetime] = None
+
+    def __init__(self, is_enabled: Optional[bool] = None, **kwargs):
+        kwargs["is_enabled"] = (is_enabled is None) or is_enabled
+        super().__init__(**kwargs)
+
+    @staticmethod
+    def from_db(schedule: AgentGraphExecutionSchedule):
+        return ExecutionSchedule(
+            id=schedule.id,
+            graph_id=schedule.agentGraphId,
+            user_id=schedule.userId,
+            graph_version=schedule.agentGraphVersion,
+            schedule=schedule.schedule,
+            is_enabled=schedule.isEnabled,
+            last_updated=schedule.lastUpdated.replace(tzinfo=None),
+            input_data=json.loads(schedule.inputData),
+        )
+
+
+async def get_active_schedules(last_fetch_time: datetime) -> list[ExecutionSchedule]:
+    query = AgentGraphExecutionSchedule.prisma().find_many(
+        where={"isEnabled": True, "lastUpdated": {"gt": last_fetch_time}},
+        order={"lastUpdated": "asc"},
+    )
+    return [ExecutionSchedule.from_db(schedule) for schedule in await query]
+
+
+async def disable_schedule(schedule_id: str):
+    await AgentGraphExecutionSchedule.prisma().update(
+        where={"id": schedule_id}, data={"isEnabled": False}
+    )
+
+
+async def get_schedules(graph_id: str, user_id: str) -> list[ExecutionSchedule]:
+    query = AgentGraphExecutionSchedule.prisma().find_many(
+        where={
+            "isEnabled": True,
+            "agentGraphId": graph_id,
+            "userId": user_id,
+        },
+    )
+    return [ExecutionSchedule.from_db(schedule) for schedule in await query]
+
+
+async def add_schedule(schedule: ExecutionSchedule) -> ExecutionSchedule:
+    obj = await AgentGraphExecutionSchedule.prisma().create(
+        data={
+            "id": schedule.id,
+            "userId": schedule.user_id,
+            "agentGraphId": schedule.graph_id,
+            "agentGraphVersion": schedule.graph_version,
+            "schedule": schedule.schedule,
+            "isEnabled": schedule.is_enabled,
+            "inputData": json.dumps(schedule.input_data),
+        }
+    )
+    return ExecutionSchedule.from_db(obj)
+
+
+async def update_schedule(schedule_id: str, is_enabled: bool, user_id: str):
+    await AgentGraphExecutionSchedule.prisma().update(
+        where={"id": schedule_id}, data={"isEnabled": is_enabled}
+    )

autogpt_platform/backend/backend/data/user.py

@@ -1,17 +1,23 @@
 import logging
 from typing import Optional, cast
 
-from autogpt_libs.auth.models import DEFAULT_USER_ID
+from autogpt_libs.supabase_integration_credentials_store.types import (
+    UserIntegrations,
+    UserMetadata,
+    UserMetadataRaw,
+)
 from fastapi import HTTPException
 from prisma import Json
 from prisma.models import User
 
 from backend.data.db import prisma
-from backend.data.model import UserIntegrations, UserMetadata, UserMetadataRaw
 from backend.util.encryption import JSONCryptor
 
 logger = logging.getLogger(__name__)
 
+DEFAULT_USER_ID = "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
+DEFAULT_EMAIL = "default@example.com"
+
 
 async def get_or_create_user(user_data: dict) -> User:
     user_id = user_data.get("sub")

autogpt_platform/backend/backend/executor/database.py

@@ -4,7 +4,6 @@ from typing import Any, Callable, Concatenate, Coroutine, ParamSpec, TypeVar, ca
 from backend.data.credit import get_user_credit_model
 from backend.data.execution import (
     ExecutionResult,
-    RedisExecutionEventBus,
     create_graph_execution,
     get_execution_results,
     get_incomplete_executions,
@@ -16,18 +15,18 @@ from backend.data.execution import (
     upsert_execution_output,
 )
 from backend.data.graph import get_graph, get_node
+from backend.data.queue import RedisExecutionEventBus
 from backend.data.user import (
     get_user_integrations,
     get_user_metadata,
     update_user_integrations,
     update_user_metadata,
 )
-from backend.util.service import AppService, expose, register_pydantic_serializers
+from backend.util.service import AppService, expose
 from backend.util.settings import Config
 
 P = ParamSpec("P")
 R = TypeVar("R")
-config = Config()
 
 
 class DatabaseManager(AppService):
@@ -39,11 +38,11 @@ class DatabaseManager(AppService):
 
     @classmethod
     def get_port(cls) -> int:
-        return config.database_api_port
+        return Config().database_api_port
 
     @expose
-    def send_execution_update(self, execution_result: ExecutionResult):
-        self.event_queue.publish(execution_result)
+    def send_execution_update(self, execution_result_dict: dict[Any, Any]):
+        self.event_queue.publish(ExecutionResult(**execution_result_dict))
 
     @staticmethod
     def exposed_run_and_wait(
@@ -56,9 +55,6 @@ class DatabaseManager(AppService):
             res = self.run_and_wait(coroutine)
             return res
 
-        # Register serializers for annotations on bare function
-        register_pydantic_serializers(f)
-
         return wrapper
 
     # Executions

autogpt_platform/backend/backend/executor/manager.py

@@ -18,7 +18,6 @@ if TYPE_CHECKING:
 
 from autogpt_libs.utils.cache import thread_cached
 
-from backend.blocks.agent import AgentExecutorBlock
 from backend.data import redis
 from backend.data.block import Block, BlockData, BlockInput, BlockType, get_block
 from backend.data.execution import (
@@ -30,7 +29,7 @@ from backend.data.execution import (
     merge_execution_input,
     parse_execution_output,
 )
-from backend.data.graph import GraphModel, Link, Node
+from backend.data.graph import Graph, Link, Node
 from backend.data.model import CREDENTIALS_FIELD_NAME, CredentialsMetaInput
 from backend.integrations.creds_manager import IntegrationCredentialsManager
 from backend.util import json
@@ -126,7 +125,7 @@ def execute_node(
 
     def update_execution(status: ExecutionStatus) -> ExecutionResult:
         exec_update = db_client.update_execution_status(node_exec_id, status)
-        db_client.send_execution_update(exec_update)
+        db_client.send_execution_update(exec_update.model_dump())
         return exec_update
 
     node = db_client.get_node(node_id)
@@ -136,6 +135,7 @@ def execute_node(
         logger.error(f"Block {node.block_id} not found.")
         return
 
+    # Sanity check: validate the execution input.
     log_metadata = LogMetadata(
         user_id=user_id,
         graph_eid=graph_exec_id,
@@ -144,20 +144,11 @@ def execute_node(
         node_id=node_id,
         block_name=node_block.name,
     )
-
-    # Sanity check: validate the execution input.
     input_data, error = validate_exec(node, data.data, resolve_input=False)
     if input_data is None:
         log_metadata.error(f"Skip execution, input validation error: {error}")
-        db_client.upsert_execution_output(node_exec_id, "error", error)
-        update_execution(ExecutionStatus.FAILED)
         return
 
-    # Re-shape the input data for agent block.
-    # AgentExecutorBlock specially separate the node input_data & its input_default.
-    if isinstance(node_block, AgentExecutorBlock):
-        input_data = {**node.input_default, "data": input_data}
-
     # Execute the node
     input_data_str = json.dumps(input_data)
     input_size = len(input_data_str)
@@ -186,7 +177,7 @@ def execute_node(
             input_data, **extra_exec_kwargs
         ):
             output_size += len(json.dumps(output_data))
-            log_metadata.info("Node produced output", **{output_name: output_data})
+            log_metadata.info("Node produced output", output_name=output_data)
             db_client.upsert_execution_output(node_exec_id, output_name, output_data)
 
             for execution in _enqueue_next_nodes(
@@ -253,13 +244,14 @@ def _enqueue_next_nodes(
     graph_id: str,
     log_metadata: LogMetadata,
 ) -> list[NodeExecution]:
+
     def add_enqueued_execution(
         node_exec_id: str, node_id: str, data: BlockInput
     ) -> NodeExecution:
         exec_update = db_client.update_execution_status(
             node_exec_id, ExecutionStatus.QUEUED, data
         )
-        db_client.send_execution_update(exec_update)
+        db_client.send_execution_update(exec_update.model_dump())
         return NodeExecution(
             user_id=user_id,
             graph_exec_id=graph_exec_id,
@@ -384,46 +376,31 @@ def validate_exec(
     if not node_block:
         return None, f"Block for {node.block_id} not found."
 
-    if isinstance(node_block, AgentExecutorBlock):
-        # Validate the execution metadata for the agent executor block.
-        try:
-            exec_data = AgentExecutorBlock.Input(**node.input_default)
-        except Exception as e:
-            return None, f"Input data doesn't match {node_block.name}: {str(e)}"
-
-        # Validation input
-        input_schema = exec_data.input_schema
-        required_fields = set(input_schema["required"])
-        input_default = exec_data.data
-    else:
-        # Convert non-matching data types to the expected input schema.
-        for name, data_type in node_block.input_schema.__annotations__.items():
-            if (value := data.get(name)) and (type(value) is not data_type):
-                data[name] = convert(value, data_type)
-
-        # Validation input
-        input_schema = node_block.input_schema.jsonschema()
-        required_fields = node_block.input_schema.get_required_fields()
-        input_default = node.input_default
+    error_prefix = f"Input data missing for {node_block.name}:"
 
     # Input data (without default values) should contain all required fields.
-    error_prefix = f"Input data missing or mismatch for `{node_block.name}`:"
     input_fields_from_nodes = {link.sink_name for link in node.input_links}
     if not input_fields_from_nodes.issubset(data):
         return None, f"{error_prefix} {input_fields_from_nodes - set(data)}"
 
     # Merge input data with default values and resolve dynamic dict/list/object pins.
-    data = {**input_default, **data}
+    data = {**node.input_default, **data}
     if resolve_input:
         data = merge_execution_input(data)
 
     # Input data post-merge should contain all required fields from the schema.
-    if not required_fields.issubset(data):
-        return None, f"{error_prefix} {required_fields - set(data)}"
+    input_fields_from_schema = node_block.input_schema.get_required_fields()
+    if not input_fields_from_schema.issubset(data):
+        return None, f"{error_prefix} {input_fields_from_schema - set(data)}"
+
+    # Convert non-matching data types to the expected input schema.
+    for name, data_type in node_block.input_schema.__annotations__.items():
+        if (value := data.get(name)) and (type(value) is not data_type):
+            data[name] = convert(value, data_type)
 
     # Last validation: Validate the input values against the schema.
-    if error := json.validate_with_jsonschema(schema=input_schema, data=data):
-        error_message = f"{error_prefix} {error}"
+    if error := node_block.input_schema.validate_data(data):
+        error_message = f"Input data doesn't match {node_block.name}: {error}"
         logger.error(error_message)
         return None, error_message
 
@@ -595,11 +572,10 @@ class Executor:
         exec_stats["walltime"] = timing_info.wall_time
         exec_stats["cputime"] = timing_info.cpu_time
         exec_stats["error"] = str(error) if error else None
-        result = cls.db_client.update_graph_execution_stats(
+        cls.db_client.update_graph_execution_stats(
             graph_exec_id=graph_exec.graph_exec_id,
             stats=exec_stats,
         )
-        cls.db_client.send_execution_update(result)
 
     @classmethod
     @time_measured
@@ -712,6 +688,7 @@ class Executor:
 
 
 class ExecutionManager(AppService):
+
     def __init__(self):
         super().__init__()
         self.use_redis = True
@@ -725,9 +702,13 @@ class ExecutionManager(AppService):
         return settings.config.execution_manager_port
 
     def run_service(self):
-        from backend.integrations.credentials_store import IntegrationCredentialsStore
+        from autogpt_libs.supabase_integration_credentials_store import (
+            SupabaseIntegrationCredentialsStore,
+        )
 
-        self.credentials_store = IntegrationCredentialsStore()
+        self.credentials_store = SupabaseIntegrationCredentialsStore(
+            redis=redis.get_redis()
+        )
         self.executor = ProcessPoolExecutor(
             max_workers=self.pool_size,
             initializer=Executor.on_graph_executor_start,
@@ -748,7 +729,7 @@ class ExecutionManager(AppService):
             )
             self.active_graph_runs[graph_exec_id] = (future, cancel_event)
             future.add_done_callback(
-                lambda _: self.active_graph_runs.pop(graph_exec_id, None)
+                lambda _: self.active_graph_runs.pop(graph_exec_id)
             )
 
     def cleanup(self):
@@ -763,17 +744,11 @@ class ExecutionManager(AppService):
 
     @expose
     def add_execution(
-        self,
-        graph_id: str,
-        data: BlockInput,
-        user_id: str,
-        graph_version: int | None = None,
-    ) -> GraphExecution:
-        graph: GraphModel | None = self.db_client.get_graph(
-            graph_id=graph_id, user_id=user_id, version=graph_version
-        )
+        self, graph_id: str, data: BlockInput, user_id: str
+    ) -> dict[str, Any]:
+        graph: Graph | None = self.db_client.get_graph(graph_id, user_id=user_id)
         if not graph:
-            raise ValueError(f"Graph #{graph_id} not found.")
+            raise Exception(f"Graph #{graph_id} not found.")
 
         graph.validate_graph(for_run=True)
         self._validate_node_input_credentials(graph, user_id)
@@ -793,18 +768,9 @@ class ExecutionManager(AppService):
                 if name and name in data:
                     input_data = {"value": data[name]}
 
-            # Extract webhook payload, and assign it to the input pin
-            webhook_payload_key = f"webhook_{node.webhook_id}_payload"
-            if (
-                block.block_type == BlockType.WEBHOOK
-                and node.webhook_id
-                and webhook_payload_key in data
-            ):
-                input_data = {"payload": data[webhook_payload_key]}
-
             input_data, error = validate_exec(node, input_data)
             if input_data is None:
-                raise ValueError(error)
+                raise Exception(error)
             else:
                 nodes_input.append((node.id, input_data))
 
@@ -830,7 +796,7 @@ class ExecutionManager(AppService):
             exec_update = self.db_client.update_execution_status(
                 node_exec.node_exec_id, ExecutionStatus.QUEUED, node_exec.input_data
             )
-            self.db_client.send_execution_update(exec_update)
+            self.db_client.send_execution_update(exec_update.model_dump())
 
         graph_exec = GraphExecution(
             user_id=user_id,
@@ -840,7 +806,7 @@ class ExecutionManager(AppService):
         )
         self.queue.add(graph_exec)
 
-        return graph_exec
+        return graph_exec.model_dump()
 
     @expose
     def cancel_execution(self, graph_exec_id: str) -> None:
@@ -877,9 +843,9 @@ class ExecutionManager(AppService):
                 exec_update = self.db_client.update_execution_status(
                     node_exec.node_exec_id, ExecutionStatus.FAILED
                 )
-                self.db_client.send_execution_update(exec_update)
+                self.db_client.send_execution_update(exec_update.model_dump())
 
-    def _validate_node_input_credentials(self, graph: GraphModel, user_id: str):
+    def _validate_node_input_credentials(self, graph: Graph, user_id: str):
         """Checks all credentials for all nodes of the graph"""
 
         for node in graph.nodes:

autogpt_platform/backend/backend/executor/scheduler.py

@@ -1,103 +1,41 @@
 import logging
-import os
-from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
+import time
+from datetime import datetime
 
-from apscheduler.events import EVENT_JOB_ERROR, EVENT_JOB_EXECUTED
-from apscheduler.job import Job as JobObj
-from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
-from apscheduler.schedulers.blocking import BlockingScheduler
+from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.cron import CronTrigger
 from autogpt_libs.utils.cache import thread_cached
-from dotenv import load_dotenv
-from pydantic import BaseModel
-from sqlalchemy import MetaData, create_engine
 
 from backend.data.block import BlockInput
+from backend.data.schedule import (
+    ExecutionSchedule,
+    add_schedule,
+    get_active_schedules,
+    get_schedules,
+    update_schedule,
+)
 from backend.executor.manager import ExecutionManager
 from backend.util.service import AppService, expose, get_service_client
 from backend.util.settings import Config
 
-
-def _extract_schema_from_url(database_url) -> tuple[str, str]:
-    """
-    Extracts the schema from the DATABASE_URL and returns the schema and cleaned URL.
-    """
-    parsed_url = urlparse(database_url)
-    query_params = parse_qs(parsed_url.query)
-
-    # Extract the 'schema' parameter
-    schema_list = query_params.pop("schema", None)
-    schema = schema_list[0] if schema_list else "public"
-
-    # Reconstruct the query string without the 'schema' parameter
-    new_query = urlencode(query_params, doseq=True)
-    new_parsed_url = parsed_url._replace(query=new_query)
-    database_url_clean = str(urlunparse(new_parsed_url))
-
-    return schema, database_url_clean
-
-
 logger = logging.getLogger(__name__)
-config = Config()
 
 
 def log(msg, **kwargs):
-    logger.info("[ExecutionScheduler] " + msg, **kwargs)
-
-
-def job_listener(event):
-    """Logs job execution outcomes for better monitoring."""
-    if event.exception:
-        log(f"Job {event.job_id} failed.")
-    else:
-        log(f"Job {event.job_id} completed successfully.")
-
-
-@thread_cached
-def get_execution_client() -> ExecutionManager:
-    return get_service_client(ExecutionManager)
-
-
-def execute_graph(**kwargs):
-    args = JobArgs(**kwargs)
-    try:
-        log(f"Executing recurring job for graph #{args.graph_id}")
-        get_execution_client().add_execution(
-            args.graph_id, args.input_data, args.user_id
-        )
-    except Exception as e:
-        logger.exception(f"Error executing graph {args.graph_id}: {e}")
-
-
-class JobArgs(BaseModel):
-    graph_id: str
-    input_data: BlockInput
-    user_id: str
-    graph_version: int
-    cron: str
-
-
-class JobInfo(JobArgs):
-    id: str
-    name: str
-    next_run_time: str
-
-    @staticmethod
-    def from_db(job_args: JobArgs, job_obj: JobObj) -> "JobInfo":
-        return JobInfo(
-            id=job_obj.id,
-            name=job_obj.name,
-            next_run_time=job_obj.next_run_time.isoformat(),
-            **job_args.model_dump(),
-        )
+    logger.warning("[ExecutionScheduler] " + msg, **kwargs)
 
 
 class ExecutionScheduler(AppService):
-    scheduler: BlockingScheduler
+
+    def __init__(self, refresh_interval=10):
+        super().__init__()
+        self.use_db = True
+        self.last_check = datetime.min
+        self.refresh_interval = refresh_interval
 
     @classmethod
     def get_port(cls) -> int:
-        return config.execution_scheduler_port
+        return Config().execution_scheduler_port
 
     @property
     @thread_cached
@@ -105,18 +43,43 @@ class ExecutionScheduler(AppService):
         return get_service_client(ExecutionManager)
 
     def run_service(self):
-        load_dotenv()
-        db_schema, db_url = _extract_schema_from_url(os.getenv("DATABASE_URL"))
-        self.scheduler = BlockingScheduler(
-            jobstores={
-                "default": SQLAlchemyJobStore(
-                    engine=create_engine(db_url),
-                    metadata=MetaData(schema=db_schema),
-                )
-            }
-        )
-        self.scheduler.add_listener(job_listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)
-        self.scheduler.start()
+        scheduler = BackgroundScheduler()
+        scheduler.start()
+        while True:
+            self.__refresh_jobs_from_db(scheduler)
+            time.sleep(self.refresh_interval)
+
+    def __refresh_jobs_from_db(self, scheduler: BackgroundScheduler):
+        schedules = self.run_and_wait(get_active_schedules(self.last_check))
+        for schedule in schedules:
+            if schedule.last_updated:
+                self.last_check = max(self.last_check, schedule.last_updated)
+
+            if not schedule.is_enabled:
+                log(f"Removing recurring job {schedule.id}: {schedule.schedule}")
+                scheduler.remove_job(schedule.id)
+                continue
+
+            log(f"Adding recurring job {schedule.id}: {schedule.schedule}")
+            scheduler.add_job(
+                self.__execute_graph,
+                CronTrigger.from_crontab(schedule.schedule),
+                id=schedule.id,
+                args=[schedule.graph_id, schedule.input_data, schedule.user_id],
+                replace_existing=True,
+            )
+
+    def __execute_graph(self, graph_id: str, input_data: dict, user_id: str):
+        try:
+            log(f"Executing recurring job for graph #{graph_id}")
+            self.execution_client.add_execution(graph_id, input_data, user_id)
+        except Exception as e:
+            logger.exception(f"Error executing graph {graph_id}: {e}")
+
+    @expose
+    def update_schedule(self, schedule_id: str, is_enabled: bool, user_id: str) -> str:
+        self.run_and_wait(update_schedule(schedule_id, is_enabled, user_id))
+        return schedule_id
 
     @expose
     def add_execution_schedule(
@@ -126,50 +89,17 @@ class ExecutionScheduler(AppService):
         cron: str,
         input_data: BlockInput,
         user_id: str,
-    ) -> JobInfo:
-        job_args = JobArgs(
+    ) -> str:
+        schedule = ExecutionSchedule(
             graph_id=graph_id,
-            input_data=input_data,
             user_id=user_id,
             graph_version=graph_version,
-            cron=cron,
+            schedule=cron,
+            input_data=input_data,
         )
-        job = self.scheduler.add_job(
-            execute_graph,
-            CronTrigger.from_crontab(cron),
-            kwargs=job_args.model_dump(),
-            replace_existing=True,
-        )
-        log(f"Added job {job.id} with cron schedule '{cron}' input data: {input_data}")
-        return JobInfo.from_db(job_args, job)
+        return self.run_and_wait(add_schedule(schedule)).id
 
     @expose
-    def delete_schedule(self, schedule_id: str, user_id: str) -> JobInfo:
-        job = self.scheduler.get_job(schedule_id)
-        if not job:
-            log(f"Job {schedule_id} not found.")
-            raise ValueError(f"Job #{schedule_id} not found.")
-
-        job_args = JobArgs(**job.kwargs)
-        if job_args.user_id != user_id:
-            raise ValueError("User ID does not match the job's user ID.")
-
-        log(f"Deleting job {schedule_id}")
-        job.remove()
-
-        return JobInfo.from_db(job_args, job)
-
-    @expose
-    def get_execution_schedules(
-        self, graph_id: str | None = None, user_id: str | None = None
-    ) -> list[JobInfo]:
-        schedules = []
-        for job in self.scheduler.get_jobs():
-            job_args = JobArgs(**job.kwargs)
-            if (
-                job.next_run_time is not None
-                and (graph_id is None or job_args.graph_id == graph_id)
-                and (user_id is None or job_args.user_id == user_id)
-            ):
-                schedules.append(JobInfo.from_db(job_args, job))
-        return schedules
+    def get_execution_schedules(self, graph_id: str, user_id: str) -> dict[str, str]:
+        schedules = self.run_and_wait(get_schedules(graph_id, user_id=user_id))
+        return {v.id: v.schedule for v in schedules}

autogpt_platform/backend/backend/integrations/creds_manager.py

@@ -2,14 +2,15 @@ import logging
 from contextlib import contextmanager
 from datetime import datetime
 
+from autogpt_libs.supabase_integration_credentials_store import (
+    Credentials,
+    SupabaseIntegrationCredentialsStore,
+)
 from autogpt_libs.utils.synchronize import RedisKeyedMutex
 from redis.lock import Lock as RedisLock
 
 from backend.data import redis
-from backend.data.model import Credentials
-from backend.integrations.credentials_store import IntegrationCredentialsStore
 from backend.integrations.oauth import HANDLERS_BY_NAME, BaseOAuthHandler
-from backend.util.exceptions import MissingConfigError
 from backend.util.settings import Settings
 
 logger = logging.getLogger(__name__)
@@ -51,7 +52,7 @@ class IntegrationCredentialsManager:
     def __init__(self):
         redis_conn = redis.get_redis()
         self._locks = RedisKeyedMutex(redis_conn)
-        self.store = IntegrationCredentialsStore()
+        self.store = SupabaseIntegrationCredentialsStore(redis=redis_conn)
 
     def create(self, user_id: str, credentials: Credentials) -> None:
         return self.store.add_creds(user_id, credentials)
@@ -128,6 +129,7 @@ class IntegrationCredentialsManager:
 
     def _acquire_lock(self, user_id: str, credentials_id: str, *args: str) -> RedisLock:
         key = (
+            self.store.db_manager,
             f"user:{user_id}",
             f"credentials:{credentials_id}",
             *args,
@@ -155,14 +157,12 @@ def _get_provider_oauth_handler(provider_name: str) -> BaseOAuthHandler:
     client_id = getattr(settings.secrets, f"{provider_name}_client_id")
     client_secret = getattr(settings.secrets, f"{provider_name}_client_secret")
     if not (client_id and client_secret):
-        raise MissingConfigError(
+        raise Exception(  # TODO: ConfigError
             f"Integration with provider '{provider_name}' is not configured",
         )
 
     handler_class = HANDLERS_BY_NAME[provider_name]
-    frontend_base_url = (
-        settings.config.frontend_base_url or settings.config.platform_base_url
-    )
+    frontend_base_url = settings.config.frontend_base_url
     return handler_class(
         client_id=client_id,
         client_secret=client_secret,

autogpt_platform/backend/backend/integrations/oauth/base.py

@@ -3,7 +3,7 @@ import time
 from abc import ABC, abstractmethod
 from typing import ClassVar
 
-from backend.data.model import OAuth2Credentials
+from autogpt_libs.supabase_integration_credentials_store import OAuth2Credentials
 
 logger = logging.getLogger(__name__)
 

autogpt_platform/backend/backend/integrations/oauth/github.py

@@ -2,7 +2,8 @@ import time
 from typing import Optional
 from urllib.parse import urlencode
 
-from backend.data.model import OAuth2Credentials
+from autogpt_libs.supabase_integration_credentials_store import OAuth2Credentials
+
 from backend.util.request import requests
 
 from .base import BaseOAuthHandler

autogpt_platform/backend/backend/integrations/oauth/google.py

@@ -1,5 +1,6 @@
 import logging
 
+from autogpt_libs.supabase_integration_credentials_store import OAuth2Credentials
 from google.auth.external_account_authorized_user import (
     Credentials as ExternalAccountCredentials,
 )
@@ -8,8 +9,6 @@ from google.oauth2.credentials import Credentials
 from google_auth_oauthlib.flow import Flow
 from pydantic import SecretStr
 
-from backend.data.model import OAuth2Credentials
-
 from .base import BaseOAuthHandler
 
 logger = logging.getLogger(__name__)

autogpt_platform/backend/backend/integrations/oauth/notion.py

@@ -1,7 +1,8 @@
 from base64 import b64encode
 from urllib.parse import urlencode
 
-from backend.data.model import OAuth2Credentials
+from autogpt_libs.supabase_integration_credentials_store import OAuth2Credentials
+
 from backend.util.request import requests
 
 from .base import BaseOAuthHandler

autogpt_platform/backend/backend/integrations/providers.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-
-class ProviderName(str, Enum):
-    GITHUB = "github"
-    GOOGLE = "google"
-    NOTION = "notion"

autogpt_platform/backend/backend/integrations/webhooks/__init__.py

@@ -1,17 +0,0 @@
-from typing import TYPE_CHECKING
-
-from .github import GithubWebhooksManager
-
-if TYPE_CHECKING:
-    from .base import BaseWebhooksManager
-
-# --8<-- [start:WEBHOOK_MANAGERS_BY_NAME]
-WEBHOOK_MANAGERS_BY_NAME: dict[str, type["BaseWebhooksManager"]] = {
-    handler.PROVIDER_NAME: handler
-    for handler in [
-        GithubWebhooksManager,
-    ]
-}
-# --8<-- [end:WEBHOOK_MANAGERS_BY_NAME]
-
-__all__ = ["WEBHOOK_MANAGERS_BY_NAME"]

autogpt_platform/backend/backend/integrations/webhooks/base.py

@@ -1,163 +0,0 @@
-import logging
-import secrets
-from abc import ABC, abstractmethod
-from typing import ClassVar, Generic, TypeVar
-from uuid import uuid4
-
-from fastapi import Request
-from strenum import StrEnum
-
-from backend.data import integrations
-from backend.data.model import Credentials
-from backend.util.exceptions import MissingConfigError
-from backend.util.settings import Config
-
-logger = logging.getLogger(__name__)
-app_config = Config()
-
-WT = TypeVar("WT", bound=StrEnum)
-
-
-class BaseWebhooksManager(ABC, Generic[WT]):
-    # --8<-- [start:BaseWebhooksManager1]
-    PROVIDER_NAME: ClassVar[str]
-    # --8<-- [end:BaseWebhooksManager1]
-
-    WebhookType: WT
-
-    async def get_suitable_webhook(
-        self,
-        user_id: str,
-        credentials: Credentials,
-        webhook_type: WT,
-        resource: str,
-        events: list[str],
-    ) -> integrations.Webhook:
-        if not app_config.platform_base_url:
-            raise MissingConfigError(
-                "PLATFORM_BASE_URL must be set to use Webhook functionality"
-            )
-
-        if webhook := await integrations.find_webhook(
-            credentials.id, webhook_type, resource, events
-        ):
-            return webhook
-        return await self._create_webhook(
-            user_id, credentials, webhook_type, resource, events
-        )
-
-    async def prune_webhook_if_dangling(
-        self, webhook_id: str, credentials: Credentials
-    ) -> bool:
-        webhook = await integrations.get_webhook(webhook_id)
-        if webhook.attached_nodes is None:
-            raise ValueError("Error retrieving webhook including attached nodes")
-        if webhook.attached_nodes:
-            # Don't prune webhook if in use
-            return False
-
-        await self._deregister_webhook(webhook, credentials)
-        await integrations.delete_webhook(webhook.id)
-        return True
-
-    # --8<-- [start:BaseWebhooksManager3]
-    @classmethod
-    @abstractmethod
-    async def validate_payload(
-        cls, webhook: integrations.Webhook, request: Request
-    ) -> tuple[dict, str]:
-        """
-        Validates an incoming webhook request and returns its payload and type.
-
-        Params:
-            webhook: Object representing the configured webhook and its properties in our system.
-            request: Incoming FastAPI `Request`
-
-        Returns:
-            dict: The validated payload
-            str: The event type associated with the payload
-        """
-
-    # --8<-- [end:BaseWebhooksManager3]
-
-    # --8<-- [start:BaseWebhooksManager5]
-    async def trigger_ping(self, webhook: integrations.Webhook) -> None:
-        """
-        Triggers a ping to the given webhook.
-
-        Raises:
-            NotImplementedError: if the provider doesn't support pinging
-        """
-        # --8<-- [end:BaseWebhooksManager5]
-        raise NotImplementedError(f"{self.__class__.__name__} doesn't support pinging")
-
-    # --8<-- [start:BaseWebhooksManager2]
-    @abstractmethod
-    async def _register_webhook(
-        self,
-        credentials: Credentials,
-        webhook_type: WT,
-        resource: str,
-        events: list[str],
-        ingress_url: str,
-        secret: str,
-    ) -> tuple[str, dict]:
-        """
-        Registers a new webhook with the provider.
-
-        Params:
-            credentials: The credentials with which to create the webhook
-            webhook_type: The provider-specific webhook type to create
-            resource: The resource to receive events for
-            events: The events to subscribe to
-            ingress_url: The ingress URL for webhook payloads
-            secret: Secret used to verify webhook payloads
-
-        Returns:
-            str: Webhook ID assigned by the provider
-            config: Provider-specific configuration for the webhook
-        """
-        ...
-
-    # --8<-- [end:BaseWebhooksManager2]
-
-    # --8<-- [start:BaseWebhooksManager4]
-    @abstractmethod
-    async def _deregister_webhook(
-        self, webhook: integrations.Webhook, credentials: Credentials
-    ) -> None: ...
-
-    # --8<-- [end:BaseWebhooksManager4]
-
-    async def _create_webhook(
-        self,
-        user_id: str,
-        credentials: Credentials,
-        webhook_type: WT,
-        resource: str,
-        events: list[str],
-    ) -> integrations.Webhook:
-        id = str(uuid4())
-        secret = secrets.token_hex(32)
-        provider_name = self.PROVIDER_NAME
-        ingress_url = (
-            f"{app_config.platform_base_url}/api/integrations/{provider_name}"
-            f"/webhooks/{id}/ingress"
-        )
-        provider_webhook_id, config = await self._register_webhook(
-            credentials, webhook_type, resource, events, ingress_url, secret
-        )
-        return await integrations.create_webhook(
-            integrations.Webhook(
-                id=id,
-                user_id=user_id,
-                provider=provider_name,
-                credentials_id=credentials.id,
-                webhook_type=webhook_type,
-                resource=resource,
-                events=events,
-                provider_webhook_id=provider_webhook_id,
-                config=config,
-                secret=secret,
-            )
-        )

autogpt_platform/backend/backend/integrations/webhooks/github.py

@@ -1,175 +0,0 @@
-import hashlib
-import hmac
-import logging
-
-import requests
-from fastapi import HTTPException, Request
-from strenum import StrEnum
-
-from backend.data import integrations
-from backend.data.model import Credentials
-
-from .base import BaseWebhooksManager
-
-logger = logging.getLogger(__name__)
-
-
-# --8<-- [start:GithubWebhooksManager]
-class GithubWebhookType(StrEnum):
-    REPO = "repo"
-
-
-class GithubWebhooksManager(BaseWebhooksManager):
-    PROVIDER_NAME = "github"
-
-    WebhookType = GithubWebhookType
-
-    GITHUB_API_URL = "https://api.github.com"
-    GITHUB_API_DEFAULT_HEADERS = {"Accept": "application/vnd.github.v3+json"}
-
-    @classmethod
-    async def validate_payload(
-        cls, webhook: integrations.Webhook, request: Request
-    ) -> tuple[dict, str]:
-        if not (event_type := request.headers.get("X-GitHub-Event")):
-            raise HTTPException(
-                status_code=400, detail="X-GitHub-Event header is missing!"
-            )
-
-        if not (signature_header := request.headers.get("X-Hub-Signature-256")):
-            raise HTTPException(
-                status_code=403, detail="X-Hub-Signature-256 header is missing!"
-            )
-
-        payload_body = await request.body()
-        hash_object = hmac.new(
-            webhook.secret.encode("utf-8"), msg=payload_body, digestmod=hashlib.sha256
-        )
-        expected_signature = "sha256=" + hash_object.hexdigest()
-
-        if not hmac.compare_digest(expected_signature, signature_header):
-            raise HTTPException(
-                status_code=403, detail="Request signatures didn't match!"
-            )
-
-        payload = await request.json()
-        if action := payload.get("action"):
-            event_type += f".{action}"
-
-        return payload, event_type
-
-    async def trigger_ping(self, webhook: integrations.Webhook) -> None:
-        headers = {
-            **self.GITHUB_API_DEFAULT_HEADERS,
-            "Authorization": f"Bearer {webhook.config.get('access_token')}",
-        }
-
-        repo, github_hook_id = webhook.resource, webhook.provider_webhook_id
-        ping_url = f"{self.GITHUB_API_URL}/repos/{repo}/hooks/{github_hook_id}/pings"
-
-        response = requests.post(ping_url, headers=headers)
-
-        if response.status_code != 204:
-            error_msg = extract_github_error_msg(response)
-            raise ValueError(f"Failed to ping GitHub webhook: {error_msg}")
-
-    async def _register_webhook(
-        self,
-        credentials: Credentials,
-        webhook_type: GithubWebhookType,
-        resource: str,
-        events: list[str],
-        ingress_url: str,
-        secret: str,
-    ) -> tuple[str, dict]:
-        if webhook_type == self.WebhookType.REPO and resource.count("/") > 1:
-            raise ValueError("Invalid repo format: expected 'owner/repo'")
-
-        # Extract main event, e.g. `pull_request.opened` -> `pull_request`
-        github_events = list({event.split(".")[0] for event in events})
-
-        headers = {
-            **self.GITHUB_API_DEFAULT_HEADERS,
-            "Authorization": credentials.bearer(),
-        }
-        webhook_data = {
-            "name": "web",
-            "active": True,
-            "events": github_events,
-            "config": {
-                "url": ingress_url,
-                "content_type": "json",
-                "insecure_ssl": "0",
-                "secret": secret,
-            },
-        }
-
-        response = requests.post(
-            f"{self.GITHUB_API_URL}/repos/{resource}/hooks",
-            headers=headers,
-            json=webhook_data,
-        )
-
-        if response.status_code != 201:
-            error_msg = extract_github_error_msg(response)
-            if "not found" in error_msg.lower():
-                error_msg = (
-                    f"{error_msg} "
-                    "(Make sure the GitHub account or API key has 'repo' or "
-                    f"webhook create permissions to '{resource}')"
-                )
-            raise ValueError(f"Failed to create GitHub webhook: {error_msg}")
-
-        webhook_id = response.json()["id"]
-        config = response.json()["config"]
-
-        return str(webhook_id), config
-
-    async def _deregister_webhook(
-        self, webhook: integrations.Webhook, credentials: Credentials
-    ) -> None:
-        webhook_type = self.WebhookType(webhook.webhook_type)
-        if webhook.credentials_id != credentials.id:
-            raise ValueError(
-                f"Webhook #{webhook.id} does not belong to credentials {credentials.id}"
-            )
-
-        headers = {
-            **self.GITHUB_API_DEFAULT_HEADERS,
-            "Authorization": credentials.bearer(),
-        }
-
-        if webhook_type == self.WebhookType.REPO:
-            repo = webhook.resource
-            delete_url = f"{self.GITHUB_API_URL}/repos/{repo}/hooks/{webhook.provider_webhook_id}"  # noqa
-        else:
-            raise NotImplementedError(
-                f"Unsupported webhook type '{webhook.webhook_type}'"
-            )
-
-        response = requests.delete(delete_url, headers=headers)
-
-        if response.status_code not in [204, 404]:
-            # 204 means successful deletion, 404 means the webhook was already deleted
-            error_msg = extract_github_error_msg(response)
-            raise ValueError(f"Failed to delete GitHub webhook: {error_msg}")
-
-        # If we reach here, the webhook was successfully deleted or didn't exist
-
-
-# --8<-- [end:GithubWebhooksManager]
-
-
-def extract_github_error_msg(response: requests.Response) -> str:
-    error_msgs = []
-    resp = response.json()
-    if resp.get("message"):
-        error_msgs.append(resp["message"])
-    if resp.get("errors"):
-        error_msgs.extend(f"* {err.get('message', err)}" for err in resp["errors"])
-    if resp.get("error"):
-        if isinstance(resp["error"], dict):
-            error_msgs.append(resp["error"].get("message", resp["error"]))
-        else:
-            error_msgs.append(resp["error"])
-    return "\n".join(error_msgs)

autogpt_platform/backend/backend/integrations/webhooks/graph_lifecycle_hooks.py

@@ -1,197 +0,0 @@
-import logging
-from typing import TYPE_CHECKING, Callable, Optional, cast
-
-from backend.data.block import get_block
-from backend.data.graph import set_node_webhook
-from backend.data.model import CREDENTIALS_FIELD_NAME
-from backend.integrations.webhooks import WEBHOOK_MANAGERS_BY_NAME
-
-if TYPE_CHECKING:
-    from backend.data.graph import GraphModel, NodeModel
-    from backend.data.model import Credentials
-
-    from .base import BaseWebhooksManager
-
-logger = logging.getLogger(__name__)
-
-
-async def on_graph_activate(
-    graph: "GraphModel", get_credentials: Callable[[str], "Credentials | None"]
-):
-    """
-    Hook to be called when a graph is activated/created.
-
-    ⚠️ Assuming node entities are not re-used between graph versions, ⚠️
-    this hook calls `on_node_activate` on all nodes in this graph.
-
-    Params:
-        get_credentials: `credentials_id` -> Credentials
-    """
-    # Compare nodes in new_graph_version with previous_graph_version
-    updated_nodes = []
-    for new_node in graph.nodes:
-        node_credentials = None
-        if creds_meta := new_node.input_default.get(CREDENTIALS_FIELD_NAME):
-            node_credentials = get_credentials(creds_meta["id"])
-            if not node_credentials:
-                raise ValueError(
-                    f"Node #{new_node.id} updated with non-existent "
-                    f"credentials #{node_credentials}"
-                )
-
-        updated_node = await on_node_activate(
-            graph.user_id, new_node, credentials=node_credentials
-        )
-        updated_nodes.append(updated_node)
-
-    graph.nodes = updated_nodes
-    return graph
-
-
-async def on_graph_deactivate(
-    graph: "GraphModel", get_credentials: Callable[[str], "Credentials | None"]
-):
-    """
-    Hook to be called when a graph is deactivated/deleted.
-
-    ⚠️ Assuming node entities are not re-used between graph versions, ⚠️
-    this hook calls `on_node_deactivate` on all nodes in `graph`.
-
-    Params:
-        get_credentials: `credentials_id` -> Credentials
-    """
-    updated_nodes = []
-    for node in graph.nodes:
-        node_credentials = None
-        if creds_meta := node.input_default.get(CREDENTIALS_FIELD_NAME):
-            node_credentials = get_credentials(creds_meta["id"])
-            if not node_credentials:
-                logger.error(
-                    f"Node #{node.id} referenced non-existent "
-                    f"credentials #{creds_meta['id']}"
-                )
-
-        updated_node = await on_node_deactivate(node, credentials=node_credentials)
-        updated_nodes.append(updated_node)
-
-    graph.nodes = updated_nodes
-    return graph
-
-
-async def on_node_activate(
-    user_id: str,
-    node: "NodeModel",
-    *,
-    credentials: Optional["Credentials"] = None,
-) -> "NodeModel":
-    """Hook to be called when the node is activated/created"""
-
-    block = get_block(node.block_id)
-    if not block:
-        raise ValueError(
-            f"Node #{node.id} is instance of unknown block #{node.block_id}"
-        )
-
-    if not block.webhook_config:
-        return node
-
-    logger.debug(
-        f"Activating webhook node #{node.id} with config {block.webhook_config}"
-    )
-
-    webhooks_manager = WEBHOOK_MANAGERS_BY_NAME[block.webhook_config.provider]()
-
-    try:
-        resource = block.webhook_config.resource_format.format(**node.input_default)
-    except KeyError:
-        resource = None
-    logger.debug(
-        f"Constructed resource string {resource} from input {node.input_default}"
-    )
-
-    event_filter_input_name = block.webhook_config.event_filter_input
-    has_everything_for_webhook = (
-        resource is not None
-        and CREDENTIALS_FIELD_NAME in node.input_default
-        and event_filter_input_name in node.input_default
-        and any(is_on for is_on in node.input_default[event_filter_input_name].values())
-    )
-
-    if has_everything_for_webhook and resource:
-        logger.debug(f"Node #{node} has everything for a webhook!")
-        if not credentials:
-            credentials_meta = node.input_default[CREDENTIALS_FIELD_NAME]
-            raise ValueError(
-                f"Cannot set up webhook for node #{node.id}: "
-                f"credentials #{credentials_meta['id']} not available"
-            )
-
-        # Shape of the event filter is enforced in Block.__init__
-        event_filter = cast(dict, node.input_default[event_filter_input_name])
-        events = [
-            block.webhook_config.event_format.format(event=event)
-            for event, enabled in event_filter.items()
-            if enabled is True
-        ]
-        logger.debug(f"Webhook events to subscribe to: {', '.join(events)}")
-
-        # Find/make and attach a suitable webhook to the node
-        new_webhook = await webhooks_manager.get_suitable_webhook(
-            user_id,
-            credentials,
-            block.webhook_config.webhook_type,
-            resource,
-            events,
-        )
-        logger.debug(f"Acquired webhook: {new_webhook}")
-        return await set_node_webhook(node.id, new_webhook.id)
-
-    return node
-
-
-async def on_node_deactivate(
-    node: "NodeModel",
-    *,
-    credentials: Optional["Credentials"] = None,
-    webhooks_manager: Optional["BaseWebhooksManager"] = None,
-) -> "NodeModel":
-    """Hook to be called when node is deactivated/deleted"""
-
-    logger.debug(f"Deactivating node #{node.id}")
-    block = get_block(node.block_id)
-    if not block:
-        raise ValueError(
-            f"Node #{node.id} is instance of unknown block #{node.block_id}"
-        )
-
-    if not block.webhook_config:
-        return node
-
-    webhooks_manager = WEBHOOK_MANAGERS_BY_NAME[block.webhook_config.provider]()
-
-    if node.webhook_id:
-        logger.debug(f"Node #{node.id} has webhook_id {node.webhook_id}")
-        if not node.webhook:
-            logger.error(f"Node #{node.id} has webhook_id but no webhook object")
-            raise ValueError("node.webhook not included")
-
-        # Detach webhook from node
-        logger.debug(f"Detaching webhook from node #{node.id}")
-        updated_node = await set_node_webhook(node.id, None)
-
-        # Prune and deregister the webhook if it is no longer used anywhere
-        logger.debug("Pruning and deregistering webhook if dangling")
-        webhook = node.webhook
-        if credentials:
-            logger.debug(f"Pruning webhook #{webhook.id} with credentials")
-            await webhooks_manager.prune_webhook_if_dangling(webhook.id, credentials)
-        else:
-            logger.warning(
-                f"Cannot deregister webhook #{webhook.id}: credentials "
-                f"#{webhook.credentials_id} not available "
-                f"({webhook.provider} webhook ID: {webhook.provider_webhook_id})"
-            )
-        return updated_node
-
-    logger.debug(f"Node #{node.id} has no webhook_id, returning")
-    return node