style(classic): update black to 24.10.0 and reformat

Update black version to match pre-commit hook (24.10.0) and reformat
all files with the new version.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

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

@@ -6,11 +6,15 @@ on:
     paths:
       - '.github/workflows/classic-autogpt-ci.yml'
       - 'classic/original_autogpt/**'
+      - 'classic/direct_benchmark/**'
+      - 'classic/forge/**'
   pull_request:
     branches: [ master, dev, release-* ]
     paths:
       - '.github/workflows/classic-autogpt-ci.yml'
       - 'classic/original_autogpt/**'
+      - 'classic/direct_benchmark/**'
+      - 'classic/forge/**'
 
 concurrency:
   group: ${{ format('classic-autogpt-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
@@ -19,47 +23,22 @@ concurrency:
 defaults:
   run:
     shell: bash
-    working-directory: classic/original_autogpt
+    working-directory: classic
 
 jobs:
   test:
     permissions:
       contents: read
     timeout-minutes: 30
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.10"]
-        platform-os: [ubuntu, macos, macos-arm64, windows]
-    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
+    runs-on: ubuntu-latest
 
     steps:
-      # Quite slow on macOS (2~4 minutes to set up Docker)
-      # - name: Set up Docker (macOS)
-      #   if: runner.os == 'macOS'
-      #   uses: crazy-max/ghaction-setup-docker@v3
-
-      - name: Start MinIO service (Linux)
-        if: runner.os == 'Linux'
+      - name: Start MinIO service
         working-directory: '.'
         run: |
           docker pull minio/minio:edge-cicd
           docker run -d -p 9000:9000 minio/minio:edge-cicd
 
-      - name: Start MinIO service (macOS)
-        if: runner.os == 'macOS'
-        working-directory: ${{ runner.temp }}
-        run: |
-          brew install minio/stable/minio
-          mkdir data
-          minio server ./data &
-
-      # No MinIO on Windows:
-      # - Windows doesn't support running Linux Docker containers
-      # - It doesn't seem possible to start background processes on Windows. They are
-      #   killed after the step returns.
-      #   See: https://github.com/actions/runner/issues/598#issuecomment-2011890429
-
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
@@ -71,41 +50,23 @@ jobs:
           git config --global user.name "Auto-GPT-Bot"
           git config --global user.email "github-bot@agpt.co"
 
-      - name: Set up Python ${{ matrix.python-version }}
+      - name: Set up Python 3.12
         uses: actions/setup-python@v5
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version: "3.12"
 
       - id: get_date
         name: Get date
         run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
 
       - name: Set up Python dependency cache
-        # On Windows, unpacking cached dependencies takes longer than just installing them
-        if: runner.os != 'Windows'
         uses: actions/cache@v4
         with:
-          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/original_autogpt/poetry.lock') }}
+          path: ~/.cache/pypoetry
+          key: poetry-${{ runner.os }}-${{ hashFiles('classic/poetry.lock') }}
 
-      - name: Install Poetry (Unix)
-        if: runner.os != 'Windows'
-        run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-
-          if [ "${{ runner.os }}" = "macOS" ]; then
-            PATH="$HOME/.local/bin:$PATH"
-            echo "$HOME/.local/bin" >> $GITHUB_PATH
-          fi
-
-      - name: Install Poetry (Windows)
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
-
-          $env:PATH += ";$env:APPDATA\Python\Scripts"
-          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
+      - name: Install Poetry
+        run: curl -sSL https://install.python-poetry.org | python3 -
 
       - name: Install Python dependencies
         run: poetry install
@@ -116,12 +77,12 @@ jobs:
             --cov=autogpt --cov-branch --cov-report term-missing --cov-report xml \
             --numprocesses=logical --durations=10 \
             --junitxml=junit.xml -o junit_family=legacy \
-            tests/unit tests/integration
+            original_autogpt/tests/unit original_autogpt/tests/integration
         env:
           CI: true
           PLAIN_OUTPUT: True
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          S3_ENDPOINT_URL: ${{ runner.os != 'Windows' && 'http://127.0.0.1:9000' || '' }}
+          S3_ENDPOINT_URL: http://127.0.0.1:9000
           AWS_ACCESS_KEY_ID: minioadmin
           AWS_SECRET_ACCESS_KEY: minioadmin
 
@@ -135,11 +96,11 @@ jobs:
         uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
-          flags: autogpt-agent,${{ runner.os }}
+          flags: autogpt-agent
 
       - name: Upload logs to artifact
         if: always()
         uses: actions/upload-artifact@v4
         with:
           name: test-logs
-          path: classic/original_autogpt/logs/
+          path: classic/logs/

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

@@ -11,9 +11,6 @@ on:
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
       - 'classic/benchmark/**'
-      - 'classic/run'
-      - 'classic/cli.py'
-      - 'classic/setup.py'
       - '!**/*.md'
   pull_request:
     branches: [ master, dev, release-* ]
@@ -22,9 +19,6 @@ on:
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
       - 'classic/benchmark/**'
-      - 'classic/run'
-      - 'classic/cli.py'
-      - 'classic/setup.py'
       - '!**/*.md'
 
 defaults:
@@ -35,13 +29,9 @@ defaults:
 jobs:
   serve-agent-protocol:
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        agent-name: [ original_autogpt ]
-      fail-fast: false
     timeout-minutes: 20
     env:
-      min-python-version: '3.10'
+      min-python-version: '3.12'
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -55,22 +45,22 @@ jobs:
           python-version: ${{ env.min-python-version }}
 
       - name: Install Poetry
-        working-directory: ./classic/${{ matrix.agent-name }}/
         run: |
           curl -sSL https://install.python-poetry.org | python -
 
-      - name: Run regression tests
+      - name: Install dependencies
+        run: poetry install
+
+      - name: Run smoke tests with direct-benchmark
         run: |
-          ./run agent start ${{ matrix.agent-name }}
-          cd ${{ matrix.agent-name }}
-          poetry run agbenchmark --mock --test=BasicRetrieval --test=Battleship --test=WebArenaTask_0
-          poetry run agbenchmark --test=WriteFile
+          poetry run direct-benchmark run \
+            --strategies one_shot \
+            --models claude \
+            --tests ReadFile,WriteFile \
+            --json
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          AGENT_NAME: ${{ matrix.agent-name }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           REQUESTS_CA_BUNDLE: /etc/ssl/certs/ca-certificates.crt
-          HELICONE_CACHE_ENABLED: false
-          HELICONE_PROPERTY_AGENT: ${{ matrix.agent-name }}
-          REPORTS_FOLDER: ${{ format('../../reports/{0}', matrix.agent-name) }}
-          TELEMETRY_ENVIRONMENT: autogpt-ci
-          TELEMETRY_OPT_IN: ${{ github.ref_name == 'master' }}
+          NONINTERACTIVE_MODE: "true"
+          CI: true

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

@@ -1,17 +1,21 @@
-name: Classic - AGBenchmark CI
+name: Classic - Direct Benchmark CI
 
 on:
   push:
     branches: [ master, dev, ci-test* ]
     paths:
-      - 'classic/benchmark/**'
-      - '!classic/benchmark/reports/**'
+      - 'classic/direct_benchmark/**'
+      - 'classic/benchmark/agbenchmark/challenges/**'
+      - 'classic/original_autogpt/**'
+      - 'classic/forge/**'
       - .github/workflows/classic-benchmark-ci.yml
   pull_request:
     branches: [ master, dev, release-* ]
     paths:
-      - 'classic/benchmark/**'
-      - '!classic/benchmark/reports/**'
+      - 'classic/direct_benchmark/**'
+      - 'classic/benchmark/agbenchmark/challenges/**'
+      - 'classic/original_autogpt/**'
+      - 'classic/forge/**'
       - .github/workflows/classic-benchmark-ci.yml
 
 concurrency:
@@ -23,23 +27,16 @@ defaults:
     shell: bash
 
 env:
-  min-python-version: '3.10'
+  min-python-version: '3.12'
 
 jobs:
-  test:
-    permissions:
-      contents: read
+  benchmark-tests:
+    runs-on: ubuntu-latest
     timeout-minutes: 30
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.10"]
-        platform-os: [ubuntu, macos, macos-arm64, windows]
-    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
     defaults:
       run:
         shell: bash
-        working-directory: classic/benchmark
+        working-directory: classic
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -47,71 +44,84 @@ jobs:
           fetch-depth: 0
           submodules: true
 
-      - name: Set up Python ${{ matrix.python-version }}
+      - name: Set up Python ${{ env.min-python-version }}
         uses: actions/setup-python@v5
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version: ${{ env.min-python-version }}
 
       - name: Set up Python dependency cache
-        # On Windows, unpacking cached dependencies takes longer than just installing them
-        if: runner.os != 'Windows'
         uses: actions/cache@v4
         with:
-          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/benchmark/poetry.lock') }}
+          path: ~/.cache/pypoetry
+          key: poetry-${{ runner.os }}-${{ hashFiles('classic/poetry.lock') }}
 
-      - name: Install Poetry (Unix)
-        if: runner.os != 'Windows'
+      - name: Install Poetry
         run: |
           curl -sSL https://install.python-poetry.org | python3 -
 
-          if [ "${{ runner.os }}" = "macOS" ]; then
-            PATH="$HOME/.local/bin:$PATH"
-            echo "$HOME/.local/bin" >> $GITHUB_PATH
-          fi
-
-      - name: Install Poetry (Windows)
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
-
-          $env:PATH += ";$env:APPDATA\Python\Scripts"
-          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
-
-      - name: Install Python dependencies
+      - name: Install dependencies
         run: poetry install
 
-      - name: Run pytest with coverage
+      - name: Run basic benchmark tests
         run: |
-          poetry run pytest -vv \
-            --cov=agbenchmark --cov-branch --cov-report term-missing --cov-report xml \
-            --durations=10 \
-            --junitxml=junit.xml -o junit_family=legacy \
-            tests
+          echo "Testing ReadFile challenge with one_shot strategy..."
+          poetry run direct-benchmark run \
+            --strategies one_shot \
+            --models claude \
+            --tests ReadFile \
+            --json
+
+          echo "Testing WriteFile challenge..."
+          poetry run direct-benchmark run \
+            --strategies one_shot \
+            --models claude \
+            --tests WriteFile \
+            --json
         env:
           CI: true
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          NONINTERACTIVE_MODE: "true"
 
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}  # Run even if tests fail
-        uses: codecov/test-results-action@v1
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
+      - name: Test category filtering
+        run: |
+          echo "Testing coding category..."
+          poetry run direct-benchmark run \
+            --strategies one_shot \
+            --models claude \
+            --categories coding \
+            --tests ReadFile,WriteFile \
+            --json
+        env:
+          CI: true
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          NONINTERACTIVE_MODE: "true"
 
-      - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          flags: agbenchmark,${{ runner.os }}
+      - name: Test multiple strategies
+        run: |
+          echo "Testing multiple strategies..."
+          poetry run direct-benchmark run \
+            --strategies one_shot,plan_execute \
+            --models claude \
+            --tests ReadFile \
+            --parallel 2 \
+            --json
+        env:
+          CI: true
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          NONINTERACTIVE_MODE: "true"
 
-  self-test-with-agent:
+  # Run regression tests on maintain challenges
+  regression-tests:
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        agent-name: [forge]
-      fail-fast: false
-    timeout-minutes: 20
+    timeout-minutes: 45
+    if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/dev'
+    defaults:
+      run:
+        shell: bash
+        working-directory: classic
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -126,51 +136,22 @@ jobs:
 
       - name: Install Poetry
         run: |
-          curl -sSL https://install.python-poetry.org | python -
+          curl -sSL https://install.python-poetry.org | python3 -
+
+      - name: Install dependencies
+        run: poetry install
 
       - name: Run regression tests
-        working-directory: classic
         run: |
-          ./run agent start ${{ matrix.agent-name }}
-          cd ${{ matrix.agent-name }}
-
-          set +e # Ignore non-zero exit codes and continue execution
-          echo "Running the following command: poetry run agbenchmark --maintain --mock"
-          poetry run agbenchmark --maintain --mock
-          EXIT_CODE=$?
-          set -e  # Stop ignoring non-zero exit codes
-          # Check if the exit code was 5, and if so, exit with 0 instead
-          if [ $EXIT_CODE -eq 5 ]; then
-            echo "regression_tests.json is empty."
-          fi
-
-          echo "Running the following command: poetry run agbenchmark --mock"
-          poetry run agbenchmark --mock
-
-          echo "Running the following command: poetry run agbenchmark --mock --category=data"
-          poetry run agbenchmark --mock --category=data
-
-          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
-          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
-
-          # 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
+          echo "Running regression tests (previously beaten challenges)..."
+          poetry run direct-benchmark run \
+            --strategies one_shot \
+            --models claude \
+            --maintain \
+            --parallel 4 \
+            --json
         env:
+          CI: true
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          TELEMETRY_ENVIRONMENT: autogpt-benchmark-ci
-          TELEMETRY_OPT_IN: ${{ github.ref_name == 'master' }}
+          NONINTERACTIVE_MODE: "true"

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

@@ -6,13 +6,11 @@ on:
     paths:
       - '.github/workflows/classic-forge-ci.yml'
       - 'classic/forge/**'
-      - '!classic/forge/tests/vcr_cassettes'
   pull_request:
     branches: [ master, dev, release-* ]
     paths:
       - '.github/workflows/classic-forge-ci.yml'
       - 'classic/forge/**'
-      - '!classic/forge/tests/vcr_cassettes'
 
 concurrency:
   group: ${{ format('forge-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
@@ -21,115 +19,38 @@ concurrency:
 defaults:
   run:
     shell: bash
-    working-directory: classic/forge
+    working-directory: classic
 
 jobs:
   test:
     permissions:
       contents: read
     timeout-minutes: 30
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.10"]
-        platform-os: [ubuntu, macos, macos-arm64, windows]
-    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
+    runs-on: ubuntu-latest
 
     steps:
-      # Quite slow on macOS (2~4 minutes to set up Docker)
-      # - name: Set up Docker (macOS)
-      #   if: runner.os == 'macOS'
-      #   uses: crazy-max/ghaction-setup-docker@v3
-
-      - name: Start MinIO service (Linux)
-        if: runner.os == 'Linux'
+      - name: Start MinIO service
         working-directory: '.'
         run: |
           docker pull minio/minio:edge-cicd
           docker run -d -p 9000:9000 minio/minio:edge-cicd
 
-      - name: Start MinIO service (macOS)
-        if: runner.os == 'macOS'
-        working-directory: ${{ runner.temp }}
-        run: |
-          brew install minio/stable/minio
-          mkdir data
-          minio server ./data &
-
-      # No MinIO on Windows:
-      # - Windows doesn't support running Linux Docker containers
-      # - It doesn't seem possible to start background processes on Windows. They are
-      #   killed after the step returns.
-      #   See: https://github.com/actions/runner/issues/598#issuecomment-2011890429
-
       - name: Checkout repository
         uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
 
-      - name: Checkout cassettes
-        if: ${{ startsWith(github.event_name, 'pull_request') }}
-        env:
-          PR_BASE: ${{ github.event.pull_request.base.ref }}
-          PR_BRANCH: ${{ github.event.pull_request.head.ref }}
-          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
-        run: |
-          cassette_branch="${PR_AUTHOR}-${PR_BRANCH}"
-          cassette_base_branch="${PR_BASE}"
-          cd tests/vcr_cassettes
-
-          if ! git ls-remote --exit-code --heads origin $cassette_base_branch ; then
-            cassette_base_branch="master"
-          fi
-
-          if git ls-remote --exit-code --heads origin $cassette_branch ; then
-            git fetch origin $cassette_branch
-            git fetch origin $cassette_base_branch
-
-            git checkout $cassette_branch
-
-            # Pick non-conflicting cassette updates from the base branch
-            git merge --no-commit --strategy-option=ours origin/$cassette_base_branch
-            echo "Using cassettes from mirror branch '$cassette_branch'," \
-              "synced to upstream branch '$cassette_base_branch'."
-          else
-            git checkout -b $cassette_branch
-            echo "Branch '$cassette_branch' does not exist in cassette submodule." \
-              "Using cassettes from '$cassette_base_branch'."
-          fi
-
-      - name: Set up Python ${{ matrix.python-version }}
+      - name: Set up Python 3.12
         uses: actions/setup-python@v5
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version: "3.12"
 
       - name: Set up Python dependency cache
-        # On Windows, unpacking cached dependencies takes longer than just installing them
-        if: runner.os != 'Windows'
         uses: actions/cache@v4
         with:
-          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/forge/poetry.lock') }}
+          path: ~/.cache/pypoetry
+          key: poetry-${{ runner.os }}-${{ hashFiles('classic/poetry.lock') }}
 
-      - name: Install Poetry (Unix)
-        if: runner.os != 'Windows'
-        run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-
-          if [ "${{ runner.os }}" = "macOS" ]; then
-            PATH="$HOME/.local/bin:$PATH"
-            echo "$HOME/.local/bin" >> $GITHUB_PATH
-          fi
-
-      - name: Install Poetry (Windows)
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
-
-          $env:PATH += ";$env:APPDATA\Python\Scripts"
-          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
+      - name: Install Poetry
+        run: curl -sSL https://install.python-poetry.org | python3 -
 
       - name: Install Python dependencies
         run: poetry install
@@ -140,12 +61,15 @@ jobs:
             --cov=forge --cov-branch --cov-report term-missing --cov-report xml \
             --durations=10 \
             --junitxml=junit.xml -o junit_family=legacy \
-            forge
+            forge/forge forge/tests
         env:
           CI: true
           PLAIN_OUTPUT: True
+          # API keys - tests that need these will skip if not available
+          # Secrets are not available to fork PRs (GitHub security feature)
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          S3_ENDPOINT_URL: ${{ runner.os != 'Windows' && 'http://127.0.0.1:9000' || '' }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          S3_ENDPOINT_URL: http://127.0.0.1:9000
           AWS_ACCESS_KEY_ID: minioadmin
           AWS_SECRET_ACCESS_KEY: minioadmin
 
@@ -159,85 +83,11 @@ jobs:
         uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
-          flags: forge,${{ runner.os }}
-
-      - id: setup_git_auth
-        name: Set up git token authentication
-        # Cassettes may be pushed even when tests fail
-        if: success() || failure()
-        run: |
-          config_key="http.${{ github.server_url }}/.extraheader"
-          if [ "${{ runner.os }}" = 'macOS' ]; then
-            base64_pat=$(echo -n "pat:${{ secrets.PAT_REVIEW }}" | base64)
-          else
-            base64_pat=$(echo -n "pat:${{ secrets.PAT_REVIEW }}" | base64 -w0)
-          fi
-
-          git config "$config_key" \
-            "Authorization: Basic $base64_pat"
-
-          cd tests/vcr_cassettes
-          git config "$config_key" \
-            "Authorization: Basic $base64_pat"
-
-          echo "config_key=$config_key" >> $GITHUB_OUTPUT
-
-      - id: push_cassettes
-        name: Push updated cassettes
-        # For pull requests, push updated cassettes even when tests fail
-        if: github.event_name == 'push' || (! github.event.pull_request.head.repo.fork && (success() || failure()))
-        env:
-          PR_BRANCH: ${{ github.event.pull_request.head.ref }}
-          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
-        run: |
-          if [ "${{ startsWith(github.event_name, 'pull_request') }}" = "true" ]; then
-            is_pull_request=true
-            cassette_branch="${PR_AUTHOR}-${PR_BRANCH}"
-          else
-            cassette_branch="${{ github.ref_name }}"
-          fi
-
-          cd tests/vcr_cassettes
-          # Commit & push changes to cassettes if any
-          if ! git diff --quiet; then
-            git add .
-            git commit -m "Auto-update cassettes"
-            git push origin HEAD:$cassette_branch
-            if [ ! $is_pull_request ]; then
-              cd ../..
-              git add tests/vcr_cassettes
-              git commit -m "Update cassette submodule"
-              git push origin HEAD:$cassette_branch
-            fi
-            echo "updated=true" >> $GITHUB_OUTPUT
-          else
-            echo "updated=false" >> $GITHUB_OUTPUT
-            echo "No cassette changes to commit"
-          fi
-
-      - name: Post Set up git token auth
-        if: steps.setup_git_auth.outcome == 'success'
-        run: |
-          git config --unset-all '${{ steps.setup_git_auth.outputs.config_key }}'
-          git submodule foreach git config --unset-all '${{ steps.setup_git_auth.outputs.config_key }}'
-
-      - name: Apply "behaviour change" label and comment on PR
-        if: ${{ startsWith(github.event_name, 'pull_request') }}
-        run: |
-          PR_NUMBER="${{ github.event.pull_request.number }}"
-          TOKEN="${{ secrets.PAT_REVIEW }}"
-          REPO="${{ github.repository }}"
-
-          if [[ "${{ steps.push_cassettes.outputs.updated }}" == "true" ]]; then
-            echo "Adding label and comment..."
-            echo $TOKEN | gh auth login --with-token
-            gh issue edit $PR_NUMBER --add-label "behaviour change"
-            gh issue comment $PR_NUMBER --body "You changed AutoGPT's behaviour on ${{ runner.os }}. The cassettes have been updated and will be merged to the submodule when this Pull Request gets merged."
-          fi
+          flags: forge
 
       - name: Upload logs to artifact
         if: always()
         uses: actions/upload-artifact@v4
         with:
           name: test-logs
-          path: classic/forge/logs/
+          path: classic/logs/

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

@@ -1,60 +0,0 @@
-name: Classic - Frontend CI/CD
-
-on:
-  push:
-    branches:
-      - master
-      - dev
-      - 'ci-test*' # This will match any branch that starts with "ci-test"
-    paths:
-      - 'classic/frontend/**'
-      - '.github/workflows/classic-frontend-ci.yml'
-  pull_request:
-    paths:
-      - 'classic/frontend/**'
-      - '.github/workflows/classic-frontend-ci.yml'
-
-jobs:
-  build:
-    permissions:
-      contents: write
-      pull-requests: write
-    runs-on: ubuntu-latest
-    env:
-      BUILD_BRANCH: ${{ format('classic-frontend-build/{0}', github.ref_name) }}
-
-    steps:
-      - name: Checkout Repo
-        uses: actions/checkout@v4
-
-      - 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: 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 }}"

.github/workflows/classic-python-checks.yml

@@ -7,7 +7,9 @@ on:
       - '.github/workflows/classic-python-checks-ci.yml'
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
-      - 'classic/benchmark/**'
+      - 'classic/direct_benchmark/**'
+      - 'classic/pyproject.toml'
+      - 'classic/poetry.lock'
       - '**.py'
       - '!classic/forge/tests/vcr_cassettes'
   pull_request:
@@ -16,7 +18,9 @@ on:
       - '.github/workflows/classic-python-checks-ci.yml'
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
-      - 'classic/benchmark/**'
+      - 'classic/direct_benchmark/**'
+      - 'classic/pyproject.toml'
+      - 'classic/poetry.lock'
       - '**.py'
       - '!classic/forge/tests/vcr_cassettes'
 
@@ -27,44 +31,13 @@ concurrency:
 defaults:
   run:
     shell: bash
+    working-directory: classic
 
 jobs:
-  get-changed-parts:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - id: changes-in
-        name: Determine affected subprojects
-        uses: dorny/paths-filter@v3
-        with:
-          filters: |
-            original_autogpt:
-              - classic/original_autogpt/autogpt/**
-              - classic/original_autogpt/tests/**
-              - classic/original_autogpt/poetry.lock
-            forge:
-              - classic/forge/forge/**
-              - classic/forge/tests/**
-              - classic/forge/poetry.lock
-            benchmark:
-              - classic/benchmark/agbenchmark/**
-              - classic/benchmark/tests/**
-              - classic/benchmark/poetry.lock
-    outputs:
-      changed-parts: ${{ steps.changes-in.outputs.changes }}
-
   lint:
-    needs: get-changed-parts
     runs-on: ubuntu-latest
     env:
-      min-python-version: "3.10"
-
-    strategy:
-      matrix:
-        sub-package: ${{ fromJson(needs.get-changed-parts.outputs.changed-parts) }}
-      fail-fast: false
+      min-python-version: "3.12"
 
     steps:
       - name: Checkout repository
@@ -81,42 +54,31 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ~/.cache/pypoetry
-          key: ${{ runner.os }}-poetry-${{ hashFiles(format('{0}/poetry.lock', matrix.sub-package)) }}
+          key: ${{ runner.os }}-poetry-${{ hashFiles('classic/poetry.lock') }}
 
       - name: Install Poetry
         run: curl -sSL https://install.python-poetry.org | python3 -
 
-      # Install dependencies
-
       - name: Install Python dependencies
-        run: poetry -C classic/${{ matrix.sub-package }} install
+        run: poetry install
 
       # Lint
 
       - name: Lint (isort)
         run: poetry run isort --check .
-        working-directory: classic/${{ matrix.sub-package }}
 
       - name: Lint (Black)
         if: success() || failure()
         run: poetry run black --check .
-        working-directory: classic/${{ matrix.sub-package }}
 
       - name: Lint (Flake8)
         if: success() || failure()
         run: poetry run flake8 .
-        working-directory: classic/${{ matrix.sub-package }}
 
   types:
-    needs: get-changed-parts
     runs-on: ubuntu-latest
     env:
-      min-python-version: "3.10"
-
-    strategy:
-      matrix:
-        sub-package: ${{ fromJson(needs.get-changed-parts.outputs.changed-parts) }}
-      fail-fast: false
+      min-python-version: "3.12"
 
     steps:
       - name: Checkout repository
@@ -133,19 +95,16 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ~/.cache/pypoetry
-          key: ${{ runner.os }}-poetry-${{ hashFiles(format('{0}/poetry.lock', matrix.sub-package)) }}
+          key: ${{ runner.os }}-poetry-${{ hashFiles('classic/poetry.lock') }}
 
       - name: Install Poetry
         run: curl -sSL https://install.python-poetry.org | python3 -
 
-      # Install dependencies
-
       - name: Install Python dependencies
-        run: poetry -C classic/${{ matrix.sub-package }} install
+        run: poetry install
 
       # Typecheck
 
       - name: Typecheck
         if: success() || failure()
         run: poetry run pyright
-        working-directory: classic/${{ matrix.sub-package }}

.github/workflows/claude-ci-failure-auto-fix.yml

@@ -93,5 +93,5 @@ jobs:
 
             Error logs:
             ${{ toJSON(fromJSON(steps.failure_details.outputs.result).errorLogs) }}
-          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
           claude_args: "--allowedTools 'Edit,MultiEdit,Write,Read,Glob,Grep,LS,Bash(git:*),Bash(bun:*),Bash(npm:*),Bash(npx:*),Bash(gh:*)'"

.github/workflows/claude-dependabot.yml

@@ -7,7 +7,7 @@
 # - Provide actionable recommendations for the development team
 #
 # Triggered on: Dependabot PRs (opened, synchronize)
-# Requirements: ANTHROPIC_API_KEY secret must be configured
+# Requirements: CLAUDE_CODE_OAUTH_TOKEN secret must be configured
 
 name: Claude Dependabot PR Review
 
@@ -308,7 +308,7 @@ jobs:
         id: claude_review
         uses: anthropics/claude-code-action@v1
         with:
-          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
           claude_args: |
             --allowedTools "Bash(npm:*),Bash(pnpm:*),Bash(poetry:*),Bash(git:*),Edit,Replace,NotebookEditCell,mcp__github_inline_comment__create_inline_comment,Bash(gh pr comment:*), Bash(gh pr diff:*), Bash(gh pr view:*)"
           prompt: |

.github/workflows/claude.yml

@@ -323,7 +323,7 @@ jobs:
         id: claude
         uses: anthropics/claude-code-action@v1
         with:
-          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
           claude_args: |
             --allowedTools "Bash(npm:*),Bash(pnpm:*),Bash(poetry:*),Bash(git:*),Edit,Replace,NotebookEditCell,mcp__github_inline_comment__create_inline_comment,Bash(gh pr comment:*), Bash(gh pr diff:*), Bash(gh pr view:*), Bash(gh pr edit:*)"
             --model opus

.github/workflows/docs-block-sync.yml

@@ -0,0 +1,78 @@
+name: Block Documentation Sync Check
+
+on:
+  push:
+    branches: [master, dev]
+    paths:
+      - "autogpt_platform/backend/backend/blocks/**"
+      - "docs/integrations/**"
+      - "autogpt_platform/backend/scripts/generate_block_docs.py"
+      - ".github/workflows/docs-block-sync.yml"
+  pull_request:
+    branches: [master, dev]
+    paths:
+      - "autogpt_platform/backend/backend/blocks/**"
+      - "docs/integrations/**"
+      - "autogpt_platform/backend/scripts/generate_block_docs.py"
+      - ".github/workflows/docs-block-sync.yml"
+
+jobs:
+  check-docs-sync:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Set up Python dependency cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pypoetry
+          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
+          restore-keys: |
+            poetry-${{ runner.os }}-
+
+      - name: Install Poetry
+        run: |
+          cd autogpt_platform/backend
+          HEAD_POETRY_VERSION=$(python3 ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
+          echo "Found Poetry version ${HEAD_POETRY_VERSION} in backend/poetry.lock"
+          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+      - name: Install dependencies
+        working-directory: autogpt_platform/backend
+        run: |
+          poetry install --only main
+          poetry run prisma generate
+
+      - name: Check block documentation is in sync
+        working-directory: autogpt_platform/backend
+        run: |
+          echo "Checking if block documentation is in sync with code..."
+          poetry run python scripts/generate_block_docs.py --check
+
+      - name: Show diff if out of sync
+        if: failure()
+        working-directory: autogpt_platform/backend
+        run: |
+          echo "::error::Block documentation is out of sync with code!"
+          echo ""
+          echo "To fix this, run the following command locally:"
+          echo "  cd autogpt_platform/backend && poetry run python scripts/generate_block_docs.py"
+          echo ""
+          echo "Then commit the updated documentation files."
+          echo ""
+          echo "Regenerating docs to show diff..."
+          poetry run python scripts/generate_block_docs.py
+          echo ""
+          echo "Changes detected:"
+          git diff ../../docs/integrations/ || true

.github/workflows/docs-claude-review.yml

@@ -0,0 +1,95 @@
+name: Claude Block Docs Review
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+    paths:
+      - "docs/integrations/**"
+      - "autogpt_platform/backend/backend/blocks/**"
+
+jobs:
+  claude-review:
+    # Only run for PRs from members/collaborators
+    if: |
+      github.event.pull_request.author_association == 'OWNER' ||
+      github.event.pull_request.author_association == 'MEMBER' ||
+      github.event.pull_request.author_association == 'COLLABORATOR'
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    permissions:
+      contents: read
+      pull-requests: write
+      id-token: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Set up Python dependency cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pypoetry
+          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
+          restore-keys: |
+            poetry-${{ runner.os }}-
+
+      - name: Install Poetry
+        run: |
+          cd autogpt_platform/backend
+          HEAD_POETRY_VERSION=$(python3 ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
+          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+      - name: Install dependencies
+        working-directory: autogpt_platform/backend
+        run: |
+          poetry install --only main
+          poetry run prisma generate
+
+      - name: Run Claude Code Review
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          claude_args: |
+            --allowedTools "Read,Glob,Grep,Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*)"
+          prompt: |
+            You are reviewing a PR that modifies block documentation or block code for AutoGPT.
+
+            ## Your Task
+            Review the changes in this PR and provide constructive feedback. Focus on:
+
+            1. **Documentation Accuracy**: For any block code changes, verify that:
+               - Input/output tables in docs match the actual block schemas
+               - Description text accurately reflects what the block does
+               - Any new blocks have corresponding documentation
+
+            2. **Manual Content Quality**: Check manual sections (marked with `<!-- MANUAL: -->` markers):
+               - "How it works" sections should have clear technical explanations
+               - "Possible use case" sections should have practical, real-world examples
+               - Content should be helpful for users trying to understand the blocks
+
+            3. **Template Compliance**: Ensure docs follow the standard template:
+               - What it is (brief intro)
+               - What it does (description)
+               - How it works (technical explanation)
+               - Inputs table
+               - Outputs table
+               - Possible use case
+
+            4. **Cross-references**: Check that links and anchors are correct
+
+            ## Review Process
+            1. First, get the PR diff to see what changed: `gh pr diff ${{ github.event.pull_request.number }}`
+            2. Read any modified block files to understand the implementation
+            3. Read corresponding documentation files to verify accuracy
+            4. Provide your feedback as a PR comment
+
+            Be constructive and specific. If everything looks good, say so!
+            If there are issues, explain what's wrong and suggest how to fix it.

.github/workflows/docs-enhance.yml

@@ -0,0 +1,194 @@
+name: Enhance Block Documentation
+
+on:
+  workflow_dispatch:
+    inputs:
+      block_pattern:
+        description: 'Block file pattern to enhance (e.g., "google/*.md" or "*" for all blocks)'
+        required: true
+        default: '*'
+        type: string
+      dry_run:
+        description: 'Dry run mode - show proposed changes without committing'
+        type: boolean
+        default: true
+      max_blocks:
+        description: 'Maximum number of blocks to process (0 for unlimited)'
+        type: number
+        default: 10
+
+jobs:
+  enhance-docs:
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    permissions:
+      contents: write
+      pull-requests: write
+      id-token: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Set up Python dependency cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pypoetry
+          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
+          restore-keys: |
+            poetry-${{ runner.os }}-
+
+      - name: Install Poetry
+        run: |
+          cd autogpt_platform/backend
+          HEAD_POETRY_VERSION=$(python3 ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
+          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+      - name: Install dependencies
+        working-directory: autogpt_platform/backend
+        run: |
+          poetry install --only main
+          poetry run prisma generate
+
+      - name: Run Claude Enhancement
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          claude_args: |
+            --allowedTools "Read,Edit,Glob,Grep,Write,Bash(git:*),Bash(gh:*),Bash(find:*),Bash(ls:*)"
+          prompt: |
+            You are enhancing block documentation for AutoGPT. Your task is to improve the MANUAL sections
+            of block documentation files by reading the actual block implementations and writing helpful content.
+
+            ## Configuration
+            - Block pattern: ${{ inputs.block_pattern }}
+            - Dry run: ${{ inputs.dry_run }}
+            - Max blocks to process: ${{ inputs.max_blocks }}
+
+            ## Your Task
+
+            1. **Find Documentation Files**
+               Find block documentation files matching the pattern in `docs/integrations/`
+               Pattern: ${{ inputs.block_pattern }}
+
+               Use: `find docs/integrations -name "*.md" -type f`
+
+            2. **For Each Documentation File** (up to ${{ inputs.max_blocks }} files):
+
+               a. Read the documentation file
+
+               b. Identify which block(s) it documents (look for the block class name)
+
+               c. Find and read the corresponding block implementation in `autogpt_platform/backend/backend/blocks/`
+
+               d. Improve the MANUAL sections:
+
+                  **"How it works" section** (within `<!-- MANUAL: how_it_works -->` markers):
+                  - Explain the technical flow of the block
+                  - Describe what APIs or services it connects to
+                  - Note any important configuration or prerequisites
+                  - Keep it concise but informative (2-4 paragraphs)
+
+                  **"Possible use case" section** (within `<!-- MANUAL: use_case -->` markers):
+                  - Provide 2-3 practical, real-world examples
+                  - Make them specific and actionable
+                  - Show how this block could be used in an automation workflow
+
+            3. **Important Rules**
+               - ONLY modify content within `<!-- MANUAL: -->` and `<!-- END MANUAL -->` markers
+               - Do NOT modify auto-generated sections (inputs/outputs tables, descriptions)
+               - Keep content accurate based on the actual block implementation
+               - Write for users who may not be technical experts
+
+            4. **Output**
+               ${{ inputs.dry_run == true && 'DRY RUN MODE: Show proposed changes for each file but do NOT actually edit the files. Describe what you would change.' || 'LIVE MODE: Actually edit the files to improve the documentation.' }}
+
+            ## Example Improvements
+
+            **Before (How it works):**
+            ```
+            _Add technical explanation here._
+            ```
+
+            **After (How it works):**
+            ```
+            This block connects to the GitHub API to retrieve issue information. When executed,
+            it authenticates using your GitHub credentials and fetches issue details including
+            title, body, labels, and assignees.
+
+            The block requires a valid GitHub OAuth connection with repository access permissions.
+            It supports both public and private repositories you have access to.
+            ```
+
+            **Before (Possible use case):**
+            ```
+            _Add practical use case examples here._
+            ```
+
+            **After (Possible use case):**
+            ```
+            **Customer Support Automation**: Monitor a GitHub repository for new issues with
+            the "bug" label, then automatically create a ticket in your support system and
+            notify the on-call engineer via Slack.
+
+            **Release Notes Generation**: When a new release is published, gather all closed
+            issues since the last release and generate a summary for your changelog.
+            ```
+
+            Begin by finding and listing the documentation files to process.
+
+      - name: Create PR with enhanced documentation
+        if: ${{ inputs.dry_run == false }}
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # Check if there are changes
+          if git diff --quiet docs/integrations/; then
+            echo "No changes to commit"
+            exit 0
+          fi
+
+          # Configure git
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          # Create branch and commit
+          BRANCH_NAME="docs/enhance-blocks-$(date +%Y%m%d-%H%M%S)"
+          git checkout -b "$BRANCH_NAME"
+          git add docs/integrations/
+          git commit -m "docs: enhance block documentation with LLM-generated content
+
+          Pattern: ${{ inputs.block_pattern }}
+          Max blocks: ${{ inputs.max_blocks }}
+
+          🤖 Generated with [Claude Code](https://claude.com/claude-code)
+
+          Co-Authored-By: Claude <noreply@anthropic.com>"
+
+          # Push and create PR
+          git push -u origin "$BRANCH_NAME"
+          gh pr create \
+            --title "docs: LLM-enhanced block documentation" \
+            --body "## Summary
+          This PR contains LLM-enhanced documentation for block files matching pattern: \`${{ inputs.block_pattern }}\`
+
+          The following manual sections were improved:
+          - **How it works**: Technical explanations based on block implementations
+          - **Possible use case**: Practical, real-world examples
+
+          ## Review Checklist
+          - [ ] Content is accurate based on block implementations
+          - [ ] Examples are practical and helpful
+          - [ ] No auto-generated sections were modified
+
+          ---
+          🤖 Generated with [Claude Code](https://claude.com/claude-code)" \
+            --base dev

.gitignore

@@ -3,6 +3,7 @@
 classic/original_autogpt/keys.py
 classic/original_autogpt/*.json
 auto_gpt_workspace/*
+.autogpt/
 *.mpeg
 .env
 # Root .env files
@@ -159,6 +160,10 @@ CURRENT_BULLETIN.md
 
 # AgBenchmark
 classic/benchmark/agbenchmark/reports/
+classic/reports/
+classic/direct_benchmark/reports/
+classic/.benchmark_workspaces/
+classic/direct_benchmark/.benchmark_workspaces/
 
 # Nodejs
 package-lock.json
@@ -177,5 +182,8 @@ autogpt_platform/backend/settings.py
 
 *.ign.*
 .test-contents
-.claude/settings.local.json
+**/.claude/settings.local.json
 /autogpt_platform/backend/logs
+
+# Test database
+test.db

.gitmodules

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

.pre-commit-config.yaml

@@ -43,29 +43,10 @@ repos:
         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$
+        name: Check & Install dependencies - Classic
+        alias: poetry-install-classic
+        entry: poetry -C classic install
+        files: ^classic/poetry\.lock$
         types: [file]
         language: system
         pass_filenames: false
@@ -116,26 +97,10 @@ repos:
         language: system
 
       - id: isort
-        name: Lint (isort) - Classic - AutoGPT
-        alias: isort-classic-autogpt
-        entry: poetry -P classic/original_autogpt run isort -p autogpt
-        files: ^classic/original_autogpt/
-        types: [file, python]
-        language: system
-
-      - id: isort
-        name: Lint (isort) - Classic - Forge
-        alias: isort-classic-forge
-        entry: poetry -P classic/forge run isort -p forge
-        files: ^classic/forge/
-        types: [file, python]
-        language: system
-
-      - id: isort
-        name: Lint (isort) - Classic - Benchmark
-        alias: isort-classic-benchmark
-        entry: poetry -P classic/benchmark run isort -p agbenchmark
-        files: ^classic/benchmark/
+        name: Lint (isort) - Classic
+        alias: isort-classic
+        entry: bash -c 'cd classic && poetry run isort $(echo "$@" | sed "s|classic/||g")' --
+        files: ^classic/(original_autogpt|forge|direct_benchmark)/
         types: [file, python]
         language: system
 
@@ -149,26 +114,13 @@ repos:
 
   - repo: https://github.com/PyCQA/flake8
     rev: 7.0.0
-    # To have flake8 load the config of the individual subprojects, we have to call
-    # them separately.
+    # Use consolidated flake8 config at classic/.flake8
     hooks:
       - id: flake8
-        name: Lint (Flake8) - Classic - AutoGPT
-        alias: flake8-classic-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
-        files: ^classic/forge/(forge|tests)/
-        args: [--config=classic/forge/.flake8]
-
-      - id: flake8
-        name: Lint (Flake8) - Classic - Benchmark
-        alias: flake8-classic-benchmark
-        files: ^classic/benchmark/(agbenchmark|tests)/((?!reports).)*[/.]
-        args: [--config=classic/benchmark/.flake8]
+        name: Lint (Flake8) - Classic
+        alias: flake8-classic
+        files: ^classic/(original_autogpt|forge|direct_benchmark)/
+        args: [--config=classic/.flake8]
 
   - repo: local
     hooks:
@@ -204,29 +156,10 @@ repos:
         pass_filenames: false
 
       - id: pyright
-        name: Typecheck - Classic - AutoGPT
-        alias: pyright-classic-autogpt
-        entry: poetry -C classic/original_autogpt run pyright
-        # 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)$)
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: pyright
-        name: Typecheck - Classic - Forge
-        alias: pyright-classic-forge
-        entry: poetry -C classic/forge run pyright
-        files: ^classic/forge/(forge/|poetry\.lock$)
-        types: [file]
-        language: system
-        pass_filenames: false
-
-      - id: pyright
-        name: Typecheck - Classic - Benchmark
-        alias: pyright-classic-benchmark
-        entry: poetry -C classic/benchmark run pyright
-        files: ^classic/benchmark/(agbenchmark/|tests/|poetry\.lock$)
+        name: Typecheck - Classic
+        alias: pyright-classic
+        entry: poetry -C classic run pyright
+        files: ^classic/(original_autogpt|forge|direct_benchmark)/.*\.py$|^classic/poetry\.lock$
         types: [file]
         language: system
         pass_filenames: false

autogpt_platform/backend/backend/api/features/admin/waitlist_admin_routes.py

@@ -1,251 +0,0 @@
-import logging
-
-import autogpt_libs.auth
-import fastapi
-import fastapi.responses
-
-import backend.api.features.store.db as store_db
-import backend.api.features.store.model as store_model
-
-logger = logging.getLogger(__name__)
-
-router = fastapi.APIRouter(
-    prefix="/admin/waitlist",
-    tags=["store", "admin", "waitlist"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_admin_user)],
-)
-
-
-@router.post(
-    "",
-    summary="Create Waitlist",
-    response_model=store_model.WaitlistAdminResponse,
-)
-async def create_waitlist(
-    request: store_model.WaitlistCreateRequest,
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
-):
-    """
-    Create a new waitlist (admin only).
-
-    Args:
-        request: Waitlist creation details
-        user_id: Authenticated admin user creating the waitlist
-
-    Returns:
-        WaitlistAdminResponse with the created waitlist details
-    """
-    try:
-        waitlist = await store_db.create_waitlist_admin(
-            admin_user_id=user_id,
-            data=request,
-        )
-        return waitlist
-    except Exception as e:
-        logger.exception("Error creating waitlist: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while creating the waitlist"},
-        )
-
-
-@router.get(
-    "",
-    summary="List All Waitlists",
-    response_model=store_model.WaitlistAdminListResponse,
-)
-async def list_waitlists():
-    """
-    Get all waitlists with admin details (admin only).
-
-    Returns:
-        WaitlistAdminListResponse with all waitlists
-    """
-    try:
-        return await store_db.get_waitlists_admin()
-    except Exception as e:
-        logger.exception("Error listing waitlists: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while fetching waitlists"},
-        )
-
-
-@router.get(
-    "/{waitlist_id}",
-    summary="Get Waitlist Details",
-    response_model=store_model.WaitlistAdminResponse,
-)
-async def get_waitlist(
-    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
-):
-    """
-    Get a single waitlist with admin details (admin only).
-
-    Args:
-        waitlist_id: ID of the waitlist to retrieve
-
-    Returns:
-        WaitlistAdminResponse with waitlist details
-    """
-    try:
-        return await store_db.get_waitlist_admin(waitlist_id)
-    except ValueError:
-        logger.warning("Waitlist not found: %s", waitlist_id)
-        return fastapi.responses.JSONResponse(
-            status_code=404,
-            content={"detail": "Waitlist not found"},
-        )
-    except Exception as e:
-        logger.exception("Error fetching waitlist: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while fetching the waitlist"},
-        )
-
-
-@router.put(
-    "/{waitlist_id}",
-    summary="Update Waitlist",
-    response_model=store_model.WaitlistAdminResponse,
-)
-async def update_waitlist(
-    request: store_model.WaitlistUpdateRequest,
-    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
-):
-    """
-    Update a waitlist (admin only).
-
-    Args:
-        waitlist_id: ID of the waitlist to update
-        request: Fields to update
-
-    Returns:
-        WaitlistAdminResponse with updated waitlist details
-    """
-    try:
-        return await store_db.update_waitlist_admin(waitlist_id, request)
-    except ValueError:
-        logger.warning("Waitlist not found for update: %s", waitlist_id)
-        return fastapi.responses.JSONResponse(
-            status_code=404,
-            content={"detail": "Waitlist not found"},
-        )
-    except Exception as e:
-        logger.exception("Error updating waitlist: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while updating the waitlist"},
-        )
-
-
-@router.delete(
-    "/{waitlist_id}",
-    summary="Delete Waitlist",
-)
-async def delete_waitlist(
-    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
-):
-    """
-    Soft delete a waitlist (admin only).
-
-    Args:
-        waitlist_id: ID of the waitlist to delete
-
-    Returns:
-        Success message
-    """
-    try:
-        await store_db.delete_waitlist_admin(waitlist_id)
-        return {"message": "Waitlist deleted successfully"}
-    except ValueError:
-        logger.warning(f"Waitlist not found for deletion: {waitlist_id}")
-        return fastapi.responses.JSONResponse(
-            status_code=404,
-            content={"detail": "Waitlist not found"},
-        )
-    except Exception as e:
-        logger.exception("Error deleting waitlist: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while deleting the waitlist"},
-        )
-
-
-@router.get(
-    "/{waitlist_id}/signups",
-    summary="Get Waitlist Signups",
-    response_model=store_model.WaitlistSignupListResponse,
-)
-async def get_waitlist_signups(
-    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
-):
-    """
-    Get all signups for a waitlist (admin only).
-
-    Args:
-        waitlist_id: ID of the waitlist
-
-    Returns:
-        WaitlistSignupListResponse with all signups
-    """
-    try:
-        return await store_db.get_waitlist_signups_admin(waitlist_id)
-    except ValueError:
-        logger.warning("Waitlist not found for signups: %s", waitlist_id)
-        return fastapi.responses.JSONResponse(
-            status_code=404,
-            content={"detail": "Waitlist not found"},
-        )
-    except Exception as e:
-        logger.exception("Error fetching waitlist signups: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while fetching waitlist signups"},
-        )
-
-
-@router.post(
-    "/{waitlist_id}/link",
-    summary="Link Waitlist to Store Listing",
-    response_model=store_model.WaitlistAdminResponse,
-)
-async def link_waitlist_to_listing(
-    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
-    store_listing_id: str = fastapi.Body(
-        ..., embed=True, description="The ID of the store listing"
-    ),
-):
-    """
-    Link a waitlist to a store listing (admin only).
-
-    When the linked store listing is approved/published, waitlist users
-    will be automatically notified.
-
-    Args:
-        waitlist_id: ID of the waitlist
-        store_listing_id: ID of the store listing to link
-
-    Returns:
-        WaitlistAdminResponse with updated waitlist details
-    """
-    try:
-        return await store_db.link_waitlist_to_listing_admin(
-            waitlist_id, store_listing_id
-        )
-    except ValueError:
-        logger.warning(
-            "Link failed - waitlist or listing not found: %s, %s",
-            waitlist_id,
-            store_listing_id,
-        )
-        return fastapi.responses.JSONResponse(
-            status_code=404,
-            content={"detail": "Waitlist or store listing not found"},
-        )
-    except Exception as e:
-        logger.exception("Error linking waitlist to listing: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while linking the waitlist"},
-        )

autogpt_platform/backend/backend/api/features/chat/service.py

@@ -4,14 +4,9 @@ from collections.abc import AsyncGenerator
 from typing import Any
 
 import orjson
-from langfuse import Langfuse
-from openai import (
-    APIConnectionError,
-    APIError,
-    APIStatusError,
-    AsyncOpenAI,
-    RateLimitError,
-)
+from langfuse import get_client, propagate_attributes
+from langfuse.openai import openai  # type: ignore
+from openai import APIConnectionError, APIError, APIStatusError, RateLimitError
 from openai.types.chat import ChatCompletionChunk, ChatCompletionToolParam
 
 from backend.data.understanding import (
@@ -21,7 +16,6 @@ from backend.data.understanding import (
 from backend.util.exceptions import NotFoundError
 from backend.util.settings import Settings
 
-from . import db as chat_db
 from .config import ChatConfig
 from .model import (
     ChatMessage,
@@ -50,10 +44,10 @@ logger = logging.getLogger(__name__)
 
 config = ChatConfig()
 settings = Settings()
-client = AsyncOpenAI(api_key=config.api_key, base_url=config.base_url)
+client = openai.AsyncOpenAI(api_key=config.api_key, base_url=config.base_url)
 
-# Langfuse client (lazy initialization)
-_langfuse_client: Langfuse | None = None
+
+langfuse = get_client()
 
 
 class LangfuseNotConfiguredError(Exception):
@@ -69,65 +63,6 @@ def _is_langfuse_configured() -> bool:
     )
 
 
-def _get_langfuse_client() -> Langfuse:
-    """Get or create the Langfuse client for prompt management and tracing."""
-    global _langfuse_client
-    if _langfuse_client is None:
-        if not _is_langfuse_configured():
-            raise LangfuseNotConfiguredError(
-                "Langfuse is not configured. The chat feature requires Langfuse for prompt management. "
-                "Please set the LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY environment variables."
-            )
-        _langfuse_client = Langfuse(
-            public_key=settings.secrets.langfuse_public_key,
-            secret_key=settings.secrets.langfuse_secret_key,
-            host=settings.secrets.langfuse_host or "https://cloud.langfuse.com",
-        )
-    return _langfuse_client
-
-
-def _get_environment() -> str:
-    """Get the current environment name for Langfuse tagging."""
-    return settings.config.app_env.value
-
-
-def _get_langfuse_prompt() -> str:
-    """Fetch the latest production prompt from Langfuse.
-
-    Returns:
-        The compiled prompt text from Langfuse.
-
-    Raises:
-        Exception: If Langfuse is unavailable or prompt fetch fails.
-    """
-    try:
-        langfuse = _get_langfuse_client()
-        # cache_ttl_seconds=0 disables SDK caching to always get the latest prompt
-        prompt = langfuse.get_prompt(config.langfuse_prompt_name, cache_ttl_seconds=0)
-        compiled = prompt.compile()
-        logger.info(
-            f"Fetched prompt '{config.langfuse_prompt_name}' from Langfuse "
-            f"(version: {prompt.version})"
-        )
-        return compiled
-    except Exception as e:
-        logger.error(f"Failed to fetch prompt from Langfuse: {e}")
-        raise
-
-
-async def _is_first_session(user_id: str) -> bool:
-    """Check if this is the user's first chat session.
-
-    Returns True if the user has 1 or fewer sessions (meaning this is their first).
-    """
-    try:
-        session_count = await chat_db.get_user_session_count(user_id)
-        return session_count <= 1
-    except Exception as e:
-        logger.warning(f"Failed to check session count for user {user_id}: {e}")
-        return False  # Default to non-onboarding if we can't check
-
-
 async def _build_system_prompt(user_id: str | None) -> tuple[str, Any]:
     """Build the full system prompt including business understanding if available.
 
@@ -139,8 +74,6 @@ async def _build_system_prompt(user_id: str | None) -> tuple[str, Any]:
         Tuple of (compiled prompt string, Langfuse prompt object for tracing)
     """
 
-    langfuse = _get_langfuse_client()
-
     # cache_ttl_seconds=0 disables SDK caching to always get the latest prompt
     prompt = langfuse.get_prompt(config.langfuse_prompt_name, cache_ttl_seconds=0)
 
@@ -158,7 +91,7 @@ async def _build_system_prompt(user_id: str | None) -> tuple[str, Any]:
         context = "This is the first time you are meeting the user. Greet them and introduce them to the platform"
 
     compiled = prompt.compile(users_information=context)
-    return compiled, prompt
+    return compiled, understanding
 
 
 async def _generate_session_title(message: str) -> str | None:
@@ -217,6 +150,7 @@ async def assign_user_to_session(
 async def stream_chat_completion(
     session_id: str,
     message: str | None = None,
+    tool_call_response: str | None = None,
     is_user_message: bool = True,
     user_id: str | None = None,
     retry_count: int = 0,
@@ -256,11 +190,6 @@ async def stream_chat_completion(
         yield StreamFinish()
         return
 
-    # Langfuse observations will be created after session is loaded (need messages for input)
-    # Initialize to None so finally block can safely check and end them
-    trace = None
-    generation = None
-
     # Only fetch from Redis if session not provided (initial call)
     if session is None:
         session = await get_chat_session(session_id, user_id)
@@ -336,297 +265,259 @@ async def stream_chat_completion(
             asyncio.create_task(_update_title())
 
     # Build system prompt with business understanding
-    system_prompt, langfuse_prompt = await _build_system_prompt(user_id)
-
-    # Build input messages including system prompt for complete Langfuse logging
-    trace_input_messages = [{"role": "system", "content": system_prompt}] + [
-        m.model_dump() for m in session.messages
-    ]
+    system_prompt, understanding = await _build_system_prompt(user_id)
 
     # Create Langfuse trace for this LLM call (each call gets its own trace, grouped by session_id)
     # Using v3 SDK: start_observation creates a root span, update_trace sets trace-level attributes
-    try:
-        langfuse = _get_langfuse_client()
-        env = _get_environment()
-        trace = langfuse.start_observation(
-            name="chat_completion",
-            input={"messages": trace_input_messages},
-            metadata={
-                "environment": env,
-                "model": config.model,
-                "message_count": len(session.messages),
-                "prompt_name": langfuse_prompt.name if langfuse_prompt else None,
-                "prompt_version": langfuse_prompt.version if langfuse_prompt else None,
-            },
-        )
-        # Set trace-level attributes (session_id, user_id, tags)
-        trace.update_trace(
+    input = message
+    if not message and tool_call_response:
+        input = tool_call_response
+
+    langfuse = get_client()
+    with langfuse.start_as_current_observation(
+        as_type="span",
+        name="user-copilot-request",
+        input=input,
+    ) as span:
+        with propagate_attributes(
             session_id=session_id,
             user_id=user_id,
-            tags=[env, "copilot"],
-        )
-    except Exception as e:
-        logger.warning(f"Failed to create Langfuse trace: {e}")
+            tags=["copilot"],
+            metadata={
+                "users_information": format_understanding_for_prompt(understanding)[
+                    :200
+                ]  # langfuse only accepts upto to 200 chars
+            },
+        ):
 
-    # Initialize variables that will be used in finally block (must be defined before try)
-    assistant_response = ChatMessage(
-        role="assistant",
-        content="",
-    )
-    accumulated_tool_calls: list[dict[str, Any]] = []
-
-    # Wrap main logic in try/finally to ensure Langfuse observations are always ended
-    try:
-        has_yielded_end = False
-        has_yielded_error = False
-        has_done_tool_call = False
-        has_received_text = False
-        text_streaming_ended = False
-        tool_response_messages: list[ChatMessage] = []
-        should_retry = False
-
-        # Generate unique IDs for AI SDK protocol
-        import uuid as uuid_module
-
-        message_id = str(uuid_module.uuid4())
-        text_block_id = str(uuid_module.uuid4())
-
-        # Yield message start
-        yield StreamStart(messageId=message_id)
-
-        # Create Langfuse generation for each LLM call, linked to the prompt
-        # Using v3 SDK: start_observation with as_type="generation"
-        generation = (
-            trace.start_observation(
-                as_type="generation",
-                name="llm_call",
-                model=config.model,
-                input={"messages": trace_input_messages},
-                prompt=langfuse_prompt,
+            # Initialize variables that will be used in finally block (must be defined before try)
+            assistant_response = ChatMessage(
+                role="assistant",
+                content="",
             )
-            if trace
-            else None
-        )
+            accumulated_tool_calls: list[dict[str, Any]] = []
 
-        try:
-            async for chunk in _stream_chat_chunks(
-                session=session,
-                tools=tools,
-                system_prompt=system_prompt,
-                text_block_id=text_block_id,
-            ):
+            # Wrap main logic in try/finally to ensure Langfuse observations are always ended
+            has_yielded_end = False
+            has_yielded_error = False
+            has_done_tool_call = False
+            has_received_text = False
+            text_streaming_ended = False
+            tool_response_messages: list[ChatMessage] = []
+            should_retry = False
 
-                if isinstance(chunk, StreamTextStart):
-                    # Emit text-start before first text delta
-                    if not has_received_text:
+            # Generate unique IDs for AI SDK protocol
+            import uuid as uuid_module
+
+            message_id = str(uuid_module.uuid4())
+            text_block_id = str(uuid_module.uuid4())
+
+            # Yield message start
+            yield StreamStart(messageId=message_id)
+
+            try:
+                async for chunk in _stream_chat_chunks(
+                    session=session,
+                    tools=tools,
+                    system_prompt=system_prompt,
+                    text_block_id=text_block_id,
+                ):
+
+                    if isinstance(chunk, StreamTextStart):
+                        # Emit text-start before first text delta
+                        if not has_received_text:
+                            yield chunk
+                    elif isinstance(chunk, StreamTextDelta):
+                        delta = chunk.delta or ""
+                        assert assistant_response.content is not None
+                        assistant_response.content += delta
+                        has_received_text = True
                         yield chunk
-                elif isinstance(chunk, StreamTextDelta):
-                    delta = chunk.delta or ""
-                    assert assistant_response.content is not None
-                    assistant_response.content += delta
-                    has_received_text = True
-                    yield chunk
-                elif isinstance(chunk, StreamTextEnd):
-                    # Emit text-end after text completes
-                    if has_received_text and not text_streaming_ended:
-                        text_streaming_ended = True
-                        yield chunk
-                elif isinstance(chunk, StreamToolInputStart):
-                    # Emit text-end before first tool call, but only if we've received text
-                    if has_received_text and not text_streaming_ended:
-                        yield StreamTextEnd(id=text_block_id)
-                        text_streaming_ended = True
-                    yield chunk
-                elif isinstance(chunk, StreamToolInputAvailable):
-                    # Accumulate tool calls in OpenAI format
-                    accumulated_tool_calls.append(
-                        {
-                            "id": chunk.toolCallId,
-                            "type": "function",
-                            "function": {
-                                "name": chunk.toolName,
-                                "arguments": orjson.dumps(chunk.input).decode("utf-8"),
-                            },
-                        }
-                    )
-                elif isinstance(chunk, StreamToolOutputAvailable):
-                    result_content = (
-                        chunk.output
-                        if isinstance(chunk.output, str)
-                        else orjson.dumps(chunk.output).decode("utf-8")
-                    )
-                    tool_response_messages.append(
-                        ChatMessage(
-                            role="tool",
-                            content=result_content,
-                            tool_call_id=chunk.toolCallId,
-                        )
-                    )
-                    has_done_tool_call = True
-                    # Track if any tool execution failed
-                    if not chunk.success:
-                        logger.warning(
-                            f"Tool {chunk.toolName} (ID: {chunk.toolCallId}) execution failed"
-                        )
-                    yield chunk
-                elif isinstance(chunk, StreamFinish):
-                    if not has_done_tool_call:
-                        # Emit text-end before finish if we received text but haven't closed it
+                    elif isinstance(chunk, StreamTextEnd):
+                        # Emit text-end after text completes
+                        if has_received_text and not text_streaming_ended:
+                            text_streaming_ended = True
+                            if assistant_response.content:
+                                logger.warn(
+                                    f"StreamTextEnd: Attempting to set output {assistant_response.content}"
+                                )
+                                span.update_trace(output=assistant_response.content)
+                                span.update(output=assistant_response.content)
+                            yield chunk
+                    elif isinstance(chunk, StreamToolInputStart):
+                        # Emit text-end before first tool call, but only if we've received text
                         if has_received_text and not text_streaming_ended:
                             yield StreamTextEnd(id=text_block_id)
                             text_streaming_ended = True
-                        has_yielded_end = True
                         yield chunk
-                elif isinstance(chunk, StreamError):
-                    has_yielded_error = True
-                elif isinstance(chunk, StreamUsage):
-                    session.usage.append(
-                        Usage(
-                            prompt_tokens=chunk.promptTokens,
-                            completion_tokens=chunk.completionTokens,
-                            total_tokens=chunk.totalTokens,
+                    elif isinstance(chunk, StreamToolInputAvailable):
+                        # Accumulate tool calls in OpenAI format
+                        accumulated_tool_calls.append(
+                            {
+                                "id": chunk.toolCallId,
+                                "type": "function",
+                                "function": {
+                                    "name": chunk.toolName,
+                                    "arguments": orjson.dumps(chunk.input).decode(
+                                        "utf-8"
+                                    ),
+                                },
+                            }
                         )
+                    elif isinstance(chunk, StreamToolOutputAvailable):
+                        result_content = (
+                            chunk.output
+                            if isinstance(chunk.output, str)
+                            else orjson.dumps(chunk.output).decode("utf-8")
+                        )
+                        tool_response_messages.append(
+                            ChatMessage(
+                                role="tool",
+                                content=result_content,
+                                tool_call_id=chunk.toolCallId,
+                            )
+                        )
+                        has_done_tool_call = True
+                        # Track if any tool execution failed
+                        if not chunk.success:
+                            logger.warning(
+                                f"Tool {chunk.toolName} (ID: {chunk.toolCallId}) execution failed"
+                            )
+                        yield chunk
+                    elif isinstance(chunk, StreamFinish):
+                        if not has_done_tool_call:
+                            # Emit text-end before finish if we received text but haven't closed it
+                            if has_received_text and not text_streaming_ended:
+                                yield StreamTextEnd(id=text_block_id)
+                                text_streaming_ended = True
+                            has_yielded_end = True
+                            yield chunk
+                    elif isinstance(chunk, StreamError):
+                        has_yielded_error = True
+                    elif isinstance(chunk, StreamUsage):
+                        session.usage.append(
+                            Usage(
+                                prompt_tokens=chunk.promptTokens,
+                                completion_tokens=chunk.completionTokens,
+                                total_tokens=chunk.totalTokens,
+                            )
+                        )
+                    else:
+                        logger.error(
+                            f"Unknown chunk type: {type(chunk)}", exc_info=True
+                        )
+                if assistant_response.content:
+                    langfuse.update_current_trace(output=assistant_response.content)
+                    langfuse.update_current_span(output=assistant_response.content)
+                elif tool_response_messages:
+                    langfuse.update_current_trace(output=str(tool_response_messages))
+                    langfuse.update_current_span(output=str(tool_response_messages))
+
+            except Exception as e:
+                logger.error(f"Error during stream: {e!s}", exc_info=True)
+
+                # Check if this is a retryable error (JSON parsing, incomplete tool calls, etc.)
+                is_retryable = isinstance(
+                    e, (orjson.JSONDecodeError, KeyError, TypeError)
+                )
+
+                if is_retryable and retry_count < config.max_retries:
+                    logger.info(
+                        f"Retryable error encountered. Attempt {retry_count + 1}/{config.max_retries}"
                     )
+                    should_retry = True
                 else:
-                    logger.error(f"Unknown chunk type: {type(chunk)}", exc_info=True)
-        except Exception as e:
-            logger.error(f"Error during stream: {e!s}", exc_info=True)
+                    # Non-retryable error or max retries exceeded
+                    # Save any partial progress before reporting error
+                    messages_to_save: list[ChatMessage] = []
 
-            # Check if this is a retryable error (JSON parsing, incomplete tool calls, etc.)
-            is_retryable = isinstance(e, (orjson.JSONDecodeError, KeyError, TypeError))
+                    # Add assistant message if it has content or tool calls
+                    if accumulated_tool_calls:
+                        assistant_response.tool_calls = accumulated_tool_calls
+                    if assistant_response.content or assistant_response.tool_calls:
+                        messages_to_save.append(assistant_response)
 
-            if is_retryable and retry_count < config.max_retries:
+                    # Add tool response messages after assistant message
+                    messages_to_save.extend(tool_response_messages)
+
+                    session.messages.extend(messages_to_save)
+                    await upsert_chat_session(session)
+
+                    if not has_yielded_error:
+                        error_message = str(e)
+                        if not is_retryable:
+                            error_message = f"Non-retryable error: {error_message}"
+                        elif retry_count >= config.max_retries:
+                            error_message = f"Max retries ({config.max_retries}) exceeded: {error_message}"
+
+                        error_response = StreamError(errorText=error_message)
+                        yield error_response
+                    if not has_yielded_end:
+                        yield StreamFinish()
+                    return
+
+            # Handle retry outside of exception handler to avoid nesting
+            if should_retry and retry_count < config.max_retries:
                 logger.info(
-                    f"Retryable error encountered. Attempt {retry_count + 1}/{config.max_retries}"
+                    f"Retrying stream_chat_completion for session {session_id}, attempt {retry_count + 1}"
                 )
-                should_retry = True
-            else:
-                # Non-retryable error or max retries exceeded
-                # Save any partial progress before reporting error
-                messages_to_save: list[ChatMessage] = []
+                async for chunk in stream_chat_completion(
+                    session_id=session.session_id,
+                    user_id=user_id,
+                    retry_count=retry_count + 1,
+                    session=session,
+                    context=context,
+                ):
+                    yield chunk
+                return  # Exit after retry to avoid double-saving in finally block
 
-                # Add assistant message if it has content or tool calls
-                if accumulated_tool_calls:
-                    assistant_response.tool_calls = accumulated_tool_calls
-                if assistant_response.content or assistant_response.tool_calls:
-                    messages_to_save.append(assistant_response)
-
-                # Add tool response messages after assistant message
-                messages_to_save.extend(tool_response_messages)
-
-                session.messages.extend(messages_to_save)
-                await upsert_chat_session(session)
-
-                if not has_yielded_error:
-                    error_message = str(e)
-                    if not is_retryable:
-                        error_message = f"Non-retryable error: {error_message}"
-                    elif retry_count >= config.max_retries:
-                        error_message = f"Max retries ({config.max_retries}) exceeded: {error_message}"
-
-                    error_response = StreamError(errorText=error_message)
-                    yield error_response
-                if not has_yielded_end:
-                    yield StreamFinish()
-                return
-
-        # Handle retry outside of exception handler to avoid nesting
-        if should_retry and retry_count < config.max_retries:
+            # Normal completion path - save session and handle tool call continuation
             logger.info(
-                f"Retrying stream_chat_completion for session {session_id}, attempt {retry_count + 1}"
-            )
-            async for chunk in stream_chat_completion(
-                session_id=session.session_id,
-                user_id=user_id,
-                retry_count=retry_count + 1,
-                session=session,
-                context=context,
-            ):
-                yield chunk
-            return  # Exit after retry to avoid double-saving in finally block
-
-        # Normal completion path - save session and handle tool call continuation
-        logger.info(
-            f"Normal completion path: session={session.session_id}, "
-            f"current message_count={len(session.messages)}"
-        )
-
-        # Build the messages list in the correct order
-        messages_to_save: list[ChatMessage] = []
-
-        # Add assistant message with tool_calls if any
-        if accumulated_tool_calls:
-            assistant_response.tool_calls = accumulated_tool_calls
-            logger.info(
-                f"Added {len(accumulated_tool_calls)} tool calls to assistant message"
-            )
-        if assistant_response.content or assistant_response.tool_calls:
-            messages_to_save.append(assistant_response)
-            logger.info(
-                f"Saving assistant message with content_len={len(assistant_response.content or '')}, tool_calls={len(assistant_response.tool_calls or [])}"
+                f"Normal completion path: session={session.session_id}, "
+                f"current message_count={len(session.messages)}"
             )
 
-        # Add tool response messages after assistant message
-        messages_to_save.extend(tool_response_messages)
-        logger.info(
-            f"Saving {len(tool_response_messages)} tool response messages, "
-            f"total_to_save={len(messages_to_save)}"
-        )
+            # Build the messages list in the correct order
+            messages_to_save: list[ChatMessage] = []
 
-        session.messages.extend(messages_to_save)
-        logger.info(
-            f"Extended session messages, new message_count={len(session.messages)}"
-        )
-        await upsert_chat_session(session)
-
-        # If we did a tool call, stream the chat completion again to get the next response
-        if has_done_tool_call:
-            logger.info(
-                "Tool call executed, streaming chat completion again to get assistant response"
-            )
-            async for chunk in stream_chat_completion(
-                session_id=session.session_id,
-                user_id=user_id,
-                session=session,  # Pass session object to avoid Redis refetch
-                context=context,
-            ):
-                yield chunk
-
-    finally:
-        # Always end Langfuse observations to prevent resource leaks
-        # Guard against None and catch errors to avoid masking original exceptions
-        if generation is not None:
-            try:
-                latest_usage = session.usage[-1] if session.usage else None
-                generation.update(
-                    model=config.model,
-                    output={
-                        "content": assistant_response.content,
-                        "tool_calls": accumulated_tool_calls or None,
-                    },
-                    usage_details=(
-                        {
-                            "input": latest_usage.prompt_tokens,
-                            "output": latest_usage.completion_tokens,
-                            "total": latest_usage.total_tokens,
-                        }
-                        if latest_usage
-                        else None
-                    ),
+            # Add assistant message with tool_calls if any
+            if accumulated_tool_calls:
+                assistant_response.tool_calls = accumulated_tool_calls
+                logger.info(
+                    f"Added {len(accumulated_tool_calls)} tool calls to assistant message"
+                )
+            if assistant_response.content or assistant_response.tool_calls:
+                messages_to_save.append(assistant_response)
+                logger.info(
+                    f"Saving assistant message with content_len={len(assistant_response.content or '')}, tool_calls={len(assistant_response.tool_calls or [])}"
                 )
-                generation.end()
-            except Exception as e:
-                logger.warning(f"Failed to end Langfuse generation: {e}")
 
-        if trace is not None:
-            try:
-                if accumulated_tool_calls:
-                    trace.update_trace(output={"tool_calls": accumulated_tool_calls})
-                else:
-                    trace.update_trace(output={"response": assistant_response.content})
-                trace.end()
-            except Exception as e:
-                logger.warning(f"Failed to end Langfuse trace: {e}")
+            # Add tool response messages after assistant message
+            messages_to_save.extend(tool_response_messages)
+            logger.info(
+                f"Saving {len(tool_response_messages)} tool response messages, "
+                f"total_to_save={len(messages_to_save)}"
+            )
+
+            session.messages.extend(messages_to_save)
+            logger.info(
+                f"Extended session messages, new message_count={len(session.messages)}"
+            )
+            await upsert_chat_session(session)
+
+            # If we did a tool call, stream the chat completion again to get the next response
+            if has_done_tool_call:
+                logger.info(
+                    "Tool call executed, streaming chat completion again to get assistant response"
+                )
+                async for chunk in stream_chat_completion(
+                    session_id=session.session_id,
+                    user_id=user_id,
+                    session=session,  # Pass session object to avoid Redis refetch
+                    context=context,
+                    tool_call_response=str(tool_response_messages),
+                ):
+                    yield chunk
 
 
 # Retry configuration for OpenAI API calls
@@ -900,5 +791,4 @@ async def _yield_tool_call(
         session=session,
     )
 
-    logger.info(f"Yielding Tool execution response: {tool_execution_response}")
     yield tool_execution_response

autogpt_platform/backend/backend/api/features/chat/tools/__init__.py

@@ -30,7 +30,7 @@ TOOL_REGISTRY: dict[str, BaseTool] = {
     "find_library_agent": FindLibraryAgentTool(),
     "run_agent": RunAgentTool(),
     "run_block": RunBlockTool(),
-    "agent_output": AgentOutputTool(),
+    "view_agent_output": AgentOutputTool(),
     "search_docs": SearchDocsTool(),
     "get_doc_page": GetDocPageTool(),
 }

autogpt_platform/backend/backend/api/features/chat/tools/add_understanding.py

@@ -3,6 +3,8 @@
 import logging
 from typing import Any
 
+from langfuse import observe
+
 from backend.api.features.chat.model import ChatSession
 from backend.data.understanding import (
     BusinessUnderstandingInput,
@@ -59,6 +61,7 @@ and automations for the user's specific needs."""
         """Requires authentication to store user-specific data."""
         return True
 
+    @observe(as_type="tool", name="add_understanding")
     async def _execute(
         self,
         user_id: str | None,

autogpt_platform/backend/backend/api/features/chat/tools/agent_output.py

@@ -5,6 +5,7 @@ import re
 from datetime import datetime, timedelta, timezone
 from typing import Any
 
+from langfuse import observe
 from pydantic import BaseModel, field_validator
 
 from backend.api.features.chat.model import ChatSession
@@ -103,7 +104,7 @@ class AgentOutputTool(BaseTool):
 
     @property
     def name(self) -> str:
-        return "agent_output"
+        return "view_agent_output"
 
     @property
     def description(self) -> str:
@@ -328,6 +329,7 @@ class AgentOutputTool(BaseTool):
             total_executions=len(available_executions) if available_executions else 1,
         )
 
+    @observe(as_type="tool", name="view_agent_output")
     async def _execute(
         self,
         user_id: str | None,

autogpt_platform/backend/backend/api/features/chat/tools/create_agent.py

@@ -3,6 +3,8 @@
 import logging
 from typing import Any
 
+from langfuse import observe
+
 from backend.api.features.chat.model import ChatSession
 
 from .agent_generator import (
@@ -78,6 +80,7 @@ class CreateAgentTool(BaseTool):
             "required": ["description"],
         }
 
+    @observe(as_type="tool", name="create_agent")
     async def _execute(
         self,
         user_id: str | None,

autogpt_platform/backend/backend/api/features/chat/tools/edit_agent.py

@@ -3,6 +3,8 @@
 import logging
 from typing import Any
 
+from langfuse import observe
+
 from backend.api.features.chat.model import ChatSession
 
 from .agent_generator import (
@@ -85,6 +87,7 @@ class EditAgentTool(BaseTool):
             "required": ["agent_id", "changes"],
         }
 
+    @observe(as_type="tool", name="edit_agent")
     async def _execute(
         self,
         user_id: str | None,

autogpt_platform/backend/backend/api/features/chat/tools/find_agent.py

@@ -2,6 +2,8 @@
 
 from typing import Any
 
+from langfuse import observe
+
 from backend.api.features.chat.model import ChatSession
 
 from .agent_search import search_agents
@@ -35,6 +37,7 @@ class FindAgentTool(BaseTool):
             "required": ["query"],
         }
 
+    @observe(as_type="tool", name="find_agent")
     async def _execute(
         self, user_id: str | None, session: ChatSession, **kwargs
     ) -> ToolResponseBase:

autogpt_platform/backend/backend/api/features/chat/tools/find_block.py

@@ -1,6 +1,7 @@
 import logging
 from typing import Any
 
+from langfuse import observe
 from prisma.enums import ContentType
 
 from backend.api.features.chat.model import ChatSession
@@ -55,6 +56,7 @@ class FindBlockTool(BaseTool):
     def requires_auth(self) -> bool:
         return True
 
+    @observe(as_type="tool", name="find_block")
     async def _execute(
         self,
         user_id: str | None,

autogpt_platform/backend/backend/api/features/chat/tools/find_library_agent.py

@@ -2,6 +2,8 @@
 
 from typing import Any
 
+from langfuse import observe
+
 from backend.api.features.chat.model import ChatSession
 
 from .agent_search import search_agents
@@ -41,6 +43,7 @@ class FindLibraryAgentTool(BaseTool):
     def requires_auth(self) -> bool:
         return True
 
+    @observe(as_type="tool", name="find_library_agent")
     async def _execute(
         self, user_id: str | None, session: ChatSession, **kwargs
     ) -> ToolResponseBase:

autogpt_platform/backend/backend/api/features/chat/tools/get_doc_page.py

@@ -4,6 +4,8 @@ import logging
 from pathlib import Path
 from typing import Any
 
+from langfuse import observe
+
 from backend.api.features.chat.model import ChatSession
 from backend.api.features.chat.tools.base import BaseTool
 from backend.api.features.chat.tools.models import (
@@ -71,6 +73,7 @@ class GetDocPageTool(BaseTool):
         url_path = path.rsplit(".", 1)[0] if "." in path else path
         return f"{DOCS_BASE_URL}/{url_path}"
 
+    @observe(as_type="tool", name="get_doc_page")
     async def _execute(
         self,
         user_id: str | None,

autogpt_platform/backend/backend/api/features/chat/tools/run_agent.py

@@ -3,6 +3,7 @@
 import logging
 from typing import Any
 
+from langfuse import observe
 from pydantic import BaseModel, Field, field_validator
 
 from backend.api.features.chat.config import ChatConfig
@@ -154,6 +155,7 @@ class RunAgentTool(BaseTool):
         """All operations require authentication."""
         return True
 
+    @observe(as_type="tool", name="run_agent")
     async def _execute(
         self,
         user_id: str | None,

autogpt_platform/backend/backend/api/features/chat/tools/run_block.py

@@ -4,6 +4,8 @@ import logging
 from collections import defaultdict
 from typing import Any
 
+from langfuse import observe
+
 from backend.api.features.chat.model import ChatSession
 from backend.data.block import get_block
 from backend.data.execution import ExecutionContext
@@ -127,6 +129,7 @@ class RunBlockTool(BaseTool):
 
         return matched_credentials, missing_credentials
 
+    @observe(as_type="tool", name="run_block")
     async def _execute(
         self,
         user_id: str | None,

autogpt_platform/backend/backend/api/features/chat/tools/search_docs.py

@@ -3,6 +3,7 @@
 import logging
 from typing import Any
 
+from langfuse import observe
 from prisma.enums import ContentType
 
 from backend.api.features.chat.model import ChatSession
@@ -87,6 +88,7 @@ class SearchDocsTool(BaseTool):
         url_path = path.rsplit(".", 1)[0] if "." in path else path
         return f"{DOCS_BASE_URL}/{url_path}"
 
+    @observe(as_type="tool", name="search_docs")
     async def _execute(
         self,
         user_id: str | None,

autogpt_platform/backend/backend/api/features/store/db.py

@@ -22,7 +22,6 @@ from backend.data.notifications import (
     AgentApprovalData,
     AgentRejectionData,
     NotificationEventModel,
-    WaitlistLaunchData,
 )
 from backend.notifications.notifications import queue_notification_async
 from backend.util.exceptions import DatabaseError
@@ -1718,29 +1717,6 @@ async def review_store_submission(
                 # Don't fail the review process if email sending fails
                 pass
 
-        # Notify waitlist users if this is an approval and has a linked waitlist
-        if is_approved and submission.StoreListing:
-            try:
-                frontend_base_url = (
-                    settings.config.frontend_base_url
-                    or settings.config.platform_base_url
-                )
-                store_agent = (
-                    await prisma.models.StoreAgent.prisma().find_first_or_raise(
-                        where={"storeListingVersionId": submission.id}
-                    )
-                )
-                creator_username = store_agent.creator_username or "unknown"
-                store_url = f"{frontend_base_url}/marketplace/agent/{creator_username}/{store_agent.slug}"
-                await notify_waitlist_users_on_launch(
-                    store_listing_id=submission.StoreListing.id,
-                    agent_name=submission.name,
-                    store_url=store_url,
-                )
-            except Exception as e:
-                logger.error(f"Failed to notify waitlist users on agent approval: {e}")
-                # Don't fail the approval process
-
         # Convert to Pydantic model for consistency
         return store_model.StoreSubmission(
             listing_id=(submission.StoreListing.id if submission.StoreListing else ""),
@@ -1988,552 +1964,3 @@ async def get_agent_as_admin(
         )
 
     return graph
-
-
-def _waitlist_to_store_entry(
-    waitlist: prisma.models.WaitlistEntry,
-) -> store_model.StoreWaitlistEntry:
-    """Convert a WaitlistEntry to StoreWaitlistEntry for public display."""
-    return store_model.StoreWaitlistEntry(
-        waitlistId=waitlist.id,
-        slug=waitlist.slug,
-        name=waitlist.name,
-        subHeading=waitlist.subHeading,
-        videoUrl=waitlist.videoUrl,
-        agentOutputDemoUrl=waitlist.agentOutputDemoUrl,
-        imageUrls=waitlist.imageUrls or [],
-        description=waitlist.description,
-        categories=waitlist.categories,
-    )
-
-
-async def get_waitlist() -> list[store_model.StoreWaitlistEntry]:
-    """Get all active waitlists for public display."""
-    try:
-        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
-            where=prisma.types.WaitlistEntryWhereInput(isDeleted=False),
-        )
-
-        # Filter out closed/done waitlists and sort by votes (descending)
-        excluded_statuses = {
-            prisma.enums.WaitlistExternalStatus.CANCELED,
-            prisma.enums.WaitlistExternalStatus.DONE,
-        }
-        active_waitlists = [w for w in waitlists if w.status not in excluded_statuses]
-        sorted_list = sorted(active_waitlists, key=lambda x: x.votes, reverse=True)
-
-        return [_waitlist_to_store_entry(w) for w in sorted_list]
-    except Exception as e:
-        logger.error(f"Error fetching waitlists: {e}")
-        raise DatabaseError("Failed to fetch waitlists") from e
-
-
-async def get_user_waitlist_memberships(user_id: str) -> list[str]:
-    """Get all waitlist IDs that a user has joined."""
-    try:
-        user = await prisma.models.User.prisma().find_unique(
-            where={"id": user_id},
-            include={"joinedWaitlists": True},
-        )
-        if not user or not user.joinedWaitlists:
-            return []
-        return [w.id for w in user.joinedWaitlists]
-    except Exception as e:
-        logger.error(f"Error fetching user waitlist memberships: {e}")
-        raise DatabaseError("Failed to fetch waitlist memberships") from e
-
-
-async def add_user_to_waitlist(
-    waitlist_id: str, user_id: str | None, email: str | None
-) -> store_model.StoreWaitlistEntry:
-    """
-    Add a user to a waitlist.
-
-    For logged-in users: connects via joinedUsers relation
-    For anonymous users: adds email to unaffiliatedEmailUsers array
-    """
-    if not user_id and not email:
-        raise ValueError("Either user_id or email must be provided")
-
-    try:
-        # Find the waitlist
-        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id},
-            include={"joinedUsers": True},
-        )
-
-        if not waitlist:
-            raise ValueError(f"Waitlist {waitlist_id} not found")
-
-        if waitlist.isDeleted:
-            raise ValueError(f"Waitlist {waitlist_id} is no longer available")
-
-        if waitlist.status in [
-            prisma.enums.WaitlistExternalStatus.CANCELED,
-            prisma.enums.WaitlistExternalStatus.DONE,
-        ]:
-            raise ValueError(f"Waitlist {waitlist_id} is closed")
-
-        if user_id:
-            # Check if user already joined
-            joined_user_ids = [u.id for u in (waitlist.joinedUsers or [])]
-            if user_id in joined_user_ids:
-                # Already joined - return waitlist info
-                logger.debug(f"User {user_id} already joined waitlist {waitlist_id}")
-            else:
-                # Connect user to waitlist
-                await prisma.models.WaitlistEntry.prisma().update(
-                    where={"id": waitlist_id},
-                    data={"joinedUsers": {"connect": [{"id": user_id}]}},
-                )
-                logger.info(f"User {user_id} joined waitlist {waitlist_id}")
-
-            # If user was previously in email list, remove them
-            # Use transaction to prevent race conditions
-            if email:
-                async with transaction() as tx:
-                    current_waitlist = await tx.waitlistentry.find_unique(
-                        where={"id": waitlist_id}
-                    )
-                    if current_waitlist and email in (
-                        current_waitlist.unaffiliatedEmailUsers or []
-                    ):
-                        updated_emails: list[str] = [
-                            e
-                            for e in (current_waitlist.unaffiliatedEmailUsers or [])
-                            if e != email
-                        ]
-                        await tx.waitlistentry.update(
-                            where={"id": waitlist_id},
-                            data={"unaffiliatedEmailUsers": updated_emails},
-                        )
-        elif email:
-            # Add email to unaffiliated list if not already present
-            # Use transaction to prevent race conditions with concurrent signups
-            async with transaction() as tx:
-                # Re-fetch within transaction to get latest state
-                current_waitlist = await tx.waitlistentry.find_unique(
-                    where={"id": waitlist_id}
-                )
-                if current_waitlist:
-                    current_emails: list[str] = list(
-                        current_waitlist.unaffiliatedEmailUsers or []
-                    )
-                    if email not in current_emails:
-                        current_emails.append(email)
-                        await tx.waitlistentry.update(
-                            where={"id": waitlist_id},
-                            data={"unaffiliatedEmailUsers": current_emails},
-                        )
-                        logger.info(f"Email {email} added to waitlist {waitlist_id}")
-                    else:
-                        logger.debug(f"Email {email} already on waitlist {waitlist_id}")
-
-        # Re-fetch to return updated data
-        updated_waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id}
-        )
-        return _waitlist_to_store_entry(updated_waitlist or waitlist)
-
-    except ValueError:
-        raise
-    except Exception as e:
-        logger.error(f"Error adding user to waitlist: {e}")
-        raise DatabaseError("Failed to add user to waitlist") from e
-
-
-# ============== Admin Waitlist Functions ==============
-
-
-def _waitlist_to_admin_response(
-    waitlist: prisma.models.WaitlistEntry,
-) -> store_model.WaitlistAdminResponse:
-    """Convert a WaitlistEntry to WaitlistAdminResponse."""
-    joined_count = len(waitlist.joinedUsers) if waitlist.joinedUsers else 0
-    email_count = (
-        len(waitlist.unaffiliatedEmailUsers) if waitlist.unaffiliatedEmailUsers else 0
-    )
-
-    return store_model.WaitlistAdminResponse(
-        id=waitlist.id,
-        createdAt=waitlist.createdAt.isoformat() if waitlist.createdAt else "",
-        updatedAt=waitlist.updatedAt.isoformat() if waitlist.updatedAt else "",
-        slug=waitlist.slug,
-        name=waitlist.name,
-        subHeading=waitlist.subHeading,
-        description=waitlist.description,
-        categories=waitlist.categories,
-        imageUrls=waitlist.imageUrls or [],
-        videoUrl=waitlist.videoUrl,
-        agentOutputDemoUrl=waitlist.agentOutputDemoUrl,
-        status=waitlist.status or prisma.enums.WaitlistExternalStatus.NOT_STARTED,
-        votes=waitlist.votes,
-        signupCount=joined_count + email_count,
-        storeListingId=waitlist.storeListingId,
-        owningUserId=waitlist.owningUserId,
-    )
-
-
-async def create_waitlist_admin(
-    admin_user_id: str,
-    data: store_model.WaitlistCreateRequest,
-) -> store_model.WaitlistAdminResponse:
-    """Create a new waitlist (admin only)."""
-    logger.info(f"Admin {admin_user_id} creating waitlist: {data.name}")
-
-    try:
-        waitlist = await prisma.models.WaitlistEntry.prisma().create(
-            data=prisma.types.WaitlistEntryCreateInput(
-                name=data.name,
-                slug=data.slug,
-                subHeading=data.subHeading,
-                description=data.description,
-                categories=data.categories,
-                imageUrls=data.imageUrls,
-                videoUrl=data.videoUrl,
-                agentOutputDemoUrl=data.agentOutputDemoUrl,
-                owningUserId=admin_user_id,
-                status=prisma.enums.WaitlistExternalStatus.NOT_STARTED,
-            ),
-            include={"joinedUsers": True},
-        )
-
-        return _waitlist_to_admin_response(waitlist)
-    except Exception as e:
-        logger.error(f"Error creating waitlist: {e}")
-        raise DatabaseError("Failed to create waitlist") from e
-
-
-async def get_waitlists_admin() -> store_model.WaitlistAdminListResponse:
-    """Get all waitlists with admin details."""
-    try:
-        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
-            where=prisma.types.WaitlistEntryWhereInput(isDeleted=False),
-            include={"joinedUsers": True},
-            order={"createdAt": "desc"},
-        )
-
-        return store_model.WaitlistAdminListResponse(
-            waitlists=[_waitlist_to_admin_response(w) for w in waitlists],
-            totalCount=len(waitlists),
-        )
-    except Exception as e:
-        logger.error(f"Error fetching waitlists for admin: {e}")
-        raise DatabaseError("Failed to fetch waitlists") from e
-
-
-async def get_waitlist_admin(
-    waitlist_id: str,
-) -> store_model.WaitlistAdminResponse:
-    """Get a single waitlist with admin details."""
-    try:
-        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id},
-            include={"joinedUsers": True},
-        )
-
-        if not waitlist:
-            raise ValueError(f"Waitlist {waitlist_id} not found")
-
-        if waitlist.isDeleted:
-            raise ValueError(f"Waitlist {waitlist_id} has been deleted")
-
-        return _waitlist_to_admin_response(waitlist)
-    except ValueError:
-        raise
-    except Exception as e:
-        logger.error(f"Error fetching waitlist {waitlist_id}: {e}")
-        raise DatabaseError("Failed to fetch waitlist") from e
-
-
-async def update_waitlist_admin(
-    waitlist_id: str,
-    data: store_model.WaitlistUpdateRequest,
-) -> store_model.WaitlistAdminResponse:
-    """Update a waitlist (admin only)."""
-    logger.info(f"Updating waitlist {waitlist_id}")
-
-    try:
-        # Check if waitlist exists first
-        existing = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id}
-        )
-
-        if not existing:
-            raise ValueError(f"Waitlist {waitlist_id} not found")
-
-        if existing.isDeleted:
-            raise ValueError(f"Waitlist {waitlist_id} has been deleted")
-
-        # Build update data from explicitly provided fields
-        # Use model_fields_set to allow clearing fields by setting them to None
-        field_mappings = {
-            "name": data.name,
-            "slug": data.slug,
-            "subHeading": data.subHeading,
-            "description": data.description,
-            "categories": data.categories,
-            "imageUrls": data.imageUrls,
-            "videoUrl": data.videoUrl,
-            "agentOutputDemoUrl": data.agentOutputDemoUrl,
-            "storeListingId": data.storeListingId,
-        }
-        update_data: dict[str, Any] = {
-            k: v for k, v in field_mappings.items() if k in data.model_fields_set
-        }
-
-        # Add status if provided (already validated as enum by Pydantic)
-        if "status" in data.model_fields_set and data.status is not None:
-            update_data["status"] = data.status
-
-        if not update_data:
-            # No updates, just return current data
-            return await get_waitlist_admin(waitlist_id)
-
-        waitlist = await prisma.models.WaitlistEntry.prisma().update(
-            where={"id": waitlist_id},
-            data=prisma.types.WaitlistEntryUpdateInput(**update_data),
-            include={"joinedUsers": True},
-        )
-
-        # We already verified existence above, so this should never be None
-        assert waitlist is not None
-        return _waitlist_to_admin_response(waitlist)
-    except ValueError:
-        raise
-    except Exception as e:
-        logger.error(f"Error updating waitlist {waitlist_id}: {e}")
-        raise DatabaseError("Failed to update waitlist") from e
-
-
-async def delete_waitlist_admin(waitlist_id: str) -> None:
-    """Soft delete a waitlist (admin only)."""
-    logger.info(f"Soft deleting waitlist {waitlist_id}")
-
-    try:
-        # Check if waitlist exists first
-        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id},
-        )
-
-        if not waitlist:
-            raise ValueError(f"Waitlist {waitlist_id} not found")
-
-        if waitlist.isDeleted:
-            raise ValueError(f"Waitlist {waitlist_id} has already been deleted")
-
-        await prisma.models.WaitlistEntry.prisma().update(
-            where={"id": waitlist_id},
-            data={"isDeleted": True},
-        )
-    except ValueError:
-        raise
-    except Exception as e:
-        logger.error(f"Error deleting waitlist {waitlist_id}: {e}")
-        raise DatabaseError("Failed to delete waitlist") from e
-
-
-async def get_waitlist_signups_admin(
-    waitlist_id: str,
-) -> store_model.WaitlistSignupListResponse:
-    """Get all signups for a waitlist (admin only)."""
-    try:
-        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id},
-            include={"joinedUsers": True},
-        )
-
-        if not waitlist:
-            raise ValueError(f"Waitlist {waitlist_id} not found")
-
-        signups: list[store_model.WaitlistSignup] = []
-
-        # Add user signups
-        for user in waitlist.joinedUsers or []:
-            signups.append(
-                store_model.WaitlistSignup(
-                    type="user",
-                    userId=user.id,
-                    email=user.email,
-                    username=user.name,
-                )
-            )
-
-        # Add email signups
-        for email in waitlist.unaffiliatedEmailUsers or []:
-            signups.append(
-                store_model.WaitlistSignup(
-                    type="email",
-                    email=email,
-                )
-            )
-
-        return store_model.WaitlistSignupListResponse(
-            waitlistId=waitlist_id,
-            signups=signups,
-            totalCount=len(signups),
-        )
-    except ValueError:
-        raise
-    except Exception as e:
-        logger.error(f"Error fetching signups for waitlist {waitlist_id}: {e}")
-        raise DatabaseError("Failed to fetch waitlist signups") from e
-
-
-async def link_waitlist_to_listing_admin(
-    waitlist_id: str,
-    store_listing_id: str,
-) -> store_model.WaitlistAdminResponse:
-    """Link a waitlist to a store listing (admin only)."""
-    logger.info(f"Linking waitlist {waitlist_id} to listing {store_listing_id}")
-
-    try:
-        # Verify the waitlist exists
-        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id}
-        )
-
-        if not waitlist:
-            raise ValueError(f"Waitlist {waitlist_id} not found")
-
-        if waitlist.isDeleted:
-            raise ValueError(f"Waitlist {waitlist_id} has been deleted")
-
-        # Verify the store listing exists
-        listing = await prisma.models.StoreListing.prisma().find_unique(
-            where={"id": store_listing_id}
-        )
-
-        if not listing:
-            raise ValueError(f"Store listing {store_listing_id} not found")
-
-        updated_waitlist = await prisma.models.WaitlistEntry.prisma().update(
-            where={"id": waitlist_id},
-            data={"StoreListing": {"connect": {"id": store_listing_id}}},
-            include={"joinedUsers": True},
-        )
-
-        # We already verified existence above, so this should never be None
-        assert updated_waitlist is not None
-        return _waitlist_to_admin_response(updated_waitlist)
-    except ValueError:
-        raise
-    except Exception as e:
-        logger.error(f"Error linking waitlist to listing: {e}")
-        raise DatabaseError("Failed to link waitlist to listing") from e
-
-
-async def notify_waitlist_users_on_launch(
-    store_listing_id: str,
-    agent_name: str,
-    store_url: str,
-) -> int:
-    """
-    Notify all users on waitlists linked to a store listing when the agent is launched.
-
-    Args:
-        store_listing_id: The ID of the store listing that was approved
-        agent_name: The name of the approved agent
-        store_url: The URL to the agent's store page
-
-    Returns:
-        The number of notifications sent
-    """
-    logger.info(f"Notifying waitlist users for store listing {store_listing_id}")
-
-    try:
-        # Find all active waitlists linked to this store listing
-        # Exclude DONE and CANCELED to prevent duplicate notifications on re-approval
-        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
-            where={
-                "storeListingId": store_listing_id,
-                "isDeleted": False,
-                "status": {
-                    "not_in": [
-                        prisma.enums.WaitlistExternalStatus.DONE,
-                        prisma.enums.WaitlistExternalStatus.CANCELED,
-                    ]
-                },
-            },
-            include={"joinedUsers": True},
-        )
-
-        if not waitlists:
-            logger.info(
-                f"No active waitlists found for store listing {store_listing_id}"
-            )
-            return 0
-
-        notification_count = 0
-        launched_at = datetime.now(tz=timezone.utc)
-
-        for waitlist in waitlists:
-            # Track notification results for this waitlist
-            users_to_notify = waitlist.joinedUsers or []
-            failed_user_ids: list[str] = []
-
-            # Notify registered users
-            for user in users_to_notify:
-                try:
-                    notification_data = WaitlistLaunchData(
-                        agent_name=agent_name,
-                        waitlist_name=waitlist.name,
-                        store_url=store_url,
-                        launched_at=launched_at,
-                    )
-
-                    notification_event = NotificationEventModel[WaitlistLaunchData](
-                        user_id=user.id,
-                        type=prisma.enums.NotificationType.WAITLIST_LAUNCH,
-                        data=notification_data,
-                    )
-
-                    await queue_notification_async(notification_event)
-                    notification_count += 1
-                except Exception as e:
-                    logger.error(
-                        f"Failed to send waitlist launch notification to user {user.id}: {e}"
-                    )
-                    failed_user_ids.append(user.id)
-
-            # Note: For unaffiliated email users, you would need to send emails directly
-            # since they don't have user IDs for the notification system.
-            # This could be done via a separate email service.
-            # For now, we log these for potential manual follow-up or future implementation.
-            has_pending_email_users = bool(waitlist.unaffiliatedEmailUsers)
-            if has_pending_email_users:
-                logger.info(
-                    f"Waitlist {waitlist.id} has {len(waitlist.unaffiliatedEmailUsers)} "
-                    f"unaffiliated email users that need email notifications"
-                )
-
-            # Only mark waitlist as DONE if all registered user notifications succeeded
-            # AND there are no unaffiliated email users still waiting for notifications
-            if not failed_user_ids and not has_pending_email_users:
-                await prisma.models.WaitlistEntry.prisma().update(
-                    where={"id": waitlist.id},
-                    data={"status": prisma.enums.WaitlistExternalStatus.DONE},
-                )
-                logger.info(f"Updated waitlist {waitlist.id} status to DONE")
-            elif failed_user_ids:
-                logger.warning(
-                    f"Waitlist {waitlist.id} not marked as DONE due to "
-                    f"{len(failed_user_ids)} failed notifications"
-                )
-            elif has_pending_email_users:
-                logger.warning(
-                    f"Waitlist {waitlist.id} not marked as DONE due to "
-                    f"{len(waitlist.unaffiliatedEmailUsers)} pending email-only users"
-                )
-
-        logger.info(
-            f"Sent {notification_count} waitlist launch notifications for store listing {store_listing_id}"
-        )
-        return notification_count
-
-    except Exception as e:
-        logger.error(
-            f"Error notifying waitlist users for store listing {store_listing_id}: {e}"
-        )
-        # Don't raise - we don't want to fail the approval process
-        return 0

autogpt_platform/backend/backend/api/features/store/model.py

@@ -223,102 +223,6 @@ class ReviewSubmissionRequest(pydantic.BaseModel):
     internal_comments: str | None = None  # Private admin notes
 
 
-class StoreWaitlistEntry(pydantic.BaseModel):
-    """Public waitlist entry - no PII fields exposed."""
-
-    waitlistId: str
-    slug: str
-
-    # Content fields
-    name: str
-    subHeading: str
-    videoUrl: str | None = None
-    agentOutputDemoUrl: str | None = None
-    imageUrls: list[str]
-    description: str
-    categories: list[str]
-
-
-class StoreWaitlistsAllResponse(pydantic.BaseModel):
-    listings: list[StoreWaitlistEntry]
-
-
-# Admin Waitlist Models
-
-
-class WaitlistCreateRequest(pydantic.BaseModel):
-    """Request model for creating a new waitlist."""
-
-    name: str
-    slug: str
-    subHeading: str
-    description: str
-    categories: list[str] = []
-    imageUrls: list[str] = []
-    videoUrl: str | None = None
-    agentOutputDemoUrl: str | None = None
-
-
-class WaitlistUpdateRequest(pydantic.BaseModel):
-    """Request model for updating a waitlist."""
-
-    name: str | None = None
-    slug: str | None = None
-    subHeading: str | None = None
-    description: str | None = None
-    categories: list[str] | None = None
-    imageUrls: list[str] | None = None
-    videoUrl: str | None = None
-    agentOutputDemoUrl: str | None = None
-    status: prisma.enums.WaitlistExternalStatus | None = None
-    storeListingId: str | None = None  # Link to a store listing
-
-
-class WaitlistAdminResponse(pydantic.BaseModel):
-    """Admin response model with full waitlist details including internal data."""
-
-    id: str
-    createdAt: str
-    updatedAt: str
-    slug: str
-    name: str
-    subHeading: str
-    description: str
-    categories: list[str]
-    imageUrls: list[str]
-    videoUrl: str | None = None
-    agentOutputDemoUrl: str | None = None
-    status: prisma.enums.WaitlistExternalStatus
-    votes: int
-    signupCount: int  # Total count of joinedUsers + unaffiliatedEmailUsers
-    storeListingId: str | None = None
-    owningUserId: str
-
-
-class WaitlistSignup(pydantic.BaseModel):
-    """Individual signup entry for a waitlist."""
-
-    type: str  # "user" or "email"
-    userId: str | None = None
-    email: str | None = None
-    username: str | None = None  # For user signups
-
-
-class WaitlistSignupListResponse(pydantic.BaseModel):
-    """Response model for listing waitlist signups."""
-
-    waitlistId: str
-    signups: list[WaitlistSignup]
-    totalCount: int
-
-
-class WaitlistAdminListResponse(pydantic.BaseModel):
-    """Response model for listing all waitlists (admin view)."""
-
-    waitlists: list[WaitlistAdminResponse]
-    totalCount: int
-
-
 class UnifiedSearchResult(pydantic.BaseModel):
     """A single result from unified hybrid search across all content types."""
 

autogpt_platform/backend/backend/api/features/store/routes.py

@@ -8,7 +8,6 @@ import autogpt_libs.auth
 import fastapi
 import fastapi.responses
 import prisma.enums
-from autogpt_libs.auth.dependencies import get_optional_user_id
 
 import backend.data.graph
 import backend.util.json
@@ -82,74 +81,6 @@ async def update_or_create_profile(
     return updated_profile
 
 
-##############################################
-############## Waitlist Endpoints ############
-##############################################
-@router.get(
-    "/waitlist",
-    summary="Get the agent waitlist",
-    tags=["store", "public"],
-    response_model=store_model.StoreWaitlistsAllResponse,
-)
-async def get_waitlist():
-    """
-    Get all active waitlists for public display.
-    """
-    waitlists = await store_db.get_waitlist()
-    return store_model.StoreWaitlistsAllResponse(listings=waitlists)
-
-
-@router.get(
-    "/waitlist/my-memberships",
-    summary="Get waitlist IDs the current user has joined",
-    tags=["store", "private"],
-)
-async def get_my_waitlist_memberships(
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
-) -> list[str]:
-    """Returns list of waitlist IDs the authenticated user has joined."""
-    return await store_db.get_user_waitlist_memberships(user_id)
-
-
-@router.post(
-    path="/waitlist/{waitlist_id}/join",
-    summary="Add self to the agent waitlist",
-    tags=["store", "public"],
-    response_model=store_model.StoreWaitlistEntry,
-)
-async def add_self_to_waitlist(
-    user_id: str | None = fastapi.Security(get_optional_user_id),
-    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist to join"),
-    email: str | None = fastapi.Body(
-        default=None, embed=True, description="Email address for unauthenticated users"
-    ),
-):
-    """
-    Add the current user to the agent waitlist.
-    """
-    if not user_id and not email:
-        raise fastapi.HTTPException(
-            status_code=400,
-            detail="Either user authentication or email address is required",
-        )
-
-    try:
-        waitlist_entry = await store_db.add_user_to_waitlist(
-            waitlist_id=waitlist_id, user_id=user_id, email=email
-        )
-        return waitlist_entry
-    except ValueError as e:
-        error_msg = str(e)
-        if "not found" in error_msg:
-            raise fastapi.HTTPException(status_code=404, detail="Waitlist not found")
-        # Waitlist exists but is closed or unavailable
-        raise fastapi.HTTPException(status_code=400, detail=error_msg)
-    except Exception:
-        raise fastapi.HTTPException(
-            status_code=500, detail="An error occurred while joining the waitlist"
-        )
-
-
 ##############################################
 ############### Agent Endpoints ##############
 ##############################################

autogpt_platform/backend/backend/api/rest_api.py

@@ -19,7 +19,6 @@ from prisma.errors import PrismaError
 import backend.api.features.admin.credit_admin_routes
 import backend.api.features.admin.execution_analytics_routes
 import backend.api.features.admin.store_admin_routes
-import backend.api.features.admin.waitlist_admin_routes
 import backend.api.features.builder
 import backend.api.features.builder.routes
 import backend.api.features.chat.routes as chat_routes
@@ -284,11 +283,6 @@ app.include_router(
     tags=["v2", "admin"],
     prefix="/api/store",
 )
-app.include_router(
-    backend.api.features.admin.waitlist_admin_routes.router,
-    tags=["v2", "admin"],
-    prefix="/api/store",
-)
 app.include_router(
     backend.api.features.admin.credit_admin_routes.router,
     tags=["v2", "admin"],

autogpt_platform/backend/backend/blocks/ai_shortform_video_block.py

@@ -174,7 +174,7 @@ class AIShortformVideoCreatorBlock(Block):
         )
         frame_rate: int = SchemaField(description="Frame rate of the video", default=60)
         generation_preset: GenerationPreset = SchemaField(
-            description="Generation preset for visual style - only effects AI generated visuals",
+            description="Generation preset for visual style - only affects AI-generated visuals",
             default=GenerationPreset.LEONARDO,
             placeholder=GenerationPreset.LEONARDO,
         )

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

@@ -381,7 +381,7 @@ Each range you add needs to be a string, with the upper and lower numbers of the
     organization_locations: Optional[list[str]] = SchemaField(
         description="""The location of the company headquarters. You can search across cities, US states, and countries.
 
-If a company has several office locations, results are still based on the headquarters location. For example, if you search chicago but a company's HQ location is in boston, any Boston-based companies will not appearch in your search results, even if they match other parameters.
+If a company has several office locations, results are still based on the headquarters location. For example, if you search chicago but a company's HQ location is in boston, any Boston-based companies will not appear in your search results, even if they match other parameters.
 
 To exclude companies based on location, use the organization_not_locations parameter.
 """,

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

@@ -34,7 +34,7 @@ Each range you add needs to be a string, with the upper and lower numbers of the
         organization_locations: list[str] = SchemaField(
             description="""The location of the company headquarters. You can search across cities, US states, and countries.
 
-If a company has several office locations, results are still based on the headquarters location. For example, if you search chicago but a company's HQ location is in boston, any Boston-based companies will not appearch in your search results, even if they match other parameters.
+If a company has several office locations, results are still based on the headquarters location. For example, if you search chicago but a company's HQ location is in boston, any Boston-based companies will not appear in your search results, even if they match other parameters.
 
 To exclude companies based on location, use the organization_not_locations parameter.
 """,

autogpt_platform/backend/backend/blocks/basic.py

@@ -81,7 +81,7 @@ class StoreValueBlock(Block):
     def __init__(self):
         super().__init__(
             id="1ff065e9-88e8-4358-9d82-8dc91f622ba9",
-            description="This block forwards an input value as output, allowing reuse without change.",
+            description="A basic block that stores and forwards a value throughout workflows, allowing it to be reused without changes across multiple blocks.",
             categories={BlockCategory.BASIC},
             input_schema=StoreValueBlock.Input,
             output_schema=StoreValueBlock.Output,
@@ -111,7 +111,7 @@ class PrintToConsoleBlock(Block):
     def __init__(self):
         super().__init__(
             id="f3b1c1b2-4c4f-4f0d-8d2f-4c4f0d8d2f4c",
-            description="Print the given text to the console, this is used for a debugging purpose.",
+            description="A debugging block that outputs text to the console for monitoring and troubleshooting workflow execution.",
             categories={BlockCategory.BASIC},
             input_schema=PrintToConsoleBlock.Input,
             output_schema=PrintToConsoleBlock.Output,
@@ -137,7 +137,7 @@ class NoteBlock(Block):
     def __init__(self):
         super().__init__(
             id="cc10ff7b-7753-4ff2-9af6-9399b1a7eddc",
-            description="This block is used to display a sticky note with the given text.",
+            description="A visual annotation block that displays a sticky note in the workflow editor for documentation and organization purposes.",
             categories={BlockCategory.BASIC},
             input_schema=NoteBlock.Input,
             output_schema=NoteBlock.Output,

autogpt_platform/backend/backend/blocks/data_manipulation.py

@@ -159,7 +159,7 @@ class FindInDictionaryBlock(Block):
     def __init__(self):
         super().__init__(
             id="0e50422c-6dee-4145-83d6-3a5a392f65de",
-            description="Lookup the given key in the input dictionary/object/list and return the value.",
+            description="A block that looks up a value in a dictionary, list, or object by key or index and returns the corresponding value.",
             input_schema=FindInDictionaryBlock.Input,
             output_schema=FindInDictionaryBlock.Output,
             test_input=[

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

@@ -51,7 +51,7 @@ class GithubCommentBlock(Block):
     def __init__(self):
         super().__init__(
             id="a8db4d8d-db1c-4a25-a1b0-416a8c33602b",
-            description="This block posts a comment on a specified GitHub issue or pull request.",
+            description="A block that posts comments on GitHub issues or pull requests using the GitHub API.",
             categories={BlockCategory.DEVELOPER_TOOLS},
             input_schema=GithubCommentBlock.Input,
             output_schema=GithubCommentBlock.Output,
@@ -151,7 +151,7 @@ class GithubUpdateCommentBlock(Block):
     def __init__(self):
         super().__init__(
             id="b3f4d747-10e3-4e69-8c51-f2be1d99c9a7",
-            description="This block updates a comment on a specified GitHub issue or pull request.",
+            description="A block that updates an existing comment on a GitHub issue or pull request.",
             categories={BlockCategory.DEVELOPER_TOOLS},
             input_schema=GithubUpdateCommentBlock.Input,
             output_schema=GithubUpdateCommentBlock.Output,
@@ -249,7 +249,7 @@ class GithubListCommentsBlock(Block):
     def __init__(self):
         super().__init__(
             id="c4b5fb63-0005-4a11-b35a-0c2467bd6b59",
-            description="This block lists all comments for a specified GitHub issue or pull request.",
+            description="A block that retrieves all comments from a GitHub issue or pull request, including comment metadata and content.",
             categories={BlockCategory.DEVELOPER_TOOLS},
             input_schema=GithubListCommentsBlock.Input,
             output_schema=GithubListCommentsBlock.Output,
@@ -363,7 +363,7 @@ class GithubMakeIssueBlock(Block):
     def __init__(self):
         super().__init__(
             id="691dad47-f494-44c3-a1e8-05b7990f2dab",
-            description="This block creates a new issue on a specified GitHub repository.",
+            description="A block that creates new issues on GitHub repositories with a title and body content.",
             categories={BlockCategory.DEVELOPER_TOOLS},
             input_schema=GithubMakeIssueBlock.Input,
             output_schema=GithubMakeIssueBlock.Output,
@@ -433,7 +433,7 @@ class GithubReadIssueBlock(Block):
     def __init__(self):
         super().__init__(
             id="6443c75d-032a-4772-9c08-230c707c8acc",
-            description="This block reads the body, title, and user of a specified GitHub issue.",
+            description="A block that retrieves information about a specific GitHub issue, including its title, body content, and creator.",
             categories={BlockCategory.DEVELOPER_TOOLS},
             input_schema=GithubReadIssueBlock.Input,
             output_schema=GithubReadIssueBlock.Output,
@@ -510,7 +510,7 @@ class GithubListIssuesBlock(Block):
     def __init__(self):
         super().__init__(
             id="c215bfd7-0e57-4573-8f8c-f7d4963dcd74",
-            description="This block lists all issues for a specified GitHub repository.",
+            description="A block that retrieves a list of issues from a GitHub repository with their titles and URLs.",
             categories={BlockCategory.DEVELOPER_TOOLS},
             input_schema=GithubListIssuesBlock.Input,
             output_schema=GithubListIssuesBlock.Output,
@@ -597,7 +597,7 @@ class GithubAddLabelBlock(Block):
     def __init__(self):
         super().__init__(
             id="98bd6b77-9506-43d5-b669-6b9733c4b1f1",
-            description="This block adds a label to a specified GitHub issue or pull request.",
+            description="A block that adds a label to a GitHub issue or pull request for categorization and organization.",
             categories={BlockCategory.DEVELOPER_TOOLS},
             input_schema=GithubAddLabelBlock.Input,
             output_schema=GithubAddLabelBlock.Output,
@@ -657,7 +657,7 @@ class GithubRemoveLabelBlock(Block):
     def __init__(self):
         super().__init__(
             id="78f050c5-3e3a-48c0-9e5b-ef1ceca5589c",
-            description="This block removes a label from a specified GitHub issue or pull request.",
+            description="A block that removes a label from a GitHub issue or pull request.",
             categories={BlockCategory.DEVELOPER_TOOLS},
             input_schema=GithubRemoveLabelBlock.Input,
             output_schema=GithubRemoveLabelBlock.Output,
@@ -720,7 +720,7 @@ class GithubAssignIssueBlock(Block):
     def __init__(self):
         super().__init__(
             id="90507c72-b0ff-413a-886a-23bbbd66f542",
-            description="This block assigns a user to a specified GitHub issue.",
+            description="A block that assigns a GitHub user to an issue for task ownership and tracking.",
             categories={BlockCategory.DEVELOPER_TOOLS},
             input_schema=GithubAssignIssueBlock.Input,
             output_schema=GithubAssignIssueBlock.Output,
@@ -786,7 +786,7 @@ class GithubUnassignIssueBlock(Block):
     def __init__(self):
         super().__init__(
             id="d154002a-38f4-46c2-962d-2488f2b05ece",
-            description="This block unassigns a user from a specified GitHub issue.",
+            description="A block that removes a user's assignment from a GitHub issue.",
             categories={BlockCategory.DEVELOPER_TOOLS},
             input_schema=GithubUnassignIssueBlock.Input,
             output_schema=GithubUnassignIssueBlock.Output,

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

@@ -353,7 +353,7 @@ class GmailReadBlock(GmailBase):
     def __init__(self):
         super().__init__(
             id="25310c70-b89b-43ba-b25c-4dfa7e2a481c",
-            description="This block reads emails from Gmail.",
+            description="A block that retrieves and reads emails from a Gmail account based on search criteria, returning detailed message information including subject, sender, body, and attachments.",
             categories={BlockCategory.COMMUNICATION},
             disabled=not GOOGLE_OAUTH_IS_CONFIGURED,
             input_schema=GmailReadBlock.Input,
@@ -743,7 +743,7 @@ class GmailListLabelsBlock(GmailBase):
     def __init__(self):
         super().__init__(
             id="3e1c2c1c-c689-4520-b956-1f3bf4e02bb7",
-            description="This block lists all labels in Gmail.",
+            description="A block that retrieves all labels (categories) from a Gmail account for organizing and categorizing emails.",
             categories={BlockCategory.COMMUNICATION},
             input_schema=GmailListLabelsBlock.Input,
             output_schema=GmailListLabelsBlock.Output,
@@ -807,7 +807,7 @@ class GmailAddLabelBlock(GmailBase):
     def __init__(self):
         super().__init__(
             id="f884b2fb-04f4-4265-9658-14f433926ac9",
-            description="This block adds a label to a Gmail message.",
+            description="A block that adds a label to a specific email message in Gmail, creating the label if it doesn't exist.",
             categories={BlockCategory.COMMUNICATION},
             input_schema=GmailAddLabelBlock.Input,
             output_schema=GmailAddLabelBlock.Output,
@@ -893,7 +893,7 @@ class GmailRemoveLabelBlock(GmailBase):
     def __init__(self):
         super().__init__(
             id="0afc0526-aba1-4b2b-888e-a22b7c3f359d",
-            description="This block removes a label from a Gmail message.",
+            description="A block that removes a label from a specific email message in a Gmail account.",
             categories={BlockCategory.COMMUNICATION},
             input_schema=GmailRemoveLabelBlock.Input,
             output_schema=GmailRemoveLabelBlock.Output,
@@ -961,7 +961,7 @@ class GmailGetThreadBlock(GmailBase):
     def __init__(self):
         super().__init__(
             id="21a79166-9df7-4b5f-9f36-96f639d86112",
-            description="Get a full Gmail thread by ID",
+            description="A block that retrieves an entire Gmail thread (email conversation) by ID, returning all messages with decoded bodies for reading complete conversations.",
             categories={BlockCategory.COMMUNICATION},
             input_schema=GmailGetThreadBlock.Input,
             output_schema=GmailGetThreadBlock.Output,

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

@@ -282,7 +282,7 @@ class GoogleSheetsReadBlock(Block):
     def __init__(self):
         super().__init__(
             id="5724e902-3635-47e9-a108-aaa0263a4988",
-            description="This block reads data from a Google Sheets spreadsheet.",
+            description="A block that reads data from a Google Sheets spreadsheet using A1 notation range selection.",
             categories={BlockCategory.DATA},
             input_schema=GoogleSheetsReadBlock.Input,
             output_schema=GoogleSheetsReadBlock.Output,
@@ -409,7 +409,7 @@ class GoogleSheetsWriteBlock(Block):
     def __init__(self):
         super().__init__(
             id="d9291e87-301d-47a8-91fe-907fb55460e5",
-            description="This block writes data to a Google Sheets spreadsheet.",
+            description="A block that writes data to a Google Sheets spreadsheet at a specified A1 notation range.",
             categories={BlockCategory.DATA},
             input_schema=GoogleSheetsWriteBlock.Input,
             output_schema=GoogleSheetsWriteBlock.Output,

autogpt_platform/backend/backend/blocks/io.py

@@ -76,7 +76,7 @@ class AgentInputBlock(Block):
         super().__init__(
             **{
                 "id": "c0a8e994-ebf1-4a9c-a4d8-89d09c86741b",
-                "description": "Base block for user inputs.",
+                "description": "A block that accepts and processes user input values within a workflow, supporting various input types and validation.",
                 "input_schema": AgentInputBlock.Input,
                 "output_schema": AgentInputBlock.Output,
                 "test_input": [
@@ -168,7 +168,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="A block that records and formats workflow results for display to users, with optional Jinja2 template formatting support.",
             input_schema=AgentOutputBlock.Input,
             output_schema=AgentOutputBlock.Output,
             test_input=[

autogpt_platform/backend/backend/blocks/llm.py

@@ -854,7 +854,7 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
     def __init__(self):
         super().__init__(
             id="ed55ac19-356e-4243-a6cb-bc599e9b716f",
-            description="Call a Large Language Model (LLM) to generate formatted object based on the given prompt.",
+            description="A block that generates structured JSON responses using a Large Language Model (LLM), with schema validation and format enforcement.",
             categories={BlockCategory.AI},
             input_schema=AIStructuredResponseGeneratorBlock.Input,
             output_schema=AIStructuredResponseGeneratorBlock.Output,
@@ -1265,7 +1265,7 @@ class AITextGeneratorBlock(AIBlockBase):
     def __init__(self):
         super().__init__(
             id="1f292d4a-41a4-4977-9684-7c8d560b9f91",
-            description="Call a Large Language Model (LLM) to generate a string based on the given prompt.",
+            description="A block that produces text responses using a Large Language Model (LLM) based on customizable prompts and system instructions.",
             categories={BlockCategory.AI},
             input_schema=AITextGeneratorBlock.Input,
             output_schema=AITextGeneratorBlock.Output,
@@ -1361,7 +1361,7 @@ class AITextSummarizerBlock(AIBlockBase):
     def __init__(self):
         super().__init__(
             id="a0a69be1-4528-491c-a85a-a4ab6873e3f0",
-            description="Utilize a Large Language Model (LLM) to summarize a long text.",
+            description="A block that summarizes long texts using a Large Language Model (LLM), with configurable focus topics and summary styles.",
             categories={BlockCategory.AI, BlockCategory.TEXT},
             input_schema=AITextSummarizerBlock.Input,
             output_schema=AITextSummarizerBlock.Output,
@@ -1562,7 +1562,7 @@ class AIConversationBlock(AIBlockBase):
     def __init__(self):
         super().__init__(
             id="32a87eab-381e-4dd4-bdb8-4c47151be35a",
-            description="Advanced LLM call that takes a list of messages and sends them to the language model.",
+            description="A block that facilitates multi-turn conversations with a Large Language Model (LLM), maintaining context across message exchanges.",
             categories={BlockCategory.AI},
             input_schema=AIConversationBlock.Input,
             output_schema=AIConversationBlock.Output,
@@ -1682,7 +1682,7 @@ class AIListGeneratorBlock(AIBlockBase):
     def __init__(self):
         super().__init__(
             id="9c0b0450-d199-458b-a731-072189dd6593",
-            description="Generate a list of values based on the given prompt using a Large Language Model (LLM).",
+            description="A block that creates lists of items based on prompts using a Large Language Model (LLM), with optional source data for context.",
             categories={BlockCategory.AI, BlockCategory.TEXT},
             input_schema=AIListGeneratorBlock.Input,
             output_schema=AIListGeneratorBlock.Output,

autogpt_platform/backend/backend/blocks/medium.py

@@ -46,7 +46,7 @@ class PublishToMediumBlock(Block):
     class Input(BlockSchemaInput):
         author_id: BlockSecret = SecretField(
             key="medium_author_id",
-            description="""The Medium AuthorID of the user. You can get this by calling the /me endpoint of the Medium API.\n\ncurl -H "Authorization: Bearer YOUR_ACCESS_TOKEN" https://api.medium.com/v1/me" the response will contain the authorId field.""",
+            description="""The Medium AuthorID of the user. You can get this by calling the /me endpoint of the Medium API.\n\ncurl -H "Authorization: Bearer YOUR_ACCESS_TOKEN" https://api.medium.com/v1/me\n\nThe response will contain the authorId field.""",
             placeholder="Enter the author's Medium AuthorID",
         )
         title: str = SchemaField(

autogpt_platform/backend/backend/blocks/talking_head.py

@@ -50,7 +50,7 @@ class CreateTalkingAvatarVideoBlock(Block):
             description="The voice provider to use", default="microsoft"
         )
         voice_id: str = SchemaField(
-            description="The voice ID to use, get list of voices [here](https://docs.agpt.co/server/d_id)",
+            description="The voice ID to use, see [available voice IDs](https://agpt.co/docs/platform/using-ai-services/d_id)",
             default="en-US-JennyNeural",
         )
         presenter_id: str = SchemaField(

autogpt_platform/backend/backend/data/notifications.py

@@ -211,22 +211,6 @@ class AgentRejectionData(BaseNotificationData):
         return value
 
 
-class WaitlistLaunchData(BaseNotificationData):
-    """Notification data for when an agent from a waitlist is launched."""
-
-    agent_name: str
-    waitlist_name: str
-    store_url: str
-    launched_at: datetime
-
-    @field_validator("launched_at")
-    @classmethod
-    def validate_timezone(cls, value: datetime):
-        if value.tzinfo is None:
-            raise ValueError("datetime must have timezone information")
-        return value
-
-
 NotificationData = Annotated[
     Union[
         AgentRunData,
@@ -239,7 +223,6 @@ NotificationData = Annotated[
         DailySummaryData,
         RefundRequestData,
         BaseSummaryData,
-        WaitlistLaunchData,
     ],
     Field(discriminator="type"),
 ]
@@ -290,7 +273,6 @@ def get_notif_data_type(
         NotificationType.REFUND_PROCESSED: RefundRequestData,
         NotificationType.AGENT_APPROVED: AgentApprovalData,
         NotificationType.AGENT_REJECTED: AgentRejectionData,
-        NotificationType.WAITLIST_LAUNCH: WaitlistLaunchData,
     }[notification_type]
 
 
@@ -336,7 +318,6 @@ class NotificationTypeOverride:
             NotificationType.REFUND_PROCESSED: QueueType.ADMIN,
             NotificationType.AGENT_APPROVED: QueueType.IMMEDIATE,
             NotificationType.AGENT_REJECTED: QueueType.IMMEDIATE,
-            NotificationType.WAITLIST_LAUNCH: QueueType.IMMEDIATE,
         }
         return BATCHING_RULES.get(self.notification_type, QueueType.IMMEDIATE)
 
@@ -356,7 +337,6 @@ class NotificationTypeOverride:
             NotificationType.REFUND_PROCESSED: "refund_processed.html",
             NotificationType.AGENT_APPROVED: "agent_approved.html",
             NotificationType.AGENT_REJECTED: "agent_rejected.html",
-            NotificationType.WAITLIST_LAUNCH: "waitlist_launch.html",
         }[self.notification_type]
 
     @property
@@ -374,7 +354,6 @@ class NotificationTypeOverride:
             NotificationType.REFUND_PROCESSED: "Refund for ${{data.amount / 100}} to {{data.user_name}} has been processed",
             NotificationType.AGENT_APPROVED: "🎉 Your agent '{{data.agent_name}}' has been approved!",
             NotificationType.AGENT_REJECTED: "Your agent '{{data.agent_name}}' needs some updates",
-            NotificationType.WAITLIST_LAUNCH: "🚀 {{data.agent_name}} is now available!",
         }[self.notification_type]
 
 

autogpt_platform/backend/backend/data/understanding.py

@@ -328,6 +328,8 @@ async def clear_business_understanding(user_id: str) -> bool:
 
 def format_understanding_for_prompt(understanding: BusinessUnderstanding) -> str:
     """Format business understanding as text for system prompt injection."""
+    if not understanding:
+        return ""
     sections = []
 
     # User info section

autogpt_platform/backend/backend/notifications/templates/waitlist_launch.html.jinja2

@@ -1,59 +0,0 @@
-{# Waitlist Launch Notification Email Template #}
-{#
-  Template variables:
-  data.agent_name: the name of the launched agent
-  data.waitlist_name: the name of the waitlist the user joined
-  data.store_url: URL to view the agent in the store
-  data.launched_at: when the agent was launched
-
-  Subject: {{ data.agent_name }} is now available!
-#}
-
-{% block content %}
-<h1 style="color: #7c3aed; font-size: 32px; font-weight: 700; margin: 0 0 24px 0; text-align: center;">
-  The wait is over!
-</h1>
-
-<p style="color: #586069; font-size: 18px; text-align: center; margin: 0 0 24px 0;">
-  <strong>'{{ data.agent_name }}'</strong> is now live in the AutoGPT Store!
-</p>
-
-<div style="height: 32px; background: transparent;"></div>
-
-<div style="background: #f3e8ff; border: 1px solid #d8b4fe; border-radius: 8px; padding: 20px; margin: 0;">
-  <h3 style="color: #6b21a8; font-size: 16px; font-weight: 600; margin: 0 0 12px 0;">
-    You're one of the first to know!
-  </h3>
-  <p style="color: #6b21a8; margin: 0; font-size: 16px; line-height: 1.5;">
-    You signed up for the <strong>{{ data.waitlist_name }}</strong> waitlist, and we're excited to let you know that this agent is now ready for you to use.
-  </p>
-</div>
-
-<div style="height: 32px; background: transparent;"></div>
-
-<div style="text-align: center; margin: 24px 0;">
-  <a href="{{ data.store_url }}" style="display: inline-block; background: linear-gradient(135deg, #7c3aed 0%, #5b21b6 100%); color: white; text-decoration: none; padding: 14px 28px; border-radius: 6px; font-weight: 600; font-size: 16px;">
-    Get {{ data.agent_name }} Now
-  </a>
-</div>
-
-<div style="height: 32px; background: transparent;"></div>
-
-<div style="background: #d1ecf1; border: 1px solid #bee5eb; border-radius: 8px; padding: 20px; margin: 0;">
-  <h3 style="color: #0c5460; font-size: 16px; font-weight: 600; margin: 0 0 12px 0;">
-    What can you do now?
-  </h3>
-  <ul style="color: #0c5460; margin: 0; padding-left: 18px; font-size: 16px; line-height: 1.6;">
-    <li>Visit the store to learn more about what this agent can do</li>
-    <li>Install and start using the agent right away</li>
-    <li>Share it with others who might find it useful</li>
-  </ul>
-</div>
-
-<div style="height: 32px; background: transparent;"></div>
-
-<p style="color: #6a737d; font-size: 14px; text-align: center; margin: 24px 0;">
-  Thank you for helping us prioritize what to build! Your interest made this happen.
-</p>
-
-{% endblock %}

autogpt_platform/backend/migrations/20260108032037_add_waitlist_launch_notification/migration.sql

@@ -1,53 +0,0 @@
--- CreateEnum
-CREATE TYPE "WaitlistExternalStatus" AS ENUM ('DONE', 'NOT_STARTED', 'CANCELED', 'WORK_IN_PROGRESS');
-
--- AlterEnum
-ALTER TYPE "NotificationType" ADD VALUE 'WAITLIST_LAUNCH';
-
--- CreateTable
-CREATE TABLE "WaitlistEntry" (
-    "id" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-    "storeListingId" TEXT,
-    "owningUserId" TEXT NOT NULL,
-    "slug" TEXT NOT NULL,
-    "search" tsvector DEFAULT ''::tsvector,
-    "name" TEXT NOT NULL,
-    "subHeading" TEXT NOT NULL,
-    "videoUrl" TEXT,
-    "agentOutputDemoUrl" TEXT,
-    "imageUrls" TEXT[],
-    "description" TEXT NOT NULL,
-    "categories" TEXT[],
-    "status" "WaitlistExternalStatus" NOT NULL DEFAULT 'NOT_STARTED',
-    "votes" INTEGER NOT NULL DEFAULT 0,
-    "unaffiliatedEmailUsers" TEXT[] DEFAULT ARRAY[]::TEXT[],
-    "isDeleted" BOOLEAN NOT NULL DEFAULT false,
-
-    CONSTRAINT "WaitlistEntry_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "_joinedWaitlists" (
-    "A" TEXT NOT NULL,
-    "B" TEXT NOT NULL
-);
-
--- CreateIndex
-CREATE UNIQUE INDEX "_joinedWaitlists_AB_unique" ON "_joinedWaitlists"("A", "B");
-
--- CreateIndex
-CREATE INDEX "_joinedWaitlists_B_index" ON "_joinedWaitlists"("B");
-
--- AddForeignKey
-ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_storeListingId_fkey" FOREIGN KEY ("storeListingId") REFERENCES "StoreListing"("id") ON DELETE SET NULL ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_owningUserId_fkey" FOREIGN KEY ("owningUserId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "_joinedWaitlists" ADD CONSTRAINT "_joinedWaitlists_A_fkey" FOREIGN KEY ("A") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "_joinedWaitlists" ADD CONSTRAINT "_joinedWaitlists_B_fkey" FOREIGN KEY ("B") REFERENCES "WaitlistEntry"("id") ON DELETE CASCADE ON UPDATE CASCADE;

autogpt_platform/backend/schema.prisma

@@ -69,10 +69,6 @@ model User {
   OAuthAuthorizationCodes OAuthAuthorizationCode[]
   OAuthAccessTokens       OAuthAccessToken[]
   OAuthRefreshTokens      OAuthRefreshToken[]
-
-  // Waitlist relations
-  waitlistEntries       WaitlistEntry[]
-  joinedWaitlists       WaitlistEntry[] @relation("joinedWaitlists")
 }
 
 enum OnboardingStep {
@@ -299,7 +295,6 @@ enum NotificationType {
   REFUND_PROCESSED
   AGENT_APPROVED
   AGENT_REJECTED
-  WAITLIST_LAUNCH
 }
 
 model NotificationEvent {
@@ -906,8 +901,7 @@ model StoreListing {
   OwningUser   User   @relation(fields: [owningUserId], references: [id])
 
   // Relations
-  Versions        StoreListingVersion[] @relation("ListingVersions")
-  waitlistEntries WaitlistEntry[]
+  Versions StoreListingVersion[] @relation("ListingVersions")
 
   // Unique index on agentId to ensure only one listing per agent, regardless of number of versions the agent has.
   @@unique([agentGraphId])
@@ -1039,47 +1033,6 @@ model StoreListingReview {
   @@index([reviewByUserId])
 }
 
-enum WaitlistExternalStatus {
-  DONE
-  NOT_STARTED
-  CANCELED
-  WORK_IN_PROGRESS
-}
-
-model WaitlistEntry {
-  id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  storeListingId String?
-  StoreListing   StoreListing? @relation(fields: [storeListingId], references: [id], onDelete: SetNull)
-
-  owningUserId String
-  OwningUser   User   @relation(fields: [owningUserId], references: [id])
-
-  slug   String
-  search Unsupported("tsvector")? @default(dbgenerated("''::tsvector"))
-
-  // Content fields
-  name               String
-  subHeading         String
-  videoUrl           String?
-  agentOutputDemoUrl String?
-  imageUrls          String[]
-  description        String
-  categories         String[]
-
-  //Waitlist specific fields
-  status                 WaitlistExternalStatus @default(NOT_STARTED)
-  votes                  Int                    @default(0) // Hide from frontend api
-  joinedUsers            User[]                 @relation("joinedWaitlists")
-  // NOTE: DO NOT DOUBLE SEND TO THESE USERS, IF THEY HAVE SIGNED UP SINCE THEY MAY HAVE ALREADY RECEIVED AN EMAIL
-  // DOUBLE CHECK WHEN SENDING THAT THEY ARE NOT IN THE JOINED USERS LIST ALSO
-  unaffiliatedEmailUsers String[]               @default([])
-
-  isDeleted Boolean @default(false)
-}
-
 enum SubmissionStatus {
   DRAFT // Being prepared, not yet submitted
   PENDING // Submitted, awaiting review

autogpt_platform/backend/scripts/generate_block_docs.py

@@ -0,0 +1,864 @@
+#!/usr/bin/env python3
+"""
+Block Documentation Generator
+
+Generates markdown documentation for all blocks from code introspection.
+Preserves manually-written content between marker comments.
+
+Usage:
+    # Generate all docs
+    poetry run python scripts/generate_block_docs.py
+
+    # Check mode for CI (exits 1 if stale)
+    poetry run python scripts/generate_block_docs.py --check
+
+    # Verbose output
+    poetry run python scripts/generate_block_docs.py -v
+"""
+
+import argparse
+import inspect
+import logging
+import re
+import sys
+from collections import defaultdict
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+# Add backend to path for imports
+backend_dir = Path(__file__).parent.parent
+sys.path.insert(0, str(backend_dir))
+
+logger = logging.getLogger(__name__)
+
+# Default output directory relative to repo root
+DEFAULT_OUTPUT_DIR = (
+    Path(__file__).parent.parent.parent.parent / "docs" / "integrations"
+)
+
+
+@dataclass
+class FieldDoc:
+    """Documentation for a single input/output field."""
+
+    name: str
+    description: str
+    type_str: str
+    required: bool
+    default: Any = None
+    advanced: bool = False
+    hidden: bool = False
+    placeholder: str | None = None
+
+
+@dataclass
+class BlockDoc:
+    """Documentation data extracted from a block."""
+
+    id: str
+    name: str
+    class_name: str
+    description: str
+    categories: list[str]
+    category_descriptions: dict[str, str]
+    inputs: list[FieldDoc]
+    outputs: list[FieldDoc]
+    block_type: str
+    source_file: str
+    contributors: list[str] = field(default_factory=list)
+
+
+# Category to human-readable name mapping
+CATEGORY_DISPLAY_NAMES = {
+    "AI": "AI and Language Models",
+    "BASIC": "Basic Operations",
+    "TEXT": "Text Processing",
+    "SEARCH": "Search and Information Retrieval",
+    "SOCIAL": "Social Media and Content",
+    "DEVELOPER_TOOLS": "Developer Tools",
+    "DATA": "Data Processing",
+    "LOGIC": "Logic and Control Flow",
+    "COMMUNICATION": "Communication",
+    "INPUT": "Input/Output",
+    "OUTPUT": "Input/Output",
+    "MULTIMEDIA": "Media Generation",
+    "PRODUCTIVITY": "Productivity",
+    "HARDWARE": "Hardware",
+    "AGENT": "Agent Integration",
+    "CRM": "CRM Services",
+    "SAFETY": "AI Safety",
+    "ISSUE_TRACKING": "Issue Tracking",
+    "MARKETING": "Marketing",
+}
+
+# Category to doc file mapping (for grouping related blocks)
+CATEGORY_FILE_MAP = {
+    "BASIC": "basic",
+    "TEXT": "text",
+    "AI": "llm",
+    "SEARCH": "search",
+    "DATA": "data",
+    "LOGIC": "logic",
+    "COMMUNICATION": "communication",
+    "MULTIMEDIA": "multimedia",
+    "PRODUCTIVITY": "productivity",
+}
+
+
+def class_name_to_display_name(class_name: str) -> str:
+    """Convert BlockClassName to 'Block Class Name'."""
+    # Remove 'Block' suffix (only at the end, not all occurrences)
+    name = class_name.removesuffix("Block")
+    # Insert space before capitals
+    name = re.sub(r"([a-z])([A-Z])", r"\1 \2", name)
+    # Handle consecutive capitals (e.g., 'HTTPRequest' -> 'HTTP Request')
+    name = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1 \2", name)
+    return name.strip()
+
+
+def type_to_readable(type_schema: dict[str, Any] | Any) -> str:
+    """Convert JSON schema type to human-readable string."""
+    if not isinstance(type_schema, dict):
+        return str(type_schema) if type_schema else "Any"
+
+    if "anyOf" in type_schema:
+        # Union type - show options
+        any_of = type_schema["anyOf"]
+        if not isinstance(any_of, list):
+            return "Any"
+        options = []
+        for opt in any_of:
+            if isinstance(opt, dict) and opt.get("type") == "null":
+                continue
+            options.append(type_to_readable(opt))
+        if not options:
+            return "None"
+        if len(options) == 1:
+            return options[0]
+        return " | ".join(options)
+
+    if "allOf" in type_schema:
+        all_of = type_schema["allOf"]
+        if not isinstance(all_of, list) or not all_of:
+            return "Any"
+        return type_to_readable(all_of[0])
+
+    schema_type = type_schema.get("type")
+
+    if schema_type == "array":
+        items = type_schema.get("items", {})
+        item_type = type_to_readable(items)
+        return f"List[{item_type}]"
+
+    if schema_type == "object":
+        if "additionalProperties" in type_schema:
+            additional_props = type_schema["additionalProperties"]
+            # additionalProperties: true means any value type is allowed
+            if additional_props is True:
+                return "Dict[str, Any]"
+            value_type = type_to_readable(additional_props)
+            return f"Dict[str, {value_type}]"
+        # Check if it's a specific model
+        title = type_schema.get("title", "Object")
+        return title
+
+    if schema_type == "string":
+        if "enum" in type_schema:
+            return " | ".join(f'"{v}"' for v in type_schema["enum"])
+        if "format" in type_schema:
+            return f"str ({type_schema['format']})"
+        return "str"
+
+    if schema_type == "integer":
+        return "int"
+
+    if schema_type == "number":
+        return "float"
+
+    if schema_type == "boolean":
+        return "bool"
+
+    if schema_type == "null":
+        return "None"
+
+    # Fallback
+    return type_schema.get("title", schema_type or "Any")
+
+
+def safe_get(d: Any, key: str, default: Any = None) -> Any:
+    """Safely get a value from a dict-like object."""
+    if isinstance(d, dict):
+        return d.get(key, default)
+    return default
+
+
+def file_path_to_title(file_path: str) -> str:
+    """Convert file path to a readable title.
+
+    Examples:
+        "github/issues.md" -> "GitHub Issues"
+        "basic.md" -> "Basic"
+        "llm.md" -> "LLM"
+        "google/sheets.md" -> "Google Sheets"
+    """
+    # Special case replacements (applied after title casing)
+    TITLE_FIXES = {
+        "Llm": "LLM",
+        "Github": "GitHub",
+        "Api": "API",
+        "Ai": "AI",
+        "Oauth": "OAuth",
+        "Url": "URL",
+        "Ci": "CI",
+        "Pr": "PR",
+        "Gmb": "GMB",  # Google My Business
+        "Hubspot": "HubSpot",
+        "Linkedin": "LinkedIn",
+        "Tiktok": "TikTok",
+        "Youtube": "YouTube",
+    }
+
+    def apply_fixes(text: str) -> str:
+        # Split into words, fix each word, rejoin
+        words = text.split()
+        fixed_words = [TITLE_FIXES.get(word, word) for word in words]
+        return " ".join(fixed_words)
+
+    path = Path(file_path)
+    name = path.stem  # e.g., "issues" or "sheets"
+
+    # Get parent dir if exists
+    parent = path.parent.name if path.parent.name != "." else None
+
+    # Title case and apply fixes
+    if parent:
+        parent_title = apply_fixes(parent.replace("_", " ").title())
+        name_title = apply_fixes(name.replace("_", " ").title())
+        return f"{parent_title} {name_title}"
+    return apply_fixes(name.replace("_", " ").title())
+
+
+def extract_block_doc(block_cls: type) -> BlockDoc:
+    """Extract documentation data from a block class."""
+    block = block_cls.create()
+
+    # Get source file
+    try:
+        source_file = inspect.getfile(block_cls)
+        # Make relative to blocks directory
+        blocks_dir = Path(source_file).parent
+        while blocks_dir.name != "blocks" and blocks_dir.parent != blocks_dir:
+            blocks_dir = blocks_dir.parent
+        source_file = str(Path(source_file).relative_to(blocks_dir.parent))
+    except (TypeError, ValueError):
+        source_file = "unknown"
+
+    # Extract input fields
+    input_schema = block.input_schema.jsonschema()
+    input_properties = safe_get(input_schema, "properties", {})
+    if not isinstance(input_properties, dict):
+        input_properties = {}
+    required_raw = safe_get(input_schema, "required", [])
+    # Handle edge cases where required might not be a list
+    if isinstance(required_raw, (list, set, tuple)):
+        required_inputs = set(required_raw)
+    else:
+        required_inputs = set()
+
+    inputs = []
+    for field_name, field_schema in input_properties.items():
+        if not isinstance(field_schema, dict):
+            continue
+        # Skip credentials fields in docs (they're auto-handled)
+        if "credentials" in field_name.lower():
+            continue
+
+        inputs.append(
+            FieldDoc(
+                name=field_name,
+                description=safe_get(field_schema, "description", ""),
+                type_str=type_to_readable(field_schema),
+                required=field_name in required_inputs,
+                default=safe_get(field_schema, "default"),
+                advanced=safe_get(field_schema, "advanced", False) or False,
+                hidden=safe_get(field_schema, "hidden", False) or False,
+                placeholder=safe_get(field_schema, "placeholder"),
+            )
+        )
+
+    # Extract output fields
+    output_schema = block.output_schema.jsonschema()
+    output_properties = safe_get(output_schema, "properties", {})
+    if not isinstance(output_properties, dict):
+        output_properties = {}
+
+    outputs = []
+    for field_name, field_schema in output_properties.items():
+        if not isinstance(field_schema, dict):
+            continue
+        outputs.append(
+            FieldDoc(
+                name=field_name,
+                description=safe_get(field_schema, "description", ""),
+                type_str=type_to_readable(field_schema),
+                required=True,  # Outputs are always produced
+                hidden=safe_get(field_schema, "hidden", False) or False,
+            )
+        )
+
+    # Get category info (sort for deterministic ordering since it's a set)
+    categories = []
+    category_descriptions = {}
+    for cat in sorted(block.categories, key=lambda c: c.name):
+        categories.append(cat.name)
+        category_descriptions[cat.name] = cat.value
+
+    # Get contributors
+    contributors = []
+    for contrib in block.contributors:
+        contributors.append(contrib.name if hasattr(contrib, "name") else str(contrib))
+
+    return BlockDoc(
+        id=block.id,
+        name=class_name_to_display_name(block.name),
+        class_name=block.name,
+        description=block.description,
+        categories=categories,
+        category_descriptions=category_descriptions,
+        inputs=inputs,
+        outputs=outputs,
+        block_type=block.block_type.value,
+        source_file=source_file,
+        contributors=contributors,
+    )
+
+
+def generate_anchor(name: str) -> str:
+    """Generate markdown anchor from block name."""
+    return name.lower().replace(" ", "-").replace("(", "").replace(")", "")
+
+
+def extract_manual_content(existing_content: str) -> dict[str, str]:
+    """Extract content between MANUAL markers from existing file."""
+    manual_sections = {}
+
+    # Pattern: <!-- MANUAL: section_name -->content<!-- END MANUAL -->
+    pattern = r"<!-- MANUAL: (\w+) -->\s*(.*?)\s*<!-- END MANUAL -->"
+    matches = re.findall(pattern, existing_content, re.DOTALL)
+
+    for section_name, content in matches:
+        manual_sections[section_name] = content.strip()
+
+    return manual_sections
+
+
+def generate_block_markdown(
+    block: BlockDoc,
+    manual_content: dict[str, str] | None = None,
+) -> str:
+    """Generate markdown documentation for a single block."""
+    manual_content = manual_content or {}
+    lines = []
+
+    # All blocks use ## heading, sections use ### (consistent siblings)
+    lines.append(f"## {block.name}")
+    lines.append("")
+
+    # What it is (full description)
+    lines.append(f"### What it is")
+    lines.append(block.description or "No description available.")
+    lines.append("")
+
+    # How it works (manual section)
+    lines.append(f"### How it works")
+    how_it_works = manual_content.get(
+        "how_it_works", "_Add technical explanation here._"
+    )
+    lines.append("<!-- MANUAL: how_it_works -->")
+    lines.append(how_it_works)
+    lines.append("<!-- END MANUAL -->")
+    lines.append("")
+
+    # Inputs table (auto-generated)
+    visible_inputs = [f for f in block.inputs if not f.hidden]
+    if visible_inputs:
+        lines.append(f"### Inputs")
+        lines.append("")
+        lines.append("| Input | Description | Type | Required |")
+        lines.append("|-------|-------------|------|----------|")
+        for inp in visible_inputs:
+            required = "Yes" if inp.required else "No"
+            desc = inp.description or "-"
+            type_str = inp.type_str or "-"
+            # Normalize newlines and escape pipes for valid table syntax
+            desc = desc.replace("\n", " ").replace("|", "\\|")
+            type_str = type_str.replace("|", "\\|")
+            lines.append(f"| {inp.name} | {desc} | {type_str} | {required} |")
+        lines.append("")
+
+    # Outputs table (auto-generated)
+    visible_outputs = [f for f in block.outputs if not f.hidden]
+    if visible_outputs:
+        lines.append(f"### Outputs")
+        lines.append("")
+        lines.append("| Output | Description | Type |")
+        lines.append("|--------|-------------|------|")
+        for out in visible_outputs:
+            desc = out.description or "-"
+            type_str = out.type_str or "-"
+            # Normalize newlines and escape pipes for valid table syntax
+            desc = desc.replace("\n", " ").replace("|", "\\|")
+            type_str = type_str.replace("|", "\\|")
+            lines.append(f"| {out.name} | {desc} | {type_str} |")
+        lines.append("")
+
+    # Possible use case (manual section)
+    lines.append(f"### Possible use case")
+    use_case = manual_content.get("use_case", "_Add practical use case examples here._")
+    lines.append("<!-- MANUAL: use_case -->")
+    lines.append(use_case)
+    lines.append("<!-- END MANUAL -->")
+    lines.append("")
+
+    lines.append("---")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def get_block_file_mapping(blocks: list[BlockDoc]) -> dict[str, list[BlockDoc]]:
+    """
+    Map blocks to their documentation files.
+
+    Returns dict of {relative_file_path: [blocks]}
+    """
+    file_mapping = defaultdict(list)
+
+    for block in blocks:
+        # Determine file path based on source file or category
+        source_path = Path(block.source_file)
+
+        # If source is in a subdirectory (e.g., google/gmail.py), use that structure
+        if len(source_path.parts) > 2:  # blocks/subdir/file.py
+            subdir = source_path.parts[1]  # e.g., "google"
+            # Use the Python filename as the md filename
+            md_file = source_path.stem + ".md"  # e.g., "gmail.md"
+            file_path = f"{subdir}/{md_file}"
+        else:
+            # Use category-based grouping for top-level blocks
+            primary_category = block.categories[0] if block.categories else "BASIC"
+            file_name = CATEGORY_FILE_MAP.get(primary_category, "misc")
+            file_path = f"{file_name}.md"
+
+        file_mapping[file_path].append(block)
+
+    return dict(file_mapping)
+
+
+def generate_overview_table(blocks: list[BlockDoc]) -> str:
+    """Generate the overview table markdown (blocks.md)."""
+    lines = []
+
+    lines.append("# AutoGPT Blocks Overview")
+    lines.append("")
+    lines.append(
+        'AutoGPT uses a modular approach with various "blocks" to handle different tasks. These blocks are the building blocks of AutoGPT workflows, allowing users to create complex automations by combining simple, specialized components.'
+    )
+    lines.append("")
+    lines.append('!!! info "Creating Your Own Blocks"')
+    lines.append("    Want to create your own custom blocks? Check out our guides:")
+    lines.append("    ")
+    lines.append(
+        "    - [Build your own Blocks](https://docs.agpt.co/platform/new_blocks/) - Step-by-step tutorial with examples"
+    )
+    lines.append(
+        "    - [Block SDK Guide](https://docs.agpt.co/platform/block-sdk-guide/) - Advanced SDK patterns with OAuth, webhooks, and provider configuration"
+    )
+    lines.append("")
+    lines.append(
+        "Below is a comprehensive list of all available blocks, categorized by their primary function. Click on any block name to view its detailed documentation."
+    )
+    lines.append("")
+
+    # Group blocks by category
+    by_category = defaultdict(list)
+    for block in blocks:
+        primary_cat = block.categories[0] if block.categories else "BASIC"
+        by_category[primary_cat].append(block)
+
+    # Sort categories
+    category_order = [
+        "BASIC",
+        "DATA",
+        "TEXT",
+        "AI",
+        "SEARCH",
+        "SOCIAL",
+        "COMMUNICATION",
+        "DEVELOPER_TOOLS",
+        "MULTIMEDIA",
+        "PRODUCTIVITY",
+        "LOGIC",
+        "INPUT",
+        "OUTPUT",
+        "AGENT",
+        "CRM",
+        "SAFETY",
+        "ISSUE_TRACKING",
+        "HARDWARE",
+        "MARKETING",
+    ]
+
+    # Track emitted display names to avoid duplicate headers
+    # (e.g., INPUT and OUTPUT both map to "Input/Output")
+    emitted_display_names: set[str] = set()
+
+    for category in category_order:
+        if category not in by_category:
+            continue
+
+        display_name = CATEGORY_DISPLAY_NAMES.get(category, category)
+
+        # Collect all blocks for this display name (may span multiple categories)
+        if display_name in emitted_display_names:
+            # Already emitted header, just add rows to existing table
+            # Find the position before the last empty line and insert rows
+            cat_blocks = sorted(by_category[category], key=lambda b: b.name)
+            # Remove the trailing empty line, add rows, then re-add empty line
+            lines.pop()
+            for block in cat_blocks:
+                file_mapping = get_block_file_mapping([block])
+                file_path = list(file_mapping.keys())[0]
+                anchor = generate_anchor(block.name)
+                short_desc = (
+                    block.description.split(".")[0]
+                    if block.description
+                    else "No description"
+                )
+                short_desc = short_desc.replace("\n", " ").replace("|", "\\|")
+                lines.append(f"| [{block.name}]({file_path}#{anchor}) | {short_desc} |")
+            lines.append("")
+            continue
+
+        emitted_display_names.add(display_name)
+        cat_blocks = sorted(by_category[category], key=lambda b: b.name)
+
+        lines.append(f"## {display_name}")
+        lines.append("")
+        lines.append("| Block Name | Description |")
+        lines.append("|------------|-------------|")
+
+        for block in cat_blocks:
+            # Determine link path
+            file_mapping = get_block_file_mapping([block])
+            file_path = list(file_mapping.keys())[0]
+            anchor = generate_anchor(block.name)
+
+            # Short description (first sentence)
+            short_desc = (
+                block.description.split(".")[0]
+                if block.description
+                else "No description"
+            )
+            short_desc = short_desc.replace("\n", " ").replace("|", "\\|")
+
+            lines.append(f"| [{block.name}]({file_path}#{anchor}) | {short_desc} |")
+
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def load_all_blocks_for_docs() -> list[BlockDoc]:
+    """Load all blocks and extract documentation."""
+    from backend.blocks import load_all_blocks
+
+    block_classes = load_all_blocks()
+    blocks = []
+
+    for _block_id, block_cls in block_classes.items():
+        try:
+            block_doc = extract_block_doc(block_cls)
+            blocks.append(block_doc)
+        except Exception as e:
+            logger.warning(f"Failed to extract docs for {block_cls.__name__}: {e}")
+
+    return blocks
+
+
+def write_block_docs(
+    output_dir: Path,
+    blocks: list[BlockDoc],
+    verbose: bool = False,
+) -> dict[str, str]:
+    """
+    Write block documentation files.
+
+    Returns dict of {file_path: content} for all generated files.
+    """
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    file_mapping = get_block_file_mapping(blocks)
+    generated_files = {}
+
+    for file_path, file_blocks in file_mapping.items():
+        full_path = output_dir / file_path
+
+        # Create subdirectories if needed
+        full_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Load existing content for manual section preservation
+        existing_content = ""
+        if full_path.exists():
+            existing_content = full_path.read_text()
+
+        # Always generate title from file path (with fixes applied)
+        file_title = file_path_to_title(file_path)
+
+        # Extract existing file description if present (preserve manual content)
+        file_header_pattern = (
+            r"^# .+?\n<!-- MANUAL: file_description -->\n(.*?)\n<!-- END MANUAL -->"
+        )
+        file_header_match = re.search(file_header_pattern, existing_content, re.DOTALL)
+
+        if file_header_match:
+            file_description = file_header_match.group(1)
+        else:
+            file_description = "_Add a description of this category of blocks._"
+
+        # Generate file header
+        file_header = f"# {file_title}\n"
+        file_header += "<!-- MANUAL: file_description -->\n"
+        file_header += f"{file_description}\n"
+        file_header += "<!-- END MANUAL -->\n"
+
+        # Generate content for each block
+        content_parts = []
+        for block in sorted(file_blocks, key=lambda b: b.name):
+            # Extract manual content specific to this block
+            # Match block heading (h2) and capture until --- separator
+            block_pattern = rf"(?:^|\n)## {re.escape(block.name)}\s*\n(.*?)(?=\n---|\Z)"
+            block_match = re.search(block_pattern, existing_content, re.DOTALL)
+            if block_match:
+                manual_content = extract_manual_content(block_match.group(1))
+            else:
+                manual_content = {}
+
+            content_parts.append(
+                generate_block_markdown(
+                    block,
+                    manual_content,
+                )
+            )
+
+        full_content = file_header + "\n" + "\n".join(content_parts)
+        generated_files[str(file_path)] = full_content
+
+        if verbose:
+            print(f"  Writing {file_path} ({len(file_blocks)} blocks)")
+
+        full_path.write_text(full_content)
+
+    # Generate overview file
+    overview_content = generate_overview_table(blocks)
+    overview_path = output_dir / "README.md"
+    generated_files["README.md"] = overview_content
+    overview_path.write_text(overview_content)
+
+    if verbose:
+        print("  Writing README.md (overview)")
+
+    return generated_files
+
+
+def check_docs_in_sync(output_dir: Path, blocks: list[BlockDoc]) -> bool:
+    """
+    Check if generated docs match existing docs.
+
+    Returns True if in sync, False otherwise.
+    """
+    output_dir = Path(output_dir)
+    file_mapping = get_block_file_mapping(blocks)
+
+    all_match = True
+    out_of_sync_details: list[tuple[str, list[str]]] = []
+
+    for file_path, file_blocks in file_mapping.items():
+        full_path = output_dir / file_path
+
+        if not full_path.exists():
+            block_names = [b.name for b in sorted(file_blocks, key=lambda b: b.name)]
+            print(f"MISSING: {file_path}")
+            print(f"  Blocks: {', '.join(block_names)}")
+            out_of_sync_details.append((file_path, block_names))
+            all_match = False
+            continue
+
+        existing_content = full_path.read_text()
+
+        # Always generate title from file path (with fixes applied)
+        file_title = file_path_to_title(file_path)
+
+        # Extract existing file description if present (preserve manual content)
+        file_header_pattern = (
+            r"^# .+?\n<!-- MANUAL: file_description -->\n(.*?)\n<!-- END MANUAL -->"
+        )
+        file_header_match = re.search(file_header_pattern, existing_content, re.DOTALL)
+
+        if file_header_match:
+            file_description = file_header_match.group(1)
+        else:
+            file_description = "_Add a description of this category of blocks._"
+
+        # Generate expected file header
+        file_header = f"# {file_title}\n"
+        file_header += "<!-- MANUAL: file_description -->\n"
+        file_header += f"{file_description}\n"
+        file_header += "<!-- END MANUAL -->\n"
+
+        # Extract manual content from existing file
+        manual_sections_by_block = {}
+        for block in file_blocks:
+            block_pattern = rf"(?:^|\n)## {re.escape(block.name)}\s*\n(.*?)(?=\n---|\Z)"
+            block_match = re.search(block_pattern, existing_content, re.DOTALL)
+            if block_match:
+                manual_sections_by_block[block.name] = extract_manual_content(
+                    block_match.group(1)
+                )
+
+        # Generate expected content and check each block individually
+        content_parts = []
+        mismatched_blocks = []
+        for block in sorted(file_blocks, key=lambda b: b.name):
+            manual_content = manual_sections_by_block.get(block.name, {})
+            expected_block_content = generate_block_markdown(
+                block,
+                manual_content,
+            )
+            content_parts.append(expected_block_content)
+
+            # Check if this specific block's section exists and matches
+            # Include the --- separator to match generate_block_markdown output
+            block_pattern = rf"(?:^|\n)(## {re.escape(block.name)}\s*\n.*?\n---\n)"
+            block_match = re.search(block_pattern, existing_content, re.DOTALL)
+            if not block_match:
+                mismatched_blocks.append(f"{block.name} (missing)")
+            elif block_match.group(1).strip() != expected_block_content.strip():
+                mismatched_blocks.append(block.name)
+
+        expected_content = file_header + "\n" + "\n".join(content_parts)
+
+        if existing_content.strip() != expected_content.strip():
+            print(f"OUT OF SYNC: {file_path}")
+            if mismatched_blocks:
+                print(f"  Affected blocks: {', '.join(mismatched_blocks)}")
+            out_of_sync_details.append((file_path, mismatched_blocks))
+            all_match = False
+
+    # Check overview
+    overview_path = output_dir / "README.md"
+    if overview_path.exists():
+        existing_overview = overview_path.read_text()
+        expected_overview = generate_overview_table(blocks)
+        if existing_overview.strip() != expected_overview.strip():
+            print("OUT OF SYNC: README.md (overview)")
+            print("  The blocks overview table needs regeneration")
+            out_of_sync_details.append(("README.md", ["overview table"]))
+            all_match = False
+    else:
+        print("MISSING: README.md (overview)")
+        out_of_sync_details.append(("README.md", ["overview table"]))
+        all_match = False
+
+    # Check for unfilled manual sections
+    unfilled_patterns = [
+        "_Add a description of this category of blocks._",
+        "_Add technical explanation here._",
+        "_Add practical use case examples here._",
+    ]
+    files_with_unfilled = []
+    for file_path in file_mapping.keys():
+        full_path = output_dir / file_path
+        if full_path.exists():
+            content = full_path.read_text()
+            unfilled_count = sum(1 for p in unfilled_patterns if p in content)
+            if unfilled_count > 0:
+                files_with_unfilled.append((file_path, unfilled_count))
+
+    if files_with_unfilled:
+        print("\nWARNING: Files with unfilled manual sections:")
+        for file_path, count in sorted(files_with_unfilled):
+            print(f"  {file_path}: {count} unfilled section(s)")
+        print(
+            f"\nTotal: {len(files_with_unfilled)} files with unfilled manual sections"
+        )
+
+    return all_match
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate block documentation from code introspection"
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=DEFAULT_OUTPUT_DIR,
+        help="Output directory for generated docs",
+    )
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Check if docs are in sync (for CI), exit 1 if not",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Verbose output",
+    )
+
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(levelname)s: %(message)s",
+    )
+
+    print("Loading blocks...")
+    blocks = load_all_blocks_for_docs()
+    print(f"Found {len(blocks)} blocks")
+
+    if args.check:
+        print(f"Checking docs in {args.output_dir}...")
+        in_sync = check_docs_in_sync(args.output_dir, blocks)
+        if in_sync:
+            print("All documentation is in sync!")
+            sys.exit(0)
+        else:
+            print("\n" + "=" * 60)
+            print("Documentation is out of sync!")
+            print("=" * 60)
+            print("\nTo fix this, run one of the following:")
+            print("\n  Option 1 - Run locally:")
+            print(
+                "    cd autogpt_platform/backend && poetry run python scripts/generate_block_docs.py"
+            )
+            print("\n  Option 2 - Ask Claude Code to run it:")
+            print('    "Run the block docs generator script to sync documentation"')
+            print("\n" + "=" * 60)
+            sys.exit(1)
+    else:
+        print(f"Generating docs to {args.output_dir}...")
+        write_block_docs(
+            args.output_dir,
+            blocks,
+            verbose=args.verbose,
+        )
+        print("Done!")
+
+
+if __name__ == "__main__":
+    main()

autogpt_platform/backend/scripts/test_generate_block_docs.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""Tests for the block documentation generator."""
+import pytest
+
+from scripts.generate_block_docs import (
+    class_name_to_display_name,
+    extract_manual_content,
+    generate_anchor,
+    type_to_readable,
+)
+
+
+class TestClassNameToDisplayName:
+    """Tests for class_name_to_display_name function."""
+
+    def test_simple_block_name(self):
+        assert class_name_to_display_name("PrintBlock") == "Print"
+
+    def test_multi_word_block_name(self):
+        assert class_name_to_display_name("GetWeatherBlock") == "Get Weather"
+
+    def test_consecutive_capitals(self):
+        assert class_name_to_display_name("HTTPRequestBlock") == "HTTP Request"
+
+    def test_ai_prefix(self):
+        assert class_name_to_display_name("AIConditionBlock") == "AI Condition"
+
+    def test_no_block_suffix(self):
+        assert class_name_to_display_name("SomeClass") == "Some Class"
+
+
+class TestTypeToReadable:
+    """Tests for type_to_readable function."""
+
+    def test_string_type(self):
+        assert type_to_readable({"type": "string"}) == "str"
+
+    def test_integer_type(self):
+        assert type_to_readable({"type": "integer"}) == "int"
+
+    def test_number_type(self):
+        assert type_to_readable({"type": "number"}) == "float"
+
+    def test_boolean_type(self):
+        assert type_to_readable({"type": "boolean"}) == "bool"
+
+    def test_array_type(self):
+        result = type_to_readable({"type": "array", "items": {"type": "string"}})
+        assert result == "List[str]"
+
+    def test_object_type(self):
+        result = type_to_readable({"type": "object", "title": "MyModel"})
+        assert result == "MyModel"
+
+    def test_anyof_with_null(self):
+        result = type_to_readable({"anyOf": [{"type": "string"}, {"type": "null"}]})
+        assert result == "str"
+
+    def test_anyof_multiple_types(self):
+        result = type_to_readable({"anyOf": [{"type": "string"}, {"type": "integer"}]})
+        assert result == "str | int"
+
+    def test_enum_type(self):
+        result = type_to_readable(
+            {"type": "string", "enum": ["option1", "option2", "option3"]}
+        )
+        assert result == '"option1" | "option2" | "option3"'
+
+    def test_none_input(self):
+        assert type_to_readable(None) == "Any"
+
+    def test_non_dict_input(self):
+        assert type_to_readable("string") == "string"
+
+
+class TestExtractManualContent:
+    """Tests for extract_manual_content function."""
+
+    def test_extract_how_it_works(self):
+        content = """
+### How it works
+<!-- MANUAL: how_it_works -->
+This is how it works.
+<!-- END MANUAL -->
+"""
+        result = extract_manual_content(content)
+        assert result == {"how_it_works": "This is how it works."}
+
+    def test_extract_use_case(self):
+        content = """
+### Possible use case
+<!-- MANUAL: use_case -->
+Example use case here.
+<!-- END MANUAL -->
+"""
+        result = extract_manual_content(content)
+        assert result == {"use_case": "Example use case here."}
+
+    def test_extract_multiple_sections(self):
+        content = """
+<!-- MANUAL: how_it_works -->
+How it works content.
+<!-- END MANUAL -->
+
+<!-- MANUAL: use_case -->
+Use case content.
+<!-- END MANUAL -->
+"""
+        result = extract_manual_content(content)
+        assert result == {
+            "how_it_works": "How it works content.",
+            "use_case": "Use case content.",
+        }
+
+    def test_empty_content(self):
+        result = extract_manual_content("")
+        assert result == {}
+
+    def test_no_markers(self):
+        result = extract_manual_content("Some content without markers")
+        assert result == {}
+
+
+class TestGenerateAnchor:
+    """Tests for generate_anchor function."""
+
+    def test_simple_name(self):
+        assert generate_anchor("Print") == "print"
+
+    def test_multi_word_name(self):
+        assert generate_anchor("Get Weather") == "get-weather"
+
+    def test_name_with_parentheses(self):
+        assert generate_anchor("Something (Optional)") == "something-optional"
+
+    def test_already_lowercase(self):
+        assert generate_anchor("already lowercase") == "already-lowercase"
+
+
+class TestIntegration:
+    """Integration tests that require block loading."""
+
+    def test_load_blocks(self):
+        """Test that blocks can be loaded successfully."""
+        import logging
+        import sys
+        from pathlib import Path
+
+        logging.disable(logging.CRITICAL)
+        sys.path.insert(0, str(Path(__file__).parent.parent))
+
+        from scripts.generate_block_docs import load_all_blocks_for_docs
+
+        blocks = load_all_blocks_for_docs()
+        assert len(blocks) > 0, "Should load at least one block"
+
+    def test_block_doc_has_required_fields(self):
+        """Test that extracted block docs have required fields."""
+        import logging
+        import sys
+        from pathlib import Path
+
+        logging.disable(logging.CRITICAL)
+        sys.path.insert(0, str(Path(__file__).parent.parent))
+
+        from scripts.generate_block_docs import load_all_blocks_for_docs
+
+        blocks = load_all_blocks_for_docs()
+        block = blocks[0]
+
+        assert hasattr(block, "id")
+        assert hasattr(block, "name")
+        assert hasattr(block, "description")
+        assert hasattr(block, "categories")
+        assert hasattr(block, "inputs")
+        assert hasattr(block, "outputs")
+
+    def test_file_mapping_is_deterministic(self):
+        """Test that file mapping produces consistent results."""
+        import logging
+        import sys
+        from pathlib import Path
+
+        logging.disable(logging.CRITICAL)
+        sys.path.insert(0, str(Path(__file__).parent.parent))
+
+        from scripts.generate_block_docs import (
+            get_block_file_mapping,
+            load_all_blocks_for_docs,
+        )
+
+        # Load blocks twice and compare mappings
+        blocks1 = load_all_blocks_for_docs()
+        blocks2 = load_all_blocks_for_docs()
+
+        mapping1 = get_block_file_mapping(blocks1)
+        mapping2 = get_block_file_mapping(blocks2)
+
+        # Check same files are generated
+        assert set(mapping1.keys()) == set(mapping2.keys())
+
+        # Check same block counts per file
+        for file_path in mapping1:
+            assert len(mapping1[file_path]) == len(mapping2[file_path])
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

autogpt_platform/frontend/src/app/(platform)/admin/layout.tsx

@@ -1,5 +1,5 @@
 import { Sidebar } from "@/components/__legacy__/Sidebar";
-import { Users, DollarSign, UserSearch, FileText, Clock } from "lucide-react";
+import { Users, DollarSign, UserSearch, FileText } from "lucide-react";
 
 import { IconSliders } from "@/components/__legacy__/ui/icons";
 
@@ -11,11 +11,6 @@ const sidebarLinkGroups = [
         href: "/admin/marketplace",
         icon: <Users className="h-6 w-6" />,
       },
-      {
-        text: "Waitlist Management",
-        href: "/admin/waitlist",
-        icon: <Clock className="h-6 w-6" />,
-      },
       {
         text: "User Spending",
         href: "/admin/spending",

autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/CreateWaitlistButton.tsx

@@ -1,217 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-import { Button } from "@/components/atoms/Button/Button";
-import { Input } from "@/components/atoms/Input/Input";
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import {
-  usePostV2CreateWaitlist,
-  getGetV2ListAllWaitlistsQueryKey,
-} from "@/app/api/__generated__/endpoints/admin/admin";
-import { useToast } from "@/components/molecules/Toast/use-toast";
-import { Plus } from "@phosphor-icons/react";
-
-export function CreateWaitlistButton() {
-  const [open, setOpen] = useState(false);
-  const { toast } = useToast();
-  const queryClient = useQueryClient();
-
-  const createWaitlistMutation = usePostV2CreateWaitlist({
-    mutation: {
-      onSuccess: (response) => {
-        if (response.status === 200) {
-          toast({
-            title: "Success",
-            description: "Waitlist created successfully",
-          });
-          setOpen(false);
-          setFormData({
-            name: "",
-            slug: "",
-            subHeading: "",
-            description: "",
-            categories: "",
-            imageUrls: "",
-            videoUrl: "",
-            agentOutputDemoUrl: "",
-          });
-          queryClient.invalidateQueries({
-            queryKey: getGetV2ListAllWaitlistsQueryKey(),
-          });
-        } else {
-          toast({
-            variant: "destructive",
-            title: "Error",
-            description: "Failed to create waitlist",
-          });
-        }
-      },
-      onError: (error) => {
-        console.error("Error creating waitlist:", error);
-        toast({
-          variant: "destructive",
-          title: "Error",
-          description: "Failed to create waitlist",
-        });
-      },
-    },
-  });
-
-  const [formData, setFormData] = useState({
-    name: "",
-    slug: "",
-    subHeading: "",
-    description: "",
-    categories: "",
-    imageUrls: "",
-    videoUrl: "",
-    agentOutputDemoUrl: "",
-  });
-
-  function handleInputChange(id: string, value: string) {
-    setFormData((prev) => ({
-      ...prev,
-      [id]: value,
-    }));
-  }
-
-  function generateSlug(name: string) {
-    return name
-      .toLowerCase()
-      .replace(/[^a-z0-9]+/g, "-")
-      .replace(/^-|-$/g, "");
-  }
-
-  function handleSubmit(e: React.FormEvent) {
-    e.preventDefault();
-
-    createWaitlistMutation.mutate({
-      data: {
-        name: formData.name,
-        slug: formData.slug || generateSlug(formData.name),
-        subHeading: formData.subHeading,
-        description: formData.description,
-        categories: formData.categories
-          ? formData.categories.split(",").map((c) => c.trim())
-          : [],
-        imageUrls: formData.imageUrls
-          ? formData.imageUrls.split(",").map((u) => u.trim())
-          : [],
-        videoUrl: formData.videoUrl || null,
-        agentOutputDemoUrl: formData.agentOutputDemoUrl || null,
-      },
-    });
-  }
-
-  return (
-    <>
-      <Button onClick={() => setOpen(true)}>
-        <Plus size={16} className="mr-2" />
-        Create Waitlist
-      </Button>
-
-      <Dialog
-        title="Create New Waitlist"
-        controlled={{
-          isOpen: open,
-          set: async (isOpen) => setOpen(isOpen),
-        }}
-        onClose={() => setOpen(false)}
-        styling={{ maxWidth: "600px" }}
-      >
-        <Dialog.Content>
-          <p className="mb-4 text-sm text-zinc-500">
-            Create a new waitlist for an upcoming agent. Users can sign up to be
-            notified when it launches.
-          </p>
-          <form onSubmit={handleSubmit} className="flex flex-col gap-2">
-            <Input
-              id="name"
-              label="Name"
-              value={formData.name}
-              onChange={(e) => handleInputChange("name", e.target.value)}
-              placeholder="SEO Analysis Agent"
-              required
-            />
-
-            <Input
-              id="slug"
-              label="Slug"
-              value={formData.slug}
-              onChange={(e) => handleInputChange("slug", e.target.value)}
-              placeholder="seo-analysis-agent (auto-generated if empty)"
-            />
-
-            <Input
-              id="subHeading"
-              label="Subheading"
-              value={formData.subHeading}
-              onChange={(e) => handleInputChange("subHeading", e.target.value)}
-              placeholder="Analyze your website's SEO in minutes"
-              required
-            />
-
-            <Input
-              id="description"
-              label="Description"
-              type="textarea"
-              value={formData.description}
-              onChange={(e) => handleInputChange("description", e.target.value)}
-              placeholder="Detailed description of what this agent does..."
-              rows={4}
-              required
-            />
-
-            <Input
-              id="categories"
-              label="Categories (comma-separated)"
-              value={formData.categories}
-              onChange={(e) => handleInputChange("categories", e.target.value)}
-              placeholder="SEO, Marketing, Analysis"
-            />
-
-            <Input
-              id="imageUrls"
-              label="Image URLs (comma-separated)"
-              value={formData.imageUrls}
-              onChange={(e) => handleInputChange("imageUrls", e.target.value)}
-              placeholder="https://example.com/image1.jpg, https://example.com/image2.jpg"
-            />
-
-            <Input
-              id="videoUrl"
-              label="Video URL (optional)"
-              value={formData.videoUrl}
-              onChange={(e) => handleInputChange("videoUrl", e.target.value)}
-              placeholder="https://youtube.com/watch?v=..."
-            />
-
-            <Input
-              id="agentOutputDemoUrl"
-              label="Output Demo URL (optional)"
-              value={formData.agentOutputDemoUrl}
-              onChange={(e) =>
-                handleInputChange("agentOutputDemoUrl", e.target.value)
-              }
-              placeholder="https://example.com/demo-output.mp4"
-            />
-
-            <Dialog.Footer>
-              <Button
-                type="button"
-                variant="secondary"
-                onClick={() => setOpen(false)}
-              >
-                Cancel
-              </Button>
-              <Button type="submit" loading={createWaitlistMutation.isPending}>
-                Create Waitlist
-              </Button>
-            </Dialog.Footer>
-          </form>
-        </Dialog.Content>
-      </Dialog>
-    </>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/EditWaitlistDialog.tsx

@@ -1,221 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import { Button } from "@/components/atoms/Button/Button";
-import { Input } from "@/components/atoms/Input/Input";
-import { Select } from "@/components/atoms/Select/Select";
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import { useToast } from "@/components/molecules/Toast/use-toast";
-import { usePutV2UpdateWaitlist } from "@/app/api/__generated__/endpoints/admin/admin";
-import type { WaitlistAdminResponse } from "@/app/api/__generated__/models/waitlistAdminResponse";
-import type { WaitlistUpdateRequest } from "@/app/api/__generated__/models/waitlistUpdateRequest";
-import { WaitlistExternalStatus } from "@/app/api/__generated__/models/waitlistExternalStatus";
-
-type EditWaitlistDialogProps = {
-  waitlist: WaitlistAdminResponse;
-  onClose: () => void;
-  onSave: () => void;
-};
-
-const STATUS_OPTIONS = [
-  { value: WaitlistExternalStatus.NOT_STARTED, label: "Not Started" },
-  { value: WaitlistExternalStatus.WORK_IN_PROGRESS, label: "Work In Progress" },
-  { value: WaitlistExternalStatus.DONE, label: "Done" },
-  { value: WaitlistExternalStatus.CANCELED, label: "Canceled" },
-];
-
-export function EditWaitlistDialog({
-  waitlist,
-  onClose,
-  onSave,
-}: EditWaitlistDialogProps) {
-  const { toast } = useToast();
-  const updateWaitlistMutation = usePutV2UpdateWaitlist();
-
-  const [formData, setFormData] = useState({
-    name: waitlist.name,
-    slug: waitlist.slug,
-    subHeading: waitlist.subHeading,
-    description: waitlist.description,
-    categories: waitlist.categories.join(", "),
-    imageUrls: waitlist.imageUrls.join(", "),
-    videoUrl: waitlist.videoUrl || "",
-    agentOutputDemoUrl: waitlist.agentOutputDemoUrl || "",
-    status: waitlist.status,
-    storeListingId: waitlist.storeListingId || "",
-  });
-
-  function handleInputChange(id: string, value: string) {
-    setFormData((prev) => ({
-      ...prev,
-      [id]: value,
-    }));
-  }
-
-  function handleStatusChange(value: string) {
-    setFormData((prev) => ({
-      ...prev,
-      status: value as WaitlistExternalStatus,
-    }));
-  }
-
-  async function handleSubmit(e: React.FormEvent) {
-    e.preventDefault();
-
-    const updateData: WaitlistUpdateRequest = {
-      name: formData.name,
-      slug: formData.slug,
-      subHeading: formData.subHeading,
-      description: formData.description,
-      categories: formData.categories
-        ? formData.categories.split(",").map((c) => c.trim())
-        : [],
-      imageUrls: formData.imageUrls
-        ? formData.imageUrls.split(",").map((u) => u.trim())
-        : [],
-      videoUrl: formData.videoUrl || null,
-      agentOutputDemoUrl: formData.agentOutputDemoUrl || null,
-      status: formData.status,
-      storeListingId: formData.storeListingId || null,
-    };
-
-    updateWaitlistMutation.mutate(
-      { waitlistId: waitlist.id, data: updateData },
-      {
-        onSuccess: (response) => {
-          if (response.status === 200) {
-            toast({
-              title: "Success",
-              description: "Waitlist updated successfully",
-            });
-            onSave();
-          } else {
-            toast({
-              variant: "destructive",
-              title: "Error",
-              description: "Failed to update waitlist",
-            });
-          }
-        },
-        onError: () => {
-          toast({
-            variant: "destructive",
-            title: "Error",
-            description: "Failed to update waitlist",
-          });
-        },
-      },
-    );
-  }
-
-  return (
-    <Dialog
-      title="Edit Waitlist"
-      controlled={{
-        isOpen: true,
-        set: async (open) => {
-          if (!open) onClose();
-        },
-      }}
-      onClose={onClose}
-      styling={{ maxWidth: "600px" }}
-    >
-      <Dialog.Content>
-        <p className="mb-4 text-sm text-zinc-500">
-          Update the waitlist details. Changes will be reflected immediately.
-        </p>
-        <form onSubmit={handleSubmit} className="flex flex-col gap-2">
-          <Input
-            id="name"
-            label="Name"
-            value={formData.name}
-            onChange={(e) => handleInputChange("name", e.target.value)}
-            required
-          />
-
-          <Input
-            id="slug"
-            label="Slug"
-            value={formData.slug}
-            onChange={(e) => handleInputChange("slug", e.target.value)}
-          />
-
-          <Input
-            id="subHeading"
-            label="Subheading"
-            value={formData.subHeading}
-            onChange={(e) => handleInputChange("subHeading", e.target.value)}
-            required
-          />
-
-          <Input
-            id="description"
-            label="Description"
-            type="textarea"
-            value={formData.description}
-            onChange={(e) => handleInputChange("description", e.target.value)}
-            rows={4}
-            required
-          />
-
-          <Select
-            id="status"
-            label="Status"
-            value={formData.status}
-            onValueChange={handleStatusChange}
-            options={STATUS_OPTIONS}
-          />
-
-          <Input
-            id="categories"
-            label="Categories (comma-separated)"
-            value={formData.categories}
-            onChange={(e) => handleInputChange("categories", e.target.value)}
-          />
-
-          <Input
-            id="imageUrls"
-            label="Image URLs (comma-separated)"
-            value={formData.imageUrls}
-            onChange={(e) => handleInputChange("imageUrls", e.target.value)}
-          />
-
-          <Input
-            id="videoUrl"
-            label="Video URL"
-            value={formData.videoUrl}
-            onChange={(e) => handleInputChange("videoUrl", e.target.value)}
-          />
-
-          <Input
-            id="agentOutputDemoUrl"
-            label="Output Demo URL"
-            value={formData.agentOutputDemoUrl}
-            onChange={(e) =>
-              handleInputChange("agentOutputDemoUrl", e.target.value)
-            }
-          />
-
-          <Input
-            id="storeListingId"
-            label="Store Listing ID (for linking)"
-            value={formData.storeListingId}
-            onChange={(e) =>
-              handleInputChange("storeListingId", e.target.value)
-            }
-            placeholder="Leave empty if not linked"
-          />
-
-          <Dialog.Footer>
-            <Button type="button" variant="secondary" onClick={onClose}>
-              Cancel
-            </Button>
-            <Button type="submit" loading={updateWaitlistMutation.isPending}>
-              Save Changes
-            </Button>
-          </Dialog.Footer>
-        </form>
-      </Dialog.Content>
-    </Dialog>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/WaitlistSignupsDialog.tsx

@@ -1,156 +0,0 @@
-"use client";
-
-import { Button } from "@/components/atoms/Button/Button";
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import { User, Envelope, DownloadSimple } from "@phosphor-icons/react";
-import { useGetV2GetWaitlistSignups } from "@/app/api/__generated__/endpoints/admin/admin";
-
-type WaitlistSignupsDialogProps = {
-  waitlistId: string;
-  onClose: () => void;
-};
-
-export function WaitlistSignupsDialog({
-  waitlistId,
-  onClose,
-}: WaitlistSignupsDialogProps) {
-  const {
-    data: signupsResponse,
-    isLoading,
-    isError,
-  } = useGetV2GetWaitlistSignups(waitlistId);
-
-  const signups = signupsResponse?.status === 200 ? signupsResponse.data : null;
-
-  function exportToCSV() {
-    if (!signups) return;
-
-    const headers = ["Type", "Email", "User ID", "Username"];
-    const rows = signups.signups.map((signup) => [
-      signup.type,
-      signup.email || "",
-      signup.userId || "",
-      signup.username || "",
-    ]);
-
-    const escapeCell = (cell: string) => `"${cell.replace(/"/g, '""')}"`;
-
-    const csvContent = [
-      headers.join(","),
-      ...rows.map((row) => row.map(escapeCell).join(",")),
-    ].join("\n");
-
-    const blob = new Blob([csvContent], { type: "text/csv" });
-    const url = window.URL.createObjectURL(blob);
-    const a = document.createElement("a");
-    a.href = url;
-    a.download = `waitlist-${waitlistId}-signups.csv`;
-    a.click();
-    window.URL.revokeObjectURL(url);
-  }
-
-  function renderContent() {
-    if (isLoading) {
-      return <div className="py-10 text-center">Loading signups...</div>;
-    }
-
-    if (isError) {
-      return (
-        <div className="py-10 text-center text-red-500">
-          Failed to load signups. Please try again.
-        </div>
-      );
-    }
-
-    if (!signups || signups.signups.length === 0) {
-      return (
-        <div className="py-10 text-center text-gray-500">
-          No signups yet for this waitlist.
-        </div>
-      );
-    }
-
-    return (
-      <>
-        <div className="flex justify-end">
-          <Button variant="secondary" size="small" onClick={exportToCSV}>
-            <DownloadSimple className="mr-2 h-4 w-4" size={16} />
-            Export CSV
-          </Button>
-        </div>
-        <div className="max-h-[400px] overflow-y-auto rounded-md border">
-          <table className="w-full">
-            <thead className="bg-gray-50 dark:bg-gray-800">
-              <tr>
-                <th className="px-4 py-3 text-left text-sm font-medium">
-                  Type
-                </th>
-                <th className="px-4 py-3 text-left text-sm font-medium">
-                  Email / Username
-                </th>
-                <th className="px-4 py-3 text-left text-sm font-medium">
-                  User ID
-                </th>
-              </tr>
-            </thead>
-            <tbody className="divide-y">
-              {signups.signups.map((signup, index) => (
-                <tr key={index}>
-                  <td className="px-4 py-3">
-                    {signup.type === "user" ? (
-                      <span className="flex items-center gap-1 text-blue-600">
-                        <User className="h-4 w-4" size={16} /> User
-                      </span>
-                    ) : (
-                      <span className="flex items-center gap-1 text-gray-600">
-                        <Envelope className="h-4 w-4" size={16} /> Email
-                      </span>
-                    )}
-                  </td>
-                  <td className="px-4 py-3">
-                    {signup.type === "user"
-                      ? signup.username || signup.email
-                      : signup.email}
-                  </td>
-                  <td className="px-4 py-3 font-mono text-sm">
-                    {signup.userId || "-"}
-                  </td>
-                </tr>
-              ))}
-            </tbody>
-          </table>
-        </div>
-      </>
-    );
-  }
-
-  return (
-    <Dialog
-      title="Waitlist Signups"
-      controlled={{
-        isOpen: true,
-        set: async (open) => {
-          if (!open) onClose();
-        },
-      }}
-      onClose={onClose}
-      styling={{ maxWidth: "700px" }}
-    >
-      <Dialog.Content>
-        <p className="mb-4 text-sm text-zinc-500">
-          {signups
-            ? `${signups.totalCount} total signups`
-            : "Loading signups..."}
-        </p>
-
-        {renderContent()}
-
-        <Dialog.Footer>
-          <Button variant="secondary" onClick={onClose}>
-            Close
-          </Button>
-        </Dialog.Footer>
-      </Dialog.Content>
-    </Dialog>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/WaitlistTable.tsx

@@ -1,206 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-import {
-  Table,
-  TableBody,
-  TableCell,
-  TableHead,
-  TableHeader,
-  TableRow,
-} from "@/components/__legacy__/ui/table";
-import { Button } from "@/components/atoms/Button/Button";
-import {
-  useGetV2ListAllWaitlists,
-  useDeleteV2DeleteWaitlist,
-  getGetV2ListAllWaitlistsQueryKey,
-} from "@/app/api/__generated__/endpoints/admin/admin";
-import type { WaitlistAdminResponse } from "@/app/api/__generated__/models/waitlistAdminResponse";
-import { EditWaitlistDialog } from "./EditWaitlistDialog";
-import { WaitlistSignupsDialog } from "./WaitlistSignupsDialog";
-import { Trash, PencilSimple, Users, Link } from "@phosphor-icons/react";
-import { useToast } from "@/components/molecules/Toast/use-toast";
-
-export function WaitlistTable() {
-  const [editingWaitlist, setEditingWaitlist] =
-    useState<WaitlistAdminResponse | null>(null);
-  const [viewingSignups, setViewingSignups] = useState<string | null>(null);
-  const { toast } = useToast();
-  const queryClient = useQueryClient();
-
-  const { data: response, isLoading, error } = useGetV2ListAllWaitlists();
-
-  const deleteWaitlistMutation = useDeleteV2DeleteWaitlist({
-    mutation: {
-      onSuccess: () => {
-        toast({
-          title: "Success",
-          description: "Waitlist deleted successfully",
-        });
-        queryClient.invalidateQueries({
-          queryKey: getGetV2ListAllWaitlistsQueryKey(),
-        });
-      },
-      onError: (error) => {
-        console.error("Error deleting waitlist:", error);
-        toast({
-          variant: "destructive",
-          title: "Error",
-          description: "Failed to delete waitlist",
-        });
-      },
-    },
-  });
-
-  function handleDelete(waitlistId: string) {
-    if (!confirm("Are you sure you want to delete this waitlist?")) return;
-    deleteWaitlistMutation.mutate({ waitlistId });
-  }
-
-  function handleWaitlistSaved() {
-    setEditingWaitlist(null);
-    queryClient.invalidateQueries({
-      queryKey: getGetV2ListAllWaitlistsQueryKey(),
-    });
-  }
-
-  function formatStatus(status: string) {
-    const statusColors: Record<string, string> = {
-      NOT_STARTED: "bg-gray-100 text-gray-800",
-      WORK_IN_PROGRESS: "bg-blue-100 text-blue-800",
-      DONE: "bg-green-100 text-green-800",
-      CANCELED: "bg-red-100 text-red-800",
-    };
-
-    return (
-      <span
-        className={`rounded-full px-2 py-1 text-xs font-medium ${statusColors[status] || "bg-gray-100 text-gray-700"}`}
-      >
-        {status.replace(/_/g, " ")}
-      </span>
-    );
-  }
-
-  function formatDate(dateStr: string) {
-    if (!dateStr) return "-";
-    return new Intl.DateTimeFormat("en-US", {
-      month: "short",
-      day: "numeric",
-      year: "numeric",
-    }).format(new Date(dateStr));
-  }
-
-  if (isLoading) {
-    return <div className="py-10 text-center">Loading waitlists...</div>;
-  }
-
-  if (error) {
-    return (
-      <div className="py-10 text-center text-red-500">
-        Error loading waitlists. Please try again.
-      </div>
-    );
-  }
-
-  const waitlists = response?.status === 200 ? response.data.waitlists : [];
-
-  if (waitlists.length === 0) {
-    return (
-      <div className="py-10 text-center text-gray-500">
-        No waitlists found. Create one to get started!
-      </div>
-    );
-  }
-
-  return (
-    <>
-      <div className="rounded-md border bg-white">
-        <Table>
-          <TableHeader className="bg-gray-50">
-            <TableRow>
-              <TableHead className="font-medium">Name</TableHead>
-              <TableHead className="font-medium">Status</TableHead>
-              <TableHead className="font-medium">Signups</TableHead>
-              <TableHead className="font-medium">Votes</TableHead>
-              <TableHead className="font-medium">Created</TableHead>
-              <TableHead className="font-medium">Linked Agent</TableHead>
-              <TableHead className="font-medium">Actions</TableHead>
-            </TableRow>
-          </TableHeader>
-          <TableBody>
-            {waitlists.map((waitlist) => (
-              <TableRow key={waitlist.id}>
-                <TableCell>
-                  <div>
-                    <div className="font-medium">{waitlist.name}</div>
-                    <div className="text-sm text-gray-500">
-                      {waitlist.subHeading}
-                    </div>
-                  </div>
-                </TableCell>
-                <TableCell>{formatStatus(waitlist.status)}</TableCell>
-                <TableCell>{waitlist.signupCount}</TableCell>
-                <TableCell>{waitlist.votes}</TableCell>
-                <TableCell>{formatDate(waitlist.createdAt)}</TableCell>
-                <TableCell>
-                  {waitlist.storeListingId ? (
-                    <span className="text-green-600">
-                      <Link size={16} className="inline" /> Linked
-                    </span>
-                  ) : (
-                    <span className="text-gray-400">Not linked</span>
-                  )}
-                </TableCell>
-                <TableCell>
-                  <div className="flex gap-2">
-                    <Button
-                      variant="ghost"
-                      size="small"
-                      onClick={() => setViewingSignups(waitlist.id)}
-                      title="View signups"
-                    >
-                      <Users size={16} />
-                    </Button>
-                    <Button
-                      variant="ghost"
-                      size="small"
-                      onClick={() => setEditingWaitlist(waitlist)}
-                      title="Edit"
-                    >
-                      <PencilSimple size={16} />
-                    </Button>
-                    <Button
-                      variant="ghost"
-                      size="small"
-                      onClick={() => handleDelete(waitlist.id)}
-                      title="Delete"
-                      disabled={deleteWaitlistMutation.isPending}
-                    >
-                      <Trash size={16} className="text-red-500" />
-                    </Button>
-                  </div>
-                </TableCell>
-              </TableRow>
-            ))}
-          </TableBody>
-        </Table>
-      </div>
-
-      {editingWaitlist && (
-        <EditWaitlistDialog
-          waitlist={editingWaitlist}
-          onClose={() => setEditingWaitlist(null)}
-          onSave={handleWaitlistSaved}
-        />
-      )}
-
-      {viewingSignups && (
-        <WaitlistSignupsDialog
-          waitlistId={viewingSignups}
-          onClose={() => setViewingSignups(null)}
-        />
-      )}
-    </>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/admin/waitlist/page.tsx

@@ -1,52 +0,0 @@
-import { withRoleAccess } from "@/lib/withRoleAccess";
-import { Suspense } from "react";
-import { WaitlistTable } from "./components/WaitlistTable";
-import { CreateWaitlistButton } from "./components/CreateWaitlistButton";
-import { Warning } from "@phosphor-icons/react/dist/ssr";
-
-function WaitlistDashboard() {
-  return (
-    <div className="mx-auto p-6">
-      <div className="flex flex-col gap-4">
-        <div className="flex items-center justify-between">
-          <div>
-            <h1 className="text-3xl font-bold">Waitlist Management</h1>
-            <p className="text-gray-500">
-              Manage upcoming agent waitlists and track signups
-            </p>
-          </div>
-          <CreateWaitlistButton />
-        </div>
-
-        <div className="flex items-start gap-3 rounded-lg border border-amber-300 bg-amber-50 p-4 dark:border-amber-700 dark:bg-amber-950">
-          <Warning
-            className="mt-0.5 h-5 w-5 flex-shrink-0 text-amber-600 dark:text-amber-400"
-            weight="fill"
-          />
-          <div className="text-sm text-amber-800 dark:text-amber-200">
-            <p className="font-medium">TODO: Email-only signup notifications</p>
-            <p className="mt-1 text-amber-700 dark:text-amber-300">
-              Notifications for email-only signups (users who weren&apos;t
-              logged in) have not been implemented yet. Currently only
-              registered users will receive launch emails.
-            </p>
-          </div>
-        </div>
-
-        <Suspense
-          fallback={
-            <div className="py-10 text-center">Loading waitlists...</div>
-          }
-        >
-          <WaitlistTable />
-        </Suspense>
-      </div>
-    </div>
-  );
-}
-
-export default async function WaitlistDashboardPage() {
-  const withAdminAccess = await withRoleAccess(["admin"]);
-  const ProtectedWaitlistDashboard = await withAdminAccess(WaitlistDashboard);
-  return <ProtectedWaitlistDashboard />;
-}

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainMarketplacePage/MainMarketplacePage.tsx

@@ -8,7 +8,6 @@ import { useMainMarketplacePage } from "./useMainMarketplacePage";
 import { FeaturedCreators } from "../FeaturedCreators/FeaturedCreators";
 import { MainMarketplacePageLoading } from "../MainMarketplacePageLoading";
 import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
-import { WaitlistSection } from "../WaitlistSection/WaitlistSection";
 
 export const MainMarkeplacePage = () => {
   const { featuredAgents, topAgents, featuredCreators, isLoading, hasError } =
@@ -47,10 +46,6 @@ export const MainMarkeplacePage = () => {
         {/* 100px margin because our featured sections button are placed 40px below the container */}
         <Separator className="mb-6 mt-24" />
 
-        {/* Waitlist Section - "Help Shape What's Next" */}
-        <WaitlistSection />
-        <Separator className="mb-6 mt-12" />
-
         {topAgents && (
           <AgentsSection sectionTitle="Top Agents" agents={topAgents.agents} />
         )}

autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistCard/WaitlistCard.tsx

@@ -1,105 +0,0 @@
-"use client";
-
-import Image from "next/image";
-import { Button } from "@/components/atoms/Button/Button";
-import { Check } from "@phosphor-icons/react";
-
-interface WaitlistCardProps {
-  name: string;
-  subHeading: string;
-  description: string;
-  imageUrl: string | null;
-  isMember?: boolean;
-  onCardClick: () => void;
-  onJoinClick: (e: React.MouseEvent) => void;
-}
-
-export function WaitlistCard({
-  name,
-  subHeading,
-  description,
-  imageUrl,
-  isMember = false,
-  onCardClick,
-  onJoinClick,
-}: WaitlistCardProps) {
-  function handleJoinClick(e: React.MouseEvent) {
-    e.stopPropagation();
-    onJoinClick(e);
-  }
-
-  return (
-    <div
-      className="flex h-[24rem] w-full max-w-md cursor-pointer flex-col items-start rounded-3xl bg-white transition-all duration-300 hover:shadow-lg dark:bg-zinc-900 dark:hover:shadow-gray-700"
-      onClick={onCardClick}
-      data-testid="waitlist-card"
-      role="button"
-      tabIndex={0}
-      aria-label={`${name} waitlist card`}
-      onKeyDown={(e) => {
-        if (e.key === "Enter" || e.key === " ") {
-          onCardClick();
-        }
-      }}
-    >
-      {/* Image Section */}
-      <div className="relative aspect-[2/1.2] w-full overflow-hidden rounded-large md:aspect-[2.17/1]">
-        {imageUrl ? (
-          <Image
-            src={imageUrl}
-            alt={`${name} preview image`}
-            fill
-            className="object-cover"
-          />
-        ) : (
-          <div className="flex h-full w-full items-center justify-center bg-gradient-to-br from-neutral-200 to-neutral-300 dark:from-neutral-700 dark:to-neutral-800">
-            <span className="text-4xl font-bold text-neutral-400 dark:text-neutral-500">
-              {name.charAt(0)}
-            </span>
-          </div>
-        )}
-      </div>
-
-      <div className="mt-3 flex w-full flex-1 flex-col px-4">
-        {/* Name and Subheading */}
-        <div className="flex w-full flex-col">
-          <h3 className="line-clamp-1 font-poppins text-xl font-semibold text-[#272727] dark:text-neutral-100">
-            {name}
-          </h3>
-          <p className="mt-1 line-clamp-1 text-sm text-neutral-500 dark:text-neutral-400">
-            {subHeading}
-          </p>
-        </div>
-
-        {/* Description */}
-        <div className="mt-2 flex w-full flex-col">
-          <p className="line-clamp-5 text-sm font-normal leading-relaxed text-neutral-600 dark:text-neutral-400">
-            {description}
-          </p>
-        </div>
-
-        <div className="flex-grow" />
-
-        {/* Join Waitlist Button */}
-        <div className="mt-4 w-full pb-4">
-          {isMember ? (
-            <Button
-              disabled
-              className="w-full rounded-full bg-green-600 text-white hover:bg-green-600 dark:bg-green-700 dark:hover:bg-green-700"
-            >
-              <Check className="mr-2" size={16} weight="bold" />
-              On the waitlist
-            </Button>
-          ) : (
-            <Button
-              onClick={handleJoinClick}
-              className="w-full rounded-full bg-zinc-800 text-white hover:bg-zinc-700 dark:bg-zinc-700 dark:hover:bg-zinc-600"
-            >
-              Join waitlist
-            </Button>
-          )}
-        </div>
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistDetailModal/WaitlistDetailModal.tsx

@@ -1,356 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import Image from "next/image";
-import { Button } from "@/components/atoms/Button/Button";
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import { Input } from "@/components/atoms/Input/Input";
-import {
-  Carousel,
-  CarouselContent,
-  CarouselItem,
-  CarouselNext,
-  CarouselPrevious,
-} from "@/components/__legacy__/ui/carousel";
-import type { StoreWaitlistEntry } from "@/app/api/__generated__/models/storeWaitlistEntry";
-import { Check, Play } from "@phosphor-icons/react";
-import { useSupabaseStore } from "@/lib/supabase/hooks/useSupabaseStore";
-import { useToast } from "@/components/molecules/Toast/use-toast";
-import { usePostV2AddSelfToTheAgentWaitlist } from "@/app/api/__generated__/endpoints/store/store";
-
-interface MediaItem {
-  type: "image" | "video";
-  url: string;
-  label?: string;
-}
-
-// Extract YouTube video ID from various URL formats
-function getYouTubeVideoId(url: string): string | null {
-  const regExp =
-    /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#&?]*).*/;
-  const match = url.match(regExp);
-  return match && match[7].length === 11 ? match[7] : null;
-}
-
-// Validate video URL for security
-function isValidVideoUrl(url: string): boolean {
-  if (url.startsWith("data:video")) {
-    return true;
-  }
-  const videoExtensions = /\.(mp4|webm|ogg)$/i;
-  const youtubeRegex = /^(https?:\/\/)?(www\.)?(youtube\.com|youtu\.?be)\/.+$/;
-  const validUrl = /^(https?:\/\/)/i;
-  const cleanedUrl = url.split("?")[0];
-  return (
-    (validUrl.test(url) && videoExtensions.test(cleanedUrl)) ||
-    youtubeRegex.test(url)
-  );
-}
-
-// Video player with YouTube embed support
-function VideoPlayer({
-  url,
-  autoPlay = false,
-  className = "",
-}: {
-  url: string;
-  autoPlay?: boolean;
-  className?: string;
-}) {
-  const youtubeId = getYouTubeVideoId(url);
-
-  if (youtubeId) {
-    return (
-      <iframe
-        src={`https://www.youtube.com/embed/${youtubeId}${autoPlay ? "?autoplay=1" : ""}`}
-        title="YouTube video player"
-        className={className}
-        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
-        sandbox="allow-same-origin allow-scripts allow-presentation"
-        allowFullScreen
-      />
-    );
-  }
-
-  if (!isValidVideoUrl(url)) {
-    return (
-      <div
-        className={`flex items-center justify-center bg-zinc-800 ${className}`}
-      >
-        <span className="text-sm text-zinc-400">Invalid video URL</span>
-      </div>
-    );
-  }
-
-  return <video src={url} controls autoPlay={autoPlay} className={className} />;
-}
-
-function MediaCarousel({ waitlist }: { waitlist: StoreWaitlistEntry }) {
-  const [activeVideo, setActiveVideo] = useState<string | null>(null);
-
-  // Build media items array: videos first, then images
-  const mediaItems: MediaItem[] = [
-    ...(waitlist.videoUrl
-      ? [{ type: "video" as const, url: waitlist.videoUrl, label: "Video" }]
-      : []),
-    ...(waitlist.agentOutputDemoUrl
-      ? [
-          {
-            type: "video" as const,
-            url: waitlist.agentOutputDemoUrl,
-            label: "Demo",
-          },
-        ]
-      : []),
-    ...waitlist.imageUrls.map((url) => ({ type: "image" as const, url })),
-  ];
-
-  if (mediaItems.length === 0) return null;
-
-  // Single item - no carousel needed
-  if (mediaItems.length === 1) {
-    const item = mediaItems[0];
-    return (
-      <div className="relative aspect-[350/196] w-full overflow-hidden rounded-large">
-        {item.type === "image" ? (
-          <Image
-            src={item.url}
-            alt={`${waitlist.name} preview`}
-            fill
-            className="object-cover"
-          />
-        ) : (
-          <VideoPlayer url={item.url} className="h-full w-full object-cover" />
-        )}
-      </div>
-    );
-  }
-
-  // Multiple items - use carousel
-  return (
-    <Carousel className="w-full">
-      <CarouselContent>
-        {mediaItems.map((item, index) => (
-          <CarouselItem key={index}>
-            <div className="relative aspect-[350/196] w-full overflow-hidden rounded-large">
-              {item.type === "image" ? (
-                <Image
-                  src={item.url}
-                  alt={`${waitlist.name} preview ${index + 1}`}
-                  fill
-                  className="object-cover"
-                />
-              ) : activeVideo === item.url ? (
-                <VideoPlayer
-                  url={item.url}
-                  autoPlay
-                  className="h-full w-full object-cover"
-                />
-              ) : (
-                <button
-                  onClick={() => setActiveVideo(item.url)}
-                  className="group relative h-full w-full bg-zinc-900"
-                >
-                  <div className="absolute inset-0 flex items-center justify-center">
-                    <div className="flex h-16 w-16 items-center justify-center rounded-full bg-white/90 transition-transform group-hover:scale-110">
-                      <Play size={32} weight="fill" className="text-zinc-800" />
-                    </div>
-                  </div>
-                  <span className="absolute bottom-3 left-3 text-sm text-white">
-                    {item.label}
-                  </span>
-                </button>
-              )}
-            </div>
-          </CarouselItem>
-        ))}
-      </CarouselContent>
-      <CarouselPrevious className="left-2 top-1/2 -translate-y-1/2" />
-      <CarouselNext className="right-2 top-1/2 -translate-y-1/2" />
-    </Carousel>
-  );
-}
-
-interface WaitlistDetailModalProps {
-  waitlist: StoreWaitlistEntry;
-  isMember?: boolean;
-  onClose: () => void;
-  onJoinSuccess?: (waitlistId: string) => void;
-}
-
-export function WaitlistDetailModal({
-  waitlist,
-  isMember = false,
-  onClose,
-  onJoinSuccess,
-}: WaitlistDetailModalProps) {
-  const { user } = useSupabaseStore();
-  const [email, setEmail] = useState("");
-  const [success, setSuccess] = useState(false);
-  const { toast } = useToast();
-  const joinWaitlistMutation = usePostV2AddSelfToTheAgentWaitlist();
-
-  function handleJoin() {
-    joinWaitlistMutation.mutate(
-      {
-        waitlistId: waitlist.waitlistId,
-        data: { email: user ? undefined : email },
-      },
-      {
-        onSuccess: (response) => {
-          if (response.status === 200) {
-            setSuccess(true);
-            toast({
-              title: "You're on the waitlist!",
-              description: `We'll notify you when ${waitlist.name} goes live.`,
-            });
-            onJoinSuccess?.(waitlist.waitlistId);
-          } else {
-            toast({
-              variant: "destructive",
-              title: "Error",
-              description: "Failed to join waitlist. Please try again.",
-            });
-          }
-        },
-        onError: () => {
-          toast({
-            variant: "destructive",
-            title: "Error",
-            description: "Failed to join waitlist. Please try again.",
-          });
-        },
-      },
-    );
-  }
-
-  // Success state
-  if (success) {
-    return (
-      <Dialog
-        title=""
-        controlled={{
-          isOpen: true,
-          set: async (open) => {
-            if (!open) onClose();
-          },
-        }}
-        onClose={onClose}
-        styling={{ maxWidth: "500px" }}
-      >
-        <Dialog.Content>
-          <div className="flex flex-col items-center justify-center py-4 text-center">
-            {/* Party emoji */}
-            <span className="mb-2 text-5xl">🎉</span>
-
-            {/* Title */}
-            <h2 className="mb-2 font-poppins text-[22px] font-medium leading-7 text-zinc-900 dark:text-zinc-100">
-              You&apos;re on the waitlist
-            </h2>
-
-            {/* Subtitle */}
-            <p className="text-base leading-[26px] text-zinc-600 dark:text-zinc-400">
-              Thanks for helping us prioritize which agents to build next.
-              We&apos;ll notify you when this agent goes live in the
-              marketplace.
-            </p>
-          </div>
-
-          {/* Close button */}
-          <Dialog.Footer className="flex justify-center pb-2 pt-4">
-            <Button
-              variant="secondary"
-              onClick={onClose}
-              className="rounded-full border border-zinc-700 bg-white px-4 py-3 text-zinc-900 hover:bg-zinc-100 dark:border-zinc-500 dark:bg-zinc-800 dark:text-zinc-100 dark:hover:bg-zinc-700"
-            >
-              Close
-            </Button>
-          </Dialog.Footer>
-        </Dialog.Content>
-      </Dialog>
-    );
-  }
-
-  // Main modal - handles both member and non-member states
-  return (
-    <Dialog
-      title="Join the waitlist"
-      controlled={{
-        isOpen: true,
-        set: async (open) => {
-          if (!open) onClose();
-        },
-      }}
-      onClose={onClose}
-      styling={{ maxWidth: "500px" }}
-    >
-      <Dialog.Content>
-        {/* Subtitle */}
-        <p className="mb-6 text-center text-base text-zinc-600 dark:text-zinc-400">
-          Help us decide what to build next — and get notified when this agent
-          is ready
-        </p>
-
-        {/* Media Carousel */}
-        <MediaCarousel waitlist={waitlist} />
-
-        {/* Agent Name */}
-        <h3 className="mt-4 font-poppins text-[22px] font-medium leading-7 text-zinc-800 dark:text-zinc-100">
-          {waitlist.name}
-        </h3>
-
-        {/* Agent Description */}
-        <p className="mt-2 line-clamp-5 text-sm leading-[22px] text-zinc-500 dark:text-zinc-400">
-          {waitlist.description}
-        </p>
-
-        {/* Email input for non-logged-in users who haven't joined */}
-        {!isMember && !user && (
-          <div className="mt-4 pr-1">
-            <Input
-              id="email"
-              label="Email address"
-              type="email"
-              placeholder="you@example.com"
-              value={email}
-              onChange={(e) => setEmail(e.target.value)}
-              required
-            />
-          </div>
-        )}
-
-        {/* Footer buttons */}
-        <Dialog.Footer className="sticky bottom-0 mt-6 flex justify-center gap-3 bg-white pb-2 pt-4 dark:bg-zinc-900">
-          {isMember ? (
-            <Button
-              disabled
-              className="rounded-full bg-green-600 px-4 py-3 text-white hover:bg-green-600 dark:bg-green-700 dark:hover:bg-green-700"
-            >
-              <Check size={16} className="mr-2" />
-              You&apos;re on the waitlist
-            </Button>
-          ) : (
-            <>
-              <Button
-                onClick={handleJoin}
-                loading={joinWaitlistMutation.isPending}
-                disabled={!user && !email}
-                className="rounded-full bg-zinc-800 px-4 py-3 text-white hover:bg-zinc-700 dark:bg-zinc-700 dark:hover:bg-zinc-600"
-              >
-                Join waitlist
-              </Button>
-              <Button
-                type="button"
-                variant="secondary"
-                onClick={onClose}
-                className="rounded-full bg-zinc-200 px-4 py-3 text-zinc-900 hover:bg-zinc-300 dark:bg-zinc-700 dark:text-zinc-100 dark:hover:bg-zinc-600"
-              >
-                Not now
-              </Button>
-            </>
-          )}
-        </Dialog.Footer>
-      </Dialog.Content>
-    </Dialog>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistSection/WaitlistSection.tsx

@@ -1,102 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import {
-  Carousel,
-  CarouselContent,
-  CarouselItem,
-} from "@/components/__legacy__/ui/carousel";
-import { WaitlistCard } from "../WaitlistCard/WaitlistCard";
-import { WaitlistDetailModal } from "../WaitlistDetailModal/WaitlistDetailModal";
-import type { StoreWaitlistEntry } from "@/app/api/__generated__/models/storeWaitlistEntry";
-import { useWaitlistSection } from "./useWaitlistSection";
-
-export function WaitlistSection() {
-  const { waitlists, joinedWaitlistIds, isLoading, hasError, markAsJoined } =
-    useWaitlistSection();
-  const [selectedWaitlist, setSelectedWaitlist] =
-    useState<StoreWaitlistEntry | null>(null);
-
-  function handleOpenModal(waitlist: StoreWaitlistEntry) {
-    setSelectedWaitlist(waitlist);
-  }
-
-  function handleJoinSuccess(waitlistId: string) {
-    markAsJoined(waitlistId);
-  }
-
-  // Don't render if loading, error, or no waitlists
-  if (isLoading || hasError || !waitlists || waitlists.length === 0) {
-    return null;
-  }
-
-  return (
-    <div className="flex flex-col items-center justify-center">
-      <div className="w-full max-w-[1360px]">
-        {/* Section Header */}
-        <div className="mb-6">
-          <h2 className="font-poppins text-2xl font-semibold text-[#282828] dark:text-neutral-200">
-            Help Shape What&apos;s Next
-          </h2>
-          <p className="mt-2 text-base text-neutral-600 dark:text-neutral-400">
-            These agents are in development. Your interest helps us prioritize
-            what gets built — and we&apos;ll notify you when they&apos;re ready.
-          </p>
-        </div>
-
-        {/* Mobile Carousel View */}
-        <Carousel
-          className="md:hidden"
-          opts={{
-            loop: true,
-          }}
-        >
-          <CarouselContent>
-            {waitlists.map((waitlist) => (
-              <CarouselItem
-                key={waitlist.waitlistId}
-                className="min-w-64 max-w-71"
-              >
-                <WaitlistCard
-                  name={waitlist.name}
-                  subHeading={waitlist.subHeading}
-                  description={waitlist.description}
-                  imageUrl={waitlist.imageUrls[0] || null}
-                  isMember={joinedWaitlistIds.has(waitlist.waitlistId)}
-                  onCardClick={() => handleOpenModal(waitlist)}
-                  onJoinClick={() => handleOpenModal(waitlist)}
-                />
-              </CarouselItem>
-            ))}
-          </CarouselContent>
-        </Carousel>
-
-        {/* Desktop Grid View */}
-        <div className="hidden grid-cols-1 place-items-center gap-6 md:grid md:grid-cols-2 lg:grid-cols-3">
-          {waitlists.map((waitlist) => (
-            <WaitlistCard
-              key={waitlist.waitlistId}
-              name={waitlist.name}
-              subHeading={waitlist.subHeading}
-              description={waitlist.description}
-              imageUrl={waitlist.imageUrls[0] || null}
-              isMember={joinedWaitlistIds.has(waitlist.waitlistId)}
-              onCardClick={() => handleOpenModal(waitlist)}
-              onJoinClick={() => handleOpenModal(waitlist)}
-            />
-          ))}
-        </div>
-      </div>
-
-      {/* Single Modal for both viewing and joining */}
-      {selectedWaitlist && (
-        <WaitlistDetailModal
-          waitlist={selectedWaitlist}
-          isMember={joinedWaitlistIds.has(selectedWaitlist.waitlistId)}
-          onClose={() => setSelectedWaitlist(null)}
-          onJoinSuccess={handleJoinSuccess}
-        />
-      )}
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistSection/useWaitlistSection.ts

@@ -1,58 +0,0 @@
-"use client";
-
-import { useMemo } from "react";
-import { useSupabaseStore } from "@/lib/supabase/hooks/useSupabaseStore";
-import {
-  useGetV2GetTheAgentWaitlist,
-  useGetV2GetWaitlistIdsTheCurrentUserHasJoined,
-  getGetV2GetWaitlistIdsTheCurrentUserHasJoinedQueryKey,
-} from "@/app/api/__generated__/endpoints/store/store";
-import type { StoreWaitlistEntry } from "@/app/api/__generated__/models/storeWaitlistEntry";
-import { useQueryClient } from "@tanstack/react-query";
-
-export function useWaitlistSection() {
-  const { user } = useSupabaseStore();
-  const queryClient = useQueryClient();
-
-  // Fetch waitlists
-  const {
-    data: waitlistsResponse,
-    isLoading: waitlistsLoading,
-    isError: waitlistsError,
-  } = useGetV2GetTheAgentWaitlist();
-
-  // Fetch memberships if logged in
-  const { data: membershipsResponse, isLoading: membershipsLoading } =
-    useGetV2GetWaitlistIdsTheCurrentUserHasJoined({
-      query: {
-        enabled: !!user,
-      },
-    });
-
-  const waitlists: StoreWaitlistEntry[] = useMemo(() => {
-    if (waitlistsResponse?.status === 200) {
-      return waitlistsResponse.data.listings;
-    }
-    return [];
-  }, [waitlistsResponse]);
-
-  const joinedWaitlistIds: Set<string> = useMemo(() => {
-    if (membershipsResponse?.status === 200) {
-      return new Set(membershipsResponse.data);
-    }
-    return new Set();
-  }, [membershipsResponse]);
-
-  const isLoading = waitlistsLoading || (!!user && membershipsLoading);
-  const hasError = waitlistsError;
-
-  // Function to add a waitlist ID to joined set (called after successful join)
-  function markAsJoined(_waitlistId: string) {
-    // Invalidate the memberships query to refetch
-    queryClient.invalidateQueries({
-      queryKey: getGetV2GetWaitlistIdsTheCurrentUserHasJoinedQueryKey(),
-    });
-  }
-
-  return { waitlists, joinedWaitlistIds, isLoading, hasError, markAsJoined };
-}

autogpt_platform/frontend/src/app/api/openapi.json

@@ -5082,301 +5082,6 @@
         }
       }
     },
-    "/api/store/admin/waitlist": {
-      "get": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "List All Waitlists",
-        "description": "Get all waitlists with admin details (admin only).\n\nReturns:\n    WaitlistAdminListResponse with all waitlists",
-        "operationId": "getV2List all waitlists",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminListResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          }
-        },
-        "security": [{ "HTTPBearerJWT": [] }]
-      },
-      "post": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Create Waitlist",
-        "description": "Create a new waitlist (admin only).\n\nArgs:\n    request: Waitlist creation details\n    user_id: Authenticated admin user creating the waitlist\n\nReturns:\n    WaitlistAdminResponse with the created waitlist details",
-        "operationId": "postV2Create waitlist",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": { "$ref": "#/components/schemas/WaitlistCreateRequest" }
-            }
-          },
-          "required": true
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        },
-        "security": [{ "HTTPBearerJWT": [] }]
-      }
-    },
-    "/api/store/admin/waitlist/{waitlist_id}": {
-      "delete": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Delete Waitlist",
-        "description": "Soft delete a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to delete\n\nReturns:\n    Success message",
-        "operationId": "deleteV2Delete waitlist",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": { "application/json": { "schema": {} } }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      },
-      "get": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Get Waitlist Details",
-        "description": "Get a single waitlist with admin details (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to retrieve\n\nReturns:\n    WaitlistAdminResponse with waitlist details",
-        "operationId": "getV2Get waitlist details",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      },
-      "put": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Update Waitlist",
-        "description": "Update a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to update\n    request: Fields to update\n\nReturns:\n    WaitlistAdminResponse with updated waitlist details",
-        "operationId": "putV2Update waitlist",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": {
-              "schema": { "$ref": "#/components/schemas/WaitlistUpdateRequest" }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/store/admin/waitlist/{waitlist_id}/link": {
-      "post": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Link Waitlist to Store Listing",
-        "description": "Link a waitlist to a store listing (admin only).\n\nWhen the linked store listing is approved/published, waitlist users\nwill be automatically notified.\n\nArgs:\n    waitlist_id: ID of the waitlist\n    store_listing_id: ID of the store listing to link\n\nReturns:\n    WaitlistAdminResponse with updated waitlist details",
-        "operationId": "postV2Link waitlist to store listing",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/Body_postV2Link_waitlist_to_store_listing"
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/store/admin/waitlist/{waitlist_id}/signups": {
-      "get": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Get Waitlist Signups",
-        "description": "Get all signups for a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist\n\nReturns:\n    WaitlistSignupListResponse with all signups",
-        "operationId": "getV2Get waitlist signups",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistSignupListResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
     "/api/store/agents": {
       "get": {
         "tags": ["v2", "store", "public"],
@@ -6222,101 +5927,6 @@
         }
       }
     },
-    "/api/store/waitlist": {
-      "get": {
-        "tags": ["v2", "store", "public"],
-        "summary": "Get the agent waitlist",
-        "description": "Get all active waitlists for public display.",
-        "operationId": "getV2Get the agent waitlist",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/StoreWaitlistsAllResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/store/waitlist/my-memberships": {
-      "get": {
-        "tags": ["v2", "store", "private"],
-        "summary": "Get waitlist IDs the current user has joined",
-        "description": "Returns list of waitlist IDs the authenticated user has joined.",
-        "operationId": "getV2Get waitlist ids the current user has joined",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "items": { "type": "string" },
-                  "type": "array",
-                  "title": "Response Getv2Get Waitlist Ids The Current User Has Joined"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          }
-        },
-        "security": [{ "HTTPBearerJWT": [] }]
-      }
-    },
-    "/api/store/waitlist/{waitlist_id}/join": {
-      "post": {
-        "tags": ["v2", "store", "public"],
-        "summary": "Add self to the agent waitlist",
-        "description": "Add the current user to the agent waitlist.",
-        "operationId": "postV2Add self to the agent waitlist",
-        "security": [{ "HTTPBearer": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist to join",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist to join"
-          }
-        ],
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/Body_postV2Add_self_to_the_agent_waitlist"
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/StoreWaitlistEntry" }
-              }
-            }
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
     "/health": {
       "get": {
         "tags": ["health"],
@@ -7064,17 +6674,6 @@
         "required": ["store_listing_version_id"],
         "title": "Body_postV2Add marketplace agent"
       },
-      "Body_postV2Add_self_to_the_agent_waitlist": {
-        "properties": {
-          "email": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Email",
-            "description": "Email address for unauthenticated users"
-          }
-        },
-        "type": "object",
-        "title": "Body_postV2Add self to the agent waitlist"
-      },
       "Body_postV2Execute_a_preset": {
         "properties": {
           "inputs": {
@@ -7093,18 +6692,6 @@
         "type": "object",
         "title": "Body_postV2Execute a preset"
       },
-      "Body_postV2Link_waitlist_to_store_listing": {
-        "properties": {
-          "store_listing_id": {
-            "type": "string",
-            "title": "Store Listing Id",
-            "description": "The ID of the store listing"
-          }
-        },
-        "type": "object",
-        "required": ["store_listing_id"],
-        "title": "Body_postV2Link waitlist to store listing"
-      },
       "Body_postV2Upload_submission_media": {
         "properties": {
           "file": { "type": "string", "format": "binary", "title": "File" }
@@ -8984,8 +8571,7 @@
           "REFUND_REQUEST",
           "REFUND_PROCESSED",
           "AGENT_APPROVED",
-          "AGENT_REJECTED",
-          "WAITLIST_LAUNCH"
+          "AGENT_REJECTED"
         ],
         "title": "NotificationType"
       },
@@ -10548,57 +10134,6 @@
         "required": ["submissions", "pagination"],
         "title": "StoreSubmissionsResponse"
       },
-      "StoreWaitlistEntry": {
-        "properties": {
-          "waitlistId": { "type": "string", "title": "Waitlistid" },
-          "slug": { "type": "string", "title": "Slug" },
-          "name": { "type": "string", "title": "Name" },
-          "subHeading": { "type": "string", "title": "Subheading" },
-          "videoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Videourl"
-          },
-          "agentOutputDemoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Agentoutputdemourl"
-          },
-          "imageUrls": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Imageurls"
-          },
-          "description": { "type": "string", "title": "Description" },
-          "categories": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Categories"
-          }
-        },
-        "type": "object",
-        "required": [
-          "waitlistId",
-          "slug",
-          "name",
-          "subHeading",
-          "imageUrls",
-          "description",
-          "categories"
-        ],
-        "title": "StoreWaitlistEntry",
-        "description": "Public waitlist entry - no PII fields exposed."
-      },
-      "StoreWaitlistsAllResponse": {
-        "properties": {
-          "listings": {
-            "items": { "$ref": "#/components/schemas/StoreWaitlistEntry" },
-            "type": "array",
-            "title": "Listings"
-          }
-        },
-        "type": "object",
-        "required": ["listings"],
-        "title": "StoreWaitlistsAllResponse"
-      },
       "StreamChatRequest": {
         "properties": {
           "message": { "type": "string", "title": "Message" },
@@ -12418,203 +11953,6 @@
         "required": ["loc", "msg", "type"],
         "title": "ValidationError"
       },
-      "WaitlistAdminListResponse": {
-        "properties": {
-          "waitlists": {
-            "items": { "$ref": "#/components/schemas/WaitlistAdminResponse" },
-            "type": "array",
-            "title": "Waitlists"
-          },
-          "totalCount": { "type": "integer", "title": "Totalcount" }
-        },
-        "type": "object",
-        "required": ["waitlists", "totalCount"],
-        "title": "WaitlistAdminListResponse",
-        "description": "Response model for listing all waitlists (admin view)."
-      },
-      "WaitlistAdminResponse": {
-        "properties": {
-          "id": { "type": "string", "title": "Id" },
-          "createdAt": { "type": "string", "title": "Createdat" },
-          "updatedAt": { "type": "string", "title": "Updatedat" },
-          "slug": { "type": "string", "title": "Slug" },
-          "name": { "type": "string", "title": "Name" },
-          "subHeading": { "type": "string", "title": "Subheading" },
-          "description": { "type": "string", "title": "Description" },
-          "categories": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Categories"
-          },
-          "imageUrls": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Imageurls"
-          },
-          "videoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Videourl"
-          },
-          "agentOutputDemoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Agentoutputdemourl"
-          },
-          "status": { "$ref": "#/components/schemas/WaitlistExternalStatus" },
-          "votes": { "type": "integer", "title": "Votes" },
-          "signupCount": { "type": "integer", "title": "Signupcount" },
-          "storeListingId": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Storelistingid"
-          },
-          "owningUserId": { "type": "string", "title": "Owninguserid" }
-        },
-        "type": "object",
-        "required": [
-          "id",
-          "createdAt",
-          "updatedAt",
-          "slug",
-          "name",
-          "subHeading",
-          "description",
-          "categories",
-          "imageUrls",
-          "status",
-          "votes",
-          "signupCount",
-          "owningUserId"
-        ],
-        "title": "WaitlistAdminResponse",
-        "description": "Admin response model with full waitlist details including internal data."
-      },
-      "WaitlistCreateRequest": {
-        "properties": {
-          "name": { "type": "string", "title": "Name" },
-          "slug": { "type": "string", "title": "Slug" },
-          "subHeading": { "type": "string", "title": "Subheading" },
-          "description": { "type": "string", "title": "Description" },
-          "categories": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Categories",
-            "default": []
-          },
-          "imageUrls": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Imageurls",
-            "default": []
-          },
-          "videoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Videourl"
-          },
-          "agentOutputDemoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Agentoutputdemourl"
-          }
-        },
-        "type": "object",
-        "required": ["name", "slug", "subHeading", "description"],
-        "title": "WaitlistCreateRequest",
-        "description": "Request model for creating a new waitlist."
-      },
-      "WaitlistExternalStatus": {
-        "type": "string",
-        "enum": ["DONE", "NOT_STARTED", "CANCELED", "WORK_IN_PROGRESS"],
-        "title": "WaitlistExternalStatus"
-      },
-      "WaitlistSignup": {
-        "properties": {
-          "type": { "type": "string", "title": "Type" },
-          "userId": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Userid"
-          },
-          "email": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Email"
-          },
-          "username": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Username"
-          }
-        },
-        "type": "object",
-        "required": ["type"],
-        "title": "WaitlistSignup",
-        "description": "Individual signup entry for a waitlist."
-      },
-      "WaitlistSignupListResponse": {
-        "properties": {
-          "waitlistId": { "type": "string", "title": "Waitlistid" },
-          "signups": {
-            "items": { "$ref": "#/components/schemas/WaitlistSignup" },
-            "type": "array",
-            "title": "Signups"
-          },
-          "totalCount": { "type": "integer", "title": "Totalcount" }
-        },
-        "type": "object",
-        "required": ["waitlistId", "signups", "totalCount"],
-        "title": "WaitlistSignupListResponse",
-        "description": "Response model for listing waitlist signups."
-      },
-      "WaitlistUpdateRequest": {
-        "properties": {
-          "name": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Name"
-          },
-          "slug": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Slug"
-          },
-          "subHeading": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Subheading"
-          },
-          "description": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Description"
-          },
-          "categories": {
-            "anyOf": [
-              { "items": { "type": "string" }, "type": "array" },
-              { "type": "null" }
-            ],
-            "title": "Categories"
-          },
-          "imageUrls": {
-            "anyOf": [
-              { "items": { "type": "string" }, "type": "array" },
-              { "type": "null" }
-            ],
-            "title": "Imageurls"
-          },
-          "videoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Videourl"
-          },
-          "agentOutputDemoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Agentoutputdemourl"
-          },
-          "status": {
-            "anyOf": [
-              { "$ref": "#/components/schemas/WaitlistExternalStatus" },
-              { "type": "null" }
-            ]
-          },
-          "storeListingId": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Storelistingid"
-          }
-        },
-        "type": "object",
-        "title": "WaitlistUpdateRequest",
-        "description": "Request model for updating a waitlist."
-      },
       "Webhook": {
         "properties": {
           "id": { "type": "string", "title": "Id" },

classic/.flake8

@@ -1,12 +1,15 @@
 [flake8]
 max-line-length = 88
+extend-ignore = E203
 exclude =
     .tox,
     __pycache__,
     *.pyc,
-    .env
-    venv*/*,
-    .venv/*,
-    reports/*,
-    dist/*,
-    data/*,
+    .env,
+    venv*,
+    .venv,
+    reports,
+    dist,
+    data,
+    .benchmark_workspaces,
+    .autogpt,

classic/CLAUDE.md

@@ -0,0 +1,291 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+AutoGPT Classic is an experimental, **unsupported** project demonstrating autonomous GPT-4 operation. Dependencies will not be updated, and the codebase contains known vulnerabilities. This is preserved for educational/historical purposes.
+
+## Repository Structure
+
+```
+classic/
+├── pyproject.toml          # Single consolidated Poetry project
+├── poetry.lock             # Single lock file
+├── forge/
+│   └── forge/              # Core agent framework package
+├── original_autogpt/
+│   └── autogpt/            # AutoGPT agent package
+├── direct_benchmark/
+│   └── direct_benchmark/   # Benchmark harness package
+└── benchmark/              # Challenge definitions (data, not code)
+```
+
+All packages are managed by a single `pyproject.toml` at the classic/ root.
+
+## Common Commands
+
+### Setup & Install
+```bash
+# Install everything from classic/ directory
+cd classic
+poetry install
+```
+
+### Running Agents
+```bash
+# Run forge agent
+poetry run python -m forge
+
+# Run original autogpt server
+poetry run serve --debug
+
+# Run autogpt CLI
+poetry run autogpt
+```
+
+Agents run on `http://localhost:8000` by default.
+
+### Benchmarking
+```bash
+# Run benchmarks
+poetry run direct-benchmark run
+
+# Run specific strategies and models
+poetry run direct-benchmark run \
+    --strategies one_shot,rewoo \
+    --models claude \
+    --parallel 4
+
+# Run a single test
+poetry run direct-benchmark run --tests ReadFile
+
+# List available commands
+poetry run direct-benchmark --help
+```
+
+### Testing
+```bash
+poetry run pytest                              # All tests
+poetry run pytest forge/tests/                 # Forge tests only
+poetry run pytest original_autogpt/tests/      # AutoGPT tests only
+poetry run pytest -k test_name                 # Single test by name
+poetry run pytest path/to/test.py              # Specific test file
+poetry run pytest --cov                        # With coverage
+```
+
+### Linting & Formatting
+
+Run from the classic/ directory:
+
+```bash
+# Format everything (recommended to run together)
+poetry run black . && poetry run isort .
+
+# Check formatting (CI-style, no changes)
+poetry run black --check . && poetry run isort --check-only .
+
+# Lint
+poetry run flake8        # Style linting
+
+# Type check
+poetry run pyright       # Type checking (some errors are expected in infrastructure code)
+```
+
+Note: Always run linters over the entire directory, not specific files, for best results.
+
+## Architecture
+
+### Forge (Core Framework)
+The `forge` package is the foundation that other components depend on:
+- `forge/agent/` - Agent implementation and protocols
+- `forge/llm/` - Multi-provider LLM integrations (OpenAI, Anthropic, Groq, LiteLLM)
+- `forge/components/` - Reusable agent components
+- `forge/file_storage/` - File system abstraction
+- `forge/config/` - Configuration management
+
+### Original AutoGPT
+- `original_autogpt/autogpt/app/` - CLI application entry points
+- `original_autogpt/autogpt/agents/` - Agent implementations
+- `original_autogpt/autogpt/agent_factory/` - Agent creation logic
+
+### Direct Benchmark
+Benchmark harness for testing agent performance:
+- `direct_benchmark/direct_benchmark/` - CLI and harness code
+- `benchmark/agbenchmark/challenges/` - Test cases organized by category (code, retrieval, data, etc.)
+- Reports generated in `direct_benchmark/reports/`
+
+### Package Structure
+All three packages are included in a single Poetry project. Imports are fully qualified:
+- `from forge.agent.base import BaseAgent`
+- `from autogpt.agents.agent import Agent`
+- `from direct_benchmark.harness import BenchmarkHarness`
+
+## Code Style
+
+- Python 3.12 target
+- Line length: 88 characters (Black default)
+- Black for formatting, isort for imports (profile="black")
+- Type hints with Pyright checking
+
+## Testing Patterns
+
+- Async support via pytest-asyncio
+- Fixtures defined in `conftest.py` files provide: `tmp_project_root`, `storage`, `config`, `llm_provider`, `agent`
+- Tests requiring API keys (OPENAI_API_KEY, ANTHROPIC_API_KEY) will skip if not set
+
+## Environment Setup
+
+Copy `.env.example` to `.env` in the relevant directory and add your API keys:
+```bash
+cp .env.example .env
+# Edit .env with your OPENAI_API_KEY, etc.
+```
+
+## Workspaces
+
+Agents operate within a **workspace** - a directory containing all agent data and files. The workspace root defaults to the current working directory.
+
+### Workspace Structure
+
+```
+{workspace}/
+├── .autogpt/
+│   ├── autogpt.yaml              # Workspace-level permissions
+│   ├── ap_server.db              # Agent Protocol database (server mode)
+│   └── agents/
+│       └── AutoGPT-{agent_id}/
+│           ├── state.json        # Agent profile, directives, action history
+│           ├── permissions.yaml  # Agent-specific permission overrides
+│           └── workspace/        # Agent's sandboxed working directory
+```
+
+### Key Concepts
+
+- **Multiple agents** can coexist in the same workspace (each gets its own subdirectory)
+- **File access** is sandboxed to the agent's `workspace/` directory by default
+- **State persistence** - agent state saves to `state.json` and survives across sessions
+- **Storage backends** - supports local filesystem, S3, and GCS (via `FILE_STORAGE_BACKEND` env var)
+
+### Specifying a Workspace
+
+```bash
+# Default: uses current directory
+cd /path/to/my/project && poetry run autogpt
+
+# Or specify explicitly via CLI (if supported)
+poetry run autogpt --workspace /path/to/workspace
+```
+
+## Settings Location
+
+Configuration uses a **layered system** with three levels (in order of precedence):
+
+### 1. Environment Variables (Global)
+
+Loaded from `.env` file in the working directory:
+
+```bash
+# Required
+OPENAI_API_KEY=sk-...
+
+# Optional LLM settings
+SMART_LLM=gpt-4o                    # Model for complex reasoning
+FAST_LLM=gpt-4o-mini                # Model for simple tasks
+EMBEDDING_MODEL=text-embedding-3-small
+
+# Optional search providers (for web search component)
+TAVILY_API_KEY=tvly-...
+SERPER_API_KEY=...
+GOOGLE_API_KEY=...
+GOOGLE_CUSTOM_SEARCH_ENGINE_ID=...
+
+# Optional infrastructure
+LOG_LEVEL=DEBUG                     # DEBUG, INFO, WARNING, ERROR
+DATABASE_STRING=sqlite:///agent.db  # Agent Protocol database
+PORT=8000                           # Server port
+FILE_STORAGE_BACKEND=local          # local, s3, or gcs
+```
+
+### 2. Workspace Settings (`{workspace}/.autogpt/autogpt.yaml`)
+
+Workspace-wide permissions that apply to **all agents** in this workspace:
+
+```yaml
+allow:
+  - read_file({workspace}/**)
+  - write_to_file({workspace}/**)
+  - list_folder({workspace}/**)
+  - web_search(*)
+
+deny:
+  - read_file(**.env)
+  - read_file(**.env.*)
+  - read_file(**.key)
+  - read_file(**.pem)
+  - execute_shell(rm -rf:*)
+  - execute_shell(sudo:*)
+```
+
+Auto-generated with sensible defaults if missing.
+
+### 3. Agent Settings (`{workspace}/.autogpt/agents/{id}/permissions.yaml`)
+
+Agent-specific permission overrides:
+
+```yaml
+allow:
+  - execute_python(*)
+  - web_search(*)
+
+deny:
+  - execute_shell(*)
+```
+
+## Permissions
+
+The permission system uses **pattern matching** with a **first-match-wins** evaluation order.
+
+### Permission Check Order
+
+1. Agent deny list → **Block**
+2. Workspace deny list → **Block**
+3. Agent allow list → **Allow**
+4. Workspace allow list → **Allow**
+5. Session denied list → **Block** (commands denied during this session)
+6. **Prompt user** → Interactive approval (if in interactive mode)
+
+### Pattern Syntax
+
+Format: `command_name(glob_pattern)`
+
+| Pattern | Description |
+|---------|-------------|
+| `read_file({workspace}/**)` | Read any file in workspace (recursive) |
+| `write_to_file({workspace}/*.txt)` | Write only .txt files in workspace root |
+| `execute_shell(python:**)` | Execute Python commands only |
+| `execute_shell(git:*)` | Execute any git command |
+| `web_search(*)` | Allow all web searches |
+
+Special tokens:
+- `{workspace}` - Replaced with actual workspace path
+- `**` - Matches any path including `/`
+- `*` - Matches any characters except `/`
+
+### Interactive Approval Scopes
+
+When prompted for permission, users can choose:
+
+| Scope | Effect |
+|-------|--------|
+| **Once** | Allow this one time only (not saved) |
+| **Agent** | Always allow for this agent (saves to agent `permissions.yaml`) |
+| **Workspace** | Always allow for all agents (saves to `autogpt.yaml`) |
+| **Deny** | Deny this command (saves to appropriate deny list) |
+
+### Default Security
+
+Out of the box, the following are **denied by default**:
+- Reading sensitive files (`.env`, `.key`, `.pem`)
+- Destructive shell commands (`rm -rf`, `sudo`)
+- Operations outside the workspace directory

classic/CLI-USAGE.md

@@ -1,182 +0,0 @@
-## CLI Documentation
-
-This document describes how to interact with the project's CLI (Command Line Interface). It includes the types of outputs you can expect from each command. Note that the `agents stop` command will terminate any process running on port 8000.
-
-### 1. Entry Point for the CLI
-
-Running the `./run` command without any parameters will display the help message, which provides a list of available commands and options. Additionally, you can append `--help` to any command to view help information specific to that command.
-
-```sh
-./run
-```
-
-**Output**:
-
-```
-Usage: cli.py [OPTIONS] COMMAND [ARGS]...
-
-Options:
-  --help  Show this message and exit.
-
-Commands:
-  agent     Commands to create, start and stop agents
-  benchmark  Commands to start the benchmark and list tests and categories
-  setup      Installs dependencies needed for your system.
-```
-
-If you need assistance with any command, simply add the `--help` parameter to the end of your command, like so:
-
-```sh
-./run COMMAND --help
-```
-
-This will display a detailed help message regarding that specific command, including a list of any additional options and arguments it accepts.
-
-### 2. Setup Command
-
-```sh
-./run setup
-```
-
-**Output**:
-
-```
-Setup initiated
-Installation has been completed.
-```
-
-This command initializes the setup of the project.
-
-### 3. Agents Commands
-
-**a. List All Agents**
-
-```sh
-./run agent list
-```
-
-**Output**:
-
-```
-Available agents: 🤖
-        🐙 forge
-        🐙 autogpt
-```
-
-Lists all the available agents.
-
-**b. Create a New Agent**
-
-```sh
-./run agent create my_agent
-```
-
-**Output**:
-
-```
-🎉 New agent 'my_agent' created and switched to the new directory in agents folder.
-```
-
-Creates a new agent named 'my_agent'.
-
-**c. Start an Agent**
-
-```sh
-./run agent start my_agent
-```
-
-**Output**:
-
-```
-... (ASCII Art representing the agent startup)
-[Date and Time] [forge.sdk.db] [DEBUG] 🐛  Initializing AgentDB with database_string: sqlite:///agent.db
-[Date and Time] [forge.sdk.agent] [INFO] 📝  Agent server starting on http://0.0.0.0:8000
-```
-
-Starts the 'my_agent' and displays startup ASCII art and logs.
-
-**d. Stop an Agent**
-
-```sh
-./run agent stop
-```
-
-**Output**:
-
-```
-Agent stopped
-```
-
-Stops the running agent.
-
-### 4. Benchmark Commands
-
-**a. List Benchmark Categories**
-
-```sh
-./run benchmark categories list
-```
-
-**Output**:
-
-```
-Available categories: 📚
-        📖 code
-        📖 safety
-        📖 memory
-        ... (and so on)
-```
-
-Lists all available benchmark categories.
-
-**b. List Benchmark Tests**
-
-```sh
-./run benchmark tests list
-```
-
-**Output**:
-
-```
-Available tests: 📚
-        📖 interface
-                🔬 Search - TestSearch
-                🔬 Write File - TestWriteFile
-        ... (and so on)
-```
-
-Lists all available benchmark tests.
-
-**c. Show Details of a Benchmark Test**
-
-```sh
-./run benchmark tests details TestWriteFile
-```
-
-**Output**:
-
-```
-TestWriteFile
--------------
-
-        Category:  interface
-        Task:  Write the word 'Washington' to a .txt file
-        ... (and other details)
-```
-
-Displays the details of the 'TestWriteFile' benchmark test.
-
-**d. Start Benchmark for the Agent**
-
-```sh
-./run benchmark start my_agent
-```
-
-**Output**:
-
-```
-(more details about the testing process shown whilst the test are running)
-============= 13 failed, 1 passed in 0.97s ============...
-```
-
-Displays the results of the benchmark tests on 'my_agent'.

classic/Dockerfile.autogpt

@@ -2,7 +2,7 @@
 ARG BUILD_TYPE=dev
 
 # Use an official Python base image from the Docker Hub
-FROM python:3.10-slim AS autogpt-base
+FROM python:3.12-slim AS autogpt-base
 
 # Install browsers
 RUN apt-get update && apt-get install -y \
@@ -34,9 +34,6 @@ COPY original_autogpt/pyproject.toml original_autogpt/poetry.lock ./
 # Include forge so it can be used as a path dependency
 COPY forge/ ../forge
 
-# Include frontend
-COPY frontend/ ../frontend
-
 # Set the entrypoint
 ENTRYPOINT ["poetry", "run", "autogpt"]
 CMD []

classic/FORGE-QUICKSTART.md

@@ -1,173 +0,0 @@
-# Quickstart Guide
-
-> For the complete getting started [tutorial series](https://aiedge.medium.com/autogpt-forge-e3de53cc58ec) <- click here
-
-Welcome to the Quickstart Guide! This guide will walk you through setting up, building, and running your own AutoGPT agent. Whether you're a seasoned AI developer or just starting out, this guide will provide you with the steps to jumpstart your journey in AI development with AutoGPT.
-
-## System Requirements
-
-This project supports Linux (Debian-based), Mac, and Windows Subsystem for Linux (WSL). If you use a Windows system, you must install WSL. You can find the installation instructions for WSL [here](https://learn.microsoft.com/en-us/windows/wsl/).
-
-
-## Getting Setup
-1. **Fork the Repository**
-   To fork the repository, follow these steps:
-   - Navigate to the main page of the repository.
-
-   ![Repository](../docs/content/imgs/quickstart/001_repo.png)
-   - In the top-right corner of the page, click Fork.
-
-   ![Create Fork UI](../docs/content/imgs/quickstart/002_fork.png)
-   - On the next page, select your GitHub account to create the fork.
-   - Wait for the forking process to complete. You now have a copy of the repository in your GitHub account.
-
-2. **Clone the Repository**
-   To clone the repository, you need to have Git installed on your system. If you don't have Git installed, download it from [here](https://git-scm.com/downloads). Once you have Git installed, follow these steps:
-   - Open your terminal.
-   - Navigate to the directory where you want to clone the repository.
-   - Run the git clone command for the fork you just created
-
-   ![Clone the Repository](../docs/content/imgs/quickstart/003_clone.png)
-
-   - Then open your project in your ide
-
-   ![Open the Project in your IDE](../docs/content/imgs/quickstart/004_ide.png)
-
-4. **Setup the Project**
-    Next, we need to set up the required dependencies. We have a tool to help you perform all the tasks on the repo.
-    It can be accessed by running the `run` command by typing `./run` in the terminal.
-
-    The first command you need to use is `./run setup.` This will guide you through setting up your system.
-    Initially, you will get instructions for installing Flutter and Chrome and setting up your GitHub access token like the following image:
-    
-    ![Setup the Project](../docs/content/imgs/quickstart/005_setup.png)
-
-### For Windows Users
-
-If you're a Windows user and experience issues after installing WSL, follow the steps below to resolve them. 
-
-#### Update WSL 
-Run the following command in Powershell or Command Prompt:
-1. Enable the optional WSL and Virtual Machine Platform components.
-2. Download and install the latest Linux kernel.
-3. Set WSL 2 as the default.
-4. Download and install the Ubuntu Linux distribution (a reboot may be required).
-
-```shell
-wsl --install
-```
-
-For more detailed information and additional steps, refer to [Microsoft's WSL Setup Environment Documentation](https://learn.microsoft.com/en-us/windows/wsl/setup/environment).
-
-#### Resolve FileNotFoundError or "No such file or directory" Errors
-When you run `./run setup`, if you encounter errors like `No such file or directory` or `FileNotFoundError`, it might be because Windows-style line endings (CRLF - Carriage Return Line Feed) are not compatible with Unix/Linux style line endings (LF - Line Feed).
-
-To resolve this, you can use the `dos2unix` utility to convert the line endings in your script from CRLF to LF. Here’s how to install and run `dos2unix` on the script:
-
-```shell
-sudo apt update
-sudo apt install dos2unix
-dos2unix ./run
-```
-
-After executing the above commands, running `./run setup` should work successfully. 
-
-#### Store Project Files within the WSL File System
-If you continue to experience issues, consider storing your project files within the WSL file system instead of the Windows file system. This method avoids path translations and permissions issues and provides a more consistent development environment.
-
-You can keep running the command to get feedback on where you are up to with your setup. 
-When setup has been completed, the command will return an output like this:
-
-![Setup Complete](../docs/content/imgs/quickstart/006_setup_complete.png)
-
-## Creating Your Agent
-
-After completing the setup, the next step is to create your agent template.
-Execute the command `./run agent create YOUR_AGENT_NAME`, where `YOUR_AGENT_NAME` should be replaced with your chosen name.
-
-Tips for naming your agent:
-* Give it its own unique name, or name it after yourself
-* Include an important aspect of your agent in the name, such as its purpose
-
-Examples: `SwiftyosAssistant`, `PwutsPRAgent`, `MySuperAgent`
-
-![Create an Agent](../docs/content/imgs/quickstart/007_create_agent.png)
-
-## Running your Agent
-
-Your agent can be started using the command: `./run agent start YOUR_AGENT_NAME`
-
-This starts the agent on the URL: `http://localhost:8000/`
-
-![Start the Agent](../docs/content/imgs/quickstart/009_start_agent.png)
-
-The front end can be accessed from `http://localhost:8000/`; first, you must log in using either a Google account or your GitHub account.
-
-![Login](../docs/content/imgs/quickstart/010_login.png)
-
-Upon logging in, you will get a page that looks something like this: your task history down the left-hand side of the page, and the 'chat' window to send tasks to your agent.
-
-![Login](../docs/content/imgs/quickstart/011_home.png)
-
-When you have finished with your agent or just need to restart it, use Ctl-C to end the session. Then, you can re-run the start command.
-
-If you are having issues and want to ensure the agent has been stopped, there is a `./run agent stop` command, which will kill the process using port 8000, which should be the agent. 
-
-## Benchmarking your Agent
-
-The benchmarking system can also be accessed using the CLI too:
-
-```bash
-agpt % ./run benchmark
-Usage: cli.py benchmark [OPTIONS] COMMAND [ARGS]...
-
-  Commands to start the benchmark and list tests and categories
-
-Options:
-  --help  Show this message and exit.
-
-Commands:
-  categories  Benchmark categories group command
-  start       Starts the benchmark command
-  tests       Benchmark tests group command
-agpt % ./run benchmark categories     
-Usage: cli.py benchmark categories [OPTIONS] COMMAND [ARGS]...
-
-  Benchmark categories group command
-
-Options:
-  --help  Show this message and exit.
-
-Commands:
-  list  List benchmark categories command
-agpt % ./run benchmark tests      
-Usage: cli.py benchmark tests [OPTIONS] COMMAND [ARGS]...
-
-  Benchmark tests group command
-
-Options:
-  --help  Show this message and exit.
-
-Commands:
-  details  Benchmark test details command
-  list     List benchmark tests command
-```
-
-The benchmark has been split into different categories of skills you can test your agent on. You can see what categories are available with
-```bash
-./run benchmark categories list
-# And what tests are available with
-./run benchmark tests list
-```
-
-![Login](../docs/content/imgs/quickstart/012_tests.png)
-
-
-Finally, you can run the benchmark with
-
-```bash
-./run benchmark start YOUR_AGENT_NAME
-
-```
-
->

classic/README.md

@@ -4,7 +4,7 @@ AutoGPT Classic was an experimental project to demonstrate autonomous GPT-4 oper
 
 ## Project Status
 
-⚠️ **This project is unsupported, and dependencies will not be updated. It was an experiment that has concluded its initial research phase. If you want to use AutoGPT, you should use the [AutoGPT Platform](/autogpt_platform)**
+**This project is unsupported, and dependencies will not be updated.** It was an experiment that has concluded its initial research phase. If you want to use AutoGPT, you should use the [AutoGPT Platform](/autogpt_platform).
 
 For those interested in autonomous AI agents, we recommend exploring more actively maintained alternatives or referring to this codebase for educational purposes only.
 
@@ -16,37 +16,171 @@ AutoGPT Classic was one of the first implementations of autonomous AI agents - A
 - Learn from the results and adjust its approach
 - Chain multiple actions together to achieve an objective
 
-## Key Features
-
-- 🔄 Autonomous task chaining
-- 🛠 Tool and API integration capabilities
-- 💾 Memory management for context retention
-- 🔍 Web browsing and information gathering
-- 📝 File operations and content creation
-- 🔄 Self-prompting and task breakdown
-
 ## Structure
 
-The project is organized into several key components:
-- `/benchmark` - Performance testing tools
-- `/forge` - Core autonomous agent framework
-- `/frontend` - User interface components
-- `/original_autogpt` - Original implementation
+```
+classic/
+├── pyproject.toml          # Single consolidated Poetry project
+├── poetry.lock             # Single lock file
+├── forge/                  # Core autonomous agent framework
+├── original_autogpt/       # Original implementation
+├── direct_benchmark/       # Benchmark harness
+└── benchmark/              # Challenge definitions (data)
+```
 
 ## Getting Started
 
-While this project is no longer actively maintained, you can still explore the codebase:
+### Prerequisites
+
+- Python 3.12+
+- [Poetry](https://python-poetry.org/docs/#installation)
+
+### Installation
 
-1. Clone the repository:
 ```bash
+# Clone the repository
 git clone https://github.com/Significant-Gravitas/AutoGPT.git
 cd classic
+
+# Install everything
+poetry install
 ```
 
-2. Review the documentation:
-- For reference, see the [documentation](https://docs.agpt.co). You can browse at the same point in time as this commit so the docs don't change.
-- Check `CLI-USAGE.md` for command-line interface details
-- Refer to `TROUBLESHOOTING.md` for common issues
+### Configuration
+
+Configuration uses a layered system:
+
+1. **Environment variables** (`.env` file)
+2. **Workspace settings** (`.autogpt/autogpt.yaml`)
+3. **Agent settings** (`.autogpt/agents/{id}/permissions.yaml`)
+
+Copy the example environment file and add your API keys:
+
+```bash
+cp .env.example .env
+```
+
+Key environment variables:
+```bash
+# Required
+OPENAI_API_KEY=sk-...
+
+# Optional LLM settings
+SMART_LLM=gpt-4o                    # Model for complex reasoning
+FAST_LLM=gpt-4o-mini                # Model for simple tasks
+
+# Optional search providers
+TAVILY_API_KEY=tvly-...
+SERPER_API_KEY=...
+
+# Optional infrastructure
+LOG_LEVEL=DEBUG
+PORT=8000
+FILE_STORAGE_BACKEND=local          # local, s3, or gcs
+```
+
+### Running
+
+All commands run from the `classic/` directory:
+
+```bash
+# Run forge agent
+poetry run python -m forge
+
+# Run original autogpt server
+poetry run serve --debug
+
+# Run autogpt CLI
+poetry run autogpt
+```
+
+Agents run on `http://localhost:8000` by default.
+
+### Benchmarking
+
+```bash
+poetry run direct-benchmark run
+```
+
+### Testing
+
+```bash
+poetry run pytest                        # All tests
+poetry run pytest forge/tests/           # Forge tests only
+poetry run pytest original_autogpt/tests/ # AutoGPT tests only
+```
+
+## Workspaces
+
+Agents operate within a **workspace** directory that contains all agent data and files:
+
+```
+{workspace}/
+├── .autogpt/
+│   ├── autogpt.yaml              # Workspace-level permissions
+│   ├── ap_server.db              # Agent Protocol database (server mode)
+│   └── agents/
+│       └── AutoGPT-{agent_id}/
+│           ├── state.json        # Agent profile, directives, history
+│           ├── permissions.yaml  # Agent-specific permissions
+│           └── workspace/        # Agent's sandboxed working directory
+```
+
+- The workspace defaults to the current working directory
+- Multiple agents can coexist in the same workspace
+- Agent file access is sandboxed to their `workspace/` subdirectory
+- State persists across sessions via `state.json`
+
+## Permissions
+
+AutoGPT uses a **layered permission system** with pattern matching:
+
+### Permission Files
+
+| File | Scope | Location |
+|------|-------|----------|
+| `autogpt.yaml` | All agents in workspace | `.autogpt/autogpt.yaml` |
+| `permissions.yaml` | Single agent | `.autogpt/agents/{id}/permissions.yaml` |
+
+### Permission Format
+
+```yaml
+allow:
+  - read_file({workspace}/**)     # Read any file in workspace
+  - write_to_file({workspace}/**) # Write any file in workspace
+  - web_search(*)                 # All web searches
+
+deny:
+  - read_file(**.env)             # Block .env files
+  - execute_shell(sudo:*)         # Block sudo commands
+```
+
+### Check Order (First Match Wins)
+
+1. Agent deny → Block
+2. Workspace deny → Block
+3. Agent allow → Allow
+4. Workspace allow → Allow
+5. Prompt user → Interactive approval
+
+### Interactive Approval
+
+When prompted, users can approve commands with different scopes:
+- **Once** - Allow this one time only
+- **Agent** - Always allow for this agent
+- **Workspace** - Always allow for all agents
+- **Deny** - Block this command
+
+### Default Security
+
+Denied by default:
+- Sensitive files (`.env`, `.key`, `.pem`)
+- Destructive commands (`rm -rf`, `sudo`)
+- Operations outside the workspace
+
+## Security Notice
+
+This codebase has **known vulnerabilities** and issues with its dependencies. It will not be updated to new dependencies. Use for educational purposes only.
 
 ## License
 
@@ -55,27 +189,3 @@ This project segment is licensed under the MIT License - see the [LICENSE](LICEN
 ## Documentation
 
 Please refer to the [documentation](https://docs.agpt.co) for more detailed information about the project's architecture and concepts.
-You can browse at the same point in time as this commit so the docs don't change.
-
-## Historical Impact
-
-AutoGPT Classic played a significant role in advancing the field of autonomous AI agents:
-- Demonstrated practical implementation of AI autonomy
-- Inspired numerous derivative projects and research
-- Contributed to the development of AI agent architectures
-- Helped identify key challenges in AI autonomy
-
-## Security Notice
-
-If you're studying this codebase, please understand this has KNOWN vulnerabilities and issues with its dependencies. It will not be updated to new dependencies.
-
-## Community & Support
-
-While active development has concluded:
-- The codebase remains available for study and reference
-- Historical discussions can be found in project issues
-- Related research and developments continue in the broader AI agent community
-
-## Acknowledgments
-
-Thanks to all contributors who participated in this experimental project and helped advance the field of autonomous AI agents.

classic/benchmark/.env.example

@@ -1,4 +0,0 @@
-AGENT_NAME=mini-agi
-REPORTS_FOLDER="reports/mini-agi"
-OPENAI_API_KEY="sk-" # for LLM eval
-BUILD_SKILL_TREE=false # set to true to build the skill tree.

classic/benchmark/.flake8

@@ -1,12 +0,0 @@
-[flake8]
-max-line-length = 88
-# Ignore rules that conflict with Black code style
-extend-ignore = E203, W503
-exclude =
-    __pycache__/,
-    *.pyc,
-    .pytest_cache/,
-    venv*/,
-    .venv/,
-    reports/,
-    agbenchmark/reports/,

classic/benchmark/.gitignore

@@ -1,174 +0,0 @@
-agbenchmark_config/workspace/
-backend/backend_stdout.txt
-reports/df*.pkl
-reports/raw*
-
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-#   in version control.
-#   https://pdm.fming.dev/#use-with-ide
-.pdm.toml
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-.idea/
-.DS_Store
-```
-secrets.json
-agbenchmark_config/challenges_already_beaten.json
-agbenchmark_config/challenges/pri_*
-agbenchmark_config/updates.json
-agbenchmark_config/reports/*
-agbenchmark_config/reports/success_rate.json
-agbenchmark_config/reports/regression_tests.json

classic/benchmark/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 AutoGPT
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

classic/benchmark/README.md

@@ -1,25 +0,0 @@
-# Auto-GPT Benchmarks
-
-Built for the purpose of benchmarking the performance of agents regardless of how they work.
-
-Objectively know how well your agent is performing in categories like code, retrieval, memory, and safety.
-
-Save time and money while doing it through smart dependencies. The best part? It's all automated.
-
-## Scores:
-
-<img width="733" alt="Screenshot 2023-07-25 at 10 35 01 AM" src="https://github.com/Significant-Gravitas/Auto-GPT-Benchmarks/assets/9652976/98963e0b-18b9-4b17-9a6a-4d3e4418af70">
-
-## Ranking overall:
-
-- 1- [Beebot](https://github.com/AutoPackAI/beebot)
-- 2- [mini-agi](https://github.com/muellerberndt/mini-agi)
-- 3- [Auto-GPT](https://github.com/Significant-Gravitas/AutoGPT)
-
-## Detailed results:
-
-<img width="733" alt="Screenshot 2023-07-25 at 10 42 15 AM" src="https://github.com/Significant-Gravitas/Auto-GPT-Benchmarks/assets/9652976/39be464c-c842-4437-b28a-07d878542a83">
-
-[Click here to see the results and the raw data!](https://docs.google.com/spreadsheets/d/1WXm16P2AHNbKpkOI0LYBpcsGG0O7D8HYTG5Uj0PaJjA/edit#gid=203558751)!
-
-More agents coming soon !

classic/benchmark/agbenchmark/README.md

@@ -1,69 +0,0 @@
-## As a user
-
-1. `pip install auto-gpt-benchmarks`
-2. Add boilerplate code to run and kill agent
-3. `agbenchmark`
-   - `--category challenge_category` to run tests in a specific category
-   - `--mock` to only run mock tests if they exists for each test
-   - `--noreg` to skip any tests that have passed in the past. When you run without this flag and a previous challenge that passed fails, it will now not be regression tests
-4. We call boilerplate code for your agent
-5. Show pass rate of tests, logs, and any other metrics
-
-## Contributing
-
-##### Diagrams: https://whimsical.com/agbenchmark-5n4hXBq1ZGzBwRsK4TVY7x
-
-### To run the existing mocks
-
-1. clone the repo `auto-gpt-benchmarks`
-2. `pip install poetry`
-3. `poetry shell`
-4. `poetry install`
-5. `cp .env_example .env`
-6. `git submodule update --init --remote --recursive`
-7. `uvicorn server:app --reload`
-8. `agbenchmark --mock`
-   Keep config the same and watch the logs :)
-
-### To run with mini-agi
-
-1. Navigate to `auto-gpt-benchmarks/agent/mini-agi`
-2. `pip install -r requirements.txt`
-3. `cp .env_example .env`, set `PROMPT_USER=false` and add your `OPENAI_API_KEY=`. Sset `MODEL="gpt-3.5-turbo"` if you don't have access to `gpt-4` yet. Also make sure you have Python 3.10^ installed
-4. set `AGENT_NAME=mini-agi` in `.env` file and where you want your `REPORTS_FOLDER` to be
-5. Make sure to follow the commands above, and remove mock flag `agbenchmark`
-
-- To add requirements `poetry add requirement`.
-
-Feel free to create prs to merge with `main` at will (but also feel free to ask for review) - if you can't send msg in R&D chat for access.
-
-If you push at any point and break things - it'll happen to everyone - fix it asap. Step 1 is to revert `master` to last working commit
-
-Let people know what beautiful code you write does, document everything well
-
-Share your progress :)
-
-#### Dataset
-
-Manually created, existing challenges within Auto-Gpt, https://osu-nlp-group.github.io/Mind2Web/
-
-## How do I add new agents to agbenchmark ?
-
-Example with smol developer.
-
-1- Create a github branch with your agent following the same pattern as this example:
-
-https://github.com/smol-ai/developer/pull/114/files
-
-2- Create the submodule and the github workflow by following the same pattern as this example:
-
-https://github.com/Significant-Gravitas/Auto-GPT-Benchmarks/pull/48/files
-
-## How do I run agent in different environments?
-
-**To just use as the benchmark for your agent**. `pip install` the package and run `agbenchmark`
-
-**For internal Auto-GPT ci runs**, specify the `AGENT_NAME` you want you use and set the `HOME_ENV`.
-Ex. `AGENT_NAME=mini-agi`
-
-**To develop agent alongside benchmark**, you can specify the `AGENT_NAME` you want you use and add as a submodule to the repo

classic/benchmark/agbenchmark/__main__.py

@@ -1,352 +0,0 @@
-import logging
-import os
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Optional
-
-import click
-from click_default_group import DefaultGroup
-from dotenv import load_dotenv
-
-from agbenchmark.config import AgentBenchmarkConfig
-from agbenchmark.utils.logging import configure_logging
-
-load_dotenv()
-
-# try:
-#     if os.getenv("HELICONE_API_KEY"):
-#         import helicone  # noqa
-
-#         helicone_enabled = True
-#     else:
-#         helicone_enabled = False
-# except ImportError:
-#     helicone_enabled = False
-
-
-class InvalidInvocationError(ValueError):
-    pass
-
-
-logger = logging.getLogger(__name__)
-
-BENCHMARK_START_TIME_DT = datetime.now(timezone.utc)
-BENCHMARK_START_TIME = BENCHMARK_START_TIME_DT.strftime("%Y-%m-%dT%H:%M:%S+00:00")
-
-
-# if helicone_enabled:
-#     from helicone.lock import HeliconeLockManager
-
-#     HeliconeLockManager.write_custom_property(
-#         "benchmark_start_time", BENCHMARK_START_TIME
-#     )
-
-
-@click.group(cls=DefaultGroup, default_if_no_args=True)
-@click.option("--debug", is_flag=True, help="Enable debug output")
-def cli(
-    debug: bool,
-) -> Any:
-    configure_logging(logging.DEBUG if debug else logging.INFO)
-
-
-@cli.command(hidden=True)
-def start():
-    raise DeprecationWarning(
-        "`agbenchmark start` is deprecated. Use `agbenchmark run` instead."
-    )
-
-
-@cli.command(default=True)
-@click.option(
-    "-N", "--attempts", default=1, help="Number of times to run each challenge."
-)
-@click.option(
-    "-c",
-    "--category",
-    multiple=True,
-    help="(+) Select a category to run.",
-)
-@click.option(
-    "-s",
-    "--skip-category",
-    multiple=True,
-    help="(+) Exclude a category from running.",
-)
-@click.option("--test", multiple=True, help="(+) Select a test to run.")
-@click.option("--maintain", is_flag=True, help="Run only regression tests.")
-@click.option("--improve", is_flag=True, help="Run only non-regression tests.")
-@click.option(
-    "--explore",
-    is_flag=True,
-    help="Run only challenges that have never been beaten.",
-)
-@click.option(
-    "--no-dep",
-    is_flag=True,
-    help="Run all (selected) challenges, regardless of dependency success/failure.",
-)
-@click.option("--cutoff", type=int, help="Override the challenge time limit (seconds).")
-@click.option("--nc", is_flag=True, help="Disable the challenge time limit.")
-@click.option("--mock", is_flag=True, help="Run with mock")
-@click.option("--keep-answers", is_flag=True, help="Keep answers")
-@click.option(
-    "--backend",
-    is_flag=True,
-    help="Write log output to a file instead of the terminal.",
-)
-# @click.argument(
-#     "agent_path",
-#     type=click.Path(exists=True, file_okay=False, path_type=Path),
-#     required=False,
-# )
-def run(
-    maintain: bool,
-    improve: bool,
-    explore: bool,
-    mock: bool,
-    no_dep: bool,
-    nc: bool,
-    keep_answers: bool,
-    test: tuple[str],
-    category: tuple[str],
-    skip_category: tuple[str],
-    attempts: int,
-    cutoff: Optional[int] = None,
-    backend: Optional[bool] = False,
-    # agent_path: Optional[Path] = None,
-) -> None:
-    """
-    Run the benchmark on the agent in the current directory.
-
-    Options marked with (+) can be specified multiple times, to select multiple items.
-    """
-    from agbenchmark.main import run_benchmark, validate_args
-
-    agbenchmark_config = AgentBenchmarkConfig.load()
-    logger.debug(f"agbenchmark_config: {agbenchmark_config.agbenchmark_config_dir}")
-    try:
-        validate_args(
-            maintain=maintain,
-            improve=improve,
-            explore=explore,
-            tests=test,
-            categories=category,
-            skip_categories=skip_category,
-            no_cutoff=nc,
-            cutoff=cutoff,
-        )
-    except InvalidInvocationError as e:
-        logger.error("Error: " + "\n".join(e.args))
-        sys.exit(1)
-
-    original_stdout = sys.stdout  # Save the original standard output
-    exit_code = None
-
-    if backend:
-        with open("backend/backend_stdout.txt", "w") as f:
-            sys.stdout = f
-            exit_code = run_benchmark(
-                config=agbenchmark_config,
-                maintain=maintain,
-                improve=improve,
-                explore=explore,
-                mock=mock,
-                no_dep=no_dep,
-                no_cutoff=nc,
-                keep_answers=keep_answers,
-                tests=test,
-                categories=category,
-                skip_categories=skip_category,
-                attempts_per_challenge=attempts,
-                cutoff=cutoff,
-            )
-
-        sys.stdout = original_stdout
-
-    else:
-        exit_code = run_benchmark(
-            config=agbenchmark_config,
-            maintain=maintain,
-            improve=improve,
-            explore=explore,
-            mock=mock,
-            no_dep=no_dep,
-            no_cutoff=nc,
-            keep_answers=keep_answers,
-            tests=test,
-            categories=category,
-            skip_categories=skip_category,
-            attempts_per_challenge=attempts,
-            cutoff=cutoff,
-        )
-
-        sys.exit(exit_code)
-
-
-@cli.command()
-@click.option("--port", type=int, help="Port to run the API on.")
-def serve(port: Optional[int] = None):
-    """Serve the benchmark frontend and API on port 8080."""
-    import uvicorn
-
-    from agbenchmark.app import setup_fastapi_app
-
-    config = AgentBenchmarkConfig.load()
-    app = setup_fastapi_app(config)
-
-    # Run the FastAPI application using uvicorn
-    port = port or int(os.getenv("PORT", 8080))
-    uvicorn.run(app, host="0.0.0.0", port=port)
-
-
-@cli.command()
-def config():
-    """Displays info regarding the present AGBenchmark config."""
-    from .utils.utils import pretty_print_model
-
-    try:
-        config = AgentBenchmarkConfig.load()
-    except FileNotFoundError as e:
-        click.echo(e, err=True)
-        return 1
-
-    pretty_print_model(config, include_header=False)
-
-
-@cli.group()
-def challenge():
-    logging.getLogger().setLevel(logging.WARNING)
-
-
-@challenge.command("list")
-@click.option(
-    "--all", "include_unavailable", is_flag=True, help="Include unavailable challenges."
-)
-@click.option(
-    "--names", "only_names", is_flag=True, help="List only the challenge names."
-)
-@click.option("--json", "output_json", is_flag=True)
-def list_challenges(include_unavailable: bool, only_names: bool, output_json: bool):
-    """Lists [available|all] challenges."""
-    import json
-
-    from tabulate import tabulate
-
-    from .challenges.builtin import load_builtin_challenges
-    from .challenges.webarena import load_webarena_challenges
-    from .utils.data_types import Category, DifficultyLevel
-    from .utils.utils import sorted_by_enum_index
-
-    DIFFICULTY_COLORS = {
-        difficulty: color
-        for difficulty, color in zip(
-            DifficultyLevel,
-            ["black", "blue", "cyan", "green", "yellow", "red", "magenta", "white"],
-        )
-    }
-    CATEGORY_COLORS = {
-        category: f"bright_{color}"
-        for category, color in zip(
-            Category,
-            ["blue", "cyan", "green", "yellow", "magenta", "red", "white", "black"],
-        )
-    }
-
-    # Load challenges
-    challenges = filter(
-        lambda c: c.info.available or include_unavailable,
-        [
-            *load_builtin_challenges(),
-            *load_webarena_challenges(skip_unavailable=False),
-        ],
-    )
-    challenges = sorted_by_enum_index(
-        challenges, DifficultyLevel, key=lambda c: c.info.difficulty
-    )
-
-    if only_names:
-        if output_json:
-            click.echo(json.dumps([c.info.name for c in challenges]))
-            return
-
-        for c in challenges:
-            click.echo(
-                click.style(c.info.name, fg=None if c.info.available else "black")
-            )
-        return
-
-    if output_json:
-        click.echo(
-            json.dumps([json.loads(c.info.model_dump_json()) for c in challenges])
-        )
-        return
-
-    headers = tuple(
-        click.style(h, bold=True) for h in ("Name", "Difficulty", "Categories")
-    )
-    table = [
-        tuple(
-            v if challenge.info.available else click.style(v, fg="black")
-            for v in (
-                challenge.info.name,
-                (
-                    click.style(
-                        challenge.info.difficulty.value,
-                        fg=DIFFICULTY_COLORS[challenge.info.difficulty],
-                    )
-                    if challenge.info.difficulty
-                    else click.style("-", fg="black")
-                ),
-                " ".join(
-                    click.style(cat.value, fg=CATEGORY_COLORS[cat])
-                    for cat in sorted_by_enum_index(challenge.info.category, Category)
-                ),
-            )
-        )
-        for challenge in challenges
-    ]
-    click.echo(tabulate(table, headers=headers))
-
-
-@challenge.command()
-@click.option("--json", is_flag=True)
-@click.argument("name")
-def info(name: str, json: bool):
-    from itertools import chain
-
-    from .challenges.builtin import load_builtin_challenges
-    from .challenges.webarena import load_webarena_challenges
-    from .utils.utils import pretty_print_model
-
-    for challenge in chain(
-        load_builtin_challenges(),
-        load_webarena_challenges(skip_unavailable=False),
-    ):
-        if challenge.info.name != name:
-            continue
-
-        if json:
-            click.echo(challenge.info.model_dump_json())
-            break
-
-        pretty_print_model(challenge.info)
-        break
-    else:
-        click.echo(click.style(f"Unknown challenge '{name}'", fg="red"), err=True)
-
-
-@cli.command()
-def version():
-    """Print version info for the AGBenchmark application."""
-    import toml
-
-    package_root = Path(__file__).resolve().parent.parent
-    pyproject = toml.load(package_root / "pyproject.toml")
-    version = pyproject["tool"]["poetry"]["version"]
-    click.echo(f"AGBenchmark version {version}")
-
-
-if __name__ == "__main__":
-    cli()

classic/benchmark/agbenchmark/agent_api_interface.py

@@ -1,111 +0,0 @@
-import logging
-import time
-from pathlib import Path
-from typing import AsyncIterator, Optional
-
-from agent_protocol_client import (
-    AgentApi,
-    ApiClient,
-    Configuration,
-    Step,
-    TaskRequestBody,
-)
-
-from agbenchmark.agent_interface import get_list_of_file_paths
-from agbenchmark.config import AgentBenchmarkConfig
-
-logger = logging.getLogger(__name__)
-
-
-async def run_api_agent(
-    task: str,
-    config: AgentBenchmarkConfig,
-    timeout: int,
-    artifacts_location: Optional[Path] = None,
-    *,
-    mock: bool = False,
-) -> AsyncIterator[Step]:
-    configuration = Configuration(host=config.host)
-    async with ApiClient(configuration) as api_client:
-        api_instance = AgentApi(api_client)
-        task_request_body = TaskRequestBody(input=task, additional_input=None)
-
-        start_time = time.time()
-        response = await api_instance.create_agent_task(
-            task_request_body=task_request_body
-        )
-        task_id = response.task_id
-
-        if artifacts_location:
-            logger.debug("Uploading task input artifacts to agent...")
-            await upload_artifacts(
-                api_instance, artifacts_location, task_id, "artifacts_in"
-            )
-
-        logger.debug("Running agent until finished or timeout...")
-        while True:
-            step = await api_instance.execute_agent_task_step(task_id=task_id)
-            yield step
-
-            if time.time() - start_time > timeout:
-                raise TimeoutError("Time limit exceeded")
-            if step and mock:
-                step.is_last = True
-            if not step or step.is_last:
-                break
-
-        if artifacts_location:
-            # In "mock" mode, we cheat by giving the correct artifacts to pass the test
-            if mock:
-                logger.debug("Uploading mock artifacts to agent...")
-                await upload_artifacts(
-                    api_instance, artifacts_location, task_id, "artifacts_out"
-                )
-
-            logger.debug("Downloading agent artifacts...")
-            await download_agent_artifacts_into_folder(
-                api_instance, task_id, config.temp_folder
-            )
-
-
-async def download_agent_artifacts_into_folder(
-    api_instance: AgentApi, task_id: str, folder: Path
-):
-    artifacts = await api_instance.list_agent_task_artifacts(task_id=task_id)
-
-    for artifact in artifacts.artifacts:
-        # current absolute path of the directory of the file
-        if artifact.relative_path:
-            path: str = (
-                artifact.relative_path
-                if not artifact.relative_path.startswith("/")
-                else artifact.relative_path[1:]
-            )
-            folder = (folder / path).parent
-
-        if not folder.exists():
-            folder.mkdir(parents=True)
-
-        file_path = folder / artifact.file_name
-        logger.debug(f"Downloading agent artifact {artifact.file_name} to {folder}")
-        with open(file_path, "wb") as f:
-            content = await api_instance.download_agent_task_artifact(
-                task_id=task_id, artifact_id=artifact.artifact_id
-            )
-
-            f.write(content)
-
-
-async def upload_artifacts(
-    api_instance: AgentApi, artifacts_location: Path, task_id: str, type: str
-) -> None:
-    for file_path in get_list_of_file_paths(artifacts_location, type):
-        relative_path: Optional[str] = "/".join(
-            str(file_path).split(f"{type}/", 1)[-1].split("/")[:-1]
-        )
-        if not relative_path:
-            relative_path = None
-
-        await api_instance.upload_agent_task_artifacts(
-            task_id=task_id, file=str(file_path), relative_path=relative_path
-        )

classic/benchmark/agbenchmark/agent_interface.py

@@ -1,27 +0,0 @@
-import os
-import shutil
-from pathlib import Path
-
-from dotenv import load_dotenv
-
-load_dotenv()
-
-HELICONE_GRAPHQL_LOGS = os.getenv("HELICONE_GRAPHQL_LOGS", "").lower() == "true"
-
-
-def get_list_of_file_paths(
-    challenge_dir_path: str | Path, artifact_folder_name: str
-) -> list[Path]:
-    source_dir = Path(challenge_dir_path) / artifact_folder_name
-    if not source_dir.exists():
-        return []
-    return list(source_dir.iterdir())
-
-
-def copy_challenge_artifacts_into_workspace(
-    challenge_dir_path: str | Path, artifact_folder_name: str, workspace: str | Path
-) -> None:
-    file_paths = get_list_of_file_paths(challenge_dir_path, artifact_folder_name)
-    for file_path in file_paths:
-        if file_path.is_file():
-            shutil.copy(file_path, workspace)

classic/benchmark/agbenchmark/app.py

@@ -1,339 +0,0 @@
-import datetime
-import glob
-import json
-import logging
-import sys
-import time
-import uuid
-from collections import deque
-from multiprocessing import Process
-from pathlib import Path
-from typing import Optional
-
-import httpx
-import psutil
-from agent_protocol_client import AgentApi, ApiClient, ApiException, Configuration
-from agent_protocol_client.models import Task, TaskRequestBody
-from fastapi import APIRouter, FastAPI, HTTPException, Request, Response
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel, ConfigDict, ValidationError
-
-from agbenchmark.challenges import ChallengeInfo
-from agbenchmark.config import AgentBenchmarkConfig
-from agbenchmark.reports.processing.report_types_v2 import (
-    BenchmarkRun,
-    Metrics,
-    RepositoryInfo,
-    RunDetails,
-    TaskInfo,
-)
-from agbenchmark.schema import TaskEvalRequestBody
-from agbenchmark.utils.utils import write_pretty_json
-
-sys.path.append(str(Path(__file__).parent.parent))
-
-logger = logging.getLogger(__name__)
-
-CHALLENGES: dict[str, ChallengeInfo] = {}
-challenges_path = Path(__file__).parent / "challenges"
-challenge_spec_files = deque(
-    glob.glob(
-        f"{challenges_path}/**/data.json",
-        recursive=True,
-    )
-)
-
-logger.debug("Loading challenges...")
-while challenge_spec_files:
-    challenge_spec_file = Path(challenge_spec_files.popleft())
-    challenge_relpath = challenge_spec_file.relative_to(challenges_path.parent)
-    if challenge_relpath.is_relative_to("challenges/deprecated"):
-        continue
-
-    logger.debug(f"Loading {challenge_relpath}...")
-    try:
-        challenge_info = ChallengeInfo.model_validate_json(
-            challenge_spec_file.read_text()
-        )
-    except ValidationError as e:
-        if logging.getLogger().level == logging.DEBUG:
-            logger.warning(f"Spec file {challenge_relpath} failed to load:\n{e}")
-        logger.debug(f"Invalid challenge spec: {challenge_spec_file.read_text()}")
-        continue
-
-    if not challenge_info.eval_id:
-        challenge_info.eval_id = str(uuid.uuid4())
-        # this will sort all the keys of the JSON systematically
-        # so that the order is always the same
-        write_pretty_json(challenge_info.model_dump(), challenge_spec_file)
-
-    CHALLENGES[challenge_info.eval_id] = challenge_info
-
-
-class BenchmarkTaskInfo(BaseModel):
-    task_id: str
-    start_time: datetime.datetime
-    challenge_info: ChallengeInfo
-
-
-task_informations: dict[str, BenchmarkTaskInfo] = {}
-
-
-def find_agbenchmark_without_uvicorn():
-    pids = []
-    for process in psutil.process_iter(
-        attrs=[
-            "pid",
-            "cmdline",
-            "name",
-            "username",
-            "status",
-            "cpu_percent",
-            "memory_info",
-            "create_time",
-            "cwd",
-            "connections",
-        ]
-    ):
-        try:
-            # Convert the process.info dictionary values to strings and concatenate them
-            full_info = " ".join([str(v) for k, v in process.as_dict().items()])
-
-            if "agbenchmark" in full_info and "uvicorn" not in full_info:
-                pids.append(process.pid)
-        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-            pass
-    return pids
-
-
-class CreateReportRequest(BaseModel):
-    test: str
-    test_run_id: str
-    # category: Optional[str] = []
-    mock: Optional[bool] = False
-
-    model_config = ConfigDict(extra="forbid")
-
-
-updates_list = []
-
-origins = [
-    "http://localhost:8000",
-    "http://localhost:8080",
-    "http://127.0.0.1:5000",
-    "http://localhost:5000",
-]
-
-
-def stream_output(pipe):
-    for line in pipe:
-        print(line, end="")
-
-
-def setup_fastapi_app(agbenchmark_config: AgentBenchmarkConfig) -> FastAPI:
-    from agbenchmark.agent_api_interface import upload_artifacts
-    from agbenchmark.challenges import get_challenge_from_source_uri
-    from agbenchmark.main import run_benchmark
-
-    configuration = Configuration(
-        host=agbenchmark_config.host or "http://localhost:8000"
-    )
-    app = FastAPI()
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=origins,
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-    router = APIRouter()
-
-    @router.post("/reports")
-    def run_single_test(body: CreateReportRequest) -> dict:
-        pids = find_agbenchmark_without_uvicorn()
-        logger.info(f"pids already running with agbenchmark: {pids}")
-
-        logger.debug(f"Request to /reports: {body.model_dump()}")
-
-        # Start the benchmark in a separate thread
-        benchmark_process = Process(
-            target=lambda: run_benchmark(
-                config=agbenchmark_config,
-                tests=(body.test,),
-                mock=body.mock or False,
-            )
-        )
-        benchmark_process.start()
-
-        # Wait for the benchmark to finish, with a timeout of 200 seconds
-        timeout = 200
-        start_time = time.time()
-        while benchmark_process.is_alive():
-            if time.time() - start_time > timeout:
-                logger.warning(f"Benchmark run timed out after {timeout} seconds")
-                benchmark_process.terminate()
-                break
-            time.sleep(1)
-        else:
-            logger.debug(f"Benchmark finished running in {time.time() - start_time} s")
-
-        # List all folders in the current working directory
-        reports_folder = agbenchmark_config.reports_folder
-        folders = [folder for folder in reports_folder.iterdir() if folder.is_dir()]
-
-        # Sort the folders based on their names
-        sorted_folders = sorted(folders, key=lambda x: x.name)
-
-        # Get the last folder
-        latest_folder = sorted_folders[-1] if sorted_folders else None
-
-        # Read report.json from this folder
-        if latest_folder:
-            report_path = latest_folder / "report.json"
-            logger.debug(f"Getting latest report from {report_path}")
-            if report_path.exists():
-                with report_path.open() as file:
-                    data = json.load(file)
-                logger.debug(f"Report data: {data}")
-            else:
-                raise HTTPException(
-                    502,
-                    "Could not get result after running benchmark: "
-                    f"'report.json' does not exist in '{latest_folder}'",
-                )
-        else:
-            raise HTTPException(
-                504, "Could not get result after running benchmark: no reports found"
-            )
-
-        return data
-
-    @router.post("/agent/tasks", tags=["agent"])
-    async def create_agent_task(task_eval_request: TaskEvalRequestBody) -> Task:
-        """
-        Creates a new task using the provided TaskEvalRequestBody and returns a Task.
-
-        Args:
-            task_eval_request: `TaskRequestBody` including an eval_id.
-
-        Returns:
-            Task: A new task with task_id, input, additional_input,
-                and empty lists for artifacts and steps.
-
-        Example:
-            Request (TaskEvalRequestBody defined in schema.py):
-                {
-                    ...,
-                    "eval_id": "50da533e-3904-4401-8a07-c49adf88b5eb"
-                }
-
-            Response (Task defined in `agent_protocol_client.models`):
-                {
-                    "task_id": "50da533e-3904-4401-8a07-c49adf88b5eb",
-                    "input": "Write the word 'Washington' to a .txt file",
-                    "artifacts": []
-                }
-        """
-        try:
-            challenge_info = CHALLENGES[task_eval_request.eval_id]
-            async with ApiClient(configuration) as api_client:
-                api_instance = AgentApi(api_client)
-                task_input = challenge_info.task
-
-                task_request_body = TaskRequestBody(
-                    input=task_input, additional_input=None
-                )
-                task_response = await api_instance.create_agent_task(
-                    task_request_body=task_request_body
-                )
-                task_info = BenchmarkTaskInfo(
-                    task_id=task_response.task_id,
-                    start_time=datetime.datetime.now(datetime.timezone.utc),
-                    challenge_info=challenge_info,
-                )
-                task_informations[task_info.task_id] = task_info
-
-                if input_artifacts_dir := challenge_info.task_artifacts_dir:
-                    await upload_artifacts(
-                        api_instance,
-                        input_artifacts_dir,
-                        task_response.task_id,
-                        "artifacts_in",
-                    )
-                return task_response
-        except ApiException as e:
-            logger.error(f"Error whilst trying to create a task:\n{e}")
-            logger.error(
-                "The above error was caused while processing request: "
-                f"{task_eval_request}"
-            )
-            raise HTTPException(500)
-
-    @router.post("/agent/tasks/{task_id}/steps")
-    async def proxy(request: Request, task_id: str):
-        timeout = httpx.Timeout(300.0, read=300.0)  # 5 minutes
-        async with httpx.AsyncClient(timeout=timeout) as client:
-            # Construct the new URL
-            new_url = f"{configuration.host}/ap/v1/agent/tasks/{task_id}/steps"
-
-            # Forward the request
-            response = await client.post(
-                new_url,
-                content=await request.body(),
-                headers=dict(request.headers),
-            )
-
-            # Return the response from the forwarded request
-            return Response(content=response.content, status_code=response.status_code)
-
-    @router.post("/agent/tasks/{task_id}/evaluations")
-    async def create_evaluation(task_id: str) -> BenchmarkRun:
-        task_info = task_informations[task_id]
-        challenge = get_challenge_from_source_uri(task_info.challenge_info.source_uri)
-        try:
-            async with ApiClient(configuration) as api_client:
-                api_instance = AgentApi(api_client)
-                eval_results = await challenge.evaluate_task_state(
-                    api_instance, task_id
-                )
-
-            eval_info = BenchmarkRun(
-                repository_info=RepositoryInfo(),
-                run_details=RunDetails(
-                    command=f"agbenchmark --test={challenge.info.name}",
-                    benchmark_start_time=(
-                        task_info.start_time.strftime("%Y-%m-%dT%H:%M:%S+00:00")
-                    ),
-                    test_name=challenge.info.name,
-                ),
-                task_info=TaskInfo(
-                    data_path=challenge.info.source_uri,
-                    is_regression=None,
-                    category=[c.value for c in challenge.info.category],
-                    task=challenge.info.task,
-                    answer=challenge.info.reference_answer or "",
-                    description=challenge.info.description or "",
-                ),
-                metrics=Metrics(
-                    success=all(e.passed for e in eval_results),
-                    success_percentage=(
-                        100 * sum(e.score for e in eval_results) / len(eval_results)
-                        if eval_results  # avoid division by 0
-                        else 0
-                    ),
-                    attempted=True,
-                ),
-                config={},
-            )
-
-            logger.debug(
-                f"Returning evaluation data:\n{eval_info.model_dump_json(indent=4)}"
-            )
-            return eval_info
-        except ApiException as e:
-            logger.error(f"Error {e} whilst trying to evaluate task: {task_id}")
-            raise HTTPException(500)
-
-    app.include_router(router, prefix="/ap/v1")
-
-    return app

classic/benchmark/agbenchmark/config.py

@@ -1,128 +0,0 @@
-import json
-import sys
-from datetime import datetime
-from pathlib import Path
-from typing import Optional
-
-from pydantic import Field, ValidationInfo, field_validator
-from pydantic_settings import BaseSettings
-
-
-def _calculate_info_test_path(base_path: Path, benchmark_start_time: datetime) -> Path:
-    """
-    Calculates the path to the directory where the test report will be saved.
-    """
-    # Ensure the reports path exists
-    base_path.mkdir(parents=True, exist_ok=True)
-
-    # Get current UTC date-time stamp
-    date_stamp = benchmark_start_time.strftime("%Y%m%dT%H%M%S")
-
-    # Default run name
-    run_name = "full_run"
-
-    # Map command-line arguments to their respective labels
-    arg_labels = {
-        "--test": None,
-        "--category": None,
-        "--maintain": "maintain",
-        "--improve": "improve",
-        "--explore": "explore",
-    }
-
-    # Identify the relevant command-line argument
-    for arg, label in arg_labels.items():
-        if arg in sys.argv:
-            test_arg = sys.argv[sys.argv.index(arg) + 1] if label is None else None
-            run_name = arg.strip("--")
-            if test_arg:
-                run_name = f"{run_name}_{test_arg}"
-            break
-
-    # Create the full new directory path with ISO standard UTC date-time stamp
-    report_path = base_path / f"{date_stamp}_{run_name}"
-
-    # Ensure the new directory is created
-    # FIXME: this is not a desirable side-effect of loading the config
-    report_path.mkdir(exist_ok=True)
-
-    return report_path
-
-
-class AgentBenchmarkConfig(BaseSettings, extra="allow"):
-    """
-    Configuration model and loader for the AGBenchmark.
-
-    Projects that want to use AGBenchmark should contain an agbenchmark_config folder
-    with a config.json file that - at minimum - specifies the `host` at which the
-    subject application exposes an Agent Protocol compliant API.
-    """
-
-    agbenchmark_config_dir: Path = Field(exclude=True)
-    """Path to the agbenchmark_config folder of the subject agent application."""
-
-    categories: list[str] | None = None
-    """Categories to benchmark the agent for. If omitted, all categories are assumed."""
-
-    host: str
-    """Host (scheme://address:port) of the subject agent application."""
-
-    reports_folder: Path = Field(None)
-    """
-    Path to the folder where new reports should be stored.
-    Defaults to {agbenchmark_config_dir}/reports.
-    """
-
-    @classmethod
-    def load(cls, config_dir: Optional[Path] = None) -> "AgentBenchmarkConfig":
-        config_dir = config_dir or cls.find_config_folder()
-        with (config_dir / "config.json").open("r") as f:
-            return cls(
-                agbenchmark_config_dir=config_dir,
-                **json.load(f),
-            )
-
-    @staticmethod
-    def find_config_folder(for_dir: Path = Path.cwd()) -> Path:
-        """
-        Find the closest ancestor folder containing an agbenchmark_config folder,
-        and returns the path of that agbenchmark_config folder.
-        """
-        current_directory = for_dir
-        while current_directory != Path("/"):
-            if (path := current_directory / "agbenchmark_config").exists():
-                if (path / "config.json").is_file():
-                    return path
-            current_directory = current_directory.parent
-        raise FileNotFoundError(
-            "No 'agbenchmark_config' directory found in the path hierarchy."
-        )
-
-    @property
-    def config_file(self) -> Path:
-        return self.agbenchmark_config_dir / "config.json"
-
-    @field_validator("reports_folder", mode="before")
-    def set_reports_folder(cls, value: Path, info: ValidationInfo):
-        if not value:
-            return info.data["agbenchmark_config_dir"] / "reports"
-        return value
-
-    def get_report_dir(self, benchmark_start_time: datetime) -> Path:
-        return _calculate_info_test_path(self.reports_folder, benchmark_start_time)
-
-    @property
-    def regression_tests_file(self) -> Path:
-        return self.reports_folder / "regression_tests.json"
-
-    @property
-    def success_rate_file(self) -> Path:
-        return self.reports_folder / "success_rate.json"
-
-    @property
-    def challenges_already_beaten_file(self) -> Path:
-        return self.agbenchmark_config_dir / "challenges_already_beaten.json"
-
-    @property
-    def temp_folder(self) -> Path:
-        return self.agbenchmark_config_dir / "temp_folder"

classic/benchmark/agbenchmark/conftest.py

@@ -1,339 +0,0 @@
-import contextlib
-import json
-import logging
-import os
-import shutil
-import threading
-import time
-from pathlib import Path
-from typing import Generator
-
-import pytest
-
-from agbenchmark.challenges import OPTIONAL_CATEGORIES, BaseChallenge
-from agbenchmark.config import AgentBenchmarkConfig
-from agbenchmark.reports.processing.report_types import Test
-from agbenchmark.reports.ReportManager import RegressionTestsTracker
-from agbenchmark.reports.reports import (
-    add_test_result_to_report,
-    make_empty_test_report,
-    session_finish,
-)
-from agbenchmark.utils.data_types import Category
-
-GLOBAL_TIMEOUT = (
-    1500  # The tests will stop after 25 minutes so we can send the reports.
-)
-
-agbenchmark_config = AgentBenchmarkConfig.load()
-logger = logging.getLogger(__name__)
-
-pytest_plugins = ["agbenchmark.utils.dependencies"]
-collect_ignore = ["challenges"]
-
-
-@pytest.fixture(scope="module")
-def config() -> AgentBenchmarkConfig:
-    return agbenchmark_config
-
-
-@pytest.fixture(autouse=True)
-def temp_folder() -> Generator[Path, None, None]:
-    """
-    Pytest fixture that sets up and tears down the temporary folder for each test.
-    It is automatically used in every test due to the 'autouse=True' parameter.
-    """
-
-    # create output directory if it doesn't exist
-    if not os.path.exists(agbenchmark_config.temp_folder):
-        os.makedirs(agbenchmark_config.temp_folder, exist_ok=True)
-
-    yield agbenchmark_config.temp_folder
-    # teardown after test function completes
-    if not os.getenv("KEEP_TEMP_FOLDER_FILES"):
-        for filename in os.listdir(agbenchmark_config.temp_folder):
-            file_path = os.path.join(agbenchmark_config.temp_folder, filename)
-            try:
-                if os.path.isfile(file_path) or os.path.islink(file_path):
-                    os.unlink(file_path)
-                elif os.path.isdir(file_path):
-                    shutil.rmtree(file_path)
-            except Exception as e:
-                logger.warning(f"Failed to delete {file_path}. Reason: {e}")
-
-
-def pytest_addoption(parser: pytest.Parser) -> None:
-    """
-    Pytest hook that adds command-line options to the `pytest` command.
-    The added options are specific to agbenchmark and control its behavior:
-    * `--mock` is used to run the tests in mock mode.
-    * `--host` is used to specify the host for the tests.
-    * `--category` is used to run only tests of a specific category.
-    * `--nc` is used to run the tests without caching.
-    * `--cutoff` is used to specify a cutoff time for the tests.
-    * `--improve` is used to run only the tests that are marked for improvement.
-    * `--maintain` is used to run only the tests that are marked for maintenance.
-    * `--explore` is used to run the tests in exploration mode.
-    * `--test` is used to run a specific test.
-    * `--no-dep` is used to run the tests without dependencies.
-    * `--keep-answers` is used to keep the answers of the tests.
-
-    Args:
-        parser: The Pytest CLI parser to which the command-line options are added.
-    """
-    parser.addoption("-N", "--attempts", action="store")
-    parser.addoption("--no-dep", action="store_true")
-    parser.addoption("--mock", action="store_true")
-    parser.addoption("--host", default=None)
-    parser.addoption("--nc", action="store_true")
-    parser.addoption("--cutoff", action="store")
-    parser.addoption("--category", action="append")
-    parser.addoption("--test", action="append")
-    parser.addoption("--improve", action="store_true")
-    parser.addoption("--maintain", action="store_true")
-    parser.addoption("--explore", action="store_true")
-    parser.addoption("--keep-answers", action="store_true")
-
-
-def pytest_configure(config: pytest.Config) -> None:
-    # Register category markers to prevent "unknown marker" warnings
-    for category in Category:
-        config.addinivalue_line("markers", f"{category.value}: {category}")
-
-
-@pytest.fixture(autouse=True)
-def check_regression(request: pytest.FixtureRequest) -> None:
-    """
-    Fixture that checks for every test if it should be treated as a regression test,
-    and whether to skip it based on that.
-
-    The test name is retrieved from the `request` object. Regression reports are loaded
-    from the path specified in the benchmark configuration.
-
-    Effect:
-    * If the `--improve` option is used and the current test is considered a regression
-      test, it is skipped.
-    * If the `--maintain` option is used and the current test  is not considered a
-      regression test, it is also skipped.
-
-    Args:
-        request: The request object from which the test name and the benchmark
-            configuration are retrieved.
-    """
-    with contextlib.suppress(FileNotFoundError):
-        rt_tracker = RegressionTestsTracker(agbenchmark_config.regression_tests_file)
-
-        assert isinstance(request.node, pytest.Function)
-        assert isinstance(request.node.parent, pytest.Class)
-        test_name = request.node.parent.name
-        challenge_location = getattr(request.node.cls, "CHALLENGE_LOCATION", "")
-        skip_string = f"Skipping {test_name} at {challenge_location}"
-
-        # Check if the test name exists in the regression tests
-        is_regression_test = rt_tracker.has_regression_test(test_name)
-        if request.config.getoption("--improve") and is_regression_test:
-            pytest.skip(f"{skip_string} because it's a regression test")
-        elif request.config.getoption("--maintain") and not is_regression_test:
-            pytest.skip(f"{skip_string} because it's not a regression test")
-
-
-@pytest.fixture(autouse=True, scope="session")
-def mock(request: pytest.FixtureRequest) -> bool:
-    """
-    Pytest fixture that retrieves the value of the `--mock` command-line option.
-    The `--mock` option is used to run the tests in mock mode.
-
-    Args:
-        request: The `pytest.FixtureRequest` from which the `--mock` option value
-            is retrieved.
-
-    Returns:
-        bool: Whether `--mock` is set for this session.
-    """
-    mock = request.config.getoption("--mock")
-    assert isinstance(mock, bool)
-    return mock
-
-
-test_reports: dict[str, Test] = {}
-
-
-def pytest_runtest_makereport(item: pytest.Item, call: pytest.CallInfo) -> None:
-    """
-    Pytest hook that is called when a test report is being generated.
-    It is used to generate and finalize reports for each test.
-
-    Args:
-        item: The test item for which the report is being generated.
-        call: The call object from which the test result is retrieved.
-    """
-    challenge: type[BaseChallenge] = item.cls  # type: ignore
-    challenge_id = challenge.info.eval_id
-
-    if challenge_id not in test_reports:
-        test_reports[challenge_id] = make_empty_test_report(challenge.info)
-
-    if call.when == "setup":
-        test_name = item.nodeid.split("::")[1]
-        item.user_properties.append(("test_name", test_name))
-
-    if call.when == "call":
-        add_test_result_to_report(
-            test_reports[challenge_id], item, call, agbenchmark_config
-        )
-
-
-def timeout_monitor(start_time: int) -> None:
-    """
-    Function that limits the total execution time of the test suite.
-    This function is supposed to be run in a separate thread and calls `pytest.exit`
-    if the total execution time has exceeded the global timeout.
-
-    Args:
-        start_time (int): The start time of the test suite.
-    """
-    while time.time() - start_time < GLOBAL_TIMEOUT:
-        time.sleep(1)  # check every second
-
-    pytest.exit("Test suite exceeded the global timeout", returncode=1)
-
-
-def pytest_sessionstart(session: pytest.Session) -> None:
-    """
-    Pytest hook that is called at the start of a test session.
-
-    Sets up and runs a `timeout_monitor` in a separate thread.
-    """
-    start_time = time.time()
-    t = threading.Thread(target=timeout_monitor, args=(start_time,))
-    t.daemon = True  # Daemon threads are abruptly stopped at shutdown
-    t.start()
-
-
-def pytest_sessionfinish(session: pytest.Session) -> None:
-    """
-    Pytest hook that is called at the end of a test session.
-
-    Finalizes and saves the test reports.
-    """
-    session_finish(agbenchmark_config)
-
-
-def pytest_generate_tests(metafunc: pytest.Metafunc):
-    n = metafunc.config.getoption("-N")
-    metafunc.parametrize("i_attempt", range(int(n)) if type(n) is str else [0])
-
-
-def pytest_collection_modifyitems(
-    items: list[pytest.Function], config: pytest.Config
-) -> None:
-    """
-    Pytest hook that is called after initial test collection has been performed.
-    Modifies the collected test items based on the agent benchmark configuration,
-    adding the dependency marker and category markers.
-
-    Args:
-        items: The collected test items to be modified.
-        config: The active pytest configuration.
-    """
-    rt_tracker = RegressionTestsTracker(agbenchmark_config.regression_tests_file)
-
-    try:
-        challenges_beaten_in_the_past = json.loads(
-            agbenchmark_config.challenges_already_beaten_file.read_bytes()
-        )
-    except FileNotFoundError:
-        challenges_beaten_in_the_past = {}
-
-    selected_tests: tuple[str] = config.getoption("--test")  # type: ignore
-    selected_categories: tuple[str] = config.getoption("--category")  # type: ignore
-
-    # Can't use a for-loop to remove items in-place
-    i = 0
-    while i < len(items):
-        item = items[i]
-        assert item.cls and issubclass(item.cls, BaseChallenge)
-        challenge = item.cls
-        challenge_name = challenge.info.name
-
-        if not issubclass(challenge, BaseChallenge):
-            item.warn(
-                pytest.PytestCollectionWarning(
-                    f"Non-challenge item collected: {challenge}"
-                )
-            )
-            i += 1
-            continue
-
-        # --test: remove the test from the set if it's not specifically selected
-        if selected_tests and challenge.info.name not in selected_tests:
-            items.remove(item)
-            continue
-
-        # Filter challenges for --maintain, --improve, and --explore:
-        # --maintain -> only challenges expected to be passed (= regression tests)
-        # --improve -> only challenges that so far are not passed (reliably)
-        # --explore -> only challenges that have never been passed
-        is_regression_test = rt_tracker.has_regression_test(challenge.info.name)
-        has_been_passed = challenges_beaten_in_the_past.get(challenge.info.name, False)
-        if (
-            (config.getoption("--maintain") and not is_regression_test)
-            or (config.getoption("--improve") and is_regression_test)
-            or (config.getoption("--explore") and has_been_passed)
-        ):
-            items.remove(item)
-            continue
-
-        dependencies = challenge.info.dependencies
-        if (
-            config.getoption("--test")
-            or config.getoption("--no-dep")
-            or config.getoption("--maintain")
-        ):
-            # Ignore dependencies:
-            # --test -> user selected specific tests to run, don't care about deps
-            # --no-dep -> ignore dependency relations regardless of test selection
-            # --maintain -> all "regression" tests must pass, so run all of them
-            dependencies = []
-        elif config.getoption("--improve"):
-            # Filter dependencies, keep only deps that are not "regression" tests
-            dependencies = [
-                d for d in dependencies if not rt_tracker.has_regression_test(d)
-            ]
-
-        # Set category markers
-        challenge_categories = set(c.value for c in challenge.info.category)
-        for category in challenge_categories:
-            item.add_marker(category)
-
-        # Enforce category selection
-        if selected_categories:
-            if not challenge_categories.intersection(set(selected_categories)):
-                items.remove(item)
-                continue
-            # # Filter dependencies, keep only deps from selected categories
-            # dependencies = [
-            #     d for d in dependencies
-            #     if not set(d.categories).intersection(set(selected_categories))
-            # ]
-
-        # Skip items in optional categories that are not selected for the subject agent
-        challenge_optional_categories = challenge_categories & set(OPTIONAL_CATEGORIES)
-        if challenge_optional_categories and not (
-            agbenchmark_config.categories
-            and challenge_optional_categories.issubset(
-                set(agbenchmark_config.categories)
-            )
-        ):
-            logger.debug(
-                f"Skipping {challenge_name}: "
-                f"category {' and '.join(challenge_optional_categories)} is optional, "
-                "and not explicitly selected in the benchmark config."
-            )
-            items.remove(item)
-            continue
-
-        # Add marker for the DependencyManager
-        item.add_marker(pytest.mark.depends(on=dependencies, name=challenge_name))
-
-        i += 1

classic/benchmark/agbenchmark/generate_test.py

@@ -1,26 +0,0 @@
-"""
-AGBenchmark's test discovery endpoint for Pytest.
-
-This module is picked up by Pytest's *_test.py file matching pattern, and all challenge
-classes in the module that conform to the `Test*` pattern are collected.
-"""
-
-import importlib
-import logging
-from itertools import chain
-
-from agbenchmark.challenges.builtin import load_builtin_challenges
-from agbenchmark.challenges.webarena import load_webarena_challenges
-
-logger = logging.getLogger(__name__)
-
-DATA_CATEGORY = {}
-
-# Load challenges and attach them to this module
-for challenge in chain(load_builtin_challenges(), load_webarena_challenges()):
-    # Attach the Challenge class to this module so it can be discovered by pytest
-    module = importlib.import_module(__name__)
-    setattr(module, challenge.__name__, challenge)
-
-    # Build a map of challenge names and their primary category
-    DATA_CATEGORY[challenge.info.name] = challenge.info.category[0].value

classic/benchmark/agbenchmark/main.py

@@ -1,158 +0,0 @@
-import logging
-import os
-from pathlib import Path
-from typing import Optional, Sequence
-
-from dotenv import load_dotenv
-
-from agbenchmark.challenges import get_unique_categories
-from agbenchmark.config import AgentBenchmarkConfig
-
-load_dotenv()
-
-logger = logging.getLogger(__name__)
-
-
-def run_benchmark(
-    config: AgentBenchmarkConfig,
-    maintain: bool = False,
-    improve: bool = False,
-    explore: bool = False,
-    tests: tuple[str, ...] = tuple(),
-    categories: tuple[str, ...] = tuple(),
-    skip_categories: tuple[str, ...] = tuple(),
-    attempts_per_challenge: int = 1,
-    mock: bool = False,
-    no_dep: bool = False,
-    no_cutoff: bool = False,
-    cutoff: Optional[int] = None,
-    keep_answers: bool = False,
-    server: bool = False,
-) -> int:
-    """
-    Starts the benchmark. If a category flag is provided, only challenges with the
-    corresponding mark will be run.
-    """
-    import pytest
-
-    from agbenchmark.reports.ReportManager import SingletonReportManager
-
-    validate_args(
-        maintain=maintain,
-        improve=improve,
-        explore=explore,
-        tests=tests,
-        categories=categories,
-        skip_categories=skip_categories,
-        no_cutoff=no_cutoff,
-        cutoff=cutoff,
-    )
-
-    SingletonReportManager()
-
-    for key, value in vars(config).items():
-        logger.debug(f"config.{key} = {repr(value)}")
-
-    pytest_args = ["-vs"]
-
-    if tests:
-        logger.info(f"Running specific test(s): {' '.join(tests)}")
-        pytest_args += [f"--test={t}" for t in tests]
-    else:
-        all_categories = get_unique_categories()
-
-        if categories or skip_categories:
-            categories_to_run = set(categories) or all_categories
-            if skip_categories:
-                categories_to_run = categories_to_run.difference(set(skip_categories))
-            assert categories_to_run, "Error: You can't skip all categories"
-            pytest_args += [f"--category={c}" for c in categories_to_run]
-            logger.info(f"Running tests of category: {categories_to_run}")
-        else:
-            logger.info("Running all categories")
-
-        if maintain:
-            logger.info("Running only regression tests")
-        elif improve:
-            logger.info("Running only non-regression tests")
-        elif explore:
-            logger.info("Only attempt challenges that have never been beaten")
-
-    if mock:
-        # TODO: unhack
-        os.environ[
-            "IS_MOCK"
-        ] = "True"  # ugly hack to make the mock work when calling from API
-
-    # Pass through flags
-    for flag, active in {
-        "--maintain": maintain,
-        "--improve": improve,
-        "--explore": explore,
-        "--no-dep": no_dep,
-        "--mock": mock,
-        "--nc": no_cutoff,
-        "--keep-answers": keep_answers,
-    }.items():
-        if active:
-            pytest_args.append(flag)
-
-    if attempts_per_challenge > 1:
-        pytest_args.append(f"--attempts={attempts_per_challenge}")
-
-    if cutoff:
-        pytest_args.append(f"--cutoff={cutoff}")
-        logger.debug(f"Setting cuttoff override to {cutoff} seconds.")
-
-    current_dir = Path(__file__).resolve().parent
-    pytest_args.append(str(current_dir / "generate_test.py"))
-
-    pytest_args.append("--cache-clear")
-    logger.debug(f"Running Pytest with args: {pytest_args}")
-    exit_code = pytest.main(pytest_args)
-
-    SingletonReportManager.clear_instance()
-    return exit_code
-
-
-class InvalidInvocationError(ValueError):
-    pass
-
-
-def validate_args(
-    maintain: bool,
-    improve: bool,
-    explore: bool,
-    tests: Sequence[str],
-    categories: Sequence[str],
-    skip_categories: Sequence[str],
-    no_cutoff: bool,
-    cutoff: Optional[int],
-) -> None:
-    if categories:
-        all_categories = get_unique_categories()
-        invalid_categories = set(categories) - all_categories
-        if invalid_categories:
-            raise InvalidInvocationError(
-                "One or more invalid categories were specified: "
-                f"{', '.join(invalid_categories)}.\n"
-                f"Valid categories are: {', '.join(all_categories)}."
-            )
-
-    if (maintain + improve + explore) > 1:
-        raise InvalidInvocationError(
-            "You can't use --maintain, --improve or --explore at the same time. "
-            "Please choose one."
-        )
-
-    if tests and (categories or skip_categories or maintain or improve or explore):
-        raise InvalidInvocationError(
-            "If you're running a specific test make sure no other options are "
-            "selected. Please just pass the --test."
-        )
-
-    if no_cutoff and cutoff:
-        raise InvalidInvocationError(
-            "You can't use both --nc and --cutoff at the same time. "
-            "Please choose one."
-        )

classic/benchmark/agbenchmark/reports/ReportManager.py

@@ -1,217 +0,0 @@
-import copy
-import json
-import logging
-import os
-import sys
-import time
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-from agbenchmark.config import AgentBenchmarkConfig
-from agbenchmark.reports.processing.graphs import save_single_radar_chart
-from agbenchmark.reports.processing.process_report import (
-    get_highest_achieved_difficulty_per_category,
-)
-from agbenchmark.reports.processing.report_types import MetricsOverall, Report, Test
-from agbenchmark.utils.utils import get_highest_success_difficulty
-
-logger = logging.getLogger(__name__)
-
-
-class SingletonReportManager:
-    instance = None
-
-    INFO_MANAGER: "SessionReportManager"
-    REGRESSION_MANAGER: "RegressionTestsTracker"
-    SUCCESS_RATE_TRACKER: "SuccessRatesTracker"
-
-    def __new__(cls):
-        if not cls.instance:
-            cls.instance = super(SingletonReportManager, cls).__new__(cls)
-
-            agent_benchmark_config = AgentBenchmarkConfig.load()
-            benchmark_start_time_dt = datetime.now(
-                timezone.utc
-            )  # or any logic to fetch the datetime
-
-            # Make the Managers class attributes
-            cls.INFO_MANAGER = SessionReportManager(
-                agent_benchmark_config.get_report_dir(benchmark_start_time_dt)
-                / "report.json",
-                benchmark_start_time_dt,
-            )
-            cls.REGRESSION_MANAGER = RegressionTestsTracker(
-                agent_benchmark_config.regression_tests_file
-            )
-            cls.SUCCESS_RATE_TRACKER = SuccessRatesTracker(
-                agent_benchmark_config.success_rate_file
-            )
-
-        return cls.instance
-
-    @classmethod
-    def clear_instance(cls):
-        cls.instance = None
-        del cls.INFO_MANAGER
-        del cls.REGRESSION_MANAGER
-        del cls.SUCCESS_RATE_TRACKER
-
-
-class BaseReportManager:
-    """Abstracts interaction with the regression tests file"""
-
-    tests: dict[str, Any]
-
-    def __init__(self, report_file: Path):
-        self.report_file = report_file
-
-        self.load()
-
-    def load(self) -> None:
-        if not self.report_file.exists():
-            self.report_file.parent.mkdir(exist_ok=True)
-
-        try:
-            with self.report_file.open("r") as f:
-                data = json.load(f)
-                self.tests = {k: data[k] for k in sorted(data)}
-        except FileNotFoundError:
-            self.tests = {}
-        except json.decoder.JSONDecodeError as e:
-            logger.warning(f"Could not parse {self.report_file}: {e}")
-            self.tests = {}
-
-    def save(self) -> None:
-        with self.report_file.open("w") as f:
-            json.dump(self.tests, f, indent=4)
-
-    def remove_test(self, test_name: str) -> None:
-        if test_name in self.tests:
-            del self.tests[test_name]
-            self.save()
-
-    def reset(self) -> None:
-        self.tests = {}
-        self.save()
-
-
-class SessionReportManager(BaseReportManager):
-    """Abstracts interaction with the regression tests file"""
-
-    tests: dict[str, Test]
-    report: Report | None = None
-
-    def __init__(self, report_file: Path, benchmark_start_time: datetime):
-        super().__init__(report_file)
-
-        self.start_time = time.time()
-        self.benchmark_start_time = benchmark_start_time
-
-    def save(self) -> None:
-        with self.report_file.open("w") as f:
-            if self.report:
-                f.write(self.report.model_dump_json(indent=4))
-            else:
-                json.dump(
-                    {k: v.model_dump() for k, v in self.tests.items()}, f, indent=4
-                )
-
-    def load(self) -> None:
-        super().load()
-
-        if "tests" in self.tests:
-            self.report = Report.model_validate(self.tests)
-        else:
-            self.tests = {n: Test.model_validate(d) for n, d in self.tests.items()}
-
-    def add_test_report(self, test_name: str, test_report: Test) -> None:
-        if self.report:
-            raise RuntimeError("Session report already finalized")
-
-        if test_name.startswith("Test"):
-            test_name = test_name[4:]
-        self.tests[test_name] = test_report
-
-        self.save()
-
-    def finalize_session_report(self, config: AgentBenchmarkConfig) -> None:
-        command = " ".join(sys.argv)
-
-        if self.report:
-            raise RuntimeError("Session report already finalized")
-
-        self.report = Report(
-            command=command.split(os.sep)[-1],
-            benchmark_git_commit_sha="---",
-            agent_git_commit_sha="---",
-            completion_time=datetime.now(timezone.utc).strftime(
-                "%Y-%m-%dT%H:%M:%S+00:00"
-            ),
-            benchmark_start_time=self.benchmark_start_time.strftime(
-                "%Y-%m-%dT%H:%M:%S+00:00"
-            ),
-            metrics=MetricsOverall(
-                run_time=str(round(time.time() - self.start_time, 2)) + " seconds",
-                highest_difficulty=get_highest_success_difficulty(self.tests),
-                total_cost=self.get_total_costs(),
-            ),
-            tests=copy.copy(self.tests),
-            config=config.model_dump(exclude={"reports_folder"}, exclude_none=True),
-        )
-
-        agent_categories = get_highest_achieved_difficulty_per_category(self.report)
-        if len(agent_categories) > 1:
-            save_single_radar_chart(
-                agent_categories,
-                config.get_report_dir(self.benchmark_start_time) / "radar_chart.png",
-            )
-
-        self.save()
-
-    def get_total_costs(self):
-        if self.report:
-            tests = self.report.tests
-        else:
-            tests = self.tests
-
-        total_cost = 0
-        all_costs_none = True
-        for test_data in tests.values():
-            cost = sum(r.cost or 0 for r in test_data.results)
-
-            if cost is not None:  # check if cost is not None
-                all_costs_none = False
-                total_cost += cost  # add cost to total
-        if all_costs_none:
-            total_cost = None
-        return total_cost
-
-
-class RegressionTestsTracker(BaseReportManager):
-    """Abstracts interaction with the regression tests file"""
-
-    tests: dict[str, dict]
-
-    def add_test(self, test_name: str, test_details: dict) -> None:
-        if test_name.startswith("Test"):
-            test_name = test_name[4:]
-
-        self.tests[test_name] = test_details
-        self.save()
-
-    def has_regression_test(self, test_name: str) -> bool:
-        return self.tests.get(test_name) is not None
-
-
-class SuccessRatesTracker(BaseReportManager):
-    """Abstracts interaction with the regression tests file"""
-
-    tests: dict[str, list[bool | None]]
-
-    def update(self, test_name: str, success_history: list[bool | None]) -> None:
-        if test_name.startswith("Test"):
-            test_name = test_name[4:]
-
-        self.tests[test_name] = success_history
-        self.save()

classic/benchmark/agbenchmark/reports/processing/gen_combined_chart.py

@@ -1,45 +0,0 @@
-import json
-import os
-from pathlib import Path
-
-from agbenchmark.reports.processing.graphs import (
-    save_combined_bar_chart,
-    save_combined_radar_chart,
-)
-from agbenchmark.reports.processing.process_report import (
-    all_agent_categories,
-    get_reports_data,
-)
-
-
-def generate_combined_chart() -> None:
-    all_agents_path = Path(__file__).parent.parent.parent.parent / "reports"
-
-    combined_charts_folder = all_agents_path / "combined_charts"
-
-    reports_data = get_reports_data(str(all_agents_path))
-
-    categories = all_agent_categories(reports_data)
-
-    # Count the number of directories in this directory
-    num_dirs = len([f for f in combined_charts_folder.iterdir() if f.is_dir()])
-
-    run_charts_folder = combined_charts_folder / f"run{num_dirs + 1}"
-
-    if not os.path.exists(run_charts_folder):
-        os.makedirs(run_charts_folder)
-
-    info_data = {
-        report_name: data.benchmark_start_time
-        for report_name, data in reports_data.items()
-        if report_name in categories
-    }
-    with open(Path(run_charts_folder) / "run_info.json", "w") as f:
-        json.dump(info_data, f)
-
-    save_combined_radar_chart(categories, Path(run_charts_folder) / "radar_chart.png")
-    save_combined_bar_chart(categories, Path(run_charts_folder) / "bar_chart.png")
-
-
-if __name__ == "__main__":
-    generate_combined_chart()

classic/benchmark/agbenchmark/reports/processing/get_files.py

@@ -1,34 +0,0 @@
-import os
-
-
-def get_last_subdirectory(directory_path: str) -> str | None:
-    # Get all subdirectories in the directory
-    subdirs = [
-        os.path.join(directory_path, name)
-        for name in os.listdir(directory_path)
-        if os.path.isdir(os.path.join(directory_path, name))
-    ]
-
-    # Sort the subdirectories by creation time
-    subdirs.sort(key=os.path.getctime)
-
-    # Return the last subdirectory in the list
-    return subdirs[-1] if subdirs else None
-
-
-def get_latest_report_from_agent_directories(
-    directory_path: str,
-) -> list[tuple[os.DirEntry[str], str]]:
-    latest_reports = []
-
-    for subdir in os.scandir(directory_path):
-        if subdir.is_dir():
-            # Get the most recently created subdirectory within this agent's directory
-            latest_subdir = get_last_subdirectory(subdir.path)
-            if latest_subdir is not None:
-                # Look for 'report.json' in the subdirectory
-                report_file = os.path.join(latest_subdir, "report.json")
-                if os.path.isfile(report_file):
-                    latest_reports.append((subdir, report_file))
-
-    return latest_reports

classic/benchmark/agbenchmark/reports/processing/graphs.py

@@ -1,199 +0,0 @@
-from pathlib import Path
-from typing import Any
-
-import matplotlib.patches as mpatches
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-
-
-def save_combined_radar_chart(
-    categories: dict[str, Any], save_path: str | Path
-) -> None:
-    categories = {k: v for k, v in categories.items() if v}
-    if not all(categories.values()):
-        raise Exception("No data to plot")
-    labels = np.array(
-        list(next(iter(categories.values())).keys())
-    )  # We use the first category to get the keys
-    num_vars = len(labels)
-    angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist()
-    angles += angles[
-        :1
-    ]  # Add the first angle to the end of the list to ensure the polygon is closed
-
-    # Create radar chart
-    fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(polar=True))
-    ax.set_theta_offset(np.pi / 2)  # type: ignore
-    ax.set_theta_direction(-1)  # type: ignore
-    ax.spines["polar"].set_visible(False)  # Remove border
-
-    cmap = plt.cm.get_cmap("nipy_spectral", len(categories))  # type: ignore
-
-    colors = [cmap(i) for i in range(len(categories))]
-
-    for i, (cat_name, cat_values) in enumerate(
-        categories.items()
-    ):  # Iterating through each category (series)
-        values = np.array(list(cat_values.values()))
-        values = np.concatenate((values, values[:1]))  # Ensure the polygon is closed
-
-        ax.fill(angles, values, color=colors[i], alpha=0.25)  # Draw the filled polygon
-        ax.plot(angles, values, color=colors[i], linewidth=2)  # Draw polygon
-        ax.plot(
-            angles,
-            values,
-            "o",
-            color="white",
-            markersize=7,
-            markeredgecolor=colors[i],
-            markeredgewidth=2,
-        )  # Draw points
-
-        # Draw legend
-        ax.legend(
-            handles=[
-                mpatches.Patch(color=color, label=cat_name, alpha=0.25)
-                for cat_name, color in zip(categories.keys(), colors)
-            ],
-            loc="upper left",
-            bbox_to_anchor=(0.7, 1.3),
-        )
-
-        # Adjust layout to make room for the legend
-        plt.tight_layout()
-
-    lines, labels = plt.thetagrids(
-        np.degrees(angles[:-1]), (list(next(iter(categories.values())).keys()))
-    )  # We use the first category to get the keys
-
-    highest_score = 7
-
-    # Set y-axis limit to 7
-    ax.set_ylim(top=highest_score)
-
-    # Move labels away from the plot
-    for label in labels:
-        label.set_position(
-            (label.get_position()[0], label.get_position()[1] + -0.05)
-        )  # adjust 0.1 as needed
-
-    # Move radial labels away from the plot
-    ax.set_rlabel_position(180)  # type: ignore
-
-    ax.set_yticks([])  # Remove default yticks
-
-    # Manually create gridlines
-    for y in np.arange(0, highest_score + 1, 1):
-        if y != highest_score:
-            ax.plot(
-                angles, [y] * len(angles), color="gray", linewidth=0.5, linestyle=":"
-            )
-        # Add labels for manually created gridlines
-        ax.text(
-            angles[0],
-            y + 0.2,
-            str(int(y)),
-            color="black",
-            size=9,
-            horizontalalignment="center",
-            verticalalignment="center",
-        )
-
-    plt.savefig(save_path, dpi=300)  # Save the figure as a PNG file
-    plt.close()  # Close the figure to free up memory
-
-
-def save_single_radar_chart(
-    category_dict: dict[str, int], save_path: str | Path
-) -> None:
-    labels = np.array(list(category_dict.keys()))
-    values = np.array(list(category_dict.values()))
-
-    num_vars = len(labels)
-
-    angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist()
-
-    angles += angles[:1]
-    values = np.concatenate((values, values[:1]))
-
-    colors = ["#1f77b4"]
-
-    fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(polar=True))
-    ax.set_theta_offset(np.pi / 2)  # type: ignore
-    ax.set_theta_direction(-1)  # type: ignore
-
-    ax.spines["polar"].set_visible(False)
-
-    lines, labels = plt.thetagrids(
-        np.degrees(angles[:-1]), (list(category_dict.keys()))
-    )
-
-    highest_score = 7
-
-    # Set y-axis limit to 7
-    ax.set_ylim(top=highest_score)
-
-    for label in labels:
-        label.set_position((label.get_position()[0], label.get_position()[1] + -0.05))
-
-    ax.fill(angles, values, color=colors[0], alpha=0.25)
-    ax.plot(angles, values, color=colors[0], linewidth=2)
-
-    for i, (angle, value) in enumerate(zip(angles, values)):
-        ha = "left"
-        if angle in {0, np.pi}:
-            ha = "center"
-        elif np.pi < angle < 2 * np.pi:
-            ha = "right"
-        ax.text(
-            angle,
-            value - 0.5,
-            f"{value}",
-            size=10,
-            horizontalalignment=ha,
-            verticalalignment="center",
-            color="black",
-        )
-
-    ax.set_yticklabels([])
-
-    ax.set_yticks([])
-
-    if values.size == 0:
-        return
-
-    for y in np.arange(0, highest_score, 1):
-        ax.plot(angles, [y] * len(angles), color="gray", linewidth=0.5, linestyle=":")
-
-    for angle, value in zip(angles, values):
-        ax.plot(
-            angle,
-            value,
-            "o",
-            color="white",
-            markersize=7,
-            markeredgecolor=colors[0],
-            markeredgewidth=2,
-        )
-
-    plt.savefig(save_path, dpi=300)  # Save the figure as a PNG file
-    plt.close()  # Close the figure to free up memory
-
-
-def save_combined_bar_chart(categories: dict[str, Any], save_path: str | Path) -> None:
-    if not all(categories.values()):
-        raise Exception("No data to plot")
-
-    # Convert dictionary to DataFrame
-    df = pd.DataFrame(categories)
-
-    # Create a grouped bar chart
-    df.plot(kind="bar", figsize=(10, 7))
-
-    plt.title("Performance by Category for Each Agent")
-    plt.xlabel("Category")
-    plt.ylabel("Performance")
-
-    plt.savefig(save_path, dpi=300)  # Save the figure as a PNG file
-    plt.close()  # Close the figure to free up memory

classic/benchmark/agbenchmark/reports/processing/process_report.py

@@ -1,67 +0,0 @@
-import json
-import logging
-import os
-from pathlib import Path
-from typing import Any
-
-from agbenchmark.reports.processing.get_files import (
-    get_latest_report_from_agent_directories,
-)
-from agbenchmark.reports.processing.report_types import Report
-from agbenchmark.utils.data_types import STRING_DIFFICULTY_MAP
-
-logger = logging.getLogger(__name__)
-
-
-def get_reports_data(report_path: str) -> dict[str, Any]:
-    latest_files = get_latest_report_from_agent_directories(report_path)
-
-    reports_data = {}
-
-    if latest_files is None:
-        raise Exception("No files found in the reports directory")
-
-    # This will print the latest file in each s
-    # ubdirectory and add to the files_data dictionary
-    for subdir, file in latest_files:
-        subdir_name = os.path.basename(os.path.normpath(subdir))
-        with open(Path(subdir) / file, "r") as f:
-            # Load the JSON data from the file
-            json_data = json.load(f)
-            converted_data = Report.model_validate(json_data)
-            # get the last directory name in the path as key
-            reports_data[subdir_name] = converted_data
-
-    return reports_data
-
-
-def get_highest_achieved_difficulty_per_category(report: Report) -> dict[str, Any]:
-    categories: dict[str, Any] = {}
-
-    for _, test_data in report.tests.items():
-        for category in test_data.category:
-            if category in ("interface", "iterate", "product_advisor"):
-                continue
-            categories.setdefault(category, 0)
-            if (
-                test_data.results
-                and all(r.success for r in test_data.results)
-                and test_data.difficulty
-            ):
-                num_dif = STRING_DIFFICULTY_MAP[test_data.difficulty]
-                if num_dif > categories[category]:
-                    categories[category] = num_dif
-
-    return categories
-
-
-def all_agent_categories(reports_data: dict[str, Any]) -> dict[str, Any]:
-    all_categories: dict[str, Any] = {}
-
-    for name, report in reports_data.items():
-        categories = get_highest_achieved_difficulty_per_category(report)
-        if categories:  # only add to all_categories if categories is not empty
-            logger.debug(f"Adding {name}: {categories}")
-            all_categories[name] = categories
-
-    return all_categories

classic/benchmark/agbenchmark/reports/processing/report_types.py

@@ -1,106 +0,0 @@
-"""
-Model definitions used internally and for reports generated during command-line runs.
-"""
-
-import logging
-from typing import Annotated, Any, Dict, List
-
-from agent_protocol_client import Step
-from pydantic import (
-    BaseModel,
-    Field,
-    StringConstraints,
-    ValidationInfo,
-    field_validator,
-)
-
-datetime_format = r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+00:00$"
-logger = logging.getLogger(__name__)
-
-
-class TestResult(BaseModel):
-    """Result details for a single run of a test/challenge."""
-
-    success: bool | None = None
-    """Whether the run was successful"""
-    run_time: str | None = None
-    """The (formatted) duration of the run"""
-    fail_reason: str | None = None
-    """If applicable, the reason why the run was not successful"""
-    reached_cutoff: bool | None = None  # None if in progress
-    """Whether the run had to be stopped due to reaching the timeout"""
-    n_steps: int | None = None
-    """The number of steps executed by the agent"""
-    steps: list[Step] = []
-    """The steps generated by the agent"""
-    cost: float | None = None
-    """The (known) cost incurred by the run, e.g. from using paid LLM APIs"""
-
-    @field_validator("fail_reason")
-    def success_xor_fail_reason(cls, value, info: ValidationInfo):
-        if bool(value) == bool(info.data["success"]):
-            logger.error(
-                "Error validating `success ^ fail_reason` on TestResult: "
-                f"success = {repr(info.data['success'])}; "
-                f"fail_reason = {repr(value)}"
-            )
-        if value:
-            success = info.data["success"]
-            assert not success, "fail_reason must only be specified if success=False"
-        else:
-            assert info.data["success"], "fail_reason is required if success=False"
-        return value
-
-
-class TestMetrics(BaseModel):
-    """
-    Result metrics for a set of runs for a test/challenge. Should be an aggregate of all
-    results for the same test/challenge within a benchmarking session.
-    """
-
-    attempted: bool
-    """Whether the challenge was attempted during this session"""
-    is_regression: bool
-    """Whether the challenge was considered a regression test at the time of running"""
-    success_percentage: float | None = Field(default=None, alias="success_%")
-    """Success rate (0-100) for this challenge within the session"""
-
-
-class MetricsOverall(BaseModel):
-    """Global metrics concerning a benchmarking session"""
-
-    run_time: str
-    """Duration from beginning to end of the session"""
-    highest_difficulty: str
-    """
-    Difficulty of the most difficult challenge that succeeded at least once this session
-    """
-    total_cost: float | None = None
-    """Total known cost of the session"""
-
-
-class Test(BaseModel):
-    category: List[str]
-    difficulty: str | None
-    data_path: str
-    description: str
-    task: str
-    answer: str
-    metrics: TestMetrics
-    results: list[TestResult]
-    metadata: dict[str, Any] | None = Field(default_factory=dict)
-
-
-class ReportBase(BaseModel):
-    command: str
-    completion_time: str | None = None
-    benchmark_start_time: Annotated[str, StringConstraints(pattern=datetime_format)]
-    metrics: MetricsOverall
-    config: Dict[str, str | dict[str, str]]
-    agent_git_commit_sha: str | None = None
-    benchmark_git_commit_sha: str | None = None
-    repo_url: str | None = None
-
-
-class Report(ReportBase):
-    tests: Dict[str, Test]

classic/benchmark/agbenchmark/reports/processing/report_types_v2.py

@@ -1,49 +0,0 @@
-"""Model definitions for use in the API"""
-from typing import Annotated
-
-from pydantic import BaseModel, StringConstraints
-
-datetime_format = r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+00:00$"
-
-
-class TaskInfo(BaseModel):
-    data_path: str
-    is_regression: bool | None
-    answer: str
-    description: str
-    category: list[str]
-    task: str
-
-
-class RepositoryInfo(BaseModel):
-    repo_url: str | None = None
-    team_name: str | None = None
-    agent_git_commit_sha: str | None = None
-    benchmark_git_commit_sha: str | None = None
-
-
-class Metrics(BaseModel):
-    cost: float | None = None
-    success: bool
-    attempted: bool
-    difficulty: str | None = None
-    run_time: str | None = None
-    fail_reason: str | None = None
-    success_percentage: float | None = None
-
-
-class RunDetails(BaseModel):
-    test_name: str
-    run_id: str | None = None
-    command: str
-    completion_time: str | None = None
-    benchmark_start_time: Annotated[str, StringConstraints(pattern=datetime_format)]
-
-
-class BenchmarkRun(BaseModel):
-    repository_info: RepositoryInfo
-    run_details: RunDetails
-    task_info: TaskInfo
-    metrics: Metrics
-    reached_cutoff: bool | None = None
-    config: dict[str, str | dict[str, str]]

classic/benchmark/agbenchmark/reports/reports.py

@@ -1,157 +0,0 @@
-import json
-import logging
-import os
-from pathlib import Path
-
-import pytest
-from pydantic import ValidationError
-
-from agbenchmark.challenges import ChallengeInfo
-from agbenchmark.config import AgentBenchmarkConfig
-from agbenchmark.reports.processing.report_types import Test, TestMetrics, TestResult
-from agbenchmark.reports.ReportManager import SingletonReportManager
-from agbenchmark.utils.data_types import DifficultyLevel
-
-# from agbenchmark.utils.get_data_from_helicone import get_data_from_helicone
-
-logger = logging.getLogger(__name__)
-
-
-def get_and_update_success_history(
-    test_name: str, success: bool | None
-) -> list[bool | None]:
-    mock = os.getenv("IS_MOCK")  # Check if --mock is in sys.argv
-
-    prev_test_results = SingletonReportManager().SUCCESS_RATE_TRACKER.tests.get(
-        test_name, []
-    )
-
-    if not mock:
-        # only add if it's an actual test
-        prev_test_results.append(success)
-        SingletonReportManager().SUCCESS_RATE_TRACKER.update(
-            test_name, prev_test_results
-        )
-
-    return prev_test_results
-
-
-def update_regression_tests(
-    prev_test_results: list[bool | None],
-    test_report: Test,
-    test_name: str,
-) -> None:
-    if len(prev_test_results) >= 3 and prev_test_results[-3:] == [True, True, True]:
-        # if the last 3 tests were successful, add to the regression tests
-        test_report.metrics.is_regression = True
-        SingletonReportManager().REGRESSION_MANAGER.add_test(
-            test_name, test_report.model_dump(include={"difficulty", "data_path"})
-        )
-
-
-def make_empty_test_report(
-    challenge_info: ChallengeInfo,
-) -> Test:
-    difficulty = challenge_info.difficulty
-    if isinstance(difficulty, DifficultyLevel):
-        difficulty = difficulty.value
-
-    return Test(
-        category=[c.value for c in challenge_info.category],
-        difficulty=difficulty,
-        data_path=challenge_info.source_uri,
-        description=challenge_info.description or "",
-        task=challenge_info.task,
-        answer=challenge_info.reference_answer or "",
-        metrics=TestMetrics(attempted=False, is_regression=False),
-        results=[],
-    )
-
-
-def add_test_result_to_report(
-    test_report: Test,
-    item: pytest.Item,
-    call: pytest.CallInfo,
-    config: AgentBenchmarkConfig,
-) -> None:
-    user_properties: dict = dict(item.user_properties)
-    test_name: str = user_properties.get("test_name", "")
-
-    mock = os.getenv("IS_MOCK")  # Check if --mock is in sys.argv
-
-    if call.excinfo:
-        if not mock:
-            SingletonReportManager().REGRESSION_MANAGER.remove_test(test_name)
-
-        test_report.metrics.attempted = call.excinfo.typename != "Skipped"
-    else:
-        test_report.metrics.attempted = True
-
-    try:
-        test_report.results.append(
-            TestResult(
-                success=call.excinfo is None,
-                run_time=f"{str(round(call.duration, 3))} seconds",
-                fail_reason=(
-                    str(call.excinfo.value) if call.excinfo is not None else None
-                ),
-                reached_cutoff=user_properties.get("timed_out", False),
-                n_steps=user_properties.get("n_steps"),
-                steps=user_properties.get("steps", []),
-                cost=user_properties.get("agent_task_cost"),
-            )
-        )
-        test_report.metrics.success_percentage = (
-            sum(r.success or False for r in test_report.results)
-            / len(test_report.results)
-            * 100
-        )
-    except ValidationError:
-        if call.excinfo:
-            logger.error(
-                "Validation failed on TestResult; "
-                f"call.excinfo = {repr(call.excinfo)};\n{call.excinfo.getrepr()})"
-            )
-        raise
-
-    prev_test_results: list[bool | None] = get_and_update_success_history(
-        test_name, test_report.results[-1].success
-    )
-
-    update_regression_tests(prev_test_results, test_report, test_name)
-
-    if test_report and test_name:
-        # if "--mock" not in sys.argv and os.environ.get("HELICONE_API_KEY"):
-        #     logger.debug("Getting cost from Helicone")
-        #     test_report.metrics.cost = get_data_from_helicone(test_name)
-        #     logger.debug(f"Cost: {cost}")
-
-        if not mock:
-            update_challenges_already_beaten(
-                config.challenges_already_beaten_file, test_report, test_name
-            )
-
-        SingletonReportManager().INFO_MANAGER.add_test_report(test_name, test_report)
-
-
-def update_challenges_already_beaten(
-    challenges_already_beaten_file: Path, test_report: Test, test_name: str
-) -> None:
-    current_run_successful = any(r.success for r in test_report.results)
-    try:
-        with open(challenges_already_beaten_file, "r") as f:
-            challenges_beaten_before = json.load(f)
-    except FileNotFoundError:
-        challenges_beaten_before = {}
-
-    has_ever_been_beaten = challenges_beaten_before.get(test_name)
-    challenges_beaten_before[test_name] = has_ever_been_beaten or current_run_successful
-
-    with open(challenges_already_beaten_file, "w") as f:
-        json.dump(challenges_beaten_before, f, indent=4)
-
-
-def session_finish(agbenchmark_config: AgentBenchmarkConfig) -> None:
-    SingletonReportManager().INFO_MANAGER.finalize_session_report(agbenchmark_config)
-    SingletonReportManager().REGRESSION_MANAGER.save()
-    SingletonReportManager().SUCCESS_RATE_TRACKER.save()

classic/benchmark/agbenchmark/schema.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Optional
-
-from pydantic import BaseModel, Field
-
-
-class TaskRequestBody(BaseModel):
-    input: str = Field(
-        min_length=1,
-        description="Input prompt for the task.",
-        examples=["Write the words you receive to the file 'output.txt'."],
-    )
-    additional_input: Optional[dict[str, Any]] = Field(default_factory=dict)
-
-
-class TaskEvalRequestBody(TaskRequestBody):
-    eval_id: str

classic/benchmark/agbenchmark/utils/data_types.py

@@ -1,46 +0,0 @@
-from enum import Enum
-from typing import Literal
-
-from pydantic import BaseModel
-
-
-class DifficultyLevel(Enum):
-    interface = "interface"
-    basic = "basic"
-    novice = "novice"
-    intermediate = "intermediate"
-    advanced = "advanced"
-    expert = "expert"
-    human = "human"
-
-
-# map from enum to difficulty level (numeric)
-DIFFICULTY_MAP = {
-    DifficultyLevel.interface: 1,
-    DifficultyLevel.basic: 2,
-    DifficultyLevel.novice: 3,
-    DifficultyLevel.intermediate: 4,
-    DifficultyLevel.advanced: 5,
-    DifficultyLevel.expert: 6,
-    DifficultyLevel.human: 7,
-}
-
-STRING_DIFFICULTY_MAP = {e.value: DIFFICULTY_MAP[e] for e in DifficultyLevel}
-
-
-class Category(str, Enum):
-    GENERALIST = "general"
-    DATA = "data"
-    CODING = "coding"
-    SCRAPE_SYNTHESIZE = "scrape_synthesize"
-    WEB = "web"
-    GAIA_1 = "GAIA_1"
-    GAIA_2 = "GAIA_2"
-    GAIA_3 = "GAIA_3"
-
-
-class EvalResult(BaseModel):
-    result: str
-    result_source: Literal["step_output"] | str
-    score: float
-    passed: bool

classic/benchmark/agbenchmark/utils/dependencies/__init__.py

@@ -1,206 +0,0 @@
-"""
-A module that provides the pytest hooks for this plugin.
-
-The logic itself is in main.py.
-"""
-
-import warnings
-from typing import Any, Callable, Optional
-
-import pytest
-from _pytest.config.argparsing import OptionGroup, Parser
-from _pytest.nodes import Item
-
-from .main import DependencyManager
-
-managers: list[DependencyManager] = []
-
-
-DEPENDENCY_PROBLEM_ACTIONS: dict[str, Callable[[str], None] | None] = {
-    "run": None,
-    "skip": lambda m: pytest.skip(m),
-    "fail": lambda m: pytest.fail(m, False),
-    "warning": lambda m: warnings.warn(m),
-}
-
-
-def _add_ini_and_option(
-    parser: Any,
-    group: OptionGroup,
-    name: str,
-    help: str,
-    default: str | bool | int,
-    **kwargs: Any,
-) -> None:
-    """
-    Add an option to both the ini file and the command line flags.
-    Command line flags/options takes precedence over the ini config.
-    """
-    parser.addini(
-        name,
-        help + " This overrides the similarly named option from the config.",
-        default=default,
-    )
-    group.addoption(f'--{name.replace("_", "-")}', help=help, default=None, **kwargs)
-
-
-def _get_ini_or_option(
-    config: Any, name: str, choices: Optional[list[str]]
-) -> str | None:
-    """
-    Get an option from either the ini file or the command line flags,
-    with the latter taking precedence.
-    """
-    value = config.getini(name)
-    if value is not None and choices is not None and value not in choices:
-        raise ValueError(
-            f'Invalid ini value for {name}, choose from {", ".join(choices)}'
-        )
-    return config.getoption(name) or value
-
-
-def pytest_addoption(parser: Parser) -> None:
-    # get all current option strings
-    current_options = []
-    for action in parser._anonymous.options:
-        current_options += action._short_opts + action._long_opts
-
-    for group in parser._groups:
-        for action in group.options:
-            current_options += action._short_opts + action._long_opts
-
-    group = parser.getgroup("depends")
-
-    # Add a flag to list all names + the tests they resolve to
-    if "--list-dependency-names" not in current_options:
-        group.addoption(
-            "--list-dependency-names",
-            action="store_true",
-            default=False,
-            help=(
-                "List all non-nodeid dependency names + the tests they resolve to. "
-                "Will also list all nodeid dependency names in verbose mode."
-            ),
-        )
-
-    # Add a flag to list all (resolved) dependencies for all tests + unresolvable names
-    if "--list-processed-dependencies" not in current_options:
-        group.addoption(
-            "--list-processed-dependencies",
-            action="store_true",
-            default=False,
-            help=(
-                "List all dependencies of all tests as a list of nodeids "
-                "+ the names that could not be resolved."
-            ),
-        )
-
-    # Add an ini option + flag to choose the action to take for failed dependencies
-    if "--failed-dependency-action" not in current_options:
-        _add_ini_and_option(
-            parser,
-            group,
-            name="failed_dependency_action",
-            help=(
-                "The action to take when a test has dependencies that failed. "
-                'Use "run" to run the test anyway, "skip" to skip the test, '
-                'and "fail" to fail the test.'
-            ),
-            default="skip",
-            choices=DEPENDENCY_PROBLEM_ACTIONS.keys(),
-        )
-
-    # Add an ini option + flag to choose the action to take for unresolved dependencies
-    if "--missing-dependency-action" not in current_options:
-        _add_ini_and_option(
-            parser,
-            group,
-            name="missing_dependency_action",
-            help=(
-                "The action to take when a test has dependencies that cannot be found "
-                "within the current scope. "
-                'Use "run" to run the test anyway, "skip" to skip the test, '
-                'and "fail" to fail the test.'
-            ),
-            default="warning",
-            choices=DEPENDENCY_PROBLEM_ACTIONS.keys(),
-        )
-
-
-def pytest_configure(config: Any) -> None:
-    manager = DependencyManager()
-    managers.append(manager)
-
-    # Setup the handling of problems with dependencies
-    manager.options["failed_dependency_action"] = _get_ini_or_option(
-        config,
-        "failed_dependency_action",
-        list(DEPENDENCY_PROBLEM_ACTIONS.keys()),
-    )
-    manager.options["missing_dependency_action"] = _get_ini_or_option(
-        config,
-        "missing_dependency_action",
-        list(DEPENDENCY_PROBLEM_ACTIONS.keys()),
-    )
-
-    # Register marker
-    config.addinivalue_line(
-        "markers",
-        "depends(name='name', on=['other_name']): marks dependencies between tests.",
-    )
-
-
-@pytest.hookimpl(trylast=True)
-def pytest_collection_modifyitems(config: Any, items: list[pytest.Function]) -> None:
-    manager = managers[-1]
-
-    # Register the founds tests on the manager
-    manager.items = items
-
-    # Show the extra information if requested
-    if config.getoption("list_dependency_names"):
-        verbose = config.getoption("verbose") > 1
-        manager.print_name_map(verbose)
-    if config.getoption("list_processed_dependencies"):
-        color = config.getoption("color")
-        manager.print_processed_dependencies(color)
-
-    # Reorder the items so that tests run after their dependencies
-    items[:] = manager.sorted_items
-
-
-@pytest.hookimpl(tryfirst=True, hookwrapper=True)
-def pytest_runtest_makereport(item: Item) -> Any:
-    manager = managers[-1]
-
-    # Run the step
-    outcome = yield
-
-    # Store the result on the manager
-    manager.register_result(item, outcome.get_result())
-
-
-def pytest_runtest_call(item: Item) -> None:
-    manager = managers[-1]
-
-    # Handle missing dependencies
-    missing_dependency_action = DEPENDENCY_PROBLEM_ACTIONS[
-        manager.options["missing_dependency_action"]
-    ]
-    missing = manager.get_missing(item)
-    if missing_dependency_action and missing:
-        missing_dependency_action(
-            f'{item.nodeid} depends on {", ".join(missing)}, which was not found'
-        )
-
-    # Check whether all dependencies succeeded
-    failed_dependency_action = DEPENDENCY_PROBLEM_ACTIONS[
-        manager.options["failed_dependency_action"]
-    ]
-    failed = manager.get_failed(item)
-    if failed_dependency_action and failed:
-        failed_dependency_action(f'{item.nodeid} depends on {", ".join(failed)}')
-
-
-def pytest_unconfigure() -> None:
-    managers.pop()

classic/benchmark/agbenchmark/utils/dependencies/constants.py

@@ -1,10 +0,0 @@
-""" Constants for this module. """
-
-# The name of the marker used
-MARKER_NAME = "depends"
-
-# The name of the kwarg for 'depends' markers that contains custom name(s) for the tests
-MARKER_KWARG_ID = "name"
-
-# The name of the keyword argument for the marker that specifies the tests to depend on
-MARKER_KWARG_DEPENDENCIES = "on"

classic/benchmark/agbenchmark/utils/dependencies/graphs.py

@@ -1,453 +0,0 @@
-import json
-import logging
-import math
-from pathlib import Path
-from typing import Any, Dict, List, Tuple
-
-import matplotlib.patches as patches
-import matplotlib.pyplot as plt
-import networkx as nx
-import numpy as np
-from pyvis.network import Network
-
-from agbenchmark.generate_test import DATA_CATEGORY
-from agbenchmark.utils.utils import write_pretty_json
-
-logger = logging.getLogger(__name__)
-
-
-def bezier_curve(
-    src: np.ndarray, ctrl: List[float], dst: np.ndarray
-) -> List[np.ndarray]:
-    """
-    Generate Bézier curve points.
-
-    Args:
-    - src (np.ndarray): The source point.
-    - ctrl (List[float]): The control point.
-    - dst (np.ndarray): The destination point.
-
-    Returns:
-    - List[np.ndarray]: The Bézier curve points.
-    """
-    curve = []
-    for t in np.linspace(0, 1, num=100):
-        curve_point = (
-            np.outer((1 - t) ** 2, src)
-            + 2 * np.outer((1 - t) * t, ctrl)
-            + np.outer(t**2, dst)
-        )
-        curve.append(curve_point[0])
-    return curve
-
-
-def curved_edges(
-    G: nx.Graph, pos: Dict[Any, Tuple[float, float]], dist: float = 0.2
-) -> None:
-    """
-    Draw curved edges for nodes on the same level.
-
-    Args:
-    - G (Any): The graph object.
-    - pos (Dict[Any, Tuple[float, float]]): Dictionary with node positions.
-    - dist (float, optional): Distance for curvature. Defaults to 0.2.
-
-    Returns:
-    - None
-    """
-    ax = plt.gca()
-    for u, v, data in G.edges(data=True):
-        _src = pos[u]
-        _dst = pos[v]
-        src = np.array(_src)
-        dst = np.array(_dst)
-
-        same_level = abs(src[1] - dst[1]) < 0.01
-
-        if same_level:
-            control = [(src[0] + dst[0]) / 2, src[1] + dist]
-            curve = bezier_curve(src, control, dst)
-            arrow = patches.FancyArrowPatch(
-                posA=curve[0],  # type: ignore
-                posB=curve[-1],  # type: ignore
-                connectionstyle="arc3,rad=0.2",
-                color="gray",
-                arrowstyle="-|>",
-                mutation_scale=15.0,
-                lw=1,
-                shrinkA=10,
-                shrinkB=10,
-            )
-            ax.add_patch(arrow)
-        else:
-            ax.annotate(
-                "",
-                xy=_dst,
-                xytext=_src,
-                arrowprops=dict(
-                    arrowstyle="-|>", color="gray", lw=1, shrinkA=10, shrinkB=10
-                ),
-            )
-
-
-def tree_layout(graph: nx.DiGraph, root_node: Any) -> Dict[Any, Tuple[float, float]]:
-    """Compute positions as a tree layout centered on the root
-    with alternating vertical shifts."""
-    bfs_tree = nx.bfs_tree(graph, source=root_node)
-    levels = {
-        node: depth
-        for node, depth in nx.single_source_shortest_path_length(
-            bfs_tree, root_node
-        ).items()
-    }
-
-    pos = {}
-    max_depth = max(levels.values())
-    level_positions = {i: 0 for i in range(max_depth + 1)}  # type: ignore
-
-    # Count the number of nodes per level to compute the width
-    level_count: Any = {}
-    for node, level in levels.items():
-        level_count[level] = level_count.get(level, 0) + 1
-
-    vertical_offset = (
-        0.07  # The amount of vertical shift per node within the same level
-    )
-
-    # Assign positions
-    for node, level in sorted(levels.items(), key=lambda x: x[1]):
-        total_nodes_in_level = level_count[level]
-        horizontal_spacing = 1.0 / (total_nodes_in_level + 1)
-        pos_x = (
-            0.5
-            - (total_nodes_in_level - 1) * horizontal_spacing / 2
-            + level_positions[level] * horizontal_spacing
-        )
-
-        # Alternately shift nodes up and down within the same level
-        pos_y = (
-            -level
-            + (level_positions[level] % 2) * vertical_offset
-            - ((level_positions[level] + 1) % 2) * vertical_offset
-        )
-        pos[node] = (pos_x, pos_y)
-
-        level_positions[level] += 1
-
-    return pos
-
-
-def graph_spring_layout(
-    dag: nx.DiGraph, labels: Dict[Any, str], tree: bool = True
-) -> None:
-    num_nodes = len(list(dag.nodes()))
-    # Setting up the figure and axis
-    fig, ax = plt.subplots()
-    ax.axis("off")  # Turn off the axis
-
-    base = 3.0
-
-    if num_nodes > 10:
-        base /= 1 + math.log(num_nodes)
-        font_size = base * 10
-
-    font_size = max(10, base * 10)
-    node_size = max(300, base * 1000)
-
-    if tree:
-        root_node = [node for node, degree in dag.in_degree() if degree == 0][0]
-        pos = tree_layout(dag, root_node)
-    else:
-        # Adjust k for the spring layout based on node count
-        k_value = 3 / math.sqrt(num_nodes)
-
-        pos = nx.spring_layout(dag, k=k_value, iterations=50)
-
-    # Draw nodes and labels
-    nx.draw_networkx_nodes(dag, pos, node_color="skyblue", node_size=int(node_size))
-    nx.draw_networkx_labels(dag, pos, labels=labels, font_size=int(font_size))
-
-    # Draw curved edges
-    curved_edges(dag, pos)  # type: ignore
-
-    plt.tight_layout()
-    plt.show()
-
-
-def rgb_to_hex(rgb: Tuple[float, float, float]) -> str:
-    return "#{:02x}{:02x}{:02x}".format(
-        int(rgb[0] * 255), int(rgb[1] * 255), int(rgb[2] * 255)
-    )
-
-
-def get_category_colors(categories: Dict[Any, str]) -> Dict[str, str]:
-    unique_categories = set(categories.values())
-    colormap = plt.cm.get_cmap("tab10", len(unique_categories))  # type: ignore
-    return {
-        category: rgb_to_hex(colormap(i)[:3])
-        for i, category in enumerate(unique_categories)
-    }
-
-
-def graph_interactive_network(
-    dag: nx.DiGraph,
-    labels: Dict[Any, Dict[str, Any]],
-    html_graph_path: str = "",
-) -> None:
-    nt = Network(notebook=True, width="100%", height="800px", directed=True)
-
-    category_colors = get_category_colors(DATA_CATEGORY)
-
-    # Add nodes and edges to the pyvis network
-    for node, json_data in labels.items():
-        label = json_data.get("name", "")
-        # remove the first 4 letters of label
-        label_without_test = label[4:]
-        node_id_str = node.nodeid
-
-        # Get the category for this label
-        category = DATA_CATEGORY.get(
-            label, "unknown"
-        )  # Default to 'unknown' if label not found
-
-        # Get the color for this category
-        color = category_colors.get(category, "grey")
-
-        nt.add_node(
-            node_id_str,
-            label=label_without_test,
-            color=color,
-            data=json_data,
-        )
-
-    # Add edges to the pyvis network
-    for edge in dag.edges():
-        source_id_str = edge[0].nodeid
-        target_id_str = edge[1].nodeid
-        edge_id_str = (
-            f"{source_id_str}_to_{target_id_str}"  # Construct a unique edge id
-        )
-        if not (source_id_str in nt.get_nodes() and target_id_str in nt.get_nodes()):
-            logger.warning(
-                f"Skipping edge {source_id_str} -> {target_id_str} due to missing nodes"
-            )
-            continue
-        nt.add_edge(source_id_str, target_id_str, id=edge_id_str)
-
-    # Configure physics for hierarchical layout
-    hierarchical_options = {
-        "enabled": True,
-        "levelSeparation": 200,  # Increased vertical spacing between levels
-        "nodeSpacing": 250,  # Increased spacing between nodes on the same level
-        "treeSpacing": 250,  # Increased spacing between different trees (for forest)
-        "blockShifting": True,
-        "edgeMinimization": True,
-        "parentCentralization": True,
-        "direction": "UD",
-        "sortMethod": "directed",
-    }
-
-    physics_options = {
-        "stabilization": {
-            "enabled": True,
-            "iterations": 1000,  # Default is often around 100
-        },
-        "hierarchicalRepulsion": {
-            "centralGravity": 0.0,
-            "springLength": 200,  # Increased edge length
-            "springConstant": 0.01,
-            "nodeDistance": 250,  # Increased minimum distance between nodes
-            "damping": 0.09,
-        },
-        "solver": "hierarchicalRepulsion",
-        "timestep": 0.5,
-    }
-
-    nt.options = {
-        "nodes": {
-            "font": {
-                "size": 20,  # Increased font size for labels
-                "color": "black",  # Set a readable font color
-            },
-            "shapeProperties": {"useBorderWithImage": True},
-        },
-        "edges": {
-            "length": 250,  # Increased edge length
-        },
-        "physics": physics_options,
-        "layout": {"hierarchical": hierarchical_options},
-    }
-
-    # Serialize the graph to JSON and save in appropriate locations
-    graph_data = {"nodes": nt.nodes, "edges": nt.edges}
-    logger.debug(f"Generated graph data:\n{json.dumps(graph_data, indent=4)}")
-
-    # FIXME: use more reliable method to find the right location for these files.
-    #   This will fail in all cases except if run from the root of our repo.
-    home_path = Path.cwd()
-    write_pretty_json(graph_data, home_path / "frontend" / "public" / "graph.json")
-
-    flutter_app_path = home_path.parent / "frontend" / "assets"
-
-    # Optionally, save to a file
-    # Sync with the flutter UI
-    # this literally only works in the AutoGPT repo, but this part of the code
-    # is not reached if BUILD_SKILL_TREE is false
-    write_pretty_json(graph_data, flutter_app_path / "tree_structure.json")
-    validate_skill_tree(graph_data, "")
-
-    # Extract node IDs with category "coding"
-
-    coding_tree = extract_subgraph_based_on_category(graph_data.copy(), "coding")
-    validate_skill_tree(coding_tree, "coding")
-    write_pretty_json(
-        coding_tree,
-        flutter_app_path / "coding_tree_structure.json",
-    )
-
-    data_tree = extract_subgraph_based_on_category(graph_data.copy(), "data")
-    # validate_skill_tree(data_tree, "data")
-    write_pretty_json(
-        data_tree,
-        flutter_app_path / "data_tree_structure.json",
-    )
-
-    general_tree = extract_subgraph_based_on_category(graph_data.copy(), "general")
-    validate_skill_tree(general_tree, "general")
-    write_pretty_json(
-        general_tree,
-        flutter_app_path / "general_tree_structure.json",
-    )
-
-    scrape_synthesize_tree = extract_subgraph_based_on_category(
-        graph_data.copy(), "scrape_synthesize"
-    )
-    validate_skill_tree(scrape_synthesize_tree, "scrape_synthesize")
-    write_pretty_json(
-        scrape_synthesize_tree,
-        flutter_app_path / "scrape_synthesize_tree_structure.json",
-    )
-
-    if html_graph_path:
-        file_path = str(Path(html_graph_path).resolve())
-
-        nt.write_html(file_path)
-
-
-def extract_subgraph_based_on_category(graph, category):
-    """
-    Extracts a subgraph that includes all nodes and edges required to reach all nodes
-    with a specified category.
-
-    :param graph: The original graph.
-    :param category: The target category.
-    :return: Subgraph with nodes and edges required to reach the nodes
-        with the given category.
-    """
-
-    subgraph = {"nodes": [], "edges": []}
-    visited = set()
-
-    def reverse_dfs(node_id):
-        if node_id in visited:
-            return
-        visited.add(node_id)
-
-        node_data = next(node for node in graph["nodes"] if node["id"] == node_id)
-
-        # Add the node to the subgraph if it's not already present.
-        if node_data not in subgraph["nodes"]:
-            subgraph["nodes"].append(node_data)
-
-        for edge in graph["edges"]:
-            if edge["to"] == node_id:
-                if edge not in subgraph["edges"]:
-                    subgraph["edges"].append(edge)
-                reverse_dfs(edge["from"])
-
-    # Identify nodes with the target category and initiate reverse DFS from them.
-    nodes_with_target_category = [
-        node["id"] for node in graph["nodes"] if category in node["data"]["category"]
-    ]
-
-    for node_id in nodes_with_target_category:
-        reverse_dfs(node_id)
-
-    return subgraph
-
-
-def is_circular(graph):
-    def dfs(node, visited, stack, parent_map):
-        visited.add(node)
-        stack.add(node)
-        for edge in graph["edges"]:
-            if edge["from"] == node:
-                if edge["to"] in stack:
-                    # Detected a cycle
-                    cycle_path = []
-                    current = node
-                    while current != edge["to"]:
-                        cycle_path.append(current)
-                        current = parent_map.get(current)
-                    cycle_path.append(edge["to"])
-                    cycle_path.append(node)
-                    return cycle_path[::-1]
-                elif edge["to"] not in visited:
-                    parent_map[edge["to"]] = node
-                    cycle_path = dfs(edge["to"], visited, stack, parent_map)
-                    if cycle_path:
-                        return cycle_path
-        stack.remove(node)
-        return None
-
-    visited = set()
-    stack = set()
-    parent_map = {}
-    for node in graph["nodes"]:
-        node_id = node["id"]
-        if node_id not in visited:
-            cycle_path = dfs(node_id, visited, stack, parent_map)
-            if cycle_path:
-                return cycle_path
-    return None
-
-
-def get_roots(graph):
-    """
-    Return the roots of a graph. Roots are nodes with no incoming edges.
-    """
-    # Create a set of all node IDs
-    all_nodes = {node["id"] for node in graph["nodes"]}
-
-    # Create a set of nodes with incoming edges
-    nodes_with_incoming_edges = {edge["to"] for edge in graph["edges"]}
-
-    # Roots are nodes that have no incoming edges
-    roots = all_nodes - nodes_with_incoming_edges
-
-    return list(roots)
-
-
-def validate_skill_tree(graph, skill_tree_name):
-    """
-    Validate if a given graph represents a valid skill tree
-    and raise appropriate exceptions if not.
-
-    :param graph: A dictionary representing the graph with 'nodes' and 'edges'.
-    :raises: ValueError with a description of the invalidity.
-    """
-    # Check for circularity
-    cycle_path = is_circular(graph)
-    if cycle_path:
-        cycle_str = " -> ".join(cycle_path)
-        raise ValueError(
-            f"{skill_tree_name} skill tree is circular! "
-            f"Detected circular path: {cycle_str}."
-        )
-
-    # Check for multiple roots
-    roots = get_roots(graph)
-    if len(roots) > 1:
-        raise ValueError(f"{skill_tree_name} skill tree has multiple roots: {roots}.")
-    elif not roots:
-        raise ValueError(f"{skill_tree_name} skill tree has no roots.")

classic/benchmark/agbenchmark/utils/dependencies/main.py

@@ -1,255 +0,0 @@
-"""
-A module to manage dependencies between pytest tests.
-
-This module provides the methods implementing the main logic.
-These are used in the pytest hooks that are in __init__.py.
-"""
-
-import collections
-import os
-from typing import Any, Generator
-
-import colorama
-import networkx
-from pytest import Function, Item
-
-from agbenchmark.challenges.base import BaseChallenge
-
-from .constants import MARKER_KWARG_DEPENDENCIES, MARKER_NAME
-from .graphs import graph_interactive_network
-from .util import clean_nodeid, get_absolute_nodeid, get_markers, get_name
-
-
-class TestResult(object):
-    """Keeps track of the results of a single test."""
-
-    STEPS = ["setup", "call", "teardown"]
-    GOOD_OUTCOMES = ["passed"]
-
-    def __init__(self, nodeid: str) -> None:
-        """Create a new instance for a test with a given node id."""
-        self.nodeid = nodeid
-        self.results: dict[str, Any] = {}
-
-    def register_result(self, result: Any) -> None:
-        """Register a result of this test."""
-        if result.when not in self.STEPS:
-            raise ValueError(
-                f"Received result for unknown step {result.when} of test {self.nodeid}"
-            )
-        if result.when in self.results:
-            raise AttributeError(
-                f"Received multiple results for step {result.when} "
-                f"of test {self.nodeid}"
-            )
-        self.results[result.when] = result.outcome
-
-    @property
-    def success(self) -> bool:
-        """Whether the entire test was successful."""
-        return all(
-            self.results.get(step, None) in self.GOOD_OUTCOMES for step in self.STEPS
-        )
-
-
-class TestDependencies(object):
-    """Information about the resolved dependencies of a single test."""
-
-    def __init__(self, item: Item, manager: "DependencyManager") -> None:
-        """Create a new instance for a given test."""
-        self.nodeid = clean_nodeid(item.nodeid)
-        self.dependencies = set()
-        self.unresolved = set()
-
-        markers = get_markers(item, MARKER_NAME)
-        dependencies = [
-            dep
-            for marker in markers
-            for dep in marker.kwargs.get(MARKER_KWARG_DEPENDENCIES, [])
-        ]
-        for dependency in dependencies:
-            # If the name is not known, try to make it absolute (file::[class::]method)
-            if dependency not in manager.name_to_nodeids:
-                absolute_dependency = get_absolute_nodeid(dependency, self.nodeid)
-                if absolute_dependency in manager.name_to_nodeids:
-                    dependency = absolute_dependency
-
-            # Add all items matching the name
-            if dependency in manager.name_to_nodeids:
-                for nodeid in manager.name_to_nodeids[dependency]:
-                    self.dependencies.add(nodeid)
-            else:
-                self.unresolved.add(dependency)
-
-
-class DependencyManager(object):
-    """Keep track of tests, their names and their dependencies."""
-
-    def __init__(self) -> None:
-        """Create a new DependencyManager."""
-        self.options: dict[str, Any] = {}
-        self._items: list[Function] | None = None
-        self._name_to_nodeids: Any = None
-        self._nodeid_to_item: Any = None
-        self._results: Any = None
-
-    @property
-    def items(self) -> list[Function]:
-        """The collected tests that are managed by this instance."""
-        if self._items is None:
-            raise AttributeError("The items attribute has not been set yet")
-        return self._items
-
-    @items.setter
-    def items(self, items: list[Function]) -> None:
-        if self._items is not None:
-            raise AttributeError("The items attribute has already been set")
-        self._items = items
-
-        self._name_to_nodeids = collections.defaultdict(list)
-        self._nodeid_to_item = {}
-        self._results = {}
-        self._dependencies = {}
-
-        for item in items:
-            nodeid = clean_nodeid(item.nodeid)
-            # Add the mapping from nodeid to the test item
-            self._nodeid_to_item[nodeid] = item
-            # Add the mappings from all names to the node id
-            name = get_name(item)
-            self._name_to_nodeids[name].append(nodeid)
-            # Create the object that will contain the results of this test
-            self._results[nodeid] = TestResult(clean_nodeid(item.nodeid))
-
-        # Don't allow using unknown keys on the name_to_nodeids mapping
-        self._name_to_nodeids.default_factory = None
-
-        for item in items:
-            nodeid = clean_nodeid(item.nodeid)
-            # Process the dependencies of this test
-            # This uses the mappings created in the previous loop,
-            # and can thus not be merged into that loop
-            self._dependencies[nodeid] = TestDependencies(item, self)
-
-    @property
-    def name_to_nodeids(self) -> dict[str, list[str]]:
-        """A mapping from names to matching node id(s)."""
-        assert self.items is not None
-        return self._name_to_nodeids
-
-    @property
-    def nodeid_to_item(self) -> dict[str, Function]:
-        """A mapping from node ids to test items."""
-        assert self.items is not None
-        return self._nodeid_to_item
-
-    @property
-    def results(self) -> dict[str, TestResult]:
-        """The results of the tests."""
-        assert self.items is not None
-        return self._results
-
-    @property
-    def dependencies(self) -> dict[str, TestDependencies]:
-        """The dependencies of the tests."""
-        assert self.items is not None
-        return self._dependencies
-
-    def print_name_map(self, verbose: bool = False) -> None:
-        """Print a human-readable version of the name -> test mapping."""
-        print("Available dependency names:")
-        for name, nodeids in sorted(self.name_to_nodeids.items(), key=lambda x: x[0]):
-            if len(nodeids) == 1:
-                if name == nodeids[0]:
-                    # This is just the base name, only print this when verbose
-                    if verbose:
-                        print(f"  {name}")
-                else:
-                    # Name refers to a single node id, so use the short format
-                    print(f"  {name} -> {nodeids[0]}")
-            else:
-                # Name refers to multiple node ids, so use the long format
-                print(f"  {name} ->")
-                for nodeid in sorted(nodeids):
-                    print(f"    {nodeid}")
-
-    def print_processed_dependencies(self, colors: bool = False) -> None:
-        """Print a human-readable list of the processed dependencies."""
-        missing = "MISSING"
-        if colors:
-            missing = f"{colorama.Fore.RED}{missing}{colorama.Fore.RESET}"
-            colorama.init()
-        try:
-            print("Dependencies:")
-            for nodeid, info in sorted(self.dependencies.items(), key=lambda x: x[0]):
-                descriptions = []
-                for dependency in info.dependencies:
-                    descriptions.append(dependency)
-                for dependency in info.unresolved:
-                    descriptions.append(f"{dependency} ({missing})")
-                if descriptions:
-                    print(f"  {nodeid} depends on")
-                    for description in sorted(descriptions):
-                        print(f"    {description}")
-        finally:
-            if colors:
-                colorama.deinit()
-
-    @property
-    def sorted_items(self) -> Generator:
-        """
-        Get a sorted list of tests where all tests are sorted after their dependencies.
-        """
-        # Build a directed graph for sorting
-        build_skill_tree = os.getenv("BUILD_SKILL_TREE")
-        BUILD_SKILL_TREE = (
-            build_skill_tree.lower() == "true" if build_skill_tree else False
-        )
-        dag = networkx.DiGraph()
-
-        # Insert all items as nodes, to prevent items that have no dependencies
-        # and are not dependencies themselves from being lost
-        dag.add_nodes_from(self.items)
-
-        # Insert edges for all the dependencies
-        for item in self.items:
-            nodeid = clean_nodeid(item.nodeid)
-            for dependency in self.dependencies[nodeid].dependencies:
-                dag.add_edge(self.nodeid_to_item[dependency], item)
-
-        labels = {}
-        for item in self.items:
-            assert item.cls and issubclass(item.cls, BaseChallenge)
-            data = item.cls.info.model_dump()
-
-            node_name = get_name(item)
-            data["name"] = node_name
-            labels[item] = data
-
-        # only build the tree if it's specified in the env and is a whole run
-        if BUILD_SKILL_TREE:
-            # graph_spring_layout(dag, labels)
-            graph_interactive_network(dag, labels, html_graph_path="")
-
-        # Sort based on the dependencies
-        return networkx.topological_sort(dag)
-
-    def register_result(self, item: Item, result: Any) -> None:
-        """Register a result of a test."""
-        nodeid = clean_nodeid(item.nodeid)
-        self.results[nodeid].register_result(result)
-
-    def get_failed(self, item: Item) -> Any:
-        """Get a list of unfulfilled dependencies for a test."""
-        nodeid = clean_nodeid(item.nodeid)
-        failed = []
-        for dependency in self.dependencies[nodeid].dependencies:
-            result = self.results[dependency]
-            if not result.success:
-                failed.append(dependency)
-        return failed
-
-    def get_missing(self, item: Item) -> Any:
-        """Get a list of missing dependencies for a test."""
-        nodeid = clean_nodeid(item.nodeid)
-        return self.dependencies[nodeid].unresolved

classic/benchmark/agbenchmark/utils/dependencies/util.py

@@ -1,86 +0,0 @@
-""" Utility functions to process the identifiers of tests. """
-import re
-from typing import Iterator
-
-from _pytest.mark.structures import Mark
-from _pytest.nodes import Item
-
-from .constants import MARKER_KWARG_ID, MARKER_NAME
-
-REGEX_PARAMETERS = re.compile(r"\[.+\]$")
-
-
-def clean_nodeid(nodeid: str) -> str:
-    """
-    Remove any superfluous ::() from a node id.
-
-    >>> clean_nodeid('test_file.py::TestClass::()::test')
-    'test_file.py::TestClass::test'
-    >>> clean_nodeid('test_file.py::TestClass::test')
-    'test_file.py::TestClass::test'
-    >>> clean_nodeid('test_file.py::test')
-    'test_file.py::test'
-    """
-    return nodeid.replace("::()::", "::")
-
-
-def strip_nodeid_parameters(nodeid: str) -> str:
-    """
-    Strip parameters from a node id.
-
-    >>> strip_nodeid_parameters('test_file.py::TestClass::test[foo]')
-    'test_file.py::TestClass::test'
-    >>> strip_nodeid_parameters('test_file.py::TestClass::test')
-    'test_file.py::TestClass::test'
-    """
-    return REGEX_PARAMETERS.sub("", nodeid)
-
-
-def get_absolute_nodeid(nodeid: str, scope: str) -> str:
-    """
-    Transform a possibly relative node id to an absolute one
-    using the scope in which it is used.
-
-    >>> scope = 'test_file.py::TestClass::test'
-    >>> get_absolute_nodeid('test2', scope)
-    'test_file.py::TestClass::test2'
-    >>> get_absolute_nodeid('TestClass2::test2', scope)
-    'test_file.py::TestClass2::test2'
-    >>> get_absolute_nodeid('test_file2.py::TestClass2::test2', scope)
-    'test_file2.py::TestClass2::test2'
-    """
-    parts = nodeid.split("::")
-    # Completely relative (test_name): add the full current scope (file::class or file)
-    if len(parts) == 1:
-        base_nodeid = scope.rsplit("::", 1)[0]
-        nodeid = f"{base_nodeid}::{nodeid}"
-    # Contains some scope already (Class::test_name), so only add the current file scope
-    elif "." not in parts[0]:
-        base_nodeid = scope.split("::", 1)[0]
-        nodeid = f"{base_nodeid}::{nodeid}"
-    return clean_nodeid(nodeid)
-
-
-def get_name(item: Item) -> str:
-    """
-    Get all names for a test.
-
-    This will use the following methods to determine the name of the test:
-        - If given, the custom name(s) passed to the keyword argument name on the marker
-    """
-    name = ""
-
-    # Custom name
-    markers = get_markers(item, MARKER_NAME)
-    for marker in markers:
-        if MARKER_KWARG_ID in marker.kwargs:
-            name = marker.kwargs[MARKER_KWARG_ID]
-
-    return name
-
-
-def get_markers(item: Item, name: str) -> Iterator[Mark]:
-    """Get all markers with the given name for a given item."""
-    for marker in item.iter_markers():
-        if marker.name == name:
-            yield marker