Merge branch 'dev' into gmail-reply-draft

Backend for the Blocks Menu Redesign.

### Changes 🏗️

- Add optional `agent_name` to the `AgentExecutorBlock` - displayed as
the block name in the Builder
- Include `output_schema` in the `LibraryAgent` model
- Make `v2.store.db.py:get_store_agents` accept multiple creators filter
- Add `api/builder` router with endpoints (and accompanying logic in
`v2/builder/db` and models in `v2/builder/models`)
  - `/suggestions`: elements for the suggestions tab
  - `/categories`: categories with a number of blocks per each
  - `/blocks`: blocks based on category, type or provider
  - `/providers`: integration providers with their block counts
- `/serach`: search blocks (including integrations), marketplace agents
and user library agents
  - `/counts`: element counts for each category in the Blocks Menu.

### Checklist 📋

#### For code changes:
- [x] I have clearly listed my changes in the PR description
- [x] I have made a test plan
- [x] I have tested my changes according to the test plan:
- [x] Modified function `get_store_agents` works in existing code paths
  - [x] Agent executor block works
  - [x] New endpoints work
  - [x] Existing Builder menu is unaffected

---------

Co-authored-by: Abhimanyu Yadav <abhimanyu1992002@gmail.com>
Co-authored-by: Abhimanyu Yadav <122007096+Abhi1992002@users.noreply.github.com>

.deepsource.toml

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

.dockerignore

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

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,36 +1,39 @@
-### Background
-
 <!-- Clearly explain the need for these changes: -->
 
 ### Changes 🏗️
 
 <!-- Concisely describe all of the changes made in this pull request: -->
 
+### Checklist 📋
 
-### Testing 🔍
-> [!NOTE] 
-Only for the new autogpt platform, currently in autogpt_platform/
+#### For code changes:
+- [ ] I have clearly listed my changes in the PR description
+- [ ] I have made a test plan
+- [ ] I have tested my changes according to the test plan:
+  <!-- Put your test plan here: -->
+  - [ ] ...
 
-<!--
-Please make sure your changes have been tested and are in good working condition. 
-Here is a list of our critical paths, if you need some inspiration on what and how to test:
--->
+<details>
+  <summary>Example test plan</summary>
+  
+  - [ ] Create from scratch and execute an agent with at least 3 blocks
+  - [ ] Import an agent from file upload, and confirm it executes correctly
+  - [ ] Upload agent to marketplace
+  - [ ] Import an agent from marketplace and confirm it executes correctly
+  - [ ] Edit an agent from monitor, and confirm it executes correctly
+</details>
 
-- Create from scratch and execute an agent with at least 3 blocks
-- Import an agent from file upload, and confirm it executes correctly
-- Upload agent to marketplace
-- Import an agent from marketplace and confirm it executes correctly
-- Edit an agent from monitor, and confirm it executes correctly
+#### For configuration changes:
 
-### Configuration Changes 📝
-> [!NOTE] 
-Only for the new autogpt platform, currently in autogpt_platform/
+- [ ] `.env.default` is updated or already compatible with my changes
+- [ ] `docker-compose.yml` is updated or already compatible with my changes
+- [ ] I have included a list of my configuration changes in the PR description (under **Changes**)
 
-If you're making configuration or infrastructure changes, please remember to check you've updated the related infrastructure code in the autogpt_platform/infra folder.
+<details>
+  <summary>Examples of configuration changes</summary>
 
-Examples of such changes might include: 
-
-- Changing ports
-- Adding new services that need to communicate with each other
-- Secrets or environment variable changes
-- New or infrastructure changes such as databases
+  - Changing ports
+  - Adding new services that need to communicate with each other
+  - Secrets or environment variable changes
+  - New or infrastructure changes such as databases
+</details>

.github/copilot-instructions.md

@@ -0,0 +1,244 @@
+# GitHub Copilot Instructions for AutoGPT
+
+This file provides comprehensive onboarding information for GitHub Copilot coding agent to work efficiently with the AutoGPT repository.
+
+## Repository Overview
+
+**AutoGPT** is a powerful platform for creating, deploying, and managing continuous AI agents that automate complex workflows. This is a large monorepo (~150MB) containing multiple components:
+
+- **AutoGPT Platform** (`autogpt_platform/`) - Main focus: Modern AI agent platform (Polyform Shield License)
+- **Classic AutoGPT** (`classic/`) - Legacy agent system (MIT License)
+- **Documentation** (`docs/`) - MkDocs-based documentation site
+- **Infrastructure** - Docker configurations, CI/CD, and development tools
+
+**Primary Languages & Frameworks:**
+- **Backend**: Python 3.10-3.13, FastAPI, Prisma ORM, PostgreSQL, RabbitMQ
+- **Frontend**: TypeScript, Next.js 15, React, Tailwind CSS, Radix UI
+- **Development**: Docker, Poetry, pnpm, Playwright, Storybook
+
+## Build and Validation Instructions
+
+### Essential Setup Commands
+
+**Always run these commands in the correct directory and in this order:**
+
+1. **Initial Setup** (required once):
+   ```bash
+   # Clone and enter repository
+   git clone <repo> && cd AutoGPT
+   
+   # Start all services (database, redis, rabbitmq, clamav)
+   cd autogpt_platform && docker compose --profile local up deps --build --detach
+   ```
+
+2. **Backend Setup** (always run before backend development):
+   ```bash
+   cd autogpt_platform/backend
+   poetry install                    # Install dependencies
+   poetry run prisma migrate dev     # Run database migrations
+   poetry run prisma generate        # Generate Prisma client
+   ```
+
+3. **Frontend Setup** (always run before frontend development):
+   ```bash
+   cd autogpt_platform/frontend
+   pnpm install                      # Install dependencies
+   ```
+
+### Runtime Requirements
+
+**Critical:** Always ensure Docker services are running before starting development:
+```bash
+cd autogpt_platform && docker compose --profile local up deps --build --detach
+```
+
+**Python Version:** Use Python 3.11 (required; managed by Poetry via pyproject.toml)
+**Node.js Version:** Use Node.js 21+ with pnpm package manager
+
+### Development Commands
+
+**Backend Development:**
+```bash
+cd autogpt_platform/backend
+poetry run serve                     # Start development server (port 8000)
+poetry run test                      # Run all tests (requires ~5 minutes)
+poetry run pytest path/to/test.py    # Run specific test
+poetry run format                    # Format code (Black + isort) - always run first
+poetry run lint                      # Lint code (ruff) - run after format
+```
+
+**Frontend Development:**
+```bash
+cd autogpt_platform/frontend
+pnpm dev                            # Start development server (port 3000) - use for active development
+pnpm build                          # Build for production (only needed for E2E tests or deployment)
+pnpm test                           # Run Playwright E2E tests (requires build first)
+pnpm test-ui                        # Run tests with UI
+pnpm format                         # Format and lint code
+pnpm storybook                      # Start component development server
+```
+
+### Testing Strategy
+
+**Backend Tests:**
+- **Block Tests**: `poetry run pytest backend/blocks/test/test_block.py -xvs` (validates all blocks)
+- **Specific Block**: `poetry run pytest 'backend/blocks/test/test_block.py::test_available_blocks[BlockName]' -xvs`
+- **Snapshot Tests**: Use `--snapshot-update` when output changes, always review with `git diff`
+
+**Frontend Tests:**
+- **E2E Tests**: Always run `pnpm dev` before `pnpm test` (Playwright requires running instance)
+- **Component Tests**: Use Storybook for isolated component development
+
+### Critical Validation Steps
+
+**Before committing changes:**
+1. Run `poetry run format` (backend) and `pnpm format` (frontend)
+2. Ensure all tests pass in modified areas
+3. Verify Docker services are still running
+4. Check that database migrations apply cleanly
+
+**Common Issues & Workarounds:**
+- **Prisma issues**: Run `poetry run prisma generate` after schema changes
+- **Permission errors**: Ensure Docker has proper permissions
+- **Port conflicts**: Check the `docker-compose.yml` file for the current list of exposed ports. You can list all mapped ports with:
+- **Test timeouts**: Backend tests can take 5+ minutes, use `-x` flag to stop on first failure
+
+## Project Layout & Architecture
+
+### Core Architecture
+
+**AutoGPT Platform** (`autogpt_platform/`):
+- `backend/` - FastAPI server with async support
+  - `backend/backend/` - Core API logic
+  - `backend/blocks/` - Agent execution blocks
+  - `backend/data/` - Database models and schemas
+  - `schema.prisma` - Database schema definition
+- `frontend/` - Next.js application
+  - `src/app/` - App Router pages and layouts
+  - `src/components/` - Reusable React components
+  - `src/lib/` - Utilities and configurations
+- `autogpt_libs/` - Shared Python utilities
+- `docker-compose.yml` - Development stack orchestration
+
+**Key Configuration Files:**
+- `pyproject.toml` - Python dependencies and tooling
+- `package.json` - Node.js dependencies and scripts
+- `schema.prisma` - Database schema and migrations
+- `next.config.mjs` - Next.js configuration
+- `tailwind.config.ts` - Styling configuration
+
+### Security & Middleware
+
+**Cache Protection**: Backend includes middleware preventing sensitive data caching in browsers/proxies
+**Authentication**: JWT-based with Supabase integration
+**User ID Validation**: All data access requires user ID checks - verify this for any `data/*.py` changes
+
+### Development Workflow
+
+**GitHub Actions**: Multiple CI/CD workflows in `.github/workflows/`
+- `platform-backend-ci.yml` - Backend testing and validation
+- `platform-frontend-ci.yml` - Frontend testing and validation
+- `platform-fullstack-ci.yml` - End-to-end integration tests
+
+**Pre-commit Hooks**: Run linting and formatting checks
+**Conventional Commits**: Use format `type(scope): description` (e.g., `feat(backend): add API`)
+
+### Key Source Files
+
+**Backend Entry Points:**
+- `backend/backend/server/server.py` - FastAPI application setup
+- `backend/backend/data/` - Database models and user management
+- `backend/blocks/` - Agent execution blocks and logic
+
+**Frontend Entry Points:**
+- `frontend/src/app/layout.tsx` - Root application layout
+- `frontend/src/app/page.tsx` - Home page
+- `frontend/src/lib/supabase/` - Authentication and database client
+
+**Protected Routes**: Update `frontend/lib/supabase/middleware.ts` when adding protected routes
+
+### Agent Block System
+
+Agents are built using a visual block-based system where each block performs a single action. Blocks are defined in `backend/blocks/` and must include:
+- Block definition with input/output schemas
+- Execution logic with proper error handling
+- Tests validating functionality
+
+### Database & ORM
+
+**Prisma ORM** with PostgreSQL backend including pgvector for embeddings:
+- Schema in `schema.prisma`
+- Migrations in `backend/migrations/`
+- Always run `prisma migrate dev` and `prisma generate` after schema changes
+
+## Environment Configuration
+
+### Configuration Files Priority Order
+1. **Backend**: `/backend/.env.default` → `/backend/.env` (user overrides)
+2. **Frontend**: `/frontend/.env.default` → `/frontend/.env` (user overrides)  
+3. **Platform**: `/.env.default` (Supabase/shared) → `/.env` (user overrides)
+4. Docker Compose `environment:` sections override file-based config
+5. Shell environment variables have highest precedence
+
+### Docker Environment Setup
+- All services use hardcoded defaults (no `${VARIABLE}` substitutions)
+- The `env_file` directive loads variables INTO containers at runtime
+- Backend/Frontend services use YAML anchors for consistent configuration
+- Copy `.env.default` files to `.env` for local development customization
+
+## Advanced Development Patterns
+
+### Adding New Blocks
+1. Create file in `/backend/backend/blocks/`
+2. Inherit from `Block` base class with input/output schemas
+3. Implement `run` method with proper error handling
+4. Generate block UUID using `uuid.uuid4()`
+5. Register in block registry
+6. Write tests alongside block implementation
+7. Consider how inputs/outputs connect with other blocks in graph editor
+
+### API Development
+1. Update routes in `/backend/backend/server/routers/`
+2. Add/update Pydantic models in same directory
+3. Write tests alongside route files
+4. For `data/*.py` changes, validate user ID checks
+5. Run `poetry run test` to verify changes
+
+### Frontend Development
+1. Components in `/frontend/src/components/`
+2. Use existing UI components from `/frontend/src/components/ui/`
+3. Add Storybook stories for component development
+4. Test user-facing features with Playwright E2E tests
+5. Update protected routes in middleware when needed
+
+### Security Guidelines
+**Cache Protection Middleware** (`/backend/backend/server/middleware/security.py`):
+- Default: Disables caching for ALL endpoints with `Cache-Control: no-store, no-cache, must-revalidate, private`
+- Uses allow list approach for cacheable paths (static assets, health checks, public pages)
+- Prevents sensitive data caching in browsers/proxies
+- Add new cacheable endpoints to `CACHEABLE_PATHS`
+
+### CI/CD Alignment
+The repository has comprehensive CI workflows that test:
+- **Backend**: Python 3.11-3.13, services (Redis/RabbitMQ/ClamAV), Prisma migrations, Poetry lock validation
+- **Frontend**: Node.js 21, pnpm, Playwright with Docker Compose stack, API schema validation
+- **Integration**: Full-stack type checking and E2E testing
+
+Match these patterns when developing locally - the copilot setup environment mirrors these CI configurations.
+
+## Collaboration with Other AI Assistants
+
+This repository is actively developed with assistance from Claude (via CLAUDE.md files). When working on this codebase:
+- Check for existing CLAUDE.md files that provide additional context
+- Follow established patterns and conventions already in the codebase
+- Maintain consistency with existing code style and architecture
+- Consider that changes may be reviewed and extended by both human developers and AI assistants
+
+## Trust These Instructions
+
+These instructions are comprehensive and tested. Only perform additional searches if:
+1. Information here is incomplete for your specific task
+2. You encounter errors not covered by the workarounds
+3. You need to understand implementation details not covered above
+
+For detailed platform development patterns, refer to `autogpt_platform/CLAUDE.md` and `AGENTS.md` in the repository root.

.github/dependabot.yml

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

.github/labeler.yml

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

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

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

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

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

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

@@ -2,7 +2,7 @@ name: Classic - AutoGPT Docker CI
 
 on:
   push:
-    branches: [ master, development ]
+    branches: [master, dev]
     paths:
       - '.github/workflows/classic-autogpt-docker-ci.yml'
       - 'classic/original_autogpt/**'
@@ -34,58 +34,58 @@ jobs:
       matrix:
         build-type: [release, dev]
     steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
+      - name: Checkout repository
+        uses: actions/checkout@v4
 
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
 
-    - if: runner.debug
-      run: |
-        ls -al
-        du -hs *
+      - if: runner.debug
+        run: |
+          ls -al
+          du -hs *
 
-    - id: build
-      name: Build image
-      uses: docker/build-push-action@v5
-      with:
-        context: classic/
-        file: classic/Dockerfile.autogpt
-        build-args: BUILD_TYPE=${{ matrix.build-type }}
-        tags: ${{ env.IMAGE_NAME }}
-        labels: GIT_REVISION=${{ github.sha }}
-        load: true    # save to docker images
-        # cache layers in GitHub Actions cache to speed up builds
-        cache-from: type=gha,scope=autogpt-docker-${{ matrix.build-type }}
-        cache-to: type=gha,scope=autogpt-docker-${{ matrix.build-type }},mode=max
+      - id: build
+        name: Build image
+        uses: docker/build-push-action@v6
+        with:
+          context: classic/
+          file: classic/Dockerfile.autogpt
+          build-args: BUILD_TYPE=${{ matrix.build-type }}
+          tags: ${{ env.IMAGE_NAME }}
+          labels: GIT_REVISION=${{ github.sha }}
+          load: true # save to docker images
+          # cache layers in GitHub Actions cache to speed up builds
+          cache-from: type=gha,scope=autogpt-docker-${{ matrix.build-type }}
+          cache-to: type=gha,scope=autogpt-docker-${{ matrix.build-type }},mode=max
 
-    - name: Generate build report
-      env:
-        event_name: ${{ github.event_name }}
-        event_ref: ${{ github.event.ref }}
-        event_ref_type: ${{ github.event.ref}}
+      - name: Generate build report
+        env:
+          event_name: ${{ github.event_name }}
+          event_ref: ${{ github.event.ref }}
+          event_ref_type: ${{ github.event.ref}}
 
-        build_type: ${{ matrix.build-type }}
+          build_type: ${{ matrix.build-type }}
 
-        prod_branch: master
-        dev_branch: development
-        repository: ${{ github.repository }}
-        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'development' && 'development' || 'master' }}
+          prod_branch: master
+          dev_branch: dev
+          repository: ${{ github.repository }}
+          base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'dev' && 'dev' || 'master' }}
 
-        current_ref: ${{ github.ref_name }}
-        commit_hash: ${{ github.event.after }}
-        source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.event.release && github.event.release.tag_name || github.sha) }}
-        push_forced_label: ${{ github.event.forced && '☢️ forced' || '' }}
+          current_ref: ${{ github.ref_name }}
+          commit_hash: ${{ github.event.after }}
+          source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.event.release && github.event.release.tag_name || github.sha) }}
+          push_forced_label: ${{ github.event.forced && '☢️ forced' || '' }}
 
-        new_commits_json: ${{ toJSON(github.event.commits) }}
-        compare_url_template: ${{ format('/{0}/compare/{{base}}...{{head}}', github.repository) }}
+          new_commits_json: ${{ toJSON(github.event.commits) }}
+          compare_url_template: ${{ format('/{0}/compare/{{base}}...{{head}}', github.repository) }}
 
-        github_context_json: ${{ toJSON(github) }}
-        job_env_json: ${{ toJSON(env) }}
-        vars_json: ${{ toJSON(vars) }}
+          github_context_json: ${{ toJSON(github) }}
+          job_env_json: ${{ toJSON(env) }}
+          vars_json: ${{ toJSON(vars) }}
 
-      run: .github/workflows/scripts/docker-ci-summary.sh >> $GITHUB_STEP_SUMMARY
-      continue-on-error: true
+        run: .github/workflows/scripts/docker-ci-summary.sh >> $GITHUB_STEP_SUMMARY
+        continue-on-error: true
 
   test:
     runs-on: ubuntu-latest
@@ -117,16 +117,16 @@ jobs:
 
       - id: build
         name: Build image
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v6
         with:
           context: classic/
           file: classic/Dockerfile.autogpt
-          build-args: BUILD_TYPE=dev  # include pytest
+          build-args: BUILD_TYPE=dev # include pytest
           tags: >
             ${{ env.IMAGE_NAME }},
             ${{ env.DEPLOY_IMAGE_NAME }}:${{ env.DEV_IMAGE_TAG }}
           labels: GIT_REVISION=${{ github.sha }}
-          load: true                  # save to docker images
+          load: true # save to docker images
           # cache layers in GitHub Actions cache to speed up builds
           cache-from: type=gha,scope=autogpt-docker-dev
           cache-to: type=gha,scope=autogpt-docker-dev,mode=max

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

@@ -2,7 +2,7 @@ name: Classic - AutoGPT Docker Release
 
 on:
   release:
-    types: [ published, edited ]
+    types: [published, edited]
 
   workflow_dispatch:
     inputs:
@@ -19,69 +19,69 @@ jobs:
     if: startsWith(github.ref, 'refs/tags/autogpt-')
     runs-on: ubuntu-latest
     steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
+      - name: Checkout repository
+        uses: actions/checkout@v4
 
-    - name: Log in to Docker hub
-      uses: docker/login-action@v3
-      with:
-        username: ${{ secrets.DOCKER_USER }}
-        password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Log in to Docker hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USER }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
 
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
 
-      # slashes are not allowed in image tags, but can appear in git branch or tag names
-    - id: sanitize_tag
-      name: Sanitize image tag
-      run: |
-        tag=${raw_tag//\//-}
-        echo tag=${tag#autogpt-} >> $GITHUB_OUTPUT
-      env:
-        raw_tag: ${{ github.ref_name }}
+        # slashes are not allowed in image tags, but can appear in git branch or tag names
+      - id: sanitize_tag
+        name: Sanitize image tag
+        run: |
+          tag=${raw_tag//\//-}
+          echo tag=${tag#autogpt-} >> $GITHUB_OUTPUT
+        env:
+          raw_tag: ${{ github.ref_name }}
 
-    - id: build
-      name: Build image
-      uses: docker/build-push-action@v5
-      with:
-        context: classic/
-        file: Dockerfile.autogpt
-        build-args: BUILD_TYPE=release
-        load: true    # save to docker images
-        # push: true  # TODO: uncomment when this issue is fixed: https://github.com/moby/buildkit/issues/1555
-        tags: >
-          ${{ env.IMAGE_NAME }},
-          ${{ env.DEPLOY_IMAGE_NAME }}:latest,
-          ${{ env.DEPLOY_IMAGE_NAME }}:${{ steps.sanitize_tag.outputs.tag }}
-        labels: GIT_REVISION=${{ github.sha }}
+      - id: build
+        name: Build image
+        uses: docker/build-push-action@v6
+        with:
+          context: classic/
+          file: Dockerfile.autogpt
+          build-args: BUILD_TYPE=release
+          load: true # save to docker images
+          # push: true  # TODO: uncomment when this issue is fixed: https://github.com/moby/buildkit/issues/1555
+          tags: >
+            ${{ env.IMAGE_NAME }},
+            ${{ env.DEPLOY_IMAGE_NAME }}:latest,
+            ${{ env.DEPLOY_IMAGE_NAME }}:${{ steps.sanitize_tag.outputs.tag }}
+          labels: GIT_REVISION=${{ github.sha }}
 
-        # cache layers in GitHub Actions cache to speed up builds
-        cache-from: ${{ !inputs.no_cache && 'type=gha' || '' }},scope=autogpt-docker-release
-        cache-to: type=gha,scope=autogpt-docker-release,mode=max
+          # cache layers in GitHub Actions cache to speed up builds
+          cache-from: ${{ !inputs.no_cache && 'type=gha' || '' }},scope=autogpt-docker-release
+          cache-to: type=gha,scope=autogpt-docker-release,mode=max
 
-    - name: Push image to Docker Hub
-      run: docker push --all-tags ${{ env.DEPLOY_IMAGE_NAME }}
+      - name: Push image to Docker Hub
+        run: docker push --all-tags ${{ env.DEPLOY_IMAGE_NAME }}
 
-    - name: Generate build report
-      env:
-        event_name: ${{ github.event_name }}
-        event_ref: ${{ github.event.ref }}
-        event_ref_type: ${{ github.event.ref}}
-        inputs_no_cache: ${{ inputs.no_cache }}
+      - name: Generate build report
+        env:
+          event_name: ${{ github.event_name }}
+          event_ref: ${{ github.event.ref }}
+          event_ref_type: ${{ github.event.ref}}
+          inputs_no_cache: ${{ inputs.no_cache }}
 
-        prod_branch: master
-        dev_branch: development
-        repository: ${{ github.repository }}
-        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'development' && 'development' || 'master' }}
+          prod_branch: master
+          dev_branch: dev
+          repository: ${{ github.repository }}
+          base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'dev' && 'dev' || 'master' }}
 
-        ref_type: ${{ github.ref_type }}
-        current_ref: ${{ github.ref_name }}
-        commit_hash: ${{ github.sha }}
-        source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.event.release && github.event.release.tag_name || github.sha) }}
+          ref_type: ${{ github.ref_type }}
+          current_ref: ${{ github.ref_name }}
+          commit_hash: ${{ github.sha }}
+          source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.event.release && github.event.release.tag_name || github.sha) }}
 
-        github_context_json: ${{ toJSON(github) }}
-        job_env_json: ${{ toJSON(env) }}
-        vars_json: ${{ toJSON(vars) }}
+          github_context_json: ${{ toJSON(github) }}
+          job_env_json: ${{ toJSON(env) }}
+          vars_json: ${{ toJSON(vars) }}
 
-      run: .github/workflows/scripts/docker-release-summary.sh >> $GITHUB_STEP_SUMMARY
-      continue-on-error: true
+        run: .github/workflows/scripts/docker-release-summary.sh >> $GITHUB_STEP_SUMMARY
+        continue-on-error: true

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

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

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

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

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

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

.github/workflows/claude.yml

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

.github/workflows/codeql.yml

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

.github/workflows/copilot-setup-steps.yml

@@ -0,0 +1,302 @@
+name: "Copilot Setup Steps"
+
+# Automatically run the setup steps when they are changed to allow for easy validation, and
+# allow manual testing through the repository's "Actions" tab
+on:
+  workflow_dispatch:
+  push:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+  pull_request:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+
+jobs:
+  # The job MUST be called `copilot-setup-steps` or it will not be picked up by Copilot.
+  copilot-setup-steps:
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+
+    # Set the permissions to the lowest permissions possible needed for your steps.
+    # Copilot will be given its own token for its operations.
+    permissions:
+      # If you want to clone the repository as part of your setup steps, for example to install dependencies, you'll need the `contents: read` permission. If you don't clone the repository in your setup steps, Copilot will do this for you automatically after the steps complete.
+      contents: read
+
+    # You can define any steps you want, and they will run before the agent starts.
+    # If you do not check out your code, Copilot will do this for you.
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      # Backend Python/Poetry setup (mirrors platform-backend-ci.yml)
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"  # Use standard version matching CI
+
+      - name: Set up Python dependency cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pypoetry
+          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
+
+      - name: Install Poetry
+        run: |
+          # Extract Poetry version from backend/poetry.lock (matches CI)
+          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"
+          
+          # Install Poetry
+          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
+          
+          # Add Poetry to PATH
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+      - name: Check poetry.lock
+        working-directory: autogpt_platform/backend
+        run: |
+          poetry lock
+          if ! git diff --quiet --ignore-matching-lines="^# " poetry.lock; then
+            echo "Warning: poetry.lock not up to date, but continuing for setup"
+            git checkout poetry.lock  # Reset for clean setup
+          fi
+
+      - name: Install Python dependencies
+        working-directory: autogpt_platform/backend
+        run: poetry install
+
+      - name: Generate Prisma Client
+        working-directory: autogpt_platform/backend
+        run: poetry run prisma generate
+
+      # Frontend Node.js/pnpm setup (mirrors platform-frontend-ci.yml)
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "21"
+
+      - name: Enable corepack
+        run: corepack enable
+
+      - name: Set pnpm store directory
+        run: |
+          pnpm config set store-dir ~/.pnpm-store
+          echo "PNPM_HOME=$HOME/.pnpm-store" >> $GITHUB_ENV
+
+      - name: Cache frontend dependencies
+        uses: actions/cache@v4
+        with:
+          path: ~/.pnpm-store
+          key: ${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml', 'autogpt_platform/frontend/package.json') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml') }}
+            ${{ runner.os }}-pnpm-
+
+      - name: Install JavaScript dependencies
+        working-directory: autogpt_platform/frontend
+        run: pnpm install --frozen-lockfile
+
+      # Install Playwright browsers for frontend testing
+      # NOTE: Disabled to save ~1 minute of setup time. Re-enable if Copilot needs browser automation (e.g., for MCP)
+      # - name: Install Playwright browsers
+      #   working-directory: autogpt_platform/frontend
+      #   run: pnpm playwright install --with-deps chromium
+
+      # Docker setup for development environment
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Copy default environment files
+        working-directory: autogpt_platform
+        run: |
+          # Copy default environment files for development
+          cp .env.default .env
+          cp backend/.env.default backend/.env
+          cp frontend/.env.default frontend/.env
+
+      # Phase 1: Cache and load Docker images for faster setup
+      - name: Set up Docker image cache
+        id: docker-cache
+        uses: actions/cache@v4
+        with:
+          path: ~/docker-cache
+          # Use a versioned key for cache invalidation when image list changes
+          key: docker-images-v2-${{ runner.os }}-${{ hashFiles('.github/workflows/copilot-setup-steps.yml') }}
+          restore-keys: |
+            docker-images-v2-${{ runner.os }}-
+            docker-images-v1-${{ runner.os }}-
+
+      - name: Load or pull Docker images
+        working-directory: autogpt_platform
+        run: |
+          mkdir -p ~/docker-cache
+          
+          # Define image list for easy maintenance
+          IMAGES=(
+            "redis:latest"
+            "rabbitmq:management"
+            "clamav/clamav-debian:latest"
+            "busybox:latest"
+            "kong:2.8.1"
+            "supabase/gotrue:v2.170.0"
+            "supabase/postgres:15.8.1.049"
+            "supabase/postgres-meta:v0.86.1"
+            "supabase/studio:20250224-d10db0f"
+          )
+          
+          # Check if any cached tar files exist (more reliable than cache-hit)
+          if ls ~/docker-cache/*.tar 1> /dev/null 2>&1; then
+            echo "Docker cache found, loading images in parallel..."
+            for image in "${IMAGES[@]}"; do
+              # Convert image name to filename (replace : and / with -)
+              filename=$(echo "$image" | tr ':/' '--')
+              if [ -f ~/docker-cache/${filename}.tar ]; then
+                echo "Loading $image..."
+                docker load -i ~/docker-cache/${filename}.tar || echo "Warning: Failed to load $image from cache" &
+              fi
+            done
+            wait
+            echo "All cached images loaded"
+          else
+            echo "No Docker cache found, pulling images in parallel..."
+            # Pull all images in parallel
+            for image in "${IMAGES[@]}"; do
+              docker pull "$image" &
+            done
+            wait
+            
+            # Only save cache on main branches (not PRs) to avoid cache pollution
+            if [[ "${{ github.ref }}" == "refs/heads/master" ]] || [[ "${{ github.ref }}" == "refs/heads/dev" ]]; then
+              echo "Saving Docker images to cache in parallel..."
+              for image in "${IMAGES[@]}"; do
+                # Convert image name to filename (replace : and / with -)
+                filename=$(echo "$image" | tr ':/' '--')
+                echo "Saving $image..."
+                docker save -o ~/docker-cache/${filename}.tar "$image" || echo "Warning: Failed to save $image" &
+              done
+              wait
+              echo "Docker image cache saved"
+            else
+              echo "Skipping cache save for PR/feature branch"
+            fi
+          fi
+          
+          echo "Docker images ready for use"
+
+      # Phase 2: Build migrate service with GitHub Actions cache
+      - name: Build migrate Docker image with cache
+        working-directory: autogpt_platform
+        run: |
+          # Build the migrate image with buildx for GHA caching
+          docker buildx build \
+            --cache-from type=gha \
+            --cache-to type=gha,mode=max \
+            --target migrate \
+            --tag autogpt_platform-migrate:latest \
+            --load \
+            -f backend/Dockerfile \
+            ..
+
+      # Start services using pre-built images
+      - name: Start Docker services for development
+        working-directory: autogpt_platform
+        run: |
+          # Start essential services (migrate image already built with correct tag)
+          docker compose --profile local up deps --no-build --detach
+          echo "Waiting for services to be ready..."
+          
+          # Wait for database to be ready
+          echo "Checking database readiness..."
+          timeout 30 sh -c 'until docker compose exec -T db pg_isready -U postgres 2>/dev/null; do 
+            echo "  Waiting for database..."
+            sleep 2
+          done' && echo "✅ Database is ready" || echo "⚠️ Database ready check timeout after 30s, continuing..."
+          
+          # Check migrate service status
+          echo "Checking migration status..."
+          docker compose ps migrate || echo "  Migrate service not visible in ps output"
+          
+          # Wait for migrate service to complete
+          echo "Waiting for migrations to complete..."
+          timeout 30 bash -c '
+            ATTEMPTS=0
+            while [ $ATTEMPTS -lt 15 ]; do
+              ATTEMPTS=$((ATTEMPTS + 1))
+              
+              # Check using docker directly (more reliable than docker compose ps)
+              CONTAINER_STATUS=$(docker ps -a --filter "label=com.docker.compose.service=migrate" --format "{{.Status}}" | head -1)
+              
+              if [ -z "$CONTAINER_STATUS" ]; then
+                echo "  Attempt $ATTEMPTS: Migrate container not found yet..."
+              elif echo "$CONTAINER_STATUS" | grep -q "Exited (0)"; then
+                echo "✅ Migrations completed successfully"
+                docker compose logs migrate --tail=5 2>/dev/null || true
+                exit 0
+              elif echo "$CONTAINER_STATUS" | grep -q "Exited ([1-9]"; then
+                EXIT_CODE=$(echo "$CONTAINER_STATUS" | grep -oE "Exited \([0-9]+\)" | grep -oE "[0-9]+")
+                echo "❌ Migrations failed with exit code: $EXIT_CODE"
+                echo "Migration logs:"
+                docker compose logs migrate --tail=20 2>/dev/null || true
+                exit 1
+              elif echo "$CONTAINER_STATUS" | grep -q "Up"; then
+                echo "  Attempt $ATTEMPTS: Migrate container is running... ($CONTAINER_STATUS)"
+              else
+                echo "  Attempt $ATTEMPTS: Migrate container status: $CONTAINER_STATUS"
+              fi
+              
+              sleep 2
+            done
+            
+            echo "⚠️ Timeout: Could not determine migration status after 30 seconds"
+            echo "Final container check:"
+            docker ps -a --filter "label=com.docker.compose.service=migrate" || true
+            echo "Migration logs (if available):"
+            docker compose logs migrate --tail=10 2>/dev/null || echo "  No logs available"
+          ' || echo "⚠️ Migration check completed with warnings, continuing..."
+          
+          # Brief wait for other services to stabilize
+          echo "Waiting 5 seconds for other services to stabilize..."
+          sleep 5
+
+      # Verify installations and provide environment info
+      - name: Verify setup and show environment info
+        run: |
+          echo "=== Python Setup ==="
+          python --version
+          poetry --version
+          
+          echo "=== Node.js Setup ==="
+          node --version
+          pnpm --version
+          
+          echo "=== Additional Tools ==="
+          docker --version
+          docker compose version
+          gh --version || true
+          
+          echo "=== Services Status ==="
+          cd autogpt_platform
+          docker compose ps || true
+          
+          echo "=== Backend Dependencies ==="
+          cd backend
+          poetry show | head -10 || true
+          
+          echo "=== Frontend Dependencies ==="
+          cd ../frontend
+          pnpm list --depth=0 | head -10 || true
+          
+          echo "=== Environment Files ==="
+          ls -la ../.env* || true
+          ls -la .env* || true
+          ls -la ../backend/.env* || true
+          
+          echo "✅ AutoGPT Platform development environment setup complete!"
+          echo "🚀 Ready for development with Docker services running"
+          echo "📝 Backend server: poetry run serve (port 8000)"
+          echo "🌐 Frontend server: pnpm dev (port 3000)"

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

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

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

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

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

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

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

@@ -1,56 +0,0 @@
-name: AutoGPT Platform - Infra
-
-on:
-  push:
-    branches: [ master, dev ]
-    paths:
-      - '.github/workflows/platform-autogpt-infra-ci.yml'
-      - 'autogpt_platform/infra/**'
-  pull_request:
-    paths:
-      - '.github/workflows/platform-autogpt-infra-ci.yml'
-      - 'autogpt_platform/infra/**'
-
-defaults:
-  run:
-    shell: bash
-    working-directory: autogpt_platform/infra
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: TFLint
-        uses: pauloconnor/tflint-action@v0.0.2
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-            tflint_path: terraform/
-            tflint_recurse: true
-            tflint_changed_only: false
-
-      - name: Set up Helm
-        uses: azure/setup-helm@v4
-        with:
-          version: v3.14.4
-
-      - name: Set up chart-testing
-        uses: helm/chart-testing-action@v2.6.1
-
-      - name: Run chart-testing (list-changed)
-        id: list-changed
-        run: |
-          changed=$(ct list-changed --target-branch ${{ github.event.repository.default_branch }})
-          if [[ -n "$changed" ]]; then
-            echo "changed=true" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Run chart-testing (lint)
-        if: steps.list-changed.outputs.changed == 'true'
-        run: ct lint --target-branch ${{ github.event.repository.default_branch }}

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

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

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

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

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

@@ -10,6 +10,7 @@ on:
     paths:
       - ".github/workflows/platform-frontend-ci.yml"
       - "autogpt_platform/frontend/**"
+  merge_group:
 
 defaults:
   run:
@@ -17,44 +18,118 @@ defaults:
     working-directory: autogpt_platform/frontend
 
 jobs:
-  lint:
+  setup:
     runs-on: ubuntu-latest
+    outputs:
+      cache-key: ${{ steps.cache-key.outputs.key }}
 
     steps:
-      - uses: actions/checkout@v4
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
           node-version: "21"
 
+      - name: Enable corepack
+        run: corepack enable
+
+      - name: Generate cache key
+        id: cache-key
+        run: echo "key=${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml', 'autogpt_platform/frontend/package.json') }}" >> $GITHUB_OUTPUT
+
+      - name: Cache dependencies
+        uses: actions/cache@v4
+        with:
+          path: ~/.pnpm-store
+          key: ${{ steps.cache-key.outputs.key }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml') }}
+            ${{ runner.os }}-pnpm-
+
       - name: Install dependencies
-        run: |
-          yarn install --frozen-lockfile
+        run: pnpm install --frozen-lockfile
 
-      - name: Run lint
-        run: |
-          yarn lint
-
-  test:
+  lint:
     runs-on: ubuntu-latest
+    needs: setup
 
     steps:
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
         with:
-          # this might remove tools that are actually needed,
-          # if set to "true" but frees about 6 GB
-          tool-cache: false
+          node-version: "21"
 
-          # all of these default to true, but feel free to set to
-          # "false" if necessary for your workflow
-          android: false
-          dotnet: false
-          haskell: false
-          large-packages: true
-          docker-images: true
-          swap-storage: true
+      - name: Enable corepack
+        run: corepack enable
 
+      - name: Restore dependencies cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.pnpm-store
+          key: ${{ needs.setup.outputs.cache-key }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml') }}
+            ${{ runner.os }}-pnpm-
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Run lint
+        run: pnpm lint
+
+  chromatic:
+    runs-on: ubuntu-latest
+    needs: setup
+    # Only run on dev branch pushes or PRs targeting dev
+    if: github.ref == 'refs/heads/dev' || github.base_ref == 'dev'
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "21"
+
+      - name: Enable corepack
+        run: corepack enable
+
+      - name: Restore dependencies cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.pnpm-store
+          key: ${{ needs.setup.outputs.cache-key }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml') }}
+            ${{ runner.os }}-pnpm-
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Run Chromatic
+        uses: chromaui/action@latest
+        with:
+          projectToken: chpt_9e7c1a76478c9c8
+          onlyChanged: true
+          workingDir: autogpt_platform/frontend
+          token: ${{ secrets.GITHUB_TOKEN }}
+          exitOnceUploaded: true
+
+  test:
+    runs-on: big-boi
+    needs: setup
+    strategy:
+      fail-fast: false
+
+    steps:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
@@ -65,32 +140,96 @@ jobs:
         with:
           node-version: "21"
 
+      - name: Enable corepack
+        run: corepack enable
+
       - name: Copy default supabase .env
         run: |
-          cp ../supabase/docker/.env.example ../.env
+          cp ../.env.default ../.env
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Cache Docker layers
+        uses: actions/cache@v4
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-buildx-frontend-test-${{ hashFiles('autogpt_platform/docker-compose.yml', 'autogpt_platform/backend/Dockerfile', 'autogpt_platform/backend/pyproject.toml', 'autogpt_platform/backend/poetry.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-buildx-frontend-test-
 
       - name: Run docker compose
         run: |
           docker compose -f ../docker-compose.yml up -d
+        env:
+          DOCKER_BUILDKIT: 1
+          BUILDX_CACHE_FROM: type=local,src=/tmp/.buildx-cache
+          BUILDX_CACHE_TO: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+      - name: Move cache
+        run: |
+          rm -rf /tmp/.buildx-cache
+          if [ -d "/tmp/.buildx-cache-new" ]; then
+            mv /tmp/.buildx-cache-new /tmp/.buildx-cache
+          fi
+
+      - name: Wait for services to be ready
+        run: |
+          echo "Waiting for rest_server to be ready..."
+          timeout 60 sh -c 'until curl -f http://localhost:8006/health 2>/dev/null; do sleep 2; done' || echo "Rest server health check timeout, continuing..."
+          echo "Waiting for database to be ready..."
+          timeout 60 sh -c 'until docker compose -f ../docker-compose.yml exec -T db pg_isready -U postgres 2>/dev/null; do sleep 2; done' || echo "Database ready check timeout, continuing..."
+
+      - name: Create E2E test data
+        run: |
+          echo "Creating E2E test data..."
+          # First try to run the script from inside the container
+          if docker compose -f ../docker-compose.yml exec -T rest_server test -f /app/autogpt_platform/backend/test/e2e_test_data.py; then
+            echo "✅ Found e2e_test_data.py in container, running it..."
+            docker compose -f ../docker-compose.yml exec -T rest_server sh -c "cd /app/autogpt_platform && python backend/test/e2e_test_data.py" || {
+              echo "❌ E2E test data creation failed!"
+              docker compose -f ../docker-compose.yml logs --tail=50 rest_server
+              exit 1
+            }
+          else
+            echo "⚠️ e2e_test_data.py not found in container, copying and running..."
+            # Copy the script into the container and run it
+            docker cp ../backend/test/e2e_test_data.py $(docker compose -f ../docker-compose.yml ps -q rest_server):/tmp/e2e_test_data.py || {
+              echo "❌ Failed to copy script to container"
+              exit 1
+            }
+            docker compose -f ../docker-compose.yml exec -T rest_server sh -c "cd /app/autogpt_platform && python /tmp/e2e_test_data.py" || {
+              echo "❌ E2E test data creation failed!"
+              docker compose -f ../docker-compose.yml logs --tail=50 rest_server
+              exit 1
+            }
+          fi
+
+      - name: Restore dependencies cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.pnpm-store
+          key: ${{ needs.setup.outputs.cache-key }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml') }}
+            ${{ runner.os }}-pnpm-
 
       - name: Install dependencies
-        run: |
-          yarn install --frozen-lockfile
+        run: pnpm install --frozen-lockfile
 
-      - name: Setup Builder .env
-        run: |
-          cp .env.example .env
+      - name: Install Browser 'chromium'
+        run: pnpm playwright install --with-deps chromium
 
-      - name: Install Playwright Browsers
-        run: yarn playwright install --with-deps
+      - name: Run Playwright tests
+        run: pnpm test:no-build
 
-      - name: Run tests
-        run: |
-          yarn test
-
-      - uses: actions/upload-artifact@v4
-        if: ${{ !cancelled() }}
+      - name: Upload Playwright artifacts
+        if: failure()
+        uses: actions/upload-artifact@v4
         with:
           name: playwright-report
-          path: playwright-report/
-          retention-days: 30
+          path: playwright-report
+
+      - name: Print Final Docker Compose logs
+        if: always()
+        run: docker compose -f ../docker-compose.yml logs

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

@@ -0,0 +1,132 @@
+name: AutoGPT Platform - Frontend CI
+
+on:
+  push:
+    branches: [master, dev]
+    paths:
+      - ".github/workflows/platform-fullstack-ci.yml"
+      - "autogpt_platform/**"
+  pull_request:
+    paths:
+      - ".github/workflows/platform-fullstack-ci.yml"
+      - "autogpt_platform/**"
+  merge_group:
+
+defaults:
+  run:
+    shell: bash
+    working-directory: autogpt_platform/frontend
+
+jobs:
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      cache-key: ${{ steps.cache-key.outputs.key }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "21"
+
+      - name: Enable corepack
+        run: corepack enable
+
+      - name: Generate cache key
+        id: cache-key
+        run: echo "key=${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml', 'autogpt_platform/frontend/package.json') }}" >> $GITHUB_OUTPUT
+
+      - name: Cache dependencies
+        uses: actions/cache@v4
+        with:
+          path: ~/.pnpm-store
+          key: ${{ steps.cache-key.outputs.key }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml') }}
+            ${{ runner.os }}-pnpm-
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+  types:
+    runs-on: ubuntu-latest
+    needs: setup
+    strategy:
+      fail-fast: false
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "21"
+
+      - name: Enable corepack
+        run: corepack enable
+
+      - name: Copy default supabase .env
+        run: |
+          cp ../.env.default ../.env
+
+      - name: Copy backend .env
+        run: |
+          cp ../backend/.env.default ../backend/.env
+
+      - name: Run docker compose
+        run: |
+          docker compose -f ../docker-compose.yml --profile local --profile deps_backend up -d
+
+      - name: Restore dependencies cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.pnpm-store
+          key: ${{ needs.setup.outputs.cache-key }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Setup .env
+        run: cp .env.default .env
+
+      - name: Wait for services to be ready
+        run: |
+          echo "Waiting for rest_server to be ready..."
+          timeout 60 sh -c 'until curl -f http://localhost:8006/health 2>/dev/null; do sleep 2; done' || echo "Rest server health check timeout, continuing..."
+          echo "Waiting for database to be ready..."
+          timeout 60 sh -c 'until docker compose -f ../docker-compose.yml exec -T db pg_isready -U postgres 2>/dev/null; do sleep 2; done' || echo "Database ready check timeout, continuing..."
+
+      - name: Generate API queries
+        run: pnpm generate:api:force
+
+      - name: Check for API schema changes
+        run: |
+          if ! git diff --exit-code src/app/api/openapi.json; then
+            echo "❌ API schema changes detected in src/app/api/openapi.json"
+            echo ""
+            echo "The openapi.json file has been modified after running 'pnpm generate:api-all'."
+            echo "This usually means changes have been made in the BE endpoints without updating the Frontend."
+            echo "The API schema is now out of sync with the Front-end queries."
+            echo ""
+            echo "To fix this:"
+            echo "1. Pull the backend 'docker compose pull && docker compose up -d --build --force-recreate'"
+            echo "2. Run 'pnpm generate:api' locally"
+            echo "3. Run 'pnpm types' locally"
+            echo "4. Fix any TypeScript errors that may have been introduced"
+            echo "5. Commit and push your changes"
+            echo ""
+            exit 1
+          else
+            echo "✅ No API schema changes detected"
+          fi
+
+      - name: Run Typescript checks
+        run: pnpm types

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

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

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

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

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

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

.github/workflows/scripts/check_actions_status.py

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

.github/workflows/scripts/get_package_version_from_lockfile.py

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

.gitignore

@@ -5,6 +5,8 @@ classic/original_autogpt/*.json
 auto_gpt_workspace/*
 *.mpeg
 .env
+# Root .env files
+/.env
 azure.yaml
 .vscode
 .idea/*
@@ -121,7 +123,6 @@ celerybeat.pid
 
 # Environments
 .direnv/
-.env
 .venv
 env/
 venv*/
@@ -165,9 +166,15 @@ package-lock.json
 
 # Allow for locally private items
 # private
-pri* 
+pri*
 # ignore
 ig*
 .github_access_token
 LICENSE.rtf
 autogpt_platform/backend/settings.py
+/.auth
+/autogpt_platform/frontend/.auth
+
+*.ign.*
+.test-contents
+.claude/settings.local.json

.gitmodules

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

.pre-commit-config.yaml

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

.vscode/launch.json

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

AGENTS.md

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

CONTRIBUTING.md

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

LICENSE

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

README.md

@@ -1,24 +1,82 @@
 # AutoGPT: Build, Deploy, and Run AI Agents
 
-[![Discord Follow](https://dcbadge.vercel.app/api/server/autogpt?style=flat)](https://discord.gg/autogpt)  
+[![Discord Follow](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fdiscord.com%2Fapi%2Finvites%2Fautogpt%3Fwith_counts%3Dtrue&query=%24.approximate_member_count&label=total%20members&logo=discord&logoColor=white&color=7289da)](https://discord.gg/autogpt)  
 [![Twitter Follow](https://img.shields.io/twitter/follow/Auto_GPT?style=social)](https://twitter.com/Auto_GPT)  
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+<!-- Keep these links. Translations will automatically update with the README. -->
+[Deutsch](https://zdoc.app/de/Significant-Gravitas/AutoGPT) | 
+[Español](https://zdoc.app/es/Significant-Gravitas/AutoGPT) | 
+[français](https://zdoc.app/fr/Significant-Gravitas/AutoGPT) | 
+[日本語](https://zdoc.app/ja/Significant-Gravitas/AutoGPT) | 
+[한국어](https://zdoc.app/ko/Significant-Gravitas/AutoGPT) | 
+[Português](https://zdoc.app/pt/Significant-Gravitas/AutoGPT) | 
+[Русский](https://zdoc.app/ru/Significant-Gravitas/AutoGPT) | 
+[中文](https://zdoc.app/zh/Significant-Gravitas/AutoGPT)
 
 **AutoGPT** is a powerful platform that allows you to create, deploy, and manage continuous AI agents that automate complex workflows. 
 
 ## Hosting Options 
-   - Download to self-host
-   - [Join the Waitlist](https://bit.ly/3ZDijAI) for the cloud-hosted beta  
+   - Download to self-host (Free!)
+   - [Join the Waitlist](https://bit.ly/3ZDijAI) for the cloud-hosted beta (Closed Beta - Public release Coming Soon!)
 
-## How to Setup for Self-Hosting
+## How to Self-Host the AutoGPT Platform
 > [!NOTE]
 > Setting up and hosting the AutoGPT Platform yourself is a technical process. 
 > If you'd rather something that just works, we recommend [joining the waitlist](https://bit.ly/3ZDijAI) for the cloud-hosted beta.
 
-https://github.com/user-attachments/assets/d04273a5-b36a-4a37-818e-f631ce72d603
+### System Requirements
+
+Before proceeding with the installation, ensure your system meets the following requirements:
+
+#### Hardware Requirements
+- CPU: 4+ cores recommended
+- RAM: Minimum 8GB, 16GB recommended
+- Storage: At least 10GB of free space
+
+#### Software Requirements
+- Operating Systems:
+  - Linux (Ubuntu 20.04 or newer recommended)
+  - macOS (10.15 or newer)
+  - Windows 10/11 with WSL2
+- Required Software (with minimum versions):
+  - Docker Engine (20.10.0 or newer)
+  - Docker Compose (2.0.0 or newer)
+  - Git (2.30 or newer)
+  - Node.js (16.x or newer)
+  - npm (8.x or newer)
+  - VSCode (1.60 or newer) or any modern code editor
+
+#### Network Requirements
+- Stable internet connection
+- Access to required ports (will be configured in Docker)
+- Ability to make outbound HTTPS connections
+
+### Updated Setup Instructions:
+We've moved to a fully maintained and regularly updated documentation site.
+
+👉 [Follow the official self-hosting guide here](https://docs.agpt.co/platform/getting-started/)
+
 
 This tutorial assumes you have Docker, VSCode, git and npm installed.
 
+---
+
+#### ⚡ Quick Setup with One-Line Script (Recommended for Local Hosting)
+
+Skip the manual steps and get started in minutes using our automatic setup script.
+
+For macOS/Linux:
+```
+curl -fsSL https://setup.agpt.co/install.sh -o install.sh && bash install.sh
+```
+
+For Windows (PowerShell):
+```
+powershell -c "iwr https://setup.agpt.co/install.bat -o install.bat; ./install.bat"
+```
+
+This will install dependencies, configure Docker, and launch your local instance — all in one go.
+
 ### 🧱 AutoGPT Frontend
 
 The AutoGPT frontend is where users interact with our powerful AI automation platform. It offers multiple ways to engage with and leverage our AI agents. This is the interface where you'll bring your AI automation ideas to life:
@@ -35,7 +93,7 @@ The AutoGPT frontend is where users interact with our powerful AI automation pla
 
    **Monitoring and Analytics:** Keep track of your agents' performance and gain insights to continually improve your automation processes.
 
-[Read this guide](https://docs.agpt.co/server/new_blocks/) to learn how to build your own custom blocks.
+[Read this guide](https://docs.agpt.co/platform/new_blocks/) to learn how to build your own custom blocks.
 
 ### 💽 AutoGPT Server
 
@@ -65,7 +123,17 @@ Here are two examples of what you can do with AutoGPT:
 These examples show just a glimpse of what you can achieve with AutoGPT! You can create customized workflows to build agents for any use case.
 
 ---
-### Mission and Licencing
+
+### **License Overview:**
+
+🛡️ **Polyform Shield License:**
+All code and content within the `autogpt_platform` folder is licensed under the Polyform Shield License. This new project is our in-developlemt platform for building, deploying and managing agents.</br>_[Read more about this effort](https://agpt.co/blog/introducing-the-autogpt-platform)_
+
+🦉 **MIT License:**
+All other portions of the AutoGPT repository (i.e., everything outside the `autogpt_platform` folder) are licensed under the MIT License. This includes the original stand-alone AutoGPT Agent, along with projects such as [Forge](https://github.com/Significant-Gravitas/AutoGPT/tree/master/classic/forge), [agbenchmark](https://github.com/Significant-Gravitas/AutoGPT/tree/master/classic/benchmark) and the [AutoGPT Classic GUI](https://github.com/Significant-Gravitas/AutoGPT/tree/master/classic/frontend).</br>We also publish additional work under the MIT Licence in other repositories, such as [GravitasML](https://github.com/Significant-Gravitas/gravitasml) which is developed for and used in the AutoGPT Platform. See also our MIT Licenced [Code Ability](https://github.com/Significant-Gravitas/AutoGPT-Code-Ability) project.
+
+---
+### Mission
 Our mission is to provide the tools, so that you can focus on what matters:
 
 - 🏗️ **Building** - Lay the foundation for something amazing.
@@ -78,14 +146,6 @@ Be part of the revolution! **AutoGPT** is here to stay, at the forefront of AI i
 &ensp;|&ensp;
 **🚀 [Contributing](CONTRIBUTING.md)**
 
-**Licensing:**
-
-MIT License: The majority of the AutoGPT repository is under the MIT License.
-
-Polyform Shield License: This license applies to the autogpt_platform folder. 
-
-For more information, see https://agpt.co/blog/introducing-the-autogpt-platform
-
 ---
 ## 🤖 AutoGPT Classic
 > Below is information about the classic version of AutoGPT.
@@ -148,7 +208,7 @@ Just clone the repo, install dependencies with `./run setup`, and you should be
 
 [![Join us on Discord](https://invidget.switchblade.xyz/autogpt)](https://discord.gg/autogpt)
 
-To report a bug or request a feature, create a [GitHub Issue](https://github.com/Significant-Gravitas/AutoGPT/issues/new/choose). Please ensure someone else hasn’t created an issue for the same topic.
+To report a bug or request a feature, create a [GitHub Issue](https://github.com/Significant-Gravitas/AutoGPT/issues/new/choose). Please ensure someone else hasn't created an issue for the same topic.
 
 ## 🤝 Sister projects
 

SECURITY.md

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

autogpt_platform/.env.default

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

autogpt_platform/CLAUDE.md

@@ -0,0 +1,230 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Repository Overview
+
+AutoGPT Platform is a monorepo containing:
+
+- **Backend** (`/backend`): Python FastAPI server with async support
+- **Frontend** (`/frontend`): Next.js React application
+- **Shared Libraries** (`/autogpt_libs`): Common Python utilities
+
+## Essential Commands
+
+### Backend Development
+
+```bash
+# Install dependencies
+cd backend && poetry install
+
+# Run database migrations
+poetry run prisma migrate dev
+
+# Start all services (database, redis, rabbitmq, clamav)
+docker compose up -d
+
+# Run the backend server
+poetry run serve
+
+# Run tests
+poetry run test
+
+# Run specific test
+poetry run pytest path/to/test_file.py::test_function_name
+
+# Run block tests (tests that validate all blocks work correctly)
+poetry run pytest backend/blocks/test/test_block.py -xvs
+
+# Run tests for a specific block (e.g., GetCurrentTimeBlock)
+poetry run pytest 'backend/blocks/test/test_block.py::test_available_blocks[GetCurrentTimeBlock]' -xvs
+
+# Lint and format
+# prefer format if you want to just "fix" it and only get the errors that can't be autofixed
+poetry run format  # Black + isort
+poetry run lint    # ruff
+```
+
+More details can be found in TESTING.md
+
+#### Creating/Updating Snapshots
+
+When you first write a test or when the expected output changes:
+
+```bash
+poetry run pytest path/to/test.py --snapshot-update
+```
+
+⚠️ **Important**: Always review snapshot changes before committing! Use `git diff` to verify the changes are expected.
+
+### Frontend Development
+
+```bash
+# Install dependencies
+cd frontend && npm install
+
+# Start development server
+npm run dev
+
+# Run E2E tests
+npm run test
+
+# Run Storybook for component development
+npm run storybook
+
+# Build production
+npm run build
+
+# Type checking
+npm run types
+```
+
+## Architecture Overview
+
+### Backend Architecture
+
+- **API Layer**: FastAPI with REST and WebSocket endpoints
+- **Database**: PostgreSQL with Prisma ORM, includes pgvector for embeddings
+- **Queue System**: RabbitMQ for async task processing
+- **Execution Engine**: Separate executor service processes agent workflows
+- **Authentication**: JWT-based with Supabase integration
+- **Security**: Cache protection middleware prevents sensitive data caching in browsers/proxies
+
+### Frontend Architecture
+
+- **Framework**: Next.js App Router with React Server Components
+- **State Management**: React hooks + Supabase client for real-time updates
+- **Workflow Builder**: Visual graph editor using @xyflow/react
+- **UI Components**: Radix UI primitives with Tailwind CSS styling
+- **Feature Flags**: LaunchDarkly integration
+
+### Key Concepts
+
+1. **Agent Graphs**: Workflow definitions stored as JSON, executed by the backend
+2. **Blocks**: Reusable components in `/backend/blocks/` that perform specific tasks
+3. **Integrations**: OAuth and API connections stored per user
+4. **Store**: Marketplace for sharing agent templates
+5. **Virus Scanning**: ClamAV integration for file upload security
+
+### Testing Approach
+
+- Backend uses pytest with snapshot testing for API responses
+- Test files are colocated with source files (`*_test.py`)
+- Frontend uses Playwright for E2E tests
+- Component testing via Storybook
+
+### Database Schema
+
+Key models (defined in `/backend/schema.prisma`):
+
+- `User`: Authentication and profile data
+- `AgentGraph`: Workflow definitions with version control
+- `AgentGraphExecution`: Execution history and results
+- `AgentNode`: Individual nodes in a workflow
+- `StoreListing`: Marketplace listings for sharing agents
+
+### Environment Configuration
+
+#### Configuration Files
+
+- **Backend**: `/backend/.env.default` (defaults) → `/backend/.env` (user overrides)
+- **Frontend**: `/frontend/.env.default` (defaults) → `/frontend/.env` (user overrides)
+- **Platform**: `/.env.default` (Supabase/shared defaults) → `/.env` (user overrides)
+
+#### Docker Environment Loading Order
+
+1. `.env.default` files provide base configuration (tracked in git)
+2. `.env` files provide user-specific overrides (gitignored)
+3. Docker Compose `environment:` sections provide service-specific overrides
+4. Shell environment variables have highest precedence
+
+#### Key Points
+
+- All services use hardcoded defaults in docker-compose files (no `${VARIABLE}` substitutions)
+- The `env_file` directive loads variables INTO containers at runtime
+- Backend/Frontend services use YAML anchors for consistent configuration
+- Supabase services (`db/docker/docker-compose.yml`) follow the same pattern
+
+### Common Development Tasks
+
+**Adding a new block:**
+
+1. Create new file in `/backend/backend/blocks/`
+2. Inherit from `Block` base class
+3. Define input/output schemas
+4. Implement `run` method
+5. Register in block registry
+6. Generate the block uuid using `uuid.uuid4()`
+
+Note: when making many new blocks analyze the interfaces for each of these blocks and picture if they would go well together in a graph based editor or would they struggle to connect productively?
+ex: do the inputs and outputs tie well together?
+
+**Modifying the API:**
+
+1. Update route in `/backend/backend/server/routers/`
+2. Add/update Pydantic models in same directory
+3. Write tests alongside the route file
+4. Run `poetry run test` to verify
+
+**Frontend feature development:**
+
+1. Components go in `/frontend/src/components/`
+2. Use existing UI components from `/frontend/src/components/ui/`
+3. Add Storybook stories for new components
+4. Test with Playwright if user-facing
+
+### Security Implementation
+
+**Cache Protection Middleware:**
+
+- Located in `/backend/backend/server/middleware/security.py`
+- Default behavior: Disables caching for ALL endpoints with `Cache-Control: no-store, no-cache, must-revalidate, private`
+- Uses an allow list approach - only explicitly permitted paths can be cached
+- Cacheable paths include: static assets (`/static/*`, `/_next/static/*`), health checks, public store pages, documentation
+- Prevents sensitive data (auth tokens, API keys, user data) from being cached by browsers/proxies
+- To allow caching for a new endpoint, add it to `CACHEABLE_PATHS` in the middleware
+- Applied to both main API server and external API applications
+
+### Creating Pull Requests
+
+- Create the PR aginst the `dev` branch of the repository.
+- Ensure the branch name is descriptive (e.g., `feature/add-new-block`)/
+- Use conventional commit messages (see below)/
+- Fill out the .github/PULL_REQUEST_TEMPLATE.md template as the PR description/
+- Run the github pre-commit hooks to ensure code quality.
+
+### Reviewing/Revising Pull Requests
+
+- When the user runs /pr-comments or tries to fetch them, also run gh api /repos/Significant-Gravitas/AutoGPT/pulls/[issuenum]/reviews to get the reviews
+- Use gh api /repos/Significant-Gravitas/AutoGPT/pulls/[issuenum]/reviews/[review_id]/comments to get the review contents
+- Use gh api /repos/Significant-Gravitas/AutoGPT/issues/9924/comments to get the pr specific comments
+
+### Conventional Commits
+
+Use this format for commit messages and Pull Request titles:
+
+**Conventional Commit Types:**
+
+- `feat`: Introduces a new feature to the codebase
+- `fix`: Patches a bug in the codebase
+- `refactor`: Code change that neither fixes a bug nor adds a feature; also applies to removing features
+- `ci`: Changes to CI configuration
+- `docs`: Documentation-only changes
+- `dx`: Improvements to the developer experience
+
+**Recommended Base Scopes:**
+
+- `platform`: Changes affecting both frontend and backend
+- `frontend`
+- `backend`
+- `infra`
+- `blocks`: Modifications/additions of individual blocks
+
+**Subscope Examples:**
+
+- `backend/executor`
+- `backend/db`
+- `frontend/builder` (includes changes to the block UI component)
+- `infra/prod`
+
+Use these scopes and subscopes for clarity and consistency in commit messages.

autogpt_platform/README.md

@@ -8,60 +8,35 @@ Welcome to the AutoGPT Platform - a powerful system for creating and running AI
 
 - Docker
 - Docker Compose V2 (comes with Docker Desktop, or can be installed separately)
-- Node.js & NPM (for running the frontend application)
 
 ### Running the System
 
 To run the AutoGPT Platform, follow these steps:
 
 1. Clone this repository to your local machine and navigate to the `autogpt_platform` directory within the repository:
+
    ```
    git clone <https://github.com/Significant-Gravitas/AutoGPT.git | git@github.com:Significant-Gravitas/AutoGPT.git>
    cd AutoGPT/autogpt_platform
    ```
 
 2. Run the following command:
+
    ```
-   git submodule update --init --recursive
+   cp .env.default .env
    ```
-   This command will initialize and update the submodules in the repository. The `supabase` folder will be cloned to the root directory.
+
+   This command will copy the `.env.default` file to `.env`. You can modify the `.env` file to add your own environment variables.
 
 3. Run the following command:
-   ```
-   cp supabase/docker/.env.example .env
-   ```
-   This command will copy the `.env.example` file to `.env` in the `supabase/docker` directory. You can modify the `.env` file to add your own environment variables.
 
-4. Run the following command:
    ```
    docker compose up -d
    ```
+
    This command will start all the necessary backend services defined in the `docker-compose.yml` file in detached mode.
 
-5. Navigate to `frontend` within the `autogpt_platform` directory:
-   ```
-   cd frontend
-   ```
-   You will need to run your frontend application separately on your local machine.
-
-6. Run the following command: 
-   ```
-   cp .env.example .env.local
-   ```
-   This command will copy the `.env.example` file to `.env.local` in the `frontend` directory. You can modify the `.env.local` within this folder to add your own environment variables for the frontend application.
-
-7. Run the following command:
-   ```
-   npm install
-   npm run dev
-   ```
-   This command will install the necessary dependencies and start the frontend application in development mode.
-   If you are using Yarn, you can run the following commands instead:
-   ```
-   yarn install && yarn dev
-   ```
-
-8. Open your browser and navigate to `http://localhost:3000` to access the AutoGPT Platform frontend.
+4. After all the services are in ready state, open your browser and navigate to `http://localhost:3000` to access the AutoGPT Platform frontend.
 
 ### Docker Compose Commands
 
@@ -74,43 +49,52 @@ Here are some useful Docker Compose commands for managing your AutoGPT Platform:
 - `docker compose down`: Stop and remove containers, networks, and volumes.
 - `docker compose watch`: Watch for changes in your services and automatically update them.
 
-
 ### Sample Scenarios
 
 Here are some common scenarios where you might use multiple Docker Compose commands:
 
 1. Updating and restarting a specific service:
+
    ```
    docker compose build api_srv
    docker compose up -d --no-deps api_srv
    ```
+
    This rebuilds the `api_srv` service and restarts it without affecting other services.
 
 2. Viewing logs for troubleshooting:
+
    ```
    docker compose logs -f api_srv ws_srv
    ```
+
    This shows and follows the logs for both `api_srv` and `ws_srv` services.
 
 3. Scaling a service for increased load:
+
    ```
    docker compose up -d --scale executor=3
    ```
+
    This scales the `executor` service to 3 instances to handle increased load.
 
 4. Stopping the entire system for maintenance:
+
    ```
    docker compose stop
    docker compose rm -f
    docker compose pull
    docker compose up -d
    ```
+
    This stops all services, removes containers, pulls the latest images, and restarts the system.
 
 5. Developing with live updates:
+
    ```
    docker compose watch
    ```
+
    This watches for changes in your code and automatically updates the relevant services.
 
 6. Checking the status of services:
@@ -121,7 +105,6 @@ Here are some common scenarios where you might use multiple Docker Compose comma
 
 These scenarios demonstrate how to use Docker Compose commands in combination to manage your AutoGPT Platform effectively.
 
-
 ### Persisting Data
 
 To persist data for PostgreSQL and Redis, you can modify the `docker-compose.yml` file to add volumes. Here's how:
@@ -149,3 +132,28 @@ To persist data for PostgreSQL and Redis, you can modify the `docker-compose.yml
 3. Save the file and run `docker compose up -d` to apply the changes.
 
 This configuration will create named volumes for PostgreSQL and Redis, ensuring that your data persists across container restarts.
+
+### API Client Generation
+
+The platform includes scripts for generating and managing the API client:
+
+- `pnpm fetch:openapi`: Fetches the OpenAPI specification from the backend service (requires backend to be running on port 8006)
+- `pnpm generate:api-client`: Generates the TypeScript API client from the OpenAPI specification using Orval
+- `pnpm generate:api`: Runs both fetch and generate commands in sequence
+
+#### Manual API Client Updates
+
+If you need to update the API client after making changes to the backend API:
+
+1. Ensure the backend services are running:
+
+   ```
+   docker compose up -d
+   ```
+
+2. Generate the updated API client:
+   ```
+   pnpm generate:api
+   ```
+
+This will fetch the latest OpenAPI specification and regenerate the TypeScript client code.

autogpt_platform/autogpt_libs/README.md

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

autogpt_platform/autogpt_libs/autogpt_libs/api_key/key_manager.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/__init__.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/config.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/depends.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/middleware.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/models.py

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

autogpt_platform/autogpt_libs/autogpt_libs/logging/config.py

@@ -1,13 +1,25 @@
 """Logging module for Auto-GPT."""
 
 import logging
+import os
+import socket
 import sys
 from pathlib import Path
 
 from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
+
 from .filters import BelowLevelFilter
-from .formatters import AGPTFormatter, StructuredLoggingFormatter
+from .formatters import AGPTFormatter
+
+# Configure global socket timeout and gRPC keepalive to prevent deadlocks
+# This must be done at import time before any gRPC connections are established
+socket.setdefaulttimeout(30)  # 30-second socket timeout
+
+# Enable gRPC keepalive to detect dead connections faster
+os.environ.setdefault("GRPC_KEEPALIVE_TIME_MS", "30000")  # 30 seconds
+os.environ.setdefault("GRPC_KEEPALIVE_TIMEOUT_MS", "5000")  # 5 seconds
+os.environ.setdefault("GRPC_KEEPALIVE_PERMIT_WITHOUT_CALLS", "true")
 
 LOG_DIR = Path(__file__).parent.parent.parent.parent / "logs"
 LOG_FILE = "activity.log"
@@ -17,12 +29,11 @@ ERROR_LOG_FILE = "error.log"
 SIMPLE_LOG_FORMAT = "%(asctime)s %(levelname)s  %(title)s%(message)s"
 
 DEBUG_LOG_FORMAT = (
-    "%(asctime)s %(levelname)s %(filename)s:%(lineno)d" "  %(title)s%(message)s"
+    "%(asctime)s %(levelname)s %(filename)s:%(lineno)d  %(title)s%(message)s"
 )
 
 
 class LoggingConfig(BaseSettings):
-
     level: str = Field(
         default="INFO",
         description="Logging level",
@@ -79,46 +90,45 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
     Note: This function is typically called at the start of the application
     to set up the logging infrastructure.
     """
-
     config = LoggingConfig()
-
     log_handlers: list[logging.Handler] = []
 
+    # Console output handlers
+    stdout = logging.StreamHandler(stream=sys.stdout)
+    stdout.setLevel(config.level)
+    stdout.addFilter(BelowLevelFilter(logging.WARNING))
+    if config.level == logging.DEBUG:
+        stdout.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
+    else:
+        stdout.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
+
+    stderr = logging.StreamHandler()
+    stderr.setLevel(logging.WARNING)
+    if config.level == logging.DEBUG:
+        stderr.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
+    else:
+        stderr.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
+
+    log_handlers += [stdout, stderr]
+
     # Cloud logging setup
     if config.enable_cloud_logging or force_cloud_logging:
         import google.cloud.logging
         from google.cloud.logging.handlers import CloudLoggingHandler
-        from google.cloud.logging_v2.handlers.transports.sync import SyncTransport
+        from google.cloud.logging_v2.handlers.transports import (
+            BackgroundThreadTransport,
+        )
 
         client = google.cloud.logging.Client()
+        # Use BackgroundThreadTransport to prevent blocking the main thread
+        # and deadlocks when gRPC calls to Google Cloud Logging hang
         cloud_handler = CloudLoggingHandler(
             client,
             name="autogpt_logs",
-            transport=SyncTransport,
+            transport=BackgroundThreadTransport,
         )
         cloud_handler.setLevel(config.level)
-        cloud_handler.setFormatter(StructuredLoggingFormatter())
         log_handlers.append(cloud_handler)
-        print("Cloud logging enabled")
-    else:
-        # Console output handlers
-        stdout = logging.StreamHandler(stream=sys.stdout)
-        stdout.setLevel(config.level)
-        stdout.addFilter(BelowLevelFilter(logging.WARNING))
-        if config.level == logging.DEBUG:
-            stdout.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
-        else:
-            stdout.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
-
-        stderr = logging.StreamHandler()
-        stderr.setLevel(logging.WARNING)
-        if config.level == logging.DEBUG:
-            stderr.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
-        else:
-            stderr.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
-
-        log_handlers += [stdout, stderr]
-        print("Console logging enabled")
 
     # File logging setup
     if config.enable_file_logging:
@@ -156,7 +166,6 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
         error_log_handler.setLevel(logging.ERROR)
         error_log_handler.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT, no_color=True))
         log_handlers.append(error_log_handler)
-        print("File logging enabled")
 
     # Configure the root logger
     logging.basicConfig(

autogpt_platform/autogpt_libs/autogpt_libs/logging/formatters.py

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

autogpt_platform/autogpt_libs/autogpt_libs/logging/test_utils.py

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

autogpt_platform/autogpt_libs/autogpt_libs/logging/utils.py

@@ -1,27 +1,5 @@
-import logging
 import re
-from typing import Any
-
-from colorama import Fore
 
 
 def remove_color_codes(s: str) -> str:
     return re.sub(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])", "", s)
-
-
-def fmt_kwargs(kwargs: dict) -> str:
-    return ", ".join(f"{n}={repr(v)}" for n, v in kwargs.items())
-
-
-def print_attribute(
-    title: str, value: Any, title_color: str = Fore.GREEN, value_color: str = ""
-) -> None:
-    logger = logging.getLogger()
-    logger.info(
-        str(value),
-        extra={
-            "title": f"{title.rstrip(':')}:",
-            "title_color": title_color,
-            "color": value_color,
-        },
-    )

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/config.py

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

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/limiter.py

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

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/middleware.py

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

autogpt_platform/autogpt_libs/autogpt_libs/supabase_integration_credentials_store/__init__.py

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

autogpt_platform/autogpt_libs/autogpt_libs/supabase_integration_credentials_store/store.py

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

autogpt_platform/autogpt_libs/autogpt_libs/supabase_integration_credentials_store/types.py

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

autogpt_platform/autogpt_libs/autogpt_libs/utils/cache.py

@@ -1,20 +1,266 @@
-from typing import Callable, TypeVar, ParamSpec
+import inspect
+import logging
 import threading
+import time
+from functools import wraps
+from typing import (
+    Awaitable,
+    Callable,
+    ParamSpec,
+    Protocol,
+    Tuple,
+    TypeVar,
+    cast,
+    overload,
+    runtime_checkable,
+)
 
 P = ParamSpec("P")
 R = TypeVar("R")
 
+logger = logging.getLogger(__name__)
 
+
+@overload
+def thread_cached(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
+    pass
+
+
+@overload
 def thread_cached(func: Callable[P, R]) -> Callable[P, R]:
+    pass
+
+
+def thread_cached(
+    func: Callable[P, R] | Callable[P, Awaitable[R]],
+) -> Callable[P, R] | Callable[P, Awaitable[R]]:
     thread_local = threading.local()
 
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-        cache = getattr(thread_local, "cache", None)
-        if cache is None:
-            cache = thread_local.cache = {}
-        key = (args, tuple(sorted(kwargs.items())))
-        if key not in cache:
-            cache[key] = func(*args, **kwargs)
-        return cache[key]
+    def _clear():
+        if hasattr(thread_local, "cache"):
+            del thread_local.cache
 
-    return wrapper
+    if inspect.iscoroutinefunction(func):
+
+        async def async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            cache = getattr(thread_local, "cache", None)
+            if cache is None:
+                cache = thread_local.cache = {}
+            key = (args, tuple(sorted(kwargs.items())))
+            if key not in cache:
+                cache[key] = await cast(Callable[P, Awaitable[R]], func)(
+                    *args, **kwargs
+                )
+            return cache[key]
+
+        setattr(async_wrapper, "clear_cache", _clear)
+        return async_wrapper
+
+    else:
+
+        def sync_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            cache = getattr(thread_local, "cache", None)
+            if cache is None:
+                cache = thread_local.cache = {}
+            key = (args, tuple(sorted(kwargs.items())))
+            if key not in cache:
+                cache[key] = func(*args, **kwargs)
+            return cache[key]
+
+        setattr(sync_wrapper, "clear_cache", _clear)
+        return sync_wrapper
+
+
+def clear_thread_cache(func: Callable) -> None:
+    if clear := getattr(func, "clear_cache", None):
+        clear()
+
+
+FuncT = TypeVar("FuncT")
+
+
+R_co = TypeVar("R_co", covariant=True)
+
+
+@runtime_checkable
+class AsyncCachedFunction(Protocol[P, R_co]):
+    """Protocol for async functions with cache management methods."""
+
+    def cache_clear(self) -> None:
+        """Clear all cached entries."""
+        return None
+
+    def cache_info(self) -> dict[str, int | None]:
+        """Get cache statistics."""
+        return {}
+
+    async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R_co:
+        """Call the cached function."""
+        return None  # type: ignore
+
+
+def async_ttl_cache(
+    maxsize: int = 128, ttl_seconds: int | None = None
+) -> Callable[[Callable[P, Awaitable[R]]], AsyncCachedFunction[P, R]]:
+    """
+    TTL (Time To Live) cache decorator for async functions.
+
+    Similar to functools.lru_cache but works with async functions and includes optional TTL.
+
+    Args:
+        maxsize: Maximum number of cached entries
+        ttl_seconds: Time to live in seconds. If None, entries never expire (like lru_cache)
+
+    Returns:
+        Decorator function
+
+    Example:
+        # With TTL
+        @async_ttl_cache(maxsize=1000, ttl_seconds=300)
+        async def api_call(param: str) -> dict:
+            return {"result": param}
+
+        # Without TTL (permanent cache like lru_cache)
+        @async_ttl_cache(maxsize=1000)
+        async def expensive_computation(param: str) -> dict:
+            return {"result": param}
+    """
+
+    def decorator(
+        async_func: Callable[P, Awaitable[R]],
+    ) -> AsyncCachedFunction[P, R]:
+        # Cache storage - use union type to handle both cases
+        cache_storage: dict[tuple, R | Tuple[R, float]] = {}
+
+        @wraps(async_func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            # Create cache key from arguments
+            key = (args, tuple(sorted(kwargs.items())))
+            current_time = time.time()
+
+            # Check if we have a valid cached entry
+            if key in cache_storage:
+                if ttl_seconds is None:
+                    # No TTL - return cached result directly
+                    logger.debug(
+                        f"Cache hit for {async_func.__name__} with key: {str(key)[:50]}"
+                    )
+                    return cast(R, cache_storage[key])
+                else:
+                    # With TTL - check expiration
+                    cached_data = cache_storage[key]
+                    if isinstance(cached_data, tuple):
+                        result, timestamp = cached_data
+                        if current_time - timestamp < ttl_seconds:
+                            logger.debug(
+                                f"Cache hit for {async_func.__name__} with key: {str(key)[:50]}"
+                            )
+                            return cast(R, result)
+                        else:
+                            # Expired entry
+                            del cache_storage[key]
+                            logger.debug(
+                                f"Cache entry expired for {async_func.__name__}"
+                            )
+
+            # Cache miss or expired - fetch fresh data
+            logger.debug(
+                f"Cache miss for {async_func.__name__} with key: {str(key)[:50]}"
+            )
+            result = await async_func(*args, **kwargs)
+
+            # Store in cache
+            if ttl_seconds is None:
+                cache_storage[key] = result
+            else:
+                cache_storage[key] = (result, current_time)
+
+            # Simple cleanup when cache gets too large
+            if len(cache_storage) > maxsize:
+                # Remove oldest entries (simple FIFO cleanup)
+                cutoff = maxsize // 2
+                oldest_keys = list(cache_storage.keys())[:-cutoff] if cutoff > 0 else []
+                for old_key in oldest_keys:
+                    cache_storage.pop(old_key, None)
+                logger.debug(
+                    f"Cache cleanup: removed {len(oldest_keys)} entries for {async_func.__name__}"
+                )
+
+            return result
+
+        # Add cache management methods (similar to functools.lru_cache)
+        def cache_clear() -> None:
+            cache_storage.clear()
+
+        def cache_info() -> dict[str, int | None]:
+            return {
+                "size": len(cache_storage),
+                "maxsize": maxsize,
+                "ttl_seconds": ttl_seconds,
+            }
+
+        # Attach methods to wrapper
+        setattr(wrapper, "cache_clear", cache_clear)
+        setattr(wrapper, "cache_info", cache_info)
+
+        return cast(AsyncCachedFunction[P, R], wrapper)
+
+    return decorator
+
+
+@overload
+def async_cache(
+    func: Callable[P, Awaitable[R]],
+) -> AsyncCachedFunction[P, R]:
+    pass
+
+
+@overload
+def async_cache(
+    func: None = None,
+    *,
+    maxsize: int = 128,
+) -> Callable[[Callable[P, Awaitable[R]]], AsyncCachedFunction[P, R]]:
+    pass
+
+
+def async_cache(
+    func: Callable[P, Awaitable[R]] | None = None,
+    *,
+    maxsize: int = 128,
+) -> (
+    AsyncCachedFunction[P, R]
+    | Callable[[Callable[P, Awaitable[R]]], AsyncCachedFunction[P, R]]
+):
+    """
+    Process-level cache decorator for async functions (no TTL).
+
+    Similar to functools.lru_cache but works with async functions.
+    This is a convenience wrapper around async_ttl_cache with ttl_seconds=None.
+
+    Args:
+        func: The async function to cache (when used without parentheses)
+        maxsize: Maximum number of cached entries
+
+    Returns:
+        Decorated function or decorator
+
+    Example:
+        # Without parentheses (uses default maxsize=128)
+        @async_cache
+        async def get_data(param: str) -> dict:
+            return {"result": param}
+
+        # With parentheses and custom maxsize
+        @async_cache(maxsize=1000)
+        async def expensive_computation(param: str) -> dict:
+            # Expensive computation here
+            return {"result": param}
+    """
+    if func is None:
+        # Called with parentheses @async_cache() or @async_cache(maxsize=...)
+        return async_ttl_cache(maxsize=maxsize, ttl_seconds=None)
+    else:
+        # Called without parentheses @async_cache
+        decorator = async_ttl_cache(maxsize=maxsize, ttl_seconds=None)
+        return decorator(func)

autogpt_platform/autogpt_libs/autogpt_libs/utils/cache_test.py

@@ -0,0 +1,705 @@
+"""Tests for the @thread_cached decorator.
+
+This module tests the thread-local caching functionality including:
+- Basic caching for sync and async functions
+- Thread isolation (each thread has its own cache)
+- Cache clearing functionality
+- Exception handling (exceptions are not cached)
+- Argument handling (positional vs keyword arguments)
+"""
+
+import asyncio
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from unittest.mock import Mock
+
+import pytest
+
+from autogpt_libs.utils.cache import (
+    async_cache,
+    async_ttl_cache,
+    clear_thread_cache,
+    thread_cached,
+)
+
+
+class TestThreadCached:
+    def test_sync_function_caching(self):
+        call_count = 0
+
+        @thread_cached
+        def expensive_function(x: int, y: int = 0) -> int:
+            nonlocal call_count
+            call_count += 1
+            return x + y
+
+        assert expensive_function(1, 2) == 3
+        assert call_count == 1
+
+        assert expensive_function(1, 2) == 3
+        assert call_count == 1
+
+        assert expensive_function(1, y=2) == 3
+        assert call_count == 2
+
+        assert expensive_function(2, 3) == 5
+        assert call_count == 3
+
+        assert expensive_function(1) == 1
+        assert call_count == 4
+
+    @pytest.mark.asyncio
+    async def test_async_function_caching(self):
+        call_count = 0
+
+        @thread_cached
+        async def expensive_async_function(x: int, y: int = 0) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)
+            return x + y
+
+        assert await expensive_async_function(1, 2) == 3
+        assert call_count == 1
+
+        assert await expensive_async_function(1, 2) == 3
+        assert call_count == 1
+
+        assert await expensive_async_function(1, y=2) == 3
+        assert call_count == 2
+
+        assert await expensive_async_function(2, 3) == 5
+        assert call_count == 3
+
+    def test_thread_isolation(self):
+        call_count = 0
+        results = {}
+
+        @thread_cached
+        def thread_specific_function(x: int) -> str:
+            nonlocal call_count
+            call_count += 1
+            return f"{threading.current_thread().name}-{x}"
+
+        def worker(thread_id: int):
+            result1 = thread_specific_function(1)
+            result2 = thread_specific_function(1)
+            result3 = thread_specific_function(2)
+            results[thread_id] = (result1, result2, result3)
+
+        with ThreadPoolExecutor(max_workers=3) as executor:
+            futures = [executor.submit(worker, i) for i in range(3)]
+            for future in futures:
+                future.result()
+
+        assert call_count >= 2
+
+        for thread_id, (r1, r2, r3) in results.items():
+            assert r1 == r2
+            assert r1 != r3
+
+    @pytest.mark.asyncio
+    async def test_async_thread_isolation(self):
+        call_count = 0
+        results = {}
+
+        @thread_cached
+        async def async_thread_specific_function(x: int) -> str:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)
+            return f"{threading.current_thread().name}-{x}"
+
+        async def async_worker(worker_id: int):
+            result1 = await async_thread_specific_function(1)
+            result2 = await async_thread_specific_function(1)
+            result3 = await async_thread_specific_function(2)
+            results[worker_id] = (result1, result2, result3)
+
+        tasks = [async_worker(i) for i in range(3)]
+        await asyncio.gather(*tasks)
+
+        for worker_id, (r1, r2, r3) in results.items():
+            assert r1 == r2
+            assert r1 != r3
+
+    def test_clear_cache_sync(self):
+        call_count = 0
+
+        @thread_cached
+        def clearable_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        assert clearable_function(5) == 10
+        assert call_count == 1
+
+        assert clearable_function(5) == 10
+        assert call_count == 1
+
+        clear_thread_cache(clearable_function)
+
+        assert clearable_function(5) == 10
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_clear_cache_async(self):
+        call_count = 0
+
+        @thread_cached
+        async def clearable_async_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)
+            return x * 2
+
+        assert await clearable_async_function(5) == 10
+        assert call_count == 1
+
+        assert await clearable_async_function(5) == 10
+        assert call_count == 1
+
+        clear_thread_cache(clearable_async_function)
+
+        assert await clearable_async_function(5) == 10
+        assert call_count == 2
+
+    def test_simple_arguments(self):
+        call_count = 0
+
+        @thread_cached
+        def simple_function(a: str, b: int, c: str = "default") -> str:
+            nonlocal call_count
+            call_count += 1
+            return f"{a}-{b}-{c}"
+
+        # First call with all positional args
+        result1 = simple_function("test", 42, "custom")
+        assert call_count == 1
+
+        # Same args, all positional - should hit cache
+        result2 = simple_function("test", 42, "custom")
+        assert call_count == 1
+        assert result1 == result2
+
+        # Same values but last arg as keyword - creates different cache key
+        result3 = simple_function("test", 42, c="custom")
+        assert call_count == 2
+        assert result1 == result3  # Same result, different cache entry
+
+        # Different value - new cache entry
+        result4 = simple_function("test", 43, "custom")
+        assert call_count == 3
+        assert result1 != result4
+
+    def test_positional_vs_keyword_args(self):
+        """Test that positional and keyword arguments create different cache entries."""
+        call_count = 0
+
+        @thread_cached
+        def func(a: int, b: int = 10) -> str:
+            nonlocal call_count
+            call_count += 1
+            return f"result-{a}-{b}"
+
+        # All positional
+        result1 = func(1, 2)
+        assert call_count == 1
+        assert result1 == "result-1-2"
+
+        # Same values, but second arg as keyword
+        result2 = func(1, b=2)
+        assert call_count == 2  # Different cache key!
+        assert result2 == "result-1-2"  # Same result
+
+        # Verify both are cached separately
+        func(1, 2)  # Uses first cache entry
+        assert call_count == 2
+
+        func(1, b=2)  # Uses second cache entry
+        assert call_count == 2
+
+    def test_exception_handling(self):
+        call_count = 0
+
+        @thread_cached
+        def failing_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            if x < 0:
+                raise ValueError("Negative value")
+            return x * 2
+
+        assert failing_function(5) == 10
+        assert call_count == 1
+
+        with pytest.raises(ValueError):
+            failing_function(-1)
+        assert call_count == 2
+
+        with pytest.raises(ValueError):
+            failing_function(-1)
+        assert call_count == 3
+
+        assert failing_function(5) == 10
+        assert call_count == 3
+
+    @pytest.mark.asyncio
+    async def test_async_exception_handling(self):
+        call_count = 0
+
+        @thread_cached
+        async def async_failing_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)
+            if x < 0:
+                raise ValueError("Negative value")
+            return x * 2
+
+        assert await async_failing_function(5) == 10
+        assert call_count == 1
+
+        with pytest.raises(ValueError):
+            await async_failing_function(-1)
+        assert call_count == 2
+
+        with pytest.raises(ValueError):
+            await async_failing_function(-1)
+        assert call_count == 3
+
+    def test_sync_caching_performance(self):
+        @thread_cached
+        def slow_function(x: int) -> int:
+            print(f"slow_function called with x={x}")
+            time.sleep(0.1)
+            return x * 2
+
+        start = time.time()
+        result1 = slow_function(5)
+        first_call_time = time.time() - start
+        print(f"First call took {first_call_time:.4f} seconds")
+
+        start = time.time()
+        result2 = slow_function(5)
+        second_call_time = time.time() - start
+        print(f"Second call took {second_call_time:.4f} seconds")
+
+        assert result1 == result2 == 10
+        assert first_call_time > 0.09
+        assert second_call_time < 0.01
+
+    @pytest.mark.asyncio
+    async def test_async_caching_performance(self):
+        @thread_cached
+        async def slow_async_function(x: int) -> int:
+            print(f"slow_async_function called with x={x}")
+            await asyncio.sleep(0.1)
+            return x * 2
+
+        start = time.time()
+        result1 = await slow_async_function(5)
+        first_call_time = time.time() - start
+        print(f"First async call took {first_call_time:.4f} seconds")
+
+        start = time.time()
+        result2 = await slow_async_function(5)
+        second_call_time = time.time() - start
+        print(f"Second async call took {second_call_time:.4f} seconds")
+
+        assert result1 == result2 == 10
+        assert first_call_time > 0.09
+        assert second_call_time < 0.01
+
+    def test_with_mock_objects(self):
+        mock = Mock(return_value=42)
+
+        @thread_cached
+        def function_using_mock(x: int) -> int:
+            return mock(x)
+
+        assert function_using_mock(1) == 42
+        assert mock.call_count == 1
+
+        assert function_using_mock(1) == 42
+        assert mock.call_count == 1
+
+        assert function_using_mock(2) == 42
+        assert mock.call_count == 2
+
+
+class TestAsyncTTLCache:
+    """Tests for the @async_ttl_cache decorator."""
+
+    @pytest.mark.asyncio
+    async def test_basic_caching(self):
+        """Test basic caching functionality."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def cached_function(x: int, y: int = 0) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)  # Simulate async work
+            return x + y
+
+        # First call
+        result1 = await cached_function(1, 2)
+        assert result1 == 3
+        assert call_count == 1
+
+        # Second call with same args - should use cache
+        result2 = await cached_function(1, 2)
+        assert result2 == 3
+        assert call_count == 1  # No additional call
+
+        # Different args - should call function again
+        result3 = await cached_function(2, 3)
+        assert result3 == 5
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_ttl_expiration(self):
+        """Test that cache entries expire after TTL."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=1)  # Short TTL
+        async def short_lived_cache(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # First call
+        result1 = await short_lived_cache(5)
+        assert result1 == 10
+        assert call_count == 1
+
+        # Second call immediately - should use cache
+        result2 = await short_lived_cache(5)
+        assert result2 == 10
+        assert call_count == 1
+
+        # Wait for TTL to expire
+        await asyncio.sleep(1.1)
+
+        # Third call after expiration - should call function again
+        result3 = await short_lived_cache(5)
+        assert result3 == 10
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_cache_info(self):
+        """Test cache info functionality."""
+
+        @async_ttl_cache(maxsize=5, ttl_seconds=300)
+        async def info_test_function(x: int) -> int:
+            return x * 3
+
+        # Check initial cache info
+        info = info_test_function.cache_info()
+        assert info["size"] == 0
+        assert info["maxsize"] == 5
+        assert info["ttl_seconds"] == 300
+
+        # Add an entry
+        await info_test_function(1)
+        info = info_test_function.cache_info()
+        assert info["size"] == 1
+
+    @pytest.mark.asyncio
+    async def test_cache_clear(self):
+        """Test cache clearing functionality."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def clearable_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            return x * 4
+
+        # First call
+        result1 = await clearable_function(2)
+        assert result1 == 8
+        assert call_count == 1
+
+        # Second call - should use cache
+        result2 = await clearable_function(2)
+        assert result2 == 8
+        assert call_count == 1
+
+        # Clear cache
+        clearable_function.cache_clear()
+
+        # Third call after clear - should call function again
+        result3 = await clearable_function(2)
+        assert result3 == 8
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_maxsize_cleanup(self):
+        """Test that cache cleans up when maxsize is exceeded."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=3, ttl_seconds=60)
+        async def size_limited_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            return x**2
+
+        # Fill cache to maxsize
+        await size_limited_function(1)  # call_count: 1
+        await size_limited_function(2)  # call_count: 2
+        await size_limited_function(3)  # call_count: 3
+
+        info = size_limited_function.cache_info()
+        assert info["size"] == 3
+
+        # Add one more entry - should trigger cleanup
+        await size_limited_function(4)  # call_count: 4
+
+        # Cache size should be reduced (cleanup removes oldest entries)
+        info = size_limited_function.cache_info()
+        assert info["size"] is not None and info["size"] <= 3  # Should be cleaned up
+
+    @pytest.mark.asyncio
+    async def test_argument_variations(self):
+        """Test caching with different argument patterns."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def arg_test_function(a: int, b: str = "default", *, c: int = 100) -> str:
+            nonlocal call_count
+            call_count += 1
+            return f"{a}-{b}-{c}"
+
+        # Different ways to call with same logical arguments
+        result1 = await arg_test_function(1, "test", c=200)
+        assert call_count == 1
+
+        # Same arguments, same order - should use cache
+        result2 = await arg_test_function(1, "test", c=200)
+        assert call_count == 1
+        assert result1 == result2
+
+        # Different arguments - should call function
+        result3 = await arg_test_function(2, "test", c=200)
+        assert call_count == 2
+        assert result1 != result3
+
+    @pytest.mark.asyncio
+    async def test_exception_handling(self):
+        """Test that exceptions are not cached."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def exception_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            if x < 0:
+                raise ValueError("Negative value not allowed")
+            return x * 2
+
+        # Successful call - should be cached
+        result1 = await exception_function(5)
+        assert result1 == 10
+        assert call_count == 1
+
+        # Same successful call - should use cache
+        result2 = await exception_function(5)
+        assert result2 == 10
+        assert call_count == 1
+
+        # Exception call - should not be cached
+        with pytest.raises(ValueError):
+            await exception_function(-1)
+        assert call_count == 2
+
+        # Same exception call - should call again (not cached)
+        with pytest.raises(ValueError):
+            await exception_function(-1)
+        assert call_count == 3
+
+    @pytest.mark.asyncio
+    async def test_concurrent_calls(self):
+        """Test caching behavior with concurrent calls."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def concurrent_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.05)  # Simulate work
+            return x * x
+
+        # Launch concurrent calls with same arguments
+        tasks = [concurrent_function(3) for _ in range(5)]
+        results = await asyncio.gather(*tasks)
+
+        # All results should be the same
+        assert all(result == 9 for result in results)
+
+        # Note: Due to race conditions, call_count might be up to 5 for concurrent calls
+        # This tests that the cache doesn't break under concurrent access
+        assert 1 <= call_count <= 5
+
+
+class TestAsyncCache:
+    """Tests for the @async_cache decorator (no TTL)."""
+
+    @pytest.mark.asyncio
+    async def test_basic_caching_no_ttl(self):
+        """Test basic caching functionality without TTL."""
+        call_count = 0
+
+        @async_cache(maxsize=10)
+        async def cached_function(x: int, y: int = 0) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)  # Simulate async work
+            return x + y
+
+        # First call
+        result1 = await cached_function(1, 2)
+        assert result1 == 3
+        assert call_count == 1
+
+        # Second call with same args - should use cache
+        result2 = await cached_function(1, 2)
+        assert result2 == 3
+        assert call_count == 1  # No additional call
+
+        # Third call after some time - should still use cache (no TTL)
+        await asyncio.sleep(0.05)
+        result3 = await cached_function(1, 2)
+        assert result3 == 3
+        assert call_count == 1  # Still no additional call
+
+        # Different args - should call function again
+        result4 = await cached_function(2, 3)
+        assert result4 == 5
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_no_ttl_vs_ttl_behavior(self):
+        """Test the difference between TTL and no-TTL caching."""
+        ttl_call_count = 0
+        no_ttl_call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=1)  # Short TTL
+        async def ttl_function(x: int) -> int:
+            nonlocal ttl_call_count
+            ttl_call_count += 1
+            return x * 2
+
+        @async_cache(maxsize=10)  # No TTL
+        async def no_ttl_function(x: int) -> int:
+            nonlocal no_ttl_call_count
+            no_ttl_call_count += 1
+            return x * 2
+
+        # First calls
+        await ttl_function(5)
+        await no_ttl_function(5)
+        assert ttl_call_count == 1
+        assert no_ttl_call_count == 1
+
+        # Wait for TTL to expire
+        await asyncio.sleep(1.1)
+
+        # Second calls after TTL expiry
+        await ttl_function(5)  # Should call function again (TTL expired)
+        await no_ttl_function(5)  # Should use cache (no TTL)
+        assert ttl_call_count == 2  # TTL function called again
+        assert no_ttl_call_count == 1  # No-TTL function still cached
+
+    @pytest.mark.asyncio
+    async def test_async_cache_info(self):
+        """Test cache info for no-TTL cache."""
+
+        @async_cache(maxsize=5)
+        async def info_test_function(x: int) -> int:
+            return x * 3
+
+        # Check initial cache info
+        info = info_test_function.cache_info()
+        assert info["size"] == 0
+        assert info["maxsize"] == 5
+        assert info["ttl_seconds"] is None  # No TTL
+
+        # Add an entry
+        await info_test_function(1)
+        info = info_test_function.cache_info()
+        assert info["size"] == 1
+
+
+class TestTTLOptional:
+    """Tests for optional TTL functionality."""
+
+    @pytest.mark.asyncio
+    async def test_ttl_none_behavior(self):
+        """Test that ttl_seconds=None works like no TTL."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=None)
+        async def no_ttl_via_none(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            return x**2
+
+        # First call
+        result1 = await no_ttl_via_none(3)
+        assert result1 == 9
+        assert call_count == 1
+
+        # Wait (would expire if there was TTL)
+        await asyncio.sleep(0.1)
+
+        # Second call - should still use cache
+        result2 = await no_ttl_via_none(3)
+        assert result2 == 9
+        assert call_count == 1  # No additional call
+
+        # Check cache info
+        info = no_ttl_via_none.cache_info()
+        assert info["ttl_seconds"] is None
+
+    @pytest.mark.asyncio
+    async def test_cache_options_comparison(self):
+        """Test different cache options work as expected."""
+        ttl_calls = 0
+        no_ttl_calls = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=1)  # With TTL
+        async def ttl_function(x: int) -> int:
+            nonlocal ttl_calls
+            ttl_calls += 1
+            return x * 10
+
+        @async_cache(maxsize=10)  # Process-level cache (no TTL)
+        async def process_function(x: int) -> int:
+            nonlocal no_ttl_calls
+            no_ttl_calls += 1
+            return x * 10
+
+        # Both should cache initially
+        await ttl_function(3)
+        await process_function(3)
+        assert ttl_calls == 1
+        assert no_ttl_calls == 1
+
+        # Immediate second calls - both should use cache
+        await ttl_function(3)
+        await process_function(3)
+        assert ttl_calls == 1
+        assert no_ttl_calls == 1
+
+        # Wait for TTL to expire
+        await asyncio.sleep(1.1)
+
+        # After TTL expiry
+        await ttl_function(3)  # Should call function again
+        await process_function(3)  # Should still use cache
+        assert ttl_calls == 2  # TTL cache expired, called again
+        assert no_ttl_calls == 1  # Process cache never expires

autogpt_platform/autogpt_libs/autogpt_libs/utils/synchronize.py

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

autogpt_platform/autogpt_libs/pyproject.toml

@@ -1,25 +1,36 @@
 [tool.poetry]
 name = "autogpt-libs"
 version = "0.2.0"
-description = "Shared libraries across NextGen AutoGPT"
-authors = ["Aarushi <aarushik93@gmail.com>"]
+description = "Shared libraries across AutoGPT Platform"
+authors = ["AutoGPT team <info@agpt.co>"]
 readme = "README.md"
 packages = [{ include = "autogpt_libs" }]
 
 [tool.poetry.dependencies]
+python = ">=3.10,<4.0"
 colorama = "^0.4.6"
 expiringdict = "^1.2.2"
-google-cloud-logging = "^3.11.3"
-pydantic = "^2.9.2"
-pydantic-settings = "^2.6.1"
-pyjwt = "^2.8.0"
-python = ">=3.10,<4.0"
-python-dotenv = "^1.0.1"
-supabase = "^2.9.1"
+fastapi = "^0.116.1"
+google-cloud-logging = "^3.12.1"
+launchdarkly-server-sdk = "^9.12.0"
+pydantic = "^2.11.7"
+pydantic-settings = "^2.10.1"
+pyjwt = "^2.10.1"
+pytest-asyncio = "^1.1.0"
+pytest-mock = "^3.14.1"
+redis = "^6.2.0"
+supabase = "^2.16.0"
+uvicorn = "^0.35.0"
 
 [tool.poetry.group.dev.dependencies]
-redis = "^5.2.0"
+ruff = "^0.12.9"
 
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+extend-select = ["I"]  # sort dependencies

autogpt_platform/backend/.dockerignore

@@ -0,0 +1,52 @@
+# Development and testing files
+**/__pycache__
+**/*.pyc
+**/*.pyo
+**/*.pyd
+**/.Python
+**/env/
+**/venv/
+**/.venv/
+**/pip-log.txt
+**/.pytest_cache/
+**/test-results/
+**/snapshots/
+**/test/
+
+# IDE and editor files
+**/.vscode/
+**/.idea/
+**/*.swp
+**/*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Logs
+**/*.log
+**/logs/
+
+# Git
+.git/
+.gitignore
+
+# Documentation
+**/*.md
+!README.md
+
+# Local development files
+.env
+.env.local
+**/.env.test
+
+# Build artifacts
+**/dist/
+**/build/
+**/target/
+
+# Docker files (avoid recursion)
+Dockerfile*
+docker-compose*
+.dockerignore

autogpt_platform/backend/.env.default

@@ -0,0 +1,178 @@
+# Backend Configuration
+# This file contains environment variables that MUST be set for the AutoGPT platform
+# Variables with working defaults in settings.py are not included here
+
+## ===== REQUIRED DATABASE CONFIGURATION ===== ##
+# PostgreSQL Database Connection
+DB_USER=postgres
+DB_PASS=your-super-secret-and-long-postgres-password
+DB_NAME=postgres
+DB_PORT=5432
+DB_HOST=localhost
+DB_CONNECTION_LIMIT=12
+DB_CONNECT_TIMEOUT=60
+DB_POOL_TIMEOUT=300
+DB_SCHEMA=platform
+DATABASE_URL="postgresql://${DB_USER}:${DB_PASS}@${DB_HOST}:${DB_PORT}/${DB_NAME}?schema=${DB_SCHEMA}&connect_timeout=${DB_CONNECT_TIMEOUT}"
+DIRECT_URL="postgresql://${DB_USER}:${DB_PASS}@${DB_HOST}:${DB_PORT}/${DB_NAME}?schema=${DB_SCHEMA}&connect_timeout=${DB_CONNECT_TIMEOUT}"
+PRISMA_SCHEMA="postgres/schema.prisma"
+ENABLE_AUTH=true
+
+## ===== REQUIRED SERVICE CREDENTIALS ===== ##
+# Redis Configuration
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=password
+
+# RabbitMQ Credentials
+RABBITMQ_DEFAULT_USER=rabbitmq_user_default
+RABBITMQ_DEFAULT_PASS=k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7
+
+# Supabase Authentication
+SUPABASE_URL=http://localhost:8000
+SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJzZXJ2aWNlX3JvbGUiLAogICAgImlzcyI6ICJzdXBhYmFzZS1kZW1vIiwKICAgICJpYXQiOiAxNjQxNzY5MjAwLAogICAgImV4cCI6IDE3OTk1MzU2MDAKfQ.DaYlNEoUrrEn2Ig7tqibS-PHK5vgusbcbo7X36XVt4Q
+SUPABASE_JWT_SECRET=your-super-secret-jwt-token-with-at-least-32-characters-long
+
+## ===== REQUIRED SECURITY KEYS ===== ##
+# Generate using: from cryptography.fernet import Fernet;Fernet.generate_key().decode()
+ENCRYPTION_KEY=dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw=
+UNSUBSCRIBE_SECRET_KEY=HlP8ivStJjmbf6NKi78m_3FnOogut0t5ckzjsIqeaio=
+
+## ===== IMPORTANT OPTIONAL CONFIGURATION ===== ##
+# Platform URLs (set these for webhooks and OAuth to work)
+PLATFORM_BASE_URL=http://localhost:8000
+FRONTEND_BASE_URL=http://localhost:3000
+
+# Media Storage (required for marketplace and library functionality)
+MEDIA_GCS_BUCKET_NAME=
+
+## ===== API KEYS AND OAUTH CREDENTIALS ===== ##
+# All API keys below are optional - only add what you need
+
+# AI/LLM Services
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+GROQ_API_KEY=
+LLAMA_API_KEY=
+AIML_API_KEY=
+V0_API_KEY=
+OPEN_ROUTER_API_KEY=
+NVIDIA_API_KEY=
+
+# OAuth Credentials
+# For the OAuth callback URL, use <your_frontend_url>/auth/integrations/oauth_callback,
+# e.g. http://localhost:3000/auth/integrations/oauth_callback
+
+# GitHub OAuth App server credentials - https://github.com/settings/developers
+GITHUB_CLIENT_ID=
+GITHUB_CLIENT_SECRET=
+
+# Google OAuth App server credentials - https://console.cloud.google.com/apis/credentials, and enable gmail api and set scopes
+# https://console.cloud.google.com/apis/credentials/consent ?project=<your_project_id>
+# You'll need to add/enable the following scopes (minimum):
+# https://console.developers.google.com/apis/api/gmail.googleapis.com/overview ?project=<your_project_id>
+# https://console.cloud.google.com/apis/library/sheets.googleapis.com/ ?project=<your_project_id>
+GOOGLE_CLIENT_ID=
+GOOGLE_CLIENT_SECRET=
+
+# Twitter (X) OAuth 2.0 with PKCE Configuration
+# 1. Create a Twitter Developer Account:
+#    - Visit https://developer.x.com/en and sign up
+# 2. Set up your application:
+#    - Navigate to Developer Portal > Projects > Create Project
+#    - Add a new app to your project
+# 3. Configure app settings:
+#    - App Permissions: Read + Write + Direct Messages
+#    - App Type: Web App, Automated App or Bot
+#    - OAuth 2.0 Callback URL: http://localhost:3000/auth/integrations/oauth_callback
+#    - Save your Client ID and Client Secret below
+TWITTER_CLIENT_ID=
+TWITTER_CLIENT_SECRET=
+
+# Linear App
+# Make a new workspace for your OAuth APP -- trust me
+# https://linear.app/settings/api/applications/new
+# Callback URL: http://localhost:3000/auth/integrations/oauth_callback
+LINEAR_CLIENT_ID=
+LINEAR_CLIENT_SECRET=
+
+# To obtain Todoist API credentials:
+# 1. Create a Todoist account at todoist.com
+# 2. Visit the Developer Console: https://developer.todoist.com/appconsole.html
+# 3. Click "Create new app"
+# 4. Once created, copy your Client ID and Client Secret below
+TODOIST_CLIENT_ID=
+TODOIST_CLIENT_SECRET=
+
+NOTION_CLIENT_ID=
+NOTION_CLIENT_SECRET=
+
+# Discord OAuth App credentials
+# 1. Go to https://discord.com/developers/applications
+# 2. Create a new application
+# 3. Go to OAuth2 section and add redirect URI: http://localhost:3000/auth/integrations/oauth_callback
+# 4. Copy Client ID and Client Secret below
+DISCORD_CLIENT_ID=
+DISCORD_CLIENT_SECRET=
+
+REDDIT_CLIENT_ID=
+REDDIT_CLIENT_SECRET=
+
+# Payment Processing
+STRIPE_API_KEY=
+STRIPE_WEBHOOK_SECRET=
+
+# Email Service (for sending notifications and confirmations)
+POSTMARK_SERVER_API_TOKEN=
+POSTMARK_SENDER_EMAIL=invalid@invalid.com
+POSTMARK_WEBHOOK_TOKEN=
+
+# Error Tracking
+SENTRY_DSN=
+
+# Cloudflare Turnstile (CAPTCHA) Configuration
+# Get these from the Cloudflare Turnstile dashboard: https://dash.cloudflare.com/?to=/:account/turnstile
+# This is the backend secret key
+TURNSTILE_SECRET_KEY=
+# This is the verify URL
+TURNSTILE_VERIFY_URL=https://challenges.cloudflare.com/turnstile/v0/siteverify
+
+# Feature Flags
+LAUNCH_DARKLY_SDK_KEY=
+
+# Content Generation & Media
+DID_API_KEY=
+FAL_API_KEY=
+IDEOGRAM_API_KEY=
+REPLICATE_API_KEY=
+REVID_API_KEY=
+SCREENSHOTONE_API_KEY=
+UNREAL_SPEECH_API_KEY=
+
+# Data & Search Services
+E2B_API_KEY=
+EXA_API_KEY=
+JINA_API_KEY=
+MEM0_API_KEY=
+OPENWEATHERMAP_API_KEY=
+GOOGLE_MAPS_API_KEY=
+
+# Communication Services
+DISCORD_BOT_TOKEN=
+MEDIUM_API_KEY=
+MEDIUM_AUTHOR_ID=
+SMTP_SERVER=
+SMTP_PORT=
+SMTP_USERNAME=
+SMTP_PASSWORD=
+
+# Business & Marketing Tools
+APOLLO_API_KEY=
+ENRICHLAYER_API_KEY=
+AYRSHARE_API_KEY=
+AYRSHARE_JWT_KEY=
+SMARTLEAD_API_KEY=
+ZEROBOUNCE_API_KEY=
+
+# Other Services
+AUTOMOD_API_KEY=

autogpt_platform/backend/.env.example

@@ -1,106 +0,0 @@
-DB_USER=postgres
-DB_PASS=your-super-secret-and-long-postgres-password
-DB_NAME=postgres
-DB_PORT=5432
-DATABASE_URL="postgresql://${DB_USER}:${DB_PASS}@localhost:${DB_PORT}/${DB_NAME}?connect_timeout=60&schema=platform"
-PRISMA_SCHEMA="postgres/schema.prisma"
-
-BACKEND_CORS_ALLOW_ORIGINS=["http://localhost:3000"]
-
-# generate using `from cryptography.fernet import Fernet;Fernet.generate_key().decode()`
-ENCRYPTION_KEY='dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw='
-
-REDIS_HOST=localhost
-REDIS_PORT=6379
-REDIS_PASSWORD=password
-
-ENABLE_CREDIT=false
-# What environment things should be logged under: local dev or prod
-APP_ENV=local
-# What environment to behave as: "local" or "cloud"
-BEHAVE_AS=local
-PYRO_HOST=localhost
-SENTRY_DSN=
-
-## User auth with Supabase is required for any of the 3rd party integrations with auth to work.
-ENABLE_AUTH=true
-SUPABASE_URL=http://localhost:8000
-SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJzZXJ2aWNlX3JvbGUiLAogICAgImlzcyI6ICJzdXBhYmFzZS1kZW1vIiwKICAgICJpYXQiOiAxNjQxNzY5MjAwLAogICAgImV4cCI6IDE3OTk1MzU2MDAKfQ.DaYlNEoUrrEn2Ig7tqibS-PHK5vgusbcbo7X36XVt4Q
-SUPABASE_JWT_SECRET=your-super-secret-jwt-token-with-at-least-32-characters-long
-
-# For local development, you may need to set FRONTEND_BASE_URL for the OAuth flow for integrations to work.
-FRONTEND_BASE_URL=http://localhost:3000
-
-## == INTEGRATION CREDENTIALS == ##
-# Each set of server side credentials is required for the corresponding 3rd party
-# integration to work.
-
-# For the OAuth callback URL, use <your_frontend_url>/auth/integrations/oauth_callback,
-# e.g. http://localhost:3000/auth/integrations/oauth_callback
-
-# GitHub OAuth App server credentials - https://github.com/settings/developers
-GITHUB_CLIENT_ID=
-GITHUB_CLIENT_SECRET=
-
-# Google OAuth App server credentials - https://console.cloud.google.com/apis/credentials, and enable gmail api and set scopes
-# https://console.cloud.google.com/apis/credentials/consent ?project=<your_project_id>
-
-# You'll need to add/enable the following scopes (minimum):
-# https://console.developers.google.com/apis/api/gmail.googleapis.com/overview ?project=<your_project_id>
-# https://console.cloud.google.com/apis/library/sheets.googleapis.com/ ?project=<your_project_id>
-GOOGLE_CLIENT_ID=
-GOOGLE_CLIENT_SECRET=
-
-## ===== OPTIONAL API KEYS ===== ##
-
-# LLM
-OPENAI_API_KEY=
-ANTHROPIC_API_KEY=
-GROQ_API_KEY=
-
-# Reddit
-REDDIT_CLIENT_ID=
-REDDIT_CLIENT_SECRET=
-REDDIT_USERNAME=
-REDDIT_PASSWORD=
-
-# Discord
-DISCORD_BOT_TOKEN=
-
-# SMTP/Email
-SMTP_SERVER=
-SMTP_PORT=
-SMTP_USERNAME=
-SMTP_PASSWORD=
-
-# D-ID
-DID_API_KEY=
-
-# Open Weather Map
-OPENWEATHERMAP_API_KEY=
-
-# SMTP
-SMTP_SERVER=
-SMTP_PORT=
-SMTP_USERNAME=
-SMTP_PASSWORD=
-
-# Medium
-MEDIUM_API_KEY=
-MEDIUM_AUTHOR_ID=
-
-# Google Maps
-GOOGLE_MAPS_API_KEY=
-
-# Replicate
-REPLICATE_API_KEY=
-
-# Ideogram
-IDEOGRAM_API_KEY=
-
-# Logging Configuration
-LOG_LEVEL=INFO
-ENABLE_CLOUD_LOGGING=false
-ENABLE_FILE_LOGGING=false
-# Use to manually set the log directory
-# LOG_DIR=./logs

autogpt_platform/backend/.gitignore

@@ -1,3 +1,4 @@
+.env
 database.db
 database.db-journal
 dev.db

autogpt_platform/backend/Dockerfile

@@ -1,63 +1,69 @@
-FROM python:3.11-slim-buster AS builder
+FROM debian:13-slim AS builder
 
 # Set environment variables
-ENV PYTHONDONTWRITEBYTECODE 1
-ENV PYTHONUNBUFFERED 1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV DEBIAN_FRONTEND=noninteractive
 
 WORKDIR /app
 
-# Install build dependencies
-RUN apt-get update \
-    && apt-get install -y build-essential curl ffmpeg wget libcurl4-gnutls-dev libexpat1-dev libpq5 gettext libz-dev libssl-dev postgresql-client git \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
+RUN echo 'Acquire::http::Pipeline-Depth 0;\nAcquire::http::No-Cache true;\nAcquire::BrokenProxy true;\n' > /etc/apt/apt.conf.d/99fixbadproxy
 
-ENV POETRY_VERSION=1.8.3 \
-    POETRY_HOME="/opt/poetry" \
-    POETRY_NO_INTERACTION=1 \
-    POETRY_VIRTUALENVS_CREATE=false \
-    PATH="$POETRY_HOME/bin:$PATH"
+# Update package list and install Python and build dependencies
+RUN apt-get update --allow-releaseinfo-change --fix-missing \
+    && apt-get install -y \
+    python3.13 \
+    python3.13-dev \
+    python3.13-venv \
+    python3-pip \
+    build-essential \
+    libpq5 \
+    libz-dev \
+    libssl-dev \
+    postgresql-client
 
-# Upgrade pip and setuptools to fix security vulnerabilities
-RUN pip3 install --upgrade pip setuptools
+ENV POETRY_HOME=/opt/poetry
+ENV POETRY_NO_INTERACTION=1
+ENV POETRY_VIRTUALENVS_CREATE=true
+ENV POETRY_VIRTUALENVS_IN_PROJECT=true
+ENV PATH=/opt/poetry/bin:$PATH
 
-RUN pip3 install poetry
+RUN pip3 install poetry --break-system-packages
 
 # Copy and install dependencies
 COPY autogpt_platform/autogpt_libs /app/autogpt_platform/autogpt_libs
 COPY autogpt_platform/backend/poetry.lock autogpt_platform/backend/pyproject.toml /app/autogpt_platform/backend/
 WORKDIR /app/autogpt_platform/backend
-RUN poetry config virtualenvs.create false \
-    && poetry install --no-interaction --no-ansi
+RUN poetry install --no-ansi --no-root
 
 # Generate Prisma client
 COPY autogpt_platform/backend/schema.prisma ./
-RUN poetry config virtualenvs.create false \
-    && poetry run prisma generate
+RUN poetry run prisma generate
 
-FROM python:3.11-slim-buster AS server_dependencies
+FROM debian:13-slim AS server_dependencies
 
 WORKDIR /app
 
-ENV POETRY_VERSION=1.8.3 \
-    POETRY_HOME="/opt/poetry" \
+ENV POETRY_HOME=/opt/poetry \
     POETRY_NO_INTERACTION=1 \
-    POETRY_VIRTUALENVS_CREATE=false \
-    PATH="$POETRY_HOME/bin:$PATH"
+    POETRY_VIRTUALENVS_CREATE=true \
+    POETRY_VIRTUALENVS_IN_PROJECT=true \
+    DEBIAN_FRONTEND=noninteractive
+ENV PATH=/opt/poetry/bin:$PATH
 
-
-# Upgrade pip and setuptools to fix security vulnerabilities
-RUN pip3 install --upgrade pip setuptools
+# Install Python without upgrading system-managed packages
+RUN apt-get update && apt-get install -y \
+    python3.13 \
+    python3-pip
 
 # Copy only necessary files from builder
 COPY --from=builder /app /app
-COPY --from=builder /usr/local/lib/python3.11 /usr/local/lib/python3.11
-COPY --from=builder /usr/local/bin /usr/local/bin
+COPY --from=builder /usr/local/lib/python3* /usr/local/lib/python3*
+COPY --from=builder /usr/local/bin/poetry /usr/local/bin/poetry
 # Copy Prisma binaries
 COPY --from=builder /root/.cache/prisma-python/binaries /root/.cache/prisma-python/binaries
 
-
-ENV PATH="/app/.venv/bin:$PATH"
+ENV PATH="/app/autogpt_platform/backend/.venv/bin:$PATH"
 
 RUN mkdir -p /app/autogpt_platform/autogpt_libs
 RUN mkdir -p /app/autogpt_platform/backend
@@ -68,11 +74,17 @@ COPY autogpt_platform/backend/poetry.lock autogpt_platform/backend/pyproject.tom
 
 WORKDIR /app/autogpt_platform/backend
 
+FROM server_dependencies AS migrate
+
+# Migration stage only needs schema and migrations - much lighter than full backend
+COPY autogpt_platform/backend/schema.prisma /app/autogpt_platform/backend/
+COPY autogpt_platform/backend/migrations /app/autogpt_platform/backend/migrations
+
 FROM server_dependencies AS server
 
 COPY autogpt_platform/backend /app/autogpt_platform/backend
+RUN poetry install --no-ansi --only-root
 
-ENV DATABASE_URL=""
 ENV PORT=8000
 
 CMD ["poetry", "run", "rest"]

autogpt_platform/backend/README.advanced.md

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

autogpt_platform/backend/README.md

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

autogpt_platform/backend/TESTING.md

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

autogpt_platform/backend/backend/TEST_DATA_README.md

@@ -0,0 +1,150 @@
+# Test Data Scripts
+
+This directory contains scripts for creating and updating test data in the AutoGPT Platform database, specifically designed to test the materialized views for the store functionality.
+
+## Scripts
+
+### test_data_creator.py
+Creates a comprehensive set of test data including:
+- Users with profiles
+- Agent graphs, nodes, and executions
+- Store listings with multiple versions
+- Reviews and ratings
+- Library agents
+- Integration webhooks
+- Onboarding data
+- Credit transactions
+
+**Image/Video Domains Used:**
+- Images: `picsum.photos` (for all image URLs)
+- Videos: `youtube.com` (for store listing videos)
+
+### test_data_updater.py
+Updates existing test data to simulate real-world changes:
+- Adds new agent graph executions
+- Creates new store listing reviews
+- Updates store listing versions
+- Adds credit transactions
+- Refreshes materialized views
+
+### check_db.py
+Tests and verifies materialized views functionality:
+- Checks pg_cron job status (for automatic refresh)
+- Displays current materialized view counts
+- Adds test data (executions and reviews)
+- Creates store listings if none exist
+- Manually refreshes materialized views
+- Compares before/after counts to verify updates
+- Provides a summary of test results
+
+## Materialized Views
+
+The scripts test three key database views:
+
+1. **mv_agent_run_counts**: Tracks execution counts by agent
+2. **mv_review_stats**: Tracks review statistics (count, average rating) by store listing
+3. **StoreAgent**: A view that combines store listing data with execution counts and ratings for display
+
+The materialized views (mv_agent_run_counts and mv_review_stats) are automatically refreshed every 15 minutes via pg_cron, or can be manually refreshed using the `refresh_store_materialized_views()` function.
+
+## Usage
+
+### Prerequisites
+
+1. Ensure the database is running:
+```bash
+docker compose up -d
+# or for test database:
+docker compose -f docker-compose.test.yaml --env-file ../.env up -d
+```
+
+2. Run database migrations:
+```bash
+poetry run prisma migrate deploy
+```
+
+### Running the Scripts
+
+#### Option 1: Use the helper script (from backend directory)
+```bash
+poetry run python run_test_data.py
+```
+
+#### Option 2: Run individually
+```bash
+# From backend/test directory:
+# Create initial test data
+poetry run python test_data_creator.py
+
+# Update data to test materialized view changes
+poetry run python test_data_updater.py
+
+# From backend directory:
+# Test materialized views functionality
+poetry run python check_db.py
+
+# Check store data status
+poetry run python check_store_data.py
+```
+
+#### Option 3: Use the shell script (from backend directory)
+```bash
+./run_test_data_scripts.sh
+```
+
+### Manual Materialized View Refresh
+
+To manually refresh the materialized views:
+```sql
+SELECT refresh_store_materialized_views();
+```
+
+## Configuration
+
+The scripts use the database configuration from your `.env` file:
+- `DATABASE_URL`: PostgreSQL connection string
+- Database should have the platform schema
+
+## Data Generation Limits
+
+Configured in `test_data_creator.py`:
+- 100 users
+- 100 agent blocks
+- 1-5 graphs per user
+- 2-5 nodes per graph
+- 1-5 presets per user
+- 1-10 library agents per user
+- 1-20 executions per graph
+- 1-5 reviews per store listing version
+
+## Notes
+
+- All image URLs use `picsum.photos` for consistency with Next.js image configuration
+- The scripts create realistic relationships between entities
+- Materialized views are refreshed at the end of each script
+- Data is designed to test both happy paths and edge cases
+
+## Troubleshooting
+
+### Reviews and StoreAgent view showing 0
+
+If `check_db.py` shows that reviews remain at 0 and StoreAgent view shows 0 store agents:
+
+1. **No store listings exist**: The script will automatically create test store listings if none exist
+2. **No approved versions**: Store listings need approved versions to appear in the StoreAgent view
+3. **Check with `check_store_data.py`**: This script provides detailed information about:
+   - Total store listings
+   - Store listing versions by status
+   - Existing reviews
+   - StoreAgent view contents
+   - Agent graph executions
+
+### pg_cron not installed
+
+The warning "pg_cron extension is not installed" is normal in local development environments. The materialized views can still be refreshed manually using the `refresh_store_materialized_views()` function, which all scripts do automatically.
+
+### Common Issues
+
+- **Type errors with None values**: Fixed in the latest version of check_db.py by using `or 0` for nullable numeric fields
+- **Missing relations**: Ensure you're using the correct field names (e.g., `StoreListing` not `storeListing` in includes)
+- **Column name mismatches**: The database uses camelCase for column names (e.g., `agentGraphId` not `agent_graph_id`)

autogpt_platform/backend/backend/app.py

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

autogpt_platform/backend/backend/blocks/__init__.py

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

autogpt_platform/backend/backend/blocks/agent.py

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

autogpt_platform/backend/backend/blocks/ai_image_generator_block.py

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

autogpt_platform/backend/backend/blocks/ai_music_generator.py

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

autogpt_platform/backend/backend/blocks/ai_shortform_video_block.py

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

autogpt_platform/backend/backend/blocks/airtable/_api_test.py

@@ -0,0 +1,323 @@
+from os import getenv
+from uuid import uuid4
+
+import pytest
+
+from backend.sdk import APIKeyCredentials, SecretStr
+
+from ._api import (
+    TableFieldType,
+    WebhookFilters,
+    WebhookSpecification,
+    create_base,
+    create_field,
+    create_record,
+    create_table,
+    create_webhook,
+    delete_multiple_records,
+    delete_record,
+    delete_webhook,
+    get_record,
+    list_bases,
+    list_records,
+    list_webhook_payloads,
+    update_field,
+    update_multiple_records,
+    update_record,
+    update_table,
+)
+
+
+@pytest.mark.asyncio
+async def test_create_update_table():
+
+    key = getenv("AIRTABLE_API_KEY")
+    if not key:
+        return pytest.skip("AIRTABLE_API_KEY is not set")
+
+    credentials = APIKeyCredentials(
+        provider="airtable",
+        api_key=SecretStr(key),
+    )
+    postfix = uuid4().hex[:4]
+    workspace_id = "wsphuHmfllg7V3Brd"
+    response = await create_base(credentials, workspace_id, "API Testing Base")
+    assert response is not None, f"Checking create base response: {response}"
+    assert (
+        response.get("id") is not None
+    ), f"Checking create base response id: {response}"
+    base_id = response.get("id")
+    assert base_id is not None, f"Checking create base response id: {base_id}"
+
+    response = await list_bases(credentials)
+    assert response is not None, f"Checking list bases response: {response}"
+    assert "API Testing Base" in [
+        base.get("name") for base in response.get("bases", [])
+    ], f"Checking list bases response bases: {response}"
+
+    table_name = f"test_table_{postfix}"
+    table_fields = [{"name": "test_field", "type": "singleLineText"}]
+    table = await create_table(credentials, base_id, table_name, table_fields)
+    assert table.get("name") == table_name
+
+    table_id = table.get("id")
+
+    assert table_id is not None
+
+    table_name = f"test_table_updated_{postfix}"
+    table_description = "test_description_updated"
+    table = await update_table(
+        credentials,
+        base_id,
+        table_id,
+        table_name=table_name,
+        table_description=table_description,
+    )
+    assert table.get("name") == table_name
+    assert table.get("description") == table_description
+
+
+@pytest.mark.asyncio
+async def test_invalid_field_type():
+
+    key = getenv("AIRTABLE_API_KEY")
+    if not key:
+        return pytest.skip("AIRTABLE_API_KEY is not set")
+
+    credentials = APIKeyCredentials(
+        provider="airtable",
+        api_key=SecretStr(key),
+    )
+    postfix = uuid4().hex[:4]
+    base_id = "appZPxegHEU3kDc1S"
+    table_name = f"test_table_{postfix}"
+    table_fields = [{"name": "test_field", "type": "notValid"}]
+    with pytest.raises(AssertionError):
+        await create_table(credentials, base_id, table_name, table_fields)
+
+
+@pytest.mark.asyncio
+async def test_create_and_update_field():
+    key = getenv("AIRTABLE_API_KEY")
+    if not key:
+        return pytest.skip("AIRTABLE_API_KEY is not set")
+
+    credentials = APIKeyCredentials(
+        provider="airtable",
+        api_key=SecretStr(key),
+    )
+    postfix = uuid4().hex[:4]
+    base_id = "appZPxegHEU3kDc1S"
+    table_name = f"test_table_{postfix}"
+    table_fields = [{"name": "test_field", "type": "singleLineText"}]
+    table = await create_table(credentials, base_id, table_name, table_fields)
+    assert table.get("name") == table_name
+
+    table_id = table.get("id")
+
+    assert table_id is not None
+
+    field_name = f"test_field_{postfix}"
+    field_type = TableFieldType.SINGLE_LINE_TEXT
+    field = await create_field(credentials, base_id, table_id, field_type, field_name)
+    assert field.get("name") == field_name
+
+    field_id = field.get("id")
+
+    assert field_id is not None
+    assert isinstance(field_id, str)
+
+    field_name = f"test_field_updated_{postfix}"
+    field = await update_field(credentials, base_id, table_id, field_id, field_name)
+    assert field.get("name") == field_name
+
+    field_description = "test_description_updated"
+    field = await update_field(
+        credentials, base_id, table_id, field_id, description=field_description
+    )
+    assert field.get("description") == field_description
+
+
+@pytest.mark.asyncio
+async def test_record_management():
+    key = getenv("AIRTABLE_API_KEY")
+    if not key:
+        return pytest.skip("AIRTABLE_API_KEY is not set")
+
+    credentials = APIKeyCredentials(
+        provider="airtable",
+        api_key=SecretStr(key),
+    )
+    postfix = uuid4().hex[:4]
+    base_id = "appZPxegHEU3kDc1S"
+    table_name = f"test_table_{postfix}"
+    table_fields = [{"name": "test_field", "type": "singleLineText"}]
+    table = await create_table(credentials, base_id, table_name, table_fields)
+    assert table.get("name") == table_name
+
+    table_id = table.get("id")
+    assert table_id is not None
+
+    # Create a record
+    record_fields = {"test_field": "test_value"}
+    record = await create_record(credentials, base_id, table_id, fields=record_fields)
+    fields = record.get("fields")
+    assert fields is not None
+    assert isinstance(fields, dict)
+    assert fields.get("test_field") == "test_value"
+
+    record_id = record.get("id")
+
+    assert record_id is not None
+    assert isinstance(record_id, str)
+
+    # Get a record
+    record = await get_record(credentials, base_id, table_id, record_id)
+    fields = record.get("fields")
+    assert fields is not None
+    assert isinstance(fields, dict)
+    assert fields.get("test_field") == "test_value"
+
+    # Updata a record
+    record_fields = {"test_field": "test_value_updated"}
+    record = await update_record(
+        credentials, base_id, table_id, record_id, fields=record_fields
+    )
+    fields = record.get("fields")
+    assert fields is not None
+    assert isinstance(fields, dict)
+    assert fields.get("test_field") == "test_value_updated"
+
+    # Delete a record
+    record = await delete_record(credentials, base_id, table_id, record_id)
+    assert record is not None
+    assert record.get("id") == record_id
+    assert record.get("deleted")
+
+    # Create 2 records
+    records = [
+        {"fields": {"test_field": "test_value_1"}},
+        {"fields": {"test_field": "test_value_2"}},
+    ]
+    response = await create_record(credentials, base_id, table_id, records=records)
+    created_records = response.get("records")
+    assert created_records is not None
+    assert isinstance(created_records, list)
+    assert len(created_records) == 2, f"Created records: {created_records}"
+    first_record = created_records[0]  # type: ignore
+    second_record = created_records[1]  # type: ignore
+    first_record_id = first_record.get("id")
+    second_record_id = second_record.get("id")
+    assert first_record_id is not None
+    assert second_record_id is not None
+    assert first_record_id != second_record_id
+    first_fields = first_record.get("fields")
+    second_fields = second_record.get("fields")
+    assert first_fields is not None
+    assert second_fields is not None
+    assert first_fields.get("test_field") == "test_value_1"  # type: ignore
+    assert second_fields.get("test_field") == "test_value_2"  # type: ignore
+
+    # List records
+    response = await list_records(credentials, base_id, table_id)
+    records = response.get("records")
+    assert records is not None
+    assert len(records) == 2, f"Records: {records}"
+    assert isinstance(records, list), f"Type of records: {type(records)}"
+
+    # Update multiple records
+    records = [
+        {"id": first_record_id, "fields": {"test_field": "test_value_1_updated"}},
+        {"id": second_record_id, "fields": {"test_field": "test_value_2_updated"}},
+    ]
+    response = await update_multiple_records(
+        credentials, base_id, table_id, records=records
+    )
+    updated_records = response.get("records")
+    assert updated_records is not None
+    assert len(updated_records) == 2, f"Updated records: {updated_records}"
+    assert isinstance(
+        updated_records, list
+    ), f"Type of updated records: {type(updated_records)}"
+    first_updated = updated_records[0]  # type: ignore
+    second_updated = updated_records[1]  # type: ignore
+    first_updated_fields = first_updated.get("fields")
+    second_updated_fields = second_updated.get("fields")
+    assert first_updated_fields is not None
+    assert second_updated_fields is not None
+    assert first_updated_fields.get("test_field") == "test_value_1_updated"  # type: ignore
+    assert second_updated_fields.get("test_field") == "test_value_2_updated"  # type: ignore
+
+    # Delete multiple records
+    assert isinstance(first_record_id, str)
+    assert isinstance(second_record_id, str)
+    response = await delete_multiple_records(
+        credentials, base_id, table_id, records=[first_record_id, second_record_id]
+    )
+    deleted_records = response.get("records")
+    assert deleted_records is not None
+    assert len(deleted_records) == 2, f"Deleted records: {deleted_records}"
+    assert isinstance(
+        deleted_records, list
+    ), f"Type of deleted records: {type(deleted_records)}"
+    first_deleted = deleted_records[0]  # type: ignore
+    second_deleted = deleted_records[1]  # type: ignore
+    assert first_deleted.get("deleted")
+    assert second_deleted.get("deleted")
+
+
+@pytest.mark.asyncio
+async def test_webhook_management():
+    key = getenv("AIRTABLE_API_KEY")
+    if not key:
+        return pytest.skip("AIRTABLE_API_KEY is not set")
+
+    credentials = APIKeyCredentials(
+        provider="airtable",
+        api_key=SecretStr(key),
+    )
+    postfix = uuid4().hex[:4]
+    base_id = "appZPxegHEU3kDc1S"
+    table_name = f"test_table_{postfix}"
+    table_fields = [{"name": "test_field", "type": "singleLineText"}]
+    table = await create_table(credentials, base_id, table_name, table_fields)
+    assert table.get("name") == table_name
+
+    table_id = table.get("id")
+    assert table_id is not None
+    webhook_specification = WebhookSpecification(
+        filters=WebhookFilters(
+            dataTypes=["tableData", "tableFields", "tableMetadata"],
+            changeTypes=["add", "update", "remove"],
+        )
+    )
+    response = await create_webhook(credentials, base_id, webhook_specification)
+    assert response is not None, f"Checking create webhook response: {response}"
+    assert (
+        response.get("id") is not None
+    ), f"Checking create webhook response id: {response}"
+    assert (
+        response.get("macSecretBase64") is not None
+    ), f"Checking create webhook response macSecretBase64: {response}"
+
+    webhook_id = response.get("id")
+    assert webhook_id is not None, f"Webhook ID: {webhook_id}"
+    assert isinstance(webhook_id, str)
+
+    response = await create_record(
+        credentials, base_id, table_id, fields={"test_field": "test_value"}
+    )
+    assert response is not None, f"Checking create record response: {response}"
+    assert (
+        response.get("id") is not None
+    ), f"Checking create record response id: {response}"
+    fields = response.get("fields")
+    assert fields is not None, f"Checking create record response fields: {response}"
+    assert (
+        fields.get("test_field") == "test_value"
+    ), f"Checking create record response fields test_field: {response}"
+
+    response = await list_webhook_payloads(credentials, base_id, webhook_id)
+    assert response is not None, f"Checking list webhook payloads response: {response}"
+
+    response = await delete_webhook(credentials, base_id, webhook_id)

autogpt_platform/backend/backend/blocks/airtable/_config.py

@@ -0,0 +1,32 @@
+"""
+Shared configuration for all Airtable blocks using the SDK pattern.
+"""
+
+from backend.sdk import BlockCostType, ProviderBuilder
+
+from ._oauth import AirtableOAuthHandler, AirtableScope
+from ._webhook import AirtableWebhookManager
+
+# Configure the Airtable provider with API key authentication
+airtable = (
+    ProviderBuilder("airtable")
+    .with_api_key("AIRTABLE_API_KEY", "Airtable Personal Access Token")
+    .with_webhook_manager(AirtableWebhookManager)
+    .with_base_cost(1, BlockCostType.RUN)
+    .with_oauth(
+        AirtableOAuthHandler,
+        scopes=[
+            v.value
+            for v in [
+                AirtableScope.DATA_RECORDS_READ,
+                AirtableScope.DATA_RECORDS_WRITE,
+                AirtableScope.SCHEMA_BASES_READ,
+                AirtableScope.SCHEMA_BASES_WRITE,
+                AirtableScope.WEBHOOK_MANAGE,
+            ]
+        ],
+        client_id_env_var="AIRTABLE_CLIENT_ID",
+        client_secret_env_var="AIRTABLE_CLIENT_SECRET",
+    )
+    .build()
+)

autogpt_platform/backend/backend/blocks/airtable/_oauth.py

@@ -0,0 +1,185 @@
+"""
+Airtable OAuth handler implementation.
+"""
+
+import time
+from enum import Enum
+from logging import getLogger
+from typing import Optional
+
+from backend.sdk import BaseOAuthHandler, OAuth2Credentials, ProviderName, SecretStr
+
+from ._api import (
+    OAuthTokenResponse,
+    make_oauth_authorize_url,
+    oauth_exchange_code_for_tokens,
+    oauth_refresh_tokens,
+)
+
+logger = getLogger(__name__)
+
+
+class AirtableScope(str, Enum):
+    # Basic scopes
+    DATA_RECORDS_READ = "data.records:read"
+    DATA_RECORDS_WRITE = "data.records:write"
+    DATA_RECORD_COMMENTS_READ = "data.recordComments:read"
+    DATA_RECORD_COMMENTS_WRITE = "data.recordComments:write"
+    SCHEMA_BASES_READ = "schema.bases:read"
+    SCHEMA_BASES_WRITE = "schema.bases:write"
+    WEBHOOK_MANAGE = "webhook:manage"
+    BLOCK_MANAGE = "block:manage"
+    USER_EMAIL_READ = "user.email:read"
+
+    # Enterprise member scopes
+    ENTERPRISE_GROUPS_READ = "enterprise.groups:read"
+    WORKSPACES_AND_BASES_READ = "workspacesAndBases:read"
+    WORKSPACES_AND_BASES_WRITE = "workspacesAndBases:write"
+    WORKSPACES_AND_BASES_SHARES_MANAGE = "workspacesAndBases.shares:manage"
+
+    # Enterprise admin scopes
+    ENTERPRISE_SCIM_USERS_AND_GROUPS_MANAGE = "enterprise.scim.usersAndGroups:manage"
+    ENTERPRISE_AUDIT_LOGS_READ = "enterprise.auditLogs:read"
+    ENTERPRISE_CHANGE_EVENTS_READ = "enterprise.changeEvents:read"
+    ENTERPRISE_EXPORTS_MANAGE = "enterprise.exports:manage"
+    ENTERPRISE_ACCOUNT_READ = "enterprise.account:read"
+    ENTERPRISE_ACCOUNT_WRITE = "enterprise.account:write"
+    ENTERPRISE_USER_READ = "enterprise.user:read"
+    ENTERPRISE_USER_WRITE = "enterprise.user:write"
+    ENTERPRISE_GROUPS_MANAGE = "enterprise.groups:manage"
+    WORKSPACES_AND_BASES_MANAGE = "workspacesAndBases:manage"
+    HYPERDB_RECORDS_READ = "hyperDB.records:read"
+    HYPERDB_RECORDS_WRITE = "hyperDB.records:write"
+
+
+class AirtableOAuthHandler(BaseOAuthHandler):
+    """
+    OAuth2 handler for Airtable with PKCE support.
+    """
+
+    PROVIDER_NAME = ProviderName("airtable")
+    DEFAULT_SCOPES = [
+        v.value
+        for v in [
+            AirtableScope.DATA_RECORDS_READ,
+            AirtableScope.DATA_RECORDS_WRITE,
+            AirtableScope.SCHEMA_BASES_READ,
+            AirtableScope.SCHEMA_BASES_WRITE,
+            AirtableScope.WEBHOOK_MANAGE,
+        ]
+    ]
+
+    def __init__(self, client_id: str, client_secret: Optional[str], redirect_uri: str):
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.redirect_uri = redirect_uri
+        self.scopes = self.DEFAULT_SCOPES
+        self.auth_base_url = "https://airtable.com/oauth2/v1/authorize"
+        self.token_url = "https://airtable.com/oauth2/v1/token"
+
+    def get_login_url(
+        self, scopes: list[str], state: str, code_challenge: Optional[str]
+    ) -> str:
+        logger.debug("Generating Airtable OAuth login URL")
+        # Generate code_challenge if not provided (PKCE is required)
+        if not scopes:
+            logger.debug("No scopes provided, using default scopes")
+            scopes = self.scopes
+
+        logger.debug(f"Using scopes: {scopes}")
+        logger.debug(f"State: {state}")
+        logger.debug(f"Code challenge: {code_challenge}")
+        if not code_challenge:
+            logger.error("Code challenge is required but none was provided")
+            raise ValueError("No code challenge provided")
+
+        try:
+            url = make_oauth_authorize_url(
+                self.client_id, self.redirect_uri, scopes, state, code_challenge
+            )
+            logger.debug(f"Generated OAuth URL: {url}")
+            return url
+        except Exception as e:
+            logger.error(f"Failed to generate OAuth URL: {str(e)}")
+            raise
+
+    async def exchange_code_for_tokens(
+        self, code: str, scopes: list[str], code_verifier: Optional[str]
+    ) -> OAuth2Credentials:
+        logger.debug("Exchanging authorization code for tokens")
+        logger.debug(f"Code: {code[:4]}...")  # Log first 4 chars only for security
+        logger.debug(f"Scopes: {scopes}")
+        if not code_verifier:
+            logger.error("Code verifier is required but none was provided")
+            raise ValueError("No code verifier provided")
+
+        try:
+            response: OAuthTokenResponse = await oauth_exchange_code_for_tokens(
+                client_id=self.client_id,
+                code=code,
+                code_verifier=code_verifier.encode("utf-8"),
+                redirect_uri=self.redirect_uri,
+                client_secret=self.client_secret,
+            )
+            logger.info("Successfully exchanged code for tokens")
+
+            credentials = OAuth2Credentials(
+                access_token=SecretStr(response.access_token),
+                refresh_token=SecretStr(response.refresh_token),
+                access_token_expires_at=int(time.time()) + response.expires_in,
+                refresh_token_expires_at=int(time.time()) + response.refresh_expires_in,
+                provider=self.PROVIDER_NAME,
+                scopes=scopes,
+            )
+            logger.debug(f"Access token expires in {response.expires_in} seconds")
+            logger.debug(
+                f"Refresh token expires in {response.refresh_expires_in} seconds"
+            )
+            return credentials
+
+        except Exception as e:
+            logger.error(f"Failed to exchange code for tokens: {str(e)}")
+            raise
+
+    async def _refresh_tokens(
+        self, credentials: OAuth2Credentials
+    ) -> OAuth2Credentials:
+        logger.debug("Attempting to refresh OAuth tokens")
+
+        if credentials.refresh_token is None:
+            logger.error("Cannot refresh tokens - no refresh token available")
+            raise ValueError("No refresh token available")
+
+        try:
+            response: OAuthTokenResponse = await oauth_refresh_tokens(
+                client_id=self.client_id,
+                refresh_token=credentials.refresh_token.get_secret_value(),
+                client_secret=self.client_secret,
+            )
+            logger.info("Successfully refreshed tokens")
+
+            new_credentials = OAuth2Credentials(
+                id=credentials.id,
+                access_token=SecretStr(response.access_token),
+                refresh_token=SecretStr(response.refresh_token),
+                access_token_expires_at=int(time.time()) + response.expires_in,
+                refresh_token_expires_at=int(time.time()) + response.refresh_expires_in,
+                provider=self.PROVIDER_NAME,
+                scopes=self.scopes,
+            )
+            logger.debug(f"New access token expires in {response.expires_in} seconds")
+            logger.debug(
+                f"New refresh token expires in {response.refresh_expires_in} seconds"
+            )
+            return new_credentials
+
+        except Exception as e:
+            logger.error(f"Failed to refresh tokens: {str(e)}")
+            raise
+
+    async def revoke_tokens(self, credentials: OAuth2Credentials) -> bool:
+        logger.debug("Token revocation requested")
+        logger.info(
+            "Airtable doesn't provide a token revocation endpoint - tokens will expire naturally after 60 minutes"
+        )
+        return False

autogpt_platform/backend/backend/blocks/airtable/_webhook.py

@@ -0,0 +1,154 @@
+"""
+Webhook management for Airtable blocks.
+"""
+
+import hashlib
+import hmac
+import logging
+from enum import Enum
+
+from backend.sdk import (
+    BaseWebhooksManager,
+    Credentials,
+    ProviderName,
+    Webhook,
+    update_webhook,
+)
+
+from ._api import (
+    WebhookFilters,
+    WebhookSpecification,
+    create_webhook,
+    delete_webhook,
+    list_webhook_payloads,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AirtableWebhookEvent(str, Enum):
+    TABLE_DATA = "tableData"
+    TABLE_FIELDS = "tableFields"
+    TABLE_METADATA = "tableMetadata"
+
+
+class AirtableWebhookManager(BaseWebhooksManager):
+    """Webhook manager for Airtable API."""
+
+    PROVIDER_NAME = ProviderName("airtable")
+
+    @classmethod
+    async def validate_payload(
+        cls, webhook: Webhook, request, credentials: Credentials | None
+    ) -> tuple[dict, str]:
+        """Validate incoming webhook payload and signature."""
+
+        if not credentials:
+            raise ValueError("Missing credentials in webhook metadata")
+
+        payload = await request.json()
+
+        # Verify webhook signature using HMAC-SHA256
+        if webhook.secret:
+            mac_secret = webhook.config.get("mac_secret")
+            if mac_secret:
+                # Get the raw body for signature verification
+                body = await request.body()
+
+                # Calculate expected signature
+                mac_secret_decoded = mac_secret.encode()
+                hmac_obj = hmac.new(mac_secret_decoded, body, hashlib.sha256)
+                expected_mac = f"hmac-sha256={hmac_obj.hexdigest()}"
+
+                # Get signature from headers
+                signature = request.headers.get("X-Airtable-Content-MAC")
+
+                if signature and not hmac.compare_digest(signature, expected_mac):
+                    raise ValueError("Invalid webhook signature")
+
+        # Validate payload structure
+        required_fields = ["base", "webhook", "timestamp"]
+        if not all(field in payload for field in required_fields):
+            raise ValueError("Invalid webhook payload structure")
+
+        if "id" not in payload["base"] or "id" not in payload["webhook"]:
+            raise ValueError("Missing required IDs in webhook payload")
+        base_id = payload["base"]["id"]
+        webhook_id = payload["webhook"]["id"]
+
+        # get payload request parameters
+        cursor = webhook.config.get("cursor", 1)
+
+        response = await list_webhook_payloads(credentials, base_id, webhook_id, cursor)
+
+        # update webhook config
+        await update_webhook(
+            webhook.id,
+            config={"base_id": base_id, "cursor": response.cursor},
+        )
+
+        event_type = "notification"
+        return response.model_dump(), event_type
+
+    async def _register_webhook(
+        self,
+        credentials: Credentials,
+        webhook_type: str,
+        resource: str,
+        events: list[str],
+        ingress_url: str,
+        secret: str,
+    ) -> tuple[str, dict]:
+        """Register webhook with Airtable API."""
+
+        # Parse resource to get base_id and table_id/name
+        # Resource format: "{base_id}/{table_id_or_name}"
+        parts = resource.split("/", 1)
+        if len(parts) != 2:
+            raise ValueError("Resource must be in format: {base_id}/{table_id_or_name}")
+
+        base_id, table_id_or_name = parts
+
+        # Prepare webhook specification
+        webhook_specification = WebhookSpecification(
+            filters=WebhookFilters(
+                dataTypes=events,
+            )
+        )
+
+        # Create webhook
+        webhook_data = await create_webhook(
+            credentials=credentials,
+            base_id=base_id,
+            webhook_specification=webhook_specification,
+            notification_url=ingress_url,
+        )
+
+        webhook_id = webhook_data["id"]
+        mac_secret = webhook_data.get("macSecretBase64")
+
+        return webhook_id, {
+            "webhook_id": webhook_id,
+            "base_id": base_id,
+            "table_id_or_name": table_id_or_name,
+            "events": events,
+            "mac_secret": mac_secret,
+            "cursor": 1,
+            "expiration_time": webhook_data.get("expirationTime"),
+        }
+
+    async def _deregister_webhook(
+        self, webhook: Webhook, credentials: Credentials
+    ) -> None:
+        """Deregister webhook from Airtable API."""
+
+        base_id = webhook.config.get("base_id")
+        webhook_id = webhook.config.get("webhook_id")
+
+        if not base_id:
+            raise ValueError("Missing base_id in webhook metadata")
+
+        if not webhook_id:
+            raise ValueError("Missing webhook_id in webhook metadata")
+
+        await delete_webhook(credentials, base_id, webhook_id)

autogpt_platform/backend/backend/blocks/airtable/bases.py

@@ -0,0 +1,122 @@
+"""
+Airtable base operation blocks.
+"""
+
+from typing import Optional
+
+from backend.sdk import (
+    APIKeyCredentials,
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchema,
+    CredentialsMetaInput,
+    SchemaField,
+)
+
+from ._api import create_base, list_bases
+from ._config import airtable
+
+
+class AirtableCreateBaseBlock(Block):
+    """
+    Creates a new base in an Airtable workspace.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        workspace_id: str = SchemaField(
+            description="The workspace ID where the base will be created"
+        )
+        name: str = SchemaField(description="The name of the new base")
+        tables: list[dict] = SchemaField(
+            description="At least one table and field must be specified. Array of table objects to create in the base. Each table should have 'name' and 'fields' properties",
+            default=[
+                {
+                    "description": "Default table",
+                    "name": "Default table",
+                    "fields": [
+                        {
+                            "name": "ID",
+                            "type": "number",
+                            "description": "Auto-incrementing ID field",
+                            "options": {"precision": 0},
+                        }
+                    ],
+                }
+            ],
+        )
+
+    class Output(BlockSchema):
+        base_id: str = SchemaField(description="The ID of the created base")
+        tables: list[dict] = SchemaField(description="Array of table objects")
+        table: dict = SchemaField(description="A single table object")
+
+    def __init__(self):
+        super().__init__(
+            id="f59b88a8-54ce-4676-a508-fd614b4e8dce",
+            description="Create a new base in Airtable",
+            categories={BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        data = await create_base(
+            credentials,
+            input_data.workspace_id,
+            input_data.name,
+            input_data.tables,
+        )
+
+        yield "base_id", data.get("id", None)
+        yield "tables", data.get("tables", [])
+        for table in data.get("tables", []):
+            yield "table", table
+
+
+class AirtableListBasesBlock(Block):
+    """
+    Lists all bases in an Airtable workspace that the user has access to.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        trigger: str = SchemaField(
+            description="Trigger the block to run - value is ignored", default="manual"
+        )
+        offset: str = SchemaField(
+            description="Pagination offset from previous request", default=""
+        )
+
+    class Output(BlockSchema):
+        bases: list[dict] = SchemaField(description="Array of base objects")
+        offset: Optional[str] = SchemaField(
+            description="Offset for next page (null if no more bases)", default=None
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="4bd8d466-ed5d-4e44-8083-97f25a8044e7",
+            description="List all bases in Airtable",
+            categories={BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        data = await list_bases(
+            credentials,
+            offset=input_data.offset if input_data.offset else None,
+        )
+
+        yield "bases", data.get("bases", [])
+        yield "offset", data.get("offset", None)

autogpt_platform/backend/backend/blocks/airtable/records.py

@@ -0,0 +1,283 @@
+"""
+Airtable record operation blocks.
+"""
+
+from typing import Optional
+
+from backend.sdk import (
+    APIKeyCredentials,
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchema,
+    CredentialsMetaInput,
+    SchemaField,
+)
+
+from ._api import (
+    create_record,
+    delete_multiple_records,
+    get_record,
+    list_records,
+    update_multiple_records,
+)
+from ._config import airtable
+
+
+class AirtableListRecordsBlock(Block):
+    """
+    Lists records from an Airtable table with optional filtering, sorting, and pagination.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        base_id: str = SchemaField(description="The Airtable base ID")
+        table_id_or_name: str = SchemaField(description="Table ID or name")
+        filter_formula: str = SchemaField(
+            description="Airtable formula to filter records", default=""
+        )
+        view: str = SchemaField(description="View ID or name to use", default="")
+        sort: list[dict] = SchemaField(
+            description="Sort configuration (array of {field, direction})", default=[]
+        )
+        max_records: int = SchemaField(
+            description="Maximum number of records to return", default=100
+        )
+        page_size: int = SchemaField(
+            description="Number of records per page (max 100)", default=100
+        )
+        offset: str = SchemaField(
+            description="Pagination offset from previous request", default=""
+        )
+        return_fields: list[str] = SchemaField(
+            description="Specific fields to return (comma-separated)", default=[]
+        )
+
+    class Output(BlockSchema):
+        records: list[dict] = SchemaField(description="Array of record objects")
+        offset: Optional[str] = SchemaField(
+            description="Offset for next page (null if no more records)", default=None
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="588a9fde-5733-4da7-b03c-35f5671e960f",
+            description="List records from an Airtable table",
+            categories={BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        data = await list_records(
+            credentials,
+            input_data.base_id,
+            input_data.table_id_or_name,
+            filter_by_formula=(
+                input_data.filter_formula if input_data.filter_formula else None
+            ),
+            view=input_data.view if input_data.view else None,
+            sort=input_data.sort if input_data.sort else None,
+            max_records=input_data.max_records if input_data.max_records else None,
+            page_size=min(input_data.page_size, 100) if input_data.page_size else None,
+            offset=input_data.offset if input_data.offset else None,
+            fields=input_data.return_fields if input_data.return_fields else None,
+        )
+
+        yield "records", data.get("records", [])
+        yield "offset", data.get("offset", None)
+
+
+class AirtableGetRecordBlock(Block):
+    """
+    Retrieves a single record from an Airtable table by its ID.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        base_id: str = SchemaField(description="The Airtable base ID")
+        table_id_or_name: str = SchemaField(description="Table ID or name")
+        record_id: str = SchemaField(description="The record ID to retrieve")
+
+    class Output(BlockSchema):
+        id: str = SchemaField(description="The record ID")
+        fields: dict = SchemaField(description="The record fields")
+        created_time: str = SchemaField(description="The record created time")
+
+    def __init__(self):
+        super().__init__(
+            id="c29c5cbf-0aff-40f9-bbb5-f26061792d2b",
+            description="Get a single record from Airtable",
+            categories={BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        record = await get_record(
+            credentials,
+            input_data.base_id,
+            input_data.table_id_or_name,
+            input_data.record_id,
+        )
+
+        yield "id", record.get("id", None)
+        yield "fields", record.get("fields", None)
+        yield "created_time", record.get("createdTime", None)
+
+
+class AirtableCreateRecordsBlock(Block):
+    """
+    Creates one or more records in an Airtable table.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        base_id: str = SchemaField(description="The Airtable base ID")
+        table_id_or_name: str = SchemaField(description="Table ID or name")
+        records: list[dict] = SchemaField(
+            description="Array of records to create (each with 'fields' object)"
+        )
+        typecast: bool = SchemaField(
+            description="Automatically convert string values to appropriate types",
+            default=False,
+        )
+        return_fields_by_field_id: bool | None = SchemaField(
+            description="Return fields by field ID",
+            default=None,
+        )
+
+    class Output(BlockSchema):
+        records: list[dict] = SchemaField(description="Array of created record objects")
+        details: dict = SchemaField(description="Details of the created records")
+
+    def __init__(self):
+        super().__init__(
+            id="42527e98-47b6-44ce-ac0e-86b4883721d3",
+            description="Create records in an Airtable table",
+            categories={BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        # The create_record API expects records in a specific format
+        data = await create_record(
+            credentials,
+            input_data.base_id,
+            input_data.table_id_or_name,
+            records=[{"fields": record} for record in input_data.records],
+            typecast=input_data.typecast if input_data.typecast else None,
+            return_fields_by_field_id=input_data.return_fields_by_field_id,
+        )
+
+        yield "records", data.get("records", [])
+        details = data.get("details", None)
+        if details:
+            yield "details", details
+
+
+class AirtableUpdateRecordsBlock(Block):
+    """
+    Updates one or more existing records in an Airtable table.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        base_id: str = SchemaField(description="The Airtable base ID")
+        table_id_or_name: str = SchemaField(
+            description="Table ID or name - It's better to use the table ID instead of the name"
+        )
+        records: list[dict] = SchemaField(
+            description="Array of records to update (each with 'id' and 'fields')"
+        )
+        typecast: bool | None = SchemaField(
+            description="Automatically convert string values to appropriate types",
+            default=None,
+        )
+
+    class Output(BlockSchema):
+        records: list[dict] = SchemaField(description="Array of updated record objects")
+
+    def __init__(self):
+        super().__init__(
+            id="6e7d2590-ac2b-4b5d-b08c-fc039cd77e1f",
+            description="Update records in an Airtable table",
+            categories={BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        # The update_multiple_records API expects records with id and fields
+        data = await update_multiple_records(
+            credentials,
+            input_data.base_id,
+            input_data.table_id_or_name,
+            records=input_data.records,
+            typecast=input_data.typecast if input_data.typecast else None,
+            return_fields_by_field_id=False,  # Use field names, not IDs
+        )
+
+        yield "records", data.get("records", [])
+
+
+class AirtableDeleteRecordsBlock(Block):
+    """
+    Deletes one or more records from an Airtable table.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        base_id: str = SchemaField(description="The Airtable base ID")
+        table_id_or_name: str = SchemaField(
+            description="Table ID or name - It's better to use the table ID instead of the name"
+        )
+        record_ids: list[str] = SchemaField(
+            description="Array of upto 10 record IDs to delete"
+        )
+
+    class Output(BlockSchema):
+        records: list[dict] = SchemaField(description="Array of deletion results")
+
+    def __init__(self):
+        super().__init__(
+            id="93e22b8b-3642-4477-aefb-1c0929a4a3a6",
+            description="Delete records from an Airtable table",
+            categories={BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        if len(input_data.record_ids) > 10:
+            yield "error", "Only upto 10 record IDs can be deleted at a time"
+        else:
+            data = await delete_multiple_records(
+                credentials,
+                input_data.base_id,
+                input_data.table_id_or_name,
+                input_data.record_ids,
+            )
+
+            yield "records", data.get("records", [])

autogpt_platform/backend/backend/blocks/airtable/schema.py

@@ -0,0 +1,252 @@
+"""
+Airtable schema and table management blocks.
+"""
+
+from backend.sdk import (
+    APIKeyCredentials,
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchema,
+    CredentialsMetaInput,
+    Requests,
+    SchemaField,
+)
+
+from ._api import TableFieldType, create_field, create_table, update_field, update_table
+from ._config import airtable
+
+
+class AirtableListSchemaBlock(Block):
+    """
+    Retrieves the complete schema of an Airtable base, including all tables,
+    fields, and views.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        base_id: str = SchemaField(description="The Airtable base ID")
+
+    class Output(BlockSchema):
+        base_schema: dict = SchemaField(
+            description="Complete base schema with tables, fields, and views"
+        )
+        tables: list[dict] = SchemaField(description="Array of table objects")
+
+    def __init__(self):
+        super().__init__(
+            id="64291d3c-99b5-47b7-a976-6d94293cdb2d",
+            description="Get the complete schema of an Airtable base",
+            categories={BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        api_key = credentials.api_key.get_secret_value()
+
+        # Get base schema
+        response = await Requests().get(
+            f"https://api.airtable.com/v0/meta/bases/{input_data.base_id}/tables",
+            headers={"Authorization": f"Bearer {api_key}"},
+        )
+
+        data = response.json()
+
+        yield "base_schema", data
+        yield "tables", data.get("tables", [])
+
+
+class AirtableCreateTableBlock(Block):
+    """
+    Creates a new table in an Airtable base with specified fields and views.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        base_id: str = SchemaField(description="The Airtable base ID")
+        table_name: str = SchemaField(description="The name of the table to create")
+        table_fields: list[dict] = SchemaField(
+            description="Table fields with name, type, and options",
+            default=[{"name": "Name", "type": "singleLineText"}],
+        )
+
+    class Output(BlockSchema):
+        table: dict = SchemaField(description="Created table object")
+        table_id: str = SchemaField(description="ID of the created table")
+
+    def __init__(self):
+        super().__init__(
+            id="fcc20ced-d817-42ea-9b40-c35e7bf34b4f",
+            description="Create a new table in an Airtable base",
+            categories={BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        table_data = await create_table(
+            credentials,
+            input_data.base_id,
+            input_data.table_name,
+            input_data.table_fields,
+        )
+
+        yield "table", table_data
+        yield "table_id", table_data.get("id", "")
+
+
+class AirtableUpdateTableBlock(Block):
+    """
+    Updates an existing table's properties such as name or description.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        base_id: str = SchemaField(description="The Airtable base ID")
+        table_id: str = SchemaField(description="The table ID to update")
+        table_name: str | None = SchemaField(
+            description="The name of the table to update", default=None
+        )
+        table_description: str | None = SchemaField(
+            description="The description of the table to update", default=None
+        )
+        date_dependency: dict | None = SchemaField(
+            description="The date dependency of the table to update", default=None
+        )
+
+    class Output(BlockSchema):
+        table: dict = SchemaField(description="Updated table object")
+
+    def __init__(self):
+        super().__init__(
+            id="34077c5f-f962-49f2-9ec6-97c67077013a",
+            description="Update table properties",
+            categories={BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        table_data = await update_table(
+            credentials,
+            input_data.base_id,
+            input_data.table_id,
+            input_data.table_name,
+            input_data.table_description,
+            input_data.date_dependency,
+        )
+
+        yield "table", table_data
+
+
+class AirtableCreateFieldBlock(Block):
+    """
+    Adds a new field (column) to an existing Airtable table.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        base_id: str = SchemaField(description="The Airtable base ID")
+        table_id: str = SchemaField(description="The table ID to add field to")
+        field_type: TableFieldType = SchemaField(
+            description="The type of the field to create",
+            default=TableFieldType.SINGLE_LINE_TEXT,
+            advanced=False,
+        )
+        name: str = SchemaField(description="The name of the field to create")
+        description: str | None = SchemaField(
+            description="The description of the field to create", default=None
+        )
+        options: dict[str, str] | None = SchemaField(
+            description="The options of the field to create", default=None
+        )
+
+    class Output(BlockSchema):
+        field: dict = SchemaField(description="Created field object")
+        field_id: str = SchemaField(description="ID of the created field")
+
+    def __init__(self):
+        super().__init__(
+            id="6c98a32f-dbf9-45d8-a2a8-5e97e8326351",
+            description="Add a new field to an Airtable table",
+            categories={BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        field_data = await create_field(
+            credentials,
+            input_data.base_id,
+            input_data.table_id,
+            input_data.field_type,
+            input_data.name,
+        )
+
+        yield "field", field_data
+        yield "field_id", field_data.get("id", "")
+
+
+class AirtableUpdateFieldBlock(Block):
+    """
+    Updates an existing field's properties in an Airtable table.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        base_id: str = SchemaField(description="The Airtable base ID")
+        table_id: str = SchemaField(description="The table ID containing the field")
+        field_id: str = SchemaField(description="The field ID to update")
+        name: str | None = SchemaField(
+            description="The name of the field to update", default=None, advanced=False
+        )
+        description: str | None = SchemaField(
+            description="The description of the field to update",
+            default=None,
+            advanced=False,
+        )
+
+    class Output(BlockSchema):
+        field: dict = SchemaField(description="Updated field object")
+
+    def __init__(self):
+        super().__init__(
+            id="f46ac716-3b18-4da1-92e4-34ca9a464d48",
+            description="Update field properties in an Airtable table",
+            categories={BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        field_data = await update_field(
+            credentials,
+            input_data.base_id,
+            input_data.table_id,
+            input_data.field_id,
+            input_data.name,
+            input_data.description,
+        )
+
+        yield "field", field_data

autogpt_platform/backend/backend/blocks/airtable/triggers.py

@@ -0,0 +1,113 @@
+from backend.sdk import (
+    BaseModel,
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchema,
+    BlockType,
+    BlockWebhookConfig,
+    CredentialsMetaInput,
+    ProviderName,
+    SchemaField,
+)
+
+from ._api import WebhookPayload
+from ._config import airtable
+
+
+class AirtableEventSelector(BaseModel):
+    """
+    Selects the Airtable webhook event to trigger on.
+    """
+
+    tableData: bool = True
+    tableFields: bool = True
+    tableMetadata: bool = True
+
+
+class AirtableWebhookTriggerBlock(Block):
+    """
+    Starts a flow whenever Airtable emits a webhook event.
+
+    Thin wrapper just forwards the payloads one at a time to the next block.
+    """
+
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput = airtable.credentials_field(
+            description="Airtable API credentials"
+        )
+        base_id: str = SchemaField(description="Airtable base ID")
+        table_id_or_name: str = SchemaField(description="Airtable table ID or name")
+        payload: dict = SchemaField(hidden=True, default_factory=dict)
+        events: AirtableEventSelector = SchemaField(
+            description="Airtable webhook event filter"
+        )
+
+    class Output(BlockSchema):
+        payload: WebhookPayload = SchemaField(description="Airtable webhook payload")
+
+    def __init__(self):
+        example_payload = {
+            "payloads": [
+                {
+                    "timestamp": "2022-02-01T21:25:05.663Z",
+                    "baseTransactionNumber": 4,
+                    "actionMetadata": {
+                        "source": "client",
+                        "sourceMetadata": {
+                            "user": {
+                                "id": "usr00000000000000",
+                                "email": "foo@bar.com",
+                                "permissionLevel": "create",
+                            }
+                        },
+                    },
+                    "payloadFormat": "v0",
+                }
+            ],
+            "cursor": 5,
+            "mightHaveMore": False,
+        }
+
+        super().__init__(
+            # NOTE: This is disabled whilst the webhook system is finalised.
+            disabled=False,
+            id="d0180ce6-ccb9-48c7-8256-b39e93e62801",
+            description="Starts a flow whenever Airtable emits a webhook event",
+            categories={BlockCategory.INPUT, BlockCategory.DATA},
+            input_schema=self.Input,
+            output_schema=self.Output,
+            block_type=BlockType.WEBHOOK,
+            webhook_config=BlockWebhookConfig(
+                provider=ProviderName("airtable"),
+                webhook_type="not-used",
+                event_filter_input="events",
+                event_format="{event}",
+                resource_format="{base_id}/{table_id_or_name}",
+            ),
+            test_input={
+                "credentials": airtable.get_test_credentials().model_dump(),
+                "base_id": "app1234567890",
+                "table_id_or_name": "table1234567890",
+                "events": AirtableEventSelector(
+                    tableData=True,
+                    tableFields=True,
+                    tableMetadata=False,
+                ).model_dump(),
+                "payload": example_payload,
+            },
+            test_credentials=airtable.get_test_credentials(),
+            test_output=[
+                (
+                    "payload",
+                    WebhookPayload.model_validate(example_payload["payloads"][0]),
+                ),
+            ],
+        )
+
+    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        if len(input_data.payload["payloads"]) > 0:
+            for item in input_data.payload["payloads"]:
+                yield "payload", WebhookPayload.model_validate(item)
+        else:
+            yield "error", "No valid payloads found in webhook payload"

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

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

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

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

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

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

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

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

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

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

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

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

autogpt_platform/backend/backend/blocks/ayrshare/__init__.py

@@ -0,0 +1,15 @@
+AYRSHARE_BLOCK_IDS = [
+    "cbd52c2a-06d2-43ed-9560-6576cc163283",  # PostToBlueskyBlock
+    "3352f512-3524-49ed-a08f-003042da2fc1",  # PostToFacebookBlock
+    "9e8f844e-b4a5-4b25-80f2-9e1dd7d67625",  # PostToXBlock
+    "589af4e4-507f-42fd-b9ac-a67ecef25811",  # PostToLinkedInBlock
+    "89b02b96-a7cb-46f4-9900-c48b32fe1552",  # PostToInstagramBlock
+    "0082d712-ff1b-4c3d-8a8d-6c7721883b83",  # PostToYouTubeBlock
+    "c7733580-3c72-483e-8e47-a8d58754d853",  # PostToRedditBlock
+    "47bc74eb-4af2-452c-b933-af377c7287df",  # PostToTelegramBlock
+    "2c38c783-c484-4503-9280-ef5d1d345a7e",  # PostToGMBBlock
+    "3ca46e05-dbaa-4afb-9e95-5a429c4177e6",  # PostToPinterestBlock
+    "7faf4b27-96b0-4f05-bf64-e0de54ae74e1",  # PostToTikTokBlock
+    "f8c3b2e1-9d4a-4e5f-8c7b-6a9e8d2f1c3b",  # PostToThreadsBlock
+    "a9d7f854-2c83-4e96-b3a1-7f2e9c5d4b8e",  # PostToSnapchatBlock
+]

autogpt_platform/backend/backend/blocks/ayrshare/_util.py

@@ -0,0 +1,152 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from backend.data.block import BlockSchema
+from backend.data.model import SchemaField, UserIntegrations
+from backend.integrations.ayrshare import AyrshareClient
+from backend.util.clients import get_database_manager_async_client
+from backend.util.exceptions import MissingConfigError
+
+
+async def get_profile_key(user_id: str):
+    user_integrations: UserIntegrations = (
+        await get_database_manager_async_client().get_user_integrations(user_id)
+    )
+    return user_integrations.managed_credentials.ayrshare_profile_key
+
+
+class BaseAyrshareInput(BlockSchema):
+    """Base input model for Ayrshare social media posts with common fields."""
+
+    post: str = SchemaField(
+        description="The post text to be published", default="", advanced=False
+    )
+    media_urls: list[str] = SchemaField(
+        description="Optional list of media URLs to include. Set is_video in advanced settings to true if you want to upload videos.",
+        default_factory=list,
+        advanced=False,
+    )
+    is_video: bool = SchemaField(
+        description="Whether the media is a video", default=False, advanced=True
+    )
+    schedule_date: Optional[datetime] = SchemaField(
+        description="UTC datetime for scheduling (YYYY-MM-DDThh:mm:ssZ)",
+        default=None,
+        advanced=True,
+    )
+    disable_comments: bool = SchemaField(
+        description="Whether to disable comments", default=False, advanced=True
+    )
+    shorten_links: bool = SchemaField(
+        description="Whether to shorten links", default=False, advanced=True
+    )
+    unsplash: Optional[str] = SchemaField(
+        description="Unsplash image configuration", default=None, advanced=True
+    )
+    requires_approval: bool = SchemaField(
+        description="Whether to enable approval workflow",
+        default=False,
+        advanced=True,
+    )
+    random_post: bool = SchemaField(
+        description="Whether to generate random post text",
+        default=False,
+        advanced=True,
+    )
+    random_media_url: bool = SchemaField(
+        description="Whether to generate random media", default=False, advanced=True
+    )
+    notes: Optional[str] = SchemaField(
+        description="Additional notes for the post", default=None, advanced=True
+    )
+
+
+class CarouselItem(BaseModel):
+    """Model for Facebook carousel items."""
+
+    name: str = Field(..., description="The name of the item")
+    link: str = Field(..., description="The link of the item")
+    picture: str = Field(..., description="The picture URL of the item")
+
+
+class CallToAction(BaseModel):
+    """Model for Google My Business Call to Action."""
+
+    action_type: str = Field(
+        ..., description="Type of action (book, order, shop, learn_more, sign_up, call)"
+    )
+    url: Optional[str] = Field(
+        description="URL for the action (not required for 'call' action)"
+    )
+
+
+class EventDetails(BaseModel):
+    """Model for Google My Business Event details."""
+
+    title: str = Field(..., description="Event title")
+    start_date: str = Field(..., description="Event start date (ISO format)")
+    end_date: str = Field(..., description="Event end date (ISO format)")
+
+
+class OfferDetails(BaseModel):
+    """Model for Google My Business Offer details."""
+
+    title: str = Field(..., description="Offer title")
+    start_date: str = Field(..., description="Offer start date (ISO format)")
+    end_date: str = Field(..., description="Offer end date (ISO format)")
+    coupon_code: str = Field(..., description="Coupon code (max 58 characters)")
+    redeem_online_url: str = Field(..., description="URL to redeem the offer")
+    terms_conditions: str = Field(..., description="Terms and conditions")
+
+
+class InstagramUserTag(BaseModel):
+    """Model for Instagram user tags."""
+
+    username: str = Field(..., description="Instagram username (without @)")
+    x: Optional[float] = Field(description="X coordinate (0.0-1.0) for image posts")
+    y: Optional[float] = Field(description="Y coordinate (0.0-1.0) for image posts")
+
+
+class LinkedInTargeting(BaseModel):
+    """Model for LinkedIn audience targeting."""
+
+    countries: Optional[list[str]] = Field(
+        description="Country codes (e.g., ['US', 'IN', 'DE', 'GB'])"
+    )
+    seniorities: Optional[list[str]] = Field(
+        description="Seniority levels (e.g., ['Senior', 'VP'])"
+    )
+    degrees: Optional[list[str]] = Field(description="Education degrees")
+    fields_of_study: Optional[list[str]] = Field(description="Fields of study")
+    industries: Optional[list[str]] = Field(description="Industry categories")
+    job_functions: Optional[list[str]] = Field(description="Job function categories")
+    staff_count_ranges: Optional[list[str]] = Field(description="Company size ranges")
+
+
+class PinterestCarouselOption(BaseModel):
+    """Model for Pinterest carousel image options."""
+
+    title: Optional[str] = Field(description="Image title")
+    link: Optional[str] = Field(description="External destination link for the image")
+    description: Optional[str] = Field(description="Image description")
+
+
+class YouTubeTargeting(BaseModel):
+    """Model for YouTube country targeting."""
+
+    block: Optional[list[str]] = Field(
+        description="Country codes to block (e.g., ['US', 'CA'])"
+    )
+    allow: Optional[list[str]] = Field(
+        description="Country codes to allow (e.g., ['GB', 'AU'])"
+    )
+
+
+def create_ayrshare_client():
+    """Create an Ayrshare client instance."""
+    try:
+        return AyrshareClient()
+    except MissingConfigError:
+        return None

autogpt_platform/backend/backend/blocks/ayrshare/post_to_bluesky.py

@@ -0,0 +1,114 @@
+from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
+from backend.sdk import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchema,
+    BlockType,
+    SchemaField,
+)
+
+from ._util import BaseAyrshareInput, create_ayrshare_client, get_profile_key
+
+
+class PostToBlueskyBlock(Block):
+    """Block for posting to Bluesky with Bluesky-specific options."""
+
+    class Input(BaseAyrshareInput):
+        """Input schema for Bluesky posts."""
+
+        # Override post field to include character limit information
+        post: str = SchemaField(
+            description="The post text to be published (max 300 characters for Bluesky)",
+            default="",
+            advanced=False,
+        )
+
+        # Override media_urls to include Bluesky-specific constraints
+        media_urls: list[str] = SchemaField(
+            description="Optional list of media URLs to include. Bluesky supports up to 4 images or 1 video.",
+            default_factory=list,
+            advanced=False,
+        )
+
+        # Bluesky-specific options
+        alt_text: list[str] = SchemaField(
+            description="Alt text for each media item (accessibility)",
+            default_factory=list,
+            advanced=True,
+        )
+
+    class Output(BlockSchema):
+        post_result: PostResponse = SchemaField(description="The result of the post")
+        post: PostIds = SchemaField(description="The result of the post")
+
+    def __init__(self):
+        super().__init__(
+            disabled=True,
+            id="cbd52c2a-06d2-43ed-9560-6576cc163283",
+            description="Post to Bluesky using Ayrshare",
+            categories={BlockCategory.SOCIAL},
+            block_type=BlockType.AYRSHARE,
+            input_schema=PostToBlueskyBlock.Input,
+            output_schema=PostToBlueskyBlock.Output,
+        )
+
+    async def run(
+        self,
+        input_data: "PostToBlueskyBlock.Input",
+        *,
+        user_id: str,
+        **kwargs,
+    ) -> BlockOutput:
+        """Post to Bluesky with Bluesky-specific options."""
+
+        profile_key = await get_profile_key(user_id)
+        if not profile_key:
+            yield "error", "Please link a social account via Ayrshare"
+            return
+
+        client = create_ayrshare_client()
+        if not client:
+            yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
+            return
+
+        # Validate character limit for Bluesky
+        if len(input_data.post) > 300:
+            yield "error", f"Post text exceeds Bluesky's 300 character limit ({len(input_data.post)} characters)"
+            return
+
+        # Validate media constraints for Bluesky
+        if len(input_data.media_urls) > 4:
+            yield "error", "Bluesky supports a maximum of 4 images or 1 video"
+            return
+
+        # Convert datetime to ISO format if provided
+        iso_date = (
+            input_data.schedule_date.isoformat() if input_data.schedule_date else None
+        )
+
+        # Build Bluesky-specific options
+        bluesky_options = {}
+        if input_data.alt_text:
+            bluesky_options["altText"] = input_data.alt_text
+
+        response = await client.create_post(
+            post=input_data.post,
+            platforms=[SocialPlatform.BLUESKY],
+            media_urls=input_data.media_urls,
+            is_video=input_data.is_video,
+            schedule_date=iso_date,
+            disable_comments=input_data.disable_comments,
+            shorten_links=input_data.shorten_links,
+            unsplash=input_data.unsplash,
+            requires_approval=input_data.requires_approval,
+            random_post=input_data.random_post,
+            random_media_url=input_data.random_media_url,
+            notes=input_data.notes,
+            bluesky_options=bluesky_options if bluesky_options else None,
+            profile_key=profile_key.get_secret_value(),
+        )
+        yield "post_result", response
+        if response.postIds:
+            for p in response.postIds:
+                yield "post", p