fix(market / profile) Moving the user profile to the profile route instead of nesting it in the marketplace.

.github/dependabot.yml

@@ -129,6 +129,30 @@ updates:
         - "minor"
         - "patch"
 
+
+  # Submodules
+  - package-ecosystem: "gitsubmodule"
+    directory: "autogpt_platform/supabase"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 1
+    target-branch: "dev"
+    commit-message:
+      prefix: "chore(platform/deps)"
+      prefix-development: "chore(platform/deps-dev)"
+    groups:
+      production-dependencies:
+        dependency-type: "production"
+        update-types:
+        - "minor"
+        - "patch"
+      development-dependencies:
+        dependency-type: "development"
+        update-types:
+        - "minor"
+        - "patch"
+
+
   # Docs
   - package-ecosystem: 'pip'
     directory: "docs/"

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

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

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

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

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

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

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

@@ -42,14 +42,6 @@ jobs:
           REDIS_PASSWORD: testpassword
         ports:
           - 6379:6379
-      rabbitmq:
-        image: rabbitmq:3.12-management
-        ports:
-          - 5672:5672
-          - 15672:15672
-        env:
-          RABBITMQ_DEFAULT_USER: ${{ env.RABBITMQ_DEFAULT_USER }}
-          RABBITMQ_DEFAULT_PASS: ${{ env.RABBITMQ_DEFAULT_PASS }}
 
     steps:
       - name: Checkout repository
@@ -66,7 +58,7 @@ jobs:
       - name: Setup Supabase
         uses: supabase/setup-cli@v1
         with:
-          version: 1.178.1
+          version: latest
 
       - id: get_date
         name: Get date
@@ -147,13 +139,6 @@ jobs:
       RUN_ENV: local
       PORT: 8080
       OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-      # We know these are here, don't report this as a security vulnerability
-      # This is used as the default credential for the entire system's RabbitMQ instance
-      # If you want to replace this, you can do so by making our entire system generate
-      # new credentials for each local user and update the environment variables in
-      # the backend service, docker composes, and examples
-      RABBITMQ_DEFAULT_USER: 'rabbitmq_user_default'
-      RABBITMQ_DEFAULT_PASS: 'k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7'
 
       # - name: Upload coverage reports to Codecov
       #   uses: codecov/codecov-action@v4

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

@@ -77,12 +77,12 @@ jobs:
       - name: Free Disk Space (Ubuntu)
         uses: jlumbroso/free-disk-space@main
         with:
-          large-packages: false # slow
-          docker-images: false # limited benefit
+          large-packages: false  # slow
+          docker-images: false  # limited benefit
 
       - name: Copy default supabase .env
         run: |
-          cp ../.env.example ../.env
+          cp ../supabase/docker/.env.example ../.env
 
       - name: Copy backend .env
         run: |
@@ -104,12 +104,11 @@ jobs:
         run: yarn playwright install --with-deps ${{ matrix.browser }}
 
       - name: Run tests
-        timeout-minutes: 20
         run: |
           yarn test --project=${{ matrix.browser }}
 
-      - name: Print Final Docker Compose logs
-        if: always()
+      - name: Print Docker Compose logs in debug mode
+        if: runner.debug
         run: |
           docker compose -f ../docker-compose.yml logs
 

.gitmodules

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

.pre-commit-config.yaml

@@ -170,16 +170,6 @@ repos:
         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.
@@ -231,16 +221,6 @@ repos:
         language: system
         pass_filenames: false
 
-  - repo: local
-    hooks:
-      - id: tsc
-        name: Typecheck - AutoGPT Platform - Frontend
-        entry: bash -c 'cd autogpt_platform/frontend && npm run type-check'
-        files: ^autogpt_platform/frontend/
-        types: [file]
-        language: system
-        pass_filenames: false
-
   - repo: local
     hooks:
       - id: pytest

SECURITY.md

@@ -20,7 +20,6 @@ Instead, please report them via:
 - 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

autogpt_platform/.env.example

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

autogpt_platform/README.md

@@ -22,29 +22,35 @@ To run the AutoGPT Platform, follow these steps:
 
 2. Run the following command:
    ```
-   cp .env.example .env
+   git submodule update --init --recursive
    ```
-   This command will copy the `.env.example` file to `.env`. You can modify the `.env` file to add your own environment variables.
+   This command will initialize and update the submodules in the repository. The `supabase` folder will be cloned to the root directory.
 
 3. Run the following command:
+   ```
+   cp supabase/docker/.env.example .env
+   ```
+   This command will copy the `.env.example` file to `.env` in the `supabase/docker` directory. You can modify the `.env` file to add your own environment variables.
+
+4. Run the following command:
    ```
    docker compose up -d
    ```
    This command will start all the necessary backend services defined in the `docker-compose.yml` file in detached mode.
 
-4. Navigate to `frontend` within the `autogpt_platform` directory:
+5. Navigate to `frontend` within the `autogpt_platform` directory:
    ```
    cd frontend
    ```
    You will need to run your frontend application separately on your local machine.
 
-5. Run the following command: 
+6. Run the following command: 
    ```
    cp .env.example .env.local
    ```
    This command will copy the `.env.example` file to `.env.local` in the `frontend` directory. You can modify the `.env.local` within this folder to add your own environment variables for the frontend application.
 
-6. Run the following command:
+7. Run the following command:
    ```
    npm install
    npm run dev
@@ -55,7 +61,7 @@ To run the AutoGPT Platform, follow these steps:
    yarn install && yarn dev
    ```
 
-7. Open your browser and navigate to `http://localhost:3000` to access the AutoGPT Platform frontend.
+8. Open your browser and navigate to `http://localhost:3000` to access the AutoGPT Platform frontend.
 
 ### Docker Compose Commands
 

autogpt_platform/autogpt_libs/autogpt_libs/auth/__init__.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/middleware.py

@@ -1,10 +1,7 @@
-import inspect
 import logging
-from typing import Any, Callable, Optional
 
-from fastapi import HTTPException, Request, Security
-from fastapi.security import APIKeyHeader, HTTPBearer
-from starlette.status import HTTP_401_UNAUTHORIZED
+from fastapi import HTTPException, Request
+from fastapi.security import HTTPBearer
 
 from .config import settings
 from .jwt_utils import parse_jwt_token
@@ -32,104 +29,3 @@ async def auth_middleware(request: Request):
     except ValueError as e:
         raise HTTPException(status_code=401, detail=str(e))
     return payload
-
-
-class APIKeyValidator:
-    """
-    Configurable API key validator that supports custom validation functions
-    for FastAPI applications.
-
-    This class provides a flexible way to implement API key authentication with optional
-    custom validation logic. It can be used for simple token matching
-    or more complex validation scenarios like database lookups.
-
-    Examples:
-        Simple token validation:
-        ```python
-        validator = APIKeyValidator(
-            header_name="X-API-Key",
-            expected_token="your-secret-token"
-        )
-
-        @app.get("/protected", dependencies=[Depends(validator.get_dependency())])
-        def protected_endpoint():
-            return {"message": "Access granted"}
-        ```
-
-        Custom validation with database lookup:
-        ```python
-        async def validate_with_db(api_key: str):
-            api_key_obj = await db.get_api_key(api_key)
-            return api_key_obj if api_key_obj and api_key_obj.is_active else None
-
-        validator = APIKeyValidator(
-            header_name="X-API-Key",
-            validate_fn=validate_with_db
-        )
-        ```
-
-    Args:
-        header_name (str): The name of the header containing the API key
-        expected_token (Optional[str]): The expected API key value for simple token matching
-        validate_fn (Optional[Callable]): Custom validation function that takes an API key
-            string and returns a boolean or object. Can be async.
-        error_status (int): HTTP status code to use for validation errors
-        error_message (str): Error message to return when validation fails
-    """
-
-    def __init__(
-        self,
-        header_name: str,
-        expected_token: Optional[str] = None,
-        validate_fn: Optional[Callable[[str], bool]] = None,
-        error_status: int = HTTP_401_UNAUTHORIZED,
-        error_message: str = "Invalid API key",
-    ):
-        # Create the APIKeyHeader as a class property
-        self.security_scheme = APIKeyHeader(name=header_name)
-        self.expected_token = expected_token
-        self.custom_validate_fn = validate_fn
-        self.error_status = error_status
-        self.error_message = error_message
-
-    async def default_validator(self, api_key: str) -> bool:
-        return 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/feature_flag/client.py

@@ -13,6 +13,7 @@ from typing_extensions import ParamSpec
 from .config import SETTINGS
 
 logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.DEBUG)
 
 P = ParamSpec("P")
 T = TypeVar("T")

autogpt_platform/autogpt_libs/poetry.lock

@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 2.1.1 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.0.1 and should not be changed by hand.
 
 [[package]]
 name = "aiohappyeyeballs"
@@ -123,7 +123,7 @@ multidict = ">=4.5,<7.0"
 yarl = ">=1.0,<2.0"
 
 [package.extras]
-speedups = ["Brotli ; platform_python_implementation == \"CPython\"", "aiodns (>=3.2.0) ; sys_platform == \"linux\" or sys_platform == \"darwin\"", "brotlicffi ; platform_python_implementation != \"CPython\""]
+speedups = ["Brotli", "aiodns (>=3.2.0)", "brotlicffi"]
 
 [[package]]
 name = "aiosignal"
@@ -172,7 +172,7 @@ typing-extensions = {version = ">=4.1", markers = "python_version < \"3.11\""}
 
 [package.extras]
 doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"]
-test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17) ; platform_python_implementation == \"CPython\" and platform_system != \"Windows\""]
+test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"]
 trio = ["trio (>=0.23)"]
 
 [[package]]
@@ -201,12 +201,12 @@ files = [
 ]
 
 [package.extras]
-benchmark = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\"", "pympler", "pytest (>=4.3.0)", "pytest-codspeed", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\" and python_version < \"3.13\"", "pytest-xdist[psutil]"]
-cov = ["cloudpickle ; platform_python_implementation == \"CPython\"", "coverage[toml] (>=5.3)", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\"", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\" and python_version < \"3.13\"", "pytest-xdist[psutil]"]
-dev = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\"", "pre-commit", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\" and python_version < \"3.13\"", "pytest-xdist[psutil]"]
+benchmark = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-codspeed", "pytest-mypy-plugins", "pytest-xdist[psutil]"]
+cov = ["cloudpickle", "coverage[toml] (>=5.3)", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"]
+dev = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pre-commit", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"]
 docs = ["cogapp", "furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier (<24.7)"]
-tests = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\"", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\" and python_version < \"3.13\"", "pytest-xdist[psutil]"]
-tests-mypy = ["mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\"", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\" and python_version < \"3.13\""]
+tests = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"]
+tests-mypy = ["mypy (>=1.11.1)", "pytest-mypy-plugins"]
 
 [[package]]
 name = "cachetools"
@@ -512,18 +512,18 @@ google-auth = ">=2.14.1,<3.0.dev0"
 googleapis-common-protos = ">=1.56.2,<2.0.dev0"
 grpcio = [
     {version = ">=1.49.1,<2.0dev", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""},
-    {version = ">=1.33.2,<2.0dev", optional = true, markers = "extra == \"grpc\""},
+    {version = ">=1.33.2,<2.0dev", optional = true, markers = "python_version < \"3.11\" and extra == \"grpc\""},
 ]
 grpcio-status = [
     {version = ">=1.49.1,<2.0.dev0", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""},
-    {version = ">=1.33.2,<2.0.dev0", optional = true, markers = "extra == \"grpc\""},
+    {version = ">=1.33.2,<2.0.dev0", optional = true, markers = "python_version < \"3.11\" and extra == \"grpc\""},
 ]
 proto-plus = ">=1.22.3,<2.0.0dev"
 protobuf = ">=3.19.5,<3.20.0 || >3.20.0,<3.20.1 || >3.20.1,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<6.0.0.dev0"
 requests = ">=2.18.0,<3.0.0.dev0"
 
 [package.extras]
-grpc = ["grpcio (>=1.33.2,<2.0dev)", "grpcio (>=1.49.1,<2.0dev) ; python_version >= \"3.11\"", "grpcio-status (>=1.33.2,<2.0.dev0)", "grpcio-status (>=1.49.1,<2.0.dev0) ; python_version >= \"3.11\""]
+grpc = ["grpcio (>=1.33.2,<2.0dev)", "grpcio (>=1.49.1,<2.0dev)", "grpcio-status (>=1.33.2,<2.0.dev0)", "grpcio-status (>=1.49.1,<2.0.dev0)"]
 grpcgcp = ["grpcio-gcp (>=0.2.2,<1.0.dev0)"]
 grpcio-gcp = ["grpcio-gcp (>=0.2.2,<1.0.dev0)"]
 
@@ -842,7 +842,7 @@ idna = "*"
 sniffio = "*"
 
 [package.extras]
-brotli = ["brotli ; platform_python_implementation == \"CPython\"", "brotlicffi ; platform_python_implementation != \"CPython\""]
+brotli = ["brotli", "brotlicffi"]
 cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"]
 http2 = ["h2 (>=3,<5)"]
 socks = ["socksio (==1.*)"]
@@ -890,7 +890,7 @@ zipp = ">=0.5"
 [package.extras]
 doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
 perf = ["ipython"]
-test = ["flufl.flake8", "importlib-resources (>=1.3) ; python_version < \"3.9\"", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-perf (>=0.9.2)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""]
+test = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-perf (>=0.9.2)", "pytest-ruff (>=0.2.1)"]
 
 [[package]]
 name = "iniconfig"
@@ -1156,7 +1156,7 @@ typing-extensions = ">=4.12.2"
 
 [package.extras]
 email = ["email-validator (>=2.0.0)"]
-timezone = ["tzdata ; python_version >= \"3.9\" and platform_system == \"Windows\""]
+timezone = ["tzdata"]
 
 [[package]]
 name = "pydantic-core"
@@ -1476,30 +1476,30 @@ pyasn1 = ">=0.1.3"
 
 [[package]]
 name = "ruff"
-version = "0.9.10"
+version = "0.9.3"
 description = "An extremely fast Python linter and code formatter, written in Rust."
 optional = false
 python-versions = ">=3.7"
 groups = ["dev"]
 files = [
-    {file = "ruff-0.9.10-py3-none-linux_armv6l.whl", hash = "sha256:eb4d25532cfd9fe461acc83498361ec2e2252795b4f40b17e80692814329e42d"},
-    {file = "ruff-0.9.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:188a6638dab1aa9bb6228a7302387b2c9954e455fb25d6b4470cb0641d16759d"},
-    {file = "ruff-0.9.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:5284dcac6b9dbc2fcb71fdfc26a217b2ca4ede6ccd57476f52a587451ebe450d"},
-    {file = "ruff-0.9.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:47678f39fa2a3da62724851107f438c8229a3470f533894b5568a39b40029c0c"},
-    {file = "ruff-0.9.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:99713a6e2766b7a17147b309e8c915b32b07a25c9efd12ada79f217c9c778b3e"},
-    {file = "ruff-0.9.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:524ee184d92f7c7304aa568e2db20f50c32d1d0caa235d8ddf10497566ea1a12"},
-    {file = "ruff-0.9.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:df92aeac30af821f9acf819fc01b4afc3dfb829d2782884f8739fb52a8119a16"},
-    {file = "ruff-0.9.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de42e4edc296f520bb84954eb992a07a0ec5a02fecb834498415908469854a52"},
-    {file = "ruff-0.9.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d257f95b65806104b6b1ffca0ea53f4ef98454036df65b1eda3693534813ecd1"},
-    {file = "ruff-0.9.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b60dec7201c0b10d6d11be00e8f2dbb6f40ef1828ee75ed739923799513db24c"},
-    {file = "ruff-0.9.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:d838b60007da7a39c046fcdd317293d10b845001f38bcb55ba766c3875b01e43"},
-    {file = "ruff-0.9.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:ccaf903108b899beb8e09a63ffae5869057ab649c1e9231c05ae354ebc62066c"},
-    {file = "ruff-0.9.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:f9567d135265d46e59d62dc60c0bfad10e9a6822e231f5b24032dba5a55be6b5"},
-    {file = "ruff-0.9.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5f202f0d93738c28a89f8ed9eaba01b7be339e5d8d642c994347eaa81c6d75b8"},
-    {file = "ruff-0.9.10-py3-none-win32.whl", hash = "sha256:bfb834e87c916521ce46b1788fbb8484966e5113c02df216680102e9eb960029"},
-    {file = "ruff-0.9.10-py3-none-win_amd64.whl", hash = "sha256:f2160eeef3031bf4b17df74e307d4c5fb689a6f3a26a2de3f7ef4044e3c484f1"},
-    {file = "ruff-0.9.10-py3-none-win_arm64.whl", hash = "sha256:5fd804c0327a5e5ea26615550e706942f348b197d5475ff34c19733aee4b2e69"},
-    {file = "ruff-0.9.10.tar.gz", hash = "sha256:9bacb735d7bada9cfb0f2c227d3658fc443d90a727b47f206fb33f52f3c0eac7"},
+    {file = "ruff-0.9.3-py3-none-linux_armv6l.whl", hash = "sha256:7f39b879064c7d9670197d91124a75d118d00b0990586549949aae80cdc16624"},
+    {file = "ruff-0.9.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:a187171e7c09efa4b4cc30ee5d0d55a8d6c5311b3e1b74ac5cb96cc89bafc43c"},
+    {file = "ruff-0.9.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:c59ab92f8e92d6725b7ded9d4a31be3ef42688a115c6d3da9457a5bda140e2b4"},
+    {file = "ruff-0.9.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2dc153c25e715be41bb228bc651c1e9b1a88d5c6e5ed0194fa0dfea02b026439"},
+    {file = "ruff-0.9.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:646909a1e25e0dc28fbc529eab8eb7bb583079628e8cbe738192853dbbe43af5"},
+    {file = "ruff-0.9.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5a5a46e09355695fbdbb30ed9889d6cf1c61b77b700a9fafc21b41f097bfbba4"},
+    {file = "ruff-0.9.3-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:c4bb09d2bbb394e3730d0918c00276e79b2de70ec2a5231cd4ebb51a57df9ba1"},
+    {file = "ruff-0.9.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:96a87ec31dc1044d8c2da2ebbed1c456d9b561e7d087734336518181b26b3aa5"},
+    {file = "ruff-0.9.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9bb7554aca6f842645022fe2d301c264e6925baa708b392867b7a62645304df4"},
+    {file = "ruff-0.9.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cabc332b7075a914ecea912cd1f3d4370489c8018f2c945a30bcc934e3bc06a6"},
+    {file = "ruff-0.9.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:33866c3cc2a575cbd546f2cd02bdd466fed65118e4365ee538a3deffd6fcb730"},
+    {file = "ruff-0.9.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:006e5de2621304c8810bcd2ee101587712fa93b4f955ed0985907a36c427e0c2"},
+    {file = "ruff-0.9.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:ba6eea4459dbd6b1be4e6bfc766079fb9b8dd2e5a35aff6baee4d9b1514ea519"},
+    {file = "ruff-0.9.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:90230a6b8055ad47d3325e9ee8f8a9ae7e273078a66401ac66df68943ced029b"},
+    {file = "ruff-0.9.3-py3-none-win32.whl", hash = "sha256:eabe5eb2c19a42f4808c03b82bd313fc84d4e395133fb3fc1b1516170a31213c"},
+    {file = "ruff-0.9.3-py3-none-win_amd64.whl", hash = "sha256:040ceb7f20791dfa0e78b4230ee9dce23da3b64dd5848e40e3bf3ab76468dcf4"},
+    {file = "ruff-0.9.3-py3-none-win_arm64.whl", hash = "sha256:800d773f6d4d33b0a3c60e2c6ae8f4c202ea2de056365acfa519aa48acf28e0b"},
+    {file = "ruff-0.9.3.tar.gz", hash = "sha256:8293f89985a090ebc3ed1064df31f3b4b56320cdfcec8b60d3295bddb955c22a"},
 ]
 
 [[package]]
@@ -1633,7 +1633,7 @@ files = [
 ]
 
 [package.extras]
-brotli = ["brotli (>=1.0.9) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=0.8.0) ; platform_python_implementation != \"CPython\""]
+brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"]
 h2 = ["h2 (>=4,<5)"]
 socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
 zstd = ["zstandard (>=0.18.0)"]
@@ -1919,14 +1919,14 @@ files = [
 ]
 
 [package.extras]
-check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""]
+check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"]
 cover = ["pytest-cov"]
 doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
 enabler = ["pytest-enabler (>=2.2)"]
-test = ["big-O", "importlib-resources ; python_version < \"3.9\"", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-ignore-flaky"]
+test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-ignore-flaky"]
 type = ["pytest-mypy"]
 
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.10,<4.0"
-content-hash = "931772287f71c539575d601e6398423bf68e09ca87ae1a144057c7f5707cf978"
+content-hash = "a4d81b3b55a67036ca7a441793e13e8fbe20af973fcf1623f36cdee7bc82999f"

autogpt_platform/autogpt_libs/pyproject.toml

@@ -21,7 +21,7 @@ supabase = "^2.13.0"
 
 [tool.poetry.group.dev.dependencies]
 redis = "^5.2.1"
-ruff = "^0.9.10"
+ruff = "^0.9.3"
 
 [build-system]
 requires = ["poetry-core"]

autogpt_platform/backend/.env.example

@@ -2,23 +2,13 @@ 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}"
+DATABASE_URL="postgresql://${DB_USER}:${DB_PASS}@localhost:${DB_PORT}/${DB_NAME}?connect_timeout=60&schema=platform"
 PRISMA_SCHEMA="postgres/schema.prisma"
 
-# EXECUTOR
-NUM_GRAPH_WORKERS=10
-NUM_NODE_WORKERS=3
-
 BACKEND_CORS_ALLOW_ORIGINS=["http://localhost:3000"]
 
 # generate using `from cryptography.fernet import Fernet;Fernet.generate_key().decode()`
 ENCRYPTION_KEY='dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw='
-UNSUBSCRIBE_SECRET_KEY = 'HlP8ivStJjmbf6NKi78m_3FnOogut0t5ckzjsIqeaio='
 
 REDIS_HOST=localhost
 REDIS_PORT=6379
@@ -35,26 +25,12 @@ BEHAVE_AS=local
 PYRO_HOST=localhost
 SENTRY_DSN=
 
-# Email For Postmark so we can send emails
-POSTMARK_SERVER_API_TOKEN=
-POSTMARK_SENDER_EMAIL=invalid@invalid.com
-POSTMARK_WEBHOOK_TOKEN=
-
 ## User auth with Supabase is required for any of the 3rd party integrations with auth to work.
 ENABLE_AUTH=true
 SUPABASE_URL=http://localhost:8000
 SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJzZXJ2aWNlX3JvbGUiLAogICAgImlzcyI6ICJzdXBhYmFzZS1kZW1vIiwKICAgICJpYXQiOiAxNjQxNzY5MjAwLAogICAgImV4cCI6IDE3OTk1MzU2MDAKfQ.DaYlNEoUrrEn2Ig7tqibS-PHK5vgusbcbo7X36XVt4Q
 SUPABASE_JWT_SECRET=your-super-secret-jwt-token-with-at-least-32-characters-long
 
-# RabbitMQ credentials -- Used for communication between services
-RABBITMQ_HOST=localhost
-RABBITMQ_PORT=5672
-RABBITMQ_DEFAULT_USER=rabbitmq_user_default
-RABBITMQ_DEFAULT_PASS=k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7
-
-## GCS bucket is required for marketplace and library functionality
-MEDIA_GCS_BUCKET_NAME=
-
 ## For local development, you may need to set FRONTEND_BASE_URL for the OAuth flow
 ## for integrations to work. Defaults to the value of PLATFORM_BASE_URL if not set.
 # FRONTEND_BASE_URL=http://localhost:3000
@@ -173,24 +149,12 @@ EXA_API_KEY=
 # E2B
 E2B_API_KEY=
 
-# Example API Key
-EXAMPLE_API_KEY=
-
 # Mem0
 MEM0_API_KEY=
 
 # Nvidia
 NVIDIA_API_KEY=
 
-# Apollo
-APOLLO_API_KEY=
-
-# SmartLead
-SMARTLEAD_API_KEY=
-
-# ZeroBounce
-ZEROBOUNCE_API_KEY=
-
 # Logging Configuration
 LOG_LEVEL=INFO
 ENABLE_CLOUD_LOGGING=false

autogpt_platform/backend/README.advanced.md

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

autogpt_platform/backend/README.md

@@ -1 +1,210 @@
-[Getting Started (Released)](https://docs.agpt.co/platform/getting-started/#autogpt_agent_server)
+# AutoGPT Agent Server 
+
+This is an initial project for creating the next generation of agent execution, which is an AutoGPT agent server.
+The agent server will enable the creation of composite multi-agent systems that utilize AutoGPT agents and other non-agent components as its primitives.
+
+## Docs
+
+You can access the docs for the [AutoGPT Agent Server here](https://docs.agpt.co/server/setup).
+
+## Setup
+
+We use the Poetry to manage the dependencies. To set up the project, follow these steps inside this directory:
+
+0. Install Poetry
+    ```sh
+    pip install poetry
+    ```
+    
+1. Configure Poetry to use .venv in your project directory
+    ```sh
+    poetry config virtualenvs.in-project true
+    ```
+
+2. Enter the poetry shell
+
+   ```sh
+   poetry shell
+   ```
+   
+3. Install dependencies
+
+   ```sh
+   poetry install
+   ```
+
+4. Copy .env.example to .env
+
+   ```sh
+   cp .env.example .env
+   ```
+   
+5. Generate the Prisma client
+
+   ```sh
+   poetry run prisma generate
+   ```
+   
+
+   > In case Prisma generates the client for the global Python installation instead of the virtual environment, the current mitigation is to just uninstall the global Prisma package:
+   >
+   > ```sh
+   > pip uninstall prisma
+   > ```
+   >
+   > Then run the generation again. The path *should* look something like this:  
+   > `<some path>/pypoetry/virtualenvs/backend-TQIRSwR6-py3.12/bin/prisma`
+
+6. Migrate the database. Be careful because this deletes current data in the database.
+
+   ```sh
+   docker compose up db -d
+   poetry run prisma migrate deploy
+   ```
+
+## Running The Server
+
+### Starting the server without Docker
+
+To run the server locally, start in the autogpt_platform folder:
+
+```sh
+cd ..
+```
+
+Run the following command to run database in docker but the application locally:
+
+```sh
+docker compose --profile local up deps --build --detach
+cd backend
+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 `poetry run pytest -s test/block/test_block.py`.

autogpt_platform/backend/backend/app.py

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

autogpt_platform/backend/backend/blocks/agent.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Any
 
 from autogpt_libs.utils.cache import thread_cached
 
@@ -14,7 +13,6 @@ from backend.data.block import (
 )
 from backend.data.execution import ExecutionStatus
 from backend.data.model import SchemaField
-from backend.util import json
 
 logger = logging.getLogger(__name__)
 
@@ -44,23 +42,6 @@ class AgentExecutorBlock(Block):
         input_schema: dict = SchemaField(description="Input schema for the graph")
         output_schema: dict = SchemaField(description="Output schema for the graph")
 
-        @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("data", {})
-
-        @classmethod
-        def get_missing_input(cls, data: BlockInput) -> set[str]:
-            required_fields = cls.get_input_schema(data).get("required", [])
-            return set(required_fields) - set(data)
-
-        @classmethod
-        def get_mismatch_error(cls, data: BlockInput) -> str | None:
-            return json.validate_with_jsonschema(cls.get_input_schema(data), data)
-
     class Output(BlockSchema):
         pass
 

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

@@ -1,108 +0,0 @@
-import logging
-from typing import List
-
-from backend.blocks.apollo._auth import ApolloCredentials
-from backend.blocks.apollo.models import (
-    Contact,
-    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()}
-
-    def search_people(self, query: SearchPeopleRequest) -> List[Contact]:
-        """Search for people in Apollo"""
-        response = self.requests.get(
-            f"{self.API_URL}/mixed_people/search",
-            headers=self._get_headers(),
-            params=query.model_dump(exclude={"credentials", "max_results"}),
-        )
-        parsed_response = SearchPeopleResponse(**response.json())
-        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 = self.requests.get(
-                    f"{self.API_URL}/mixed_people/search",
-                    headers=self._get_headers(),
-                    params=query.model_dump(exclude={"credentials", "max_results"}),
-                )
-                parsed_response = SearchPeopleResponse(**response.json())
-                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
-
-    def search_organizations(
-        self, query: SearchOrganizationsRequest
-    ) -> List[Organization]:
-        """Search for organizations in Apollo"""
-        response = self.requests.get(
-            f"{self.API_URL}/mixed_companies/search",
-            headers=self._get_headers(),
-            params=query.model_dump(exclude={"credentials", "max_results"}),
-        )
-        parsed_response = SearchOrganizationsResponse(**response.json())
-        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 = self.requests.get(
-                    f"{self.API_URL}/mixed_companies/search",
-                    headers=self._get_headers(),
-                    params=query.model_dump(exclude={"credentials", "max_results"}),
-                )
-                parsed_response = SearchOrganizationsResponse(**response.json())
-                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
-        )

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

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

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

@@ -1,543 +0,0 @@
-from enum import Enum
-from typing import Any, Optional
-
-from pydantic import BaseModel
-
-from backend.data.model import SchemaField
-
-
-class PrimaryPhone(BaseModel):
-    """A primary phone in Apollo"""
-
-    number: str
-    source: str
-    sanitized_number: 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: str
-    created_at: str
-    rule_action_config_id: str
-    rule_config_id: str
-    status_cd: str
-    updated_at: str
-    id: str
-    key: str
-
-
-class ContactCampaignStatus(BaseModel):
-    """A contact campaign status in Apollo"""
-
-    id: str
-    emailer_campaign_id: str
-    send_email_from_user_id: str
-    inactive_reason: str
-    status: str
-    added_at: str
-    added_by_user_id: str
-    finished_at: str
-    paused_at: str
-    auto_unpause_at: str
-    send_email_from_email_address: str
-    send_email_from_email_account_id: str
-    manually_set_unpause: str
-    failure_reason: str
-    current_step_id: str
-    in_response_to_emailer_message_id: str
-    cc_emails: str
-    bcc_emails: str
-    to_emails: str
-
-
-class Account(BaseModel):
-    """An account in Apollo"""
-
-    id: str
-    name: str
-    website_url: str
-    blog_url: str
-    angellist_url: str
-    linkedin_url: str
-    twitter_url: str
-    facebook_url: str
-    primary_phone: PrimaryPhone
-    languages: list[str]
-    alexa_ranking: int
-    phone: str
-    linkedin_uid: str
-    founded_year: int
-    publicly_traded_symbol: str
-    publicly_traded_exchange: str
-    logo_url: str
-    chrunchbase_url: str
-    primary_domain: str
-    domain: str
-    team_id: str
-    organization_id: str
-    account_stage_id: str
-    source: str
-    original_source: str
-    creator_id: str
-    owner_id: str
-    created_at: str
-    phone_status: str
-    hubspot_id: str
-    salesforce_id: str
-    crm_owner_id: str
-    parent_account_id: str
-    sanitized_phone: str
-    # no listed type on the API docs
-    account_playbook_statues: list[Any]
-    account_rule_config_statuses: list[RuleConfigStatus]
-    existence_level: str
-    label_ids: list[str]
-    typed_custom_fields: Any
-    custom_field_errors: Any
-    modality: str
-    source_display_name: str
-    salesforce_record_id: str
-    crm_record_url: str
-
-
-class ContactEmail(BaseModel):
-    """A contact email in Apollo"""
-
-    email: str = ""
-    email_md5: str = ""
-    email_sha256: str = ""
-    email_status: str = ""
-    email_source: str = ""
-    extrapolated_email_confidence: str = ""
-    position: int = 0
-    email_from_customer: str = ""
-    free_domain: bool = True
-
-
-class EmploymentHistory(BaseModel):
-    """An employment history in Apollo"""
-
-    class Config:
-        extra = "allow"
-        arbitrary_types_allowed = True
-        from_attributes = True
-        populate_by_name = True
-
-    _id: Optional[str] = None
-    created_at: Optional[str] = None
-    current: Optional[bool] = None
-    degree: Optional[str] = None
-    description: Optional[str] = None
-    emails: Optional[str] = None
-    end_date: Optional[str] = None
-    grade_level: Optional[str] = None
-    kind: Optional[str] = None
-    major: Optional[str] = None
-    organization_id: Optional[str] = None
-    organization_name: Optional[str] = None
-    raw_address: Optional[str] = None
-    start_date: Optional[str] = None
-    title: Optional[str] = None
-    updated_at: Optional[str] = None
-    id: Optional[str] = None
-    key: Optional[str] = None
-
-
-class Breadcrumb(BaseModel):
-    """A breadcrumb in Apollo"""
-
-    label: Optional[str] = "N/A"
-    signal_field_name: Optional[str] = "N/A"
-    value: str | list | None = "N/A"
-    display_name: Optional[str] = "N/A"
-
-
-class TypedCustomField(BaseModel):
-    """A typed custom field in Apollo"""
-
-    id: Optional[str] = "N/A"
-    value: Optional[str] = "N/A"
-
-
-class Pagination(BaseModel):
-    """Pagination in Apollo"""
-
-    class Config:
-        extra = "allow"  # Allow extra fields
-        arbitrary_types_allowed = True  # Allow any type
-        from_attributes = True  # Allow from_orm
-        populate_by_name = True  # Allow field aliases to work both ways
-
-    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: str
-    country_enabled: bool
-    high_risk_calling_enabled: bool
-    potential_high_risk_number: bool
-
-
-class PhoneNumber(BaseModel):
-    """A phone number in Apollo"""
-
-    raw_number: str = ""
-    sanitized_number: str = ""
-    type: str = ""
-    position: int = 0
-    status: str = ""
-    dnc_status: str = ""
-    dnc_other_info: str = ""
-    dailer_flags: DialerFlags = DialerFlags(
-        country_name="",
-        country_enabled=True,
-        high_risk_calling_enabled=True,
-        potential_high_risk_number=True,
-    )
-
-
-class Organization(BaseModel):
-    """An organization in Apollo"""
-
-    class Config:
-        extra = "allow"
-        arbitrary_types_allowed = True
-        from_attributes = True
-        populate_by_name = True
-
-    id: Optional[str] = "N/A"
-    name: Optional[str] = "N/A"
-    website_url: Optional[str] = "N/A"
-    blog_url: Optional[str] = "N/A"
-    angellist_url: Optional[str] = "N/A"
-    linkedin_url: Optional[str] = "N/A"
-    twitter_url: Optional[str] = "N/A"
-    facebook_url: Optional[str] = "N/A"
-    primary_phone: Optional[PrimaryPhone] = PrimaryPhone(
-        number="N/A", source="N/A", sanitized_number="N/A"
-    )
-    languages: list[str] = []
-    alexa_ranking: Optional[int] = 0
-    phone: Optional[str] = "N/A"
-    linkedin_uid: Optional[str] = "N/A"
-    founded_year: Optional[int] = 0
-    publicly_traded_symbol: Optional[str] = "N/A"
-    publicly_traded_exchange: Optional[str] = "N/A"
-    logo_url: Optional[str] = "N/A"
-    chrunchbase_url: Optional[str] = "N/A"
-    primary_domain: Optional[str] = "N/A"
-    sanitized_phone: Optional[str] = "N/A"
-    owned_by_organization_id: Optional[str] = "N/A"
-    intent_strength: Optional[str] = "N/A"
-    show_intent: bool = True
-    has_intent_signal_account: Optional[bool] = True
-    intent_signal_account: Optional[str] = "N/A"
-
-
-class Contact(BaseModel):
-    """A contact in Apollo"""
-
-    class Config:
-        extra = "allow"
-        arbitrary_types_allowed = True
-        from_attributes = True
-        populate_by_name = True
-
-    contact_roles: list[Any] = []
-    id: Optional[str] = None
-    first_name: Optional[str] = None
-    last_name: Optional[str] = None
-    name: Optional[str] = None
-    linkedin_url: Optional[str] = None
-    title: Optional[str] = None
-    contact_stage_id: Optional[str] = None
-    owner_id: Optional[str] = None
-    creator_id: Optional[str] = None
-    person_id: Optional[str] = None
-    email_needs_tickling: bool = True
-    organization_name: Optional[str] = None
-    source: Optional[str] = None
-    original_source: Optional[str] = None
-    organization_id: Optional[str] = None
-    headline: Optional[str] = None
-    photo_url: Optional[str] = None
-    present_raw_address: Optional[str] = None
-    linkededin_uid: Optional[str] = None
-    extrapolated_email_confidence: Optional[float] = None
-    salesforce_id: Optional[str] = None
-    salesforce_lead_id: Optional[str] = None
-    salesforce_contact_id: Optional[str] = None
-    saleforce_account_id: Optional[str] = None
-    crm_owner_id: Optional[str] = None
-    created_at: Optional[str] = None
-    emailer_campaign_ids: list[str] = []
-    direct_dial_status: Optional[str] = None
-    direct_dial_enrichment_failed_at: Optional[str] = None
-    email_status: Optional[str] = None
-    email_source: Optional[str] = None
-    account_id: Optional[str] = None
-    last_activity_date: Optional[str] = None
-    hubspot_vid: Optional[str] = None
-    hubspot_company_id: Optional[str] = None
-    crm_id: Optional[str] = None
-    sanitized_phone: Optional[str] = None
-    merged_crm_ids: Optional[str] = None
-    updated_at: Optional[str] = None
-    queued_for_crm_push: bool = True
-    suggested_from_rule_engine_config_id: Optional[str] = None
-    email_unsubscribed: Optional[str] = None
-    label_ids: list[Any] = []
-    has_pending_email_arcgate_request: bool = True
-    has_email_arcgate_request: bool = True
-    existence_level: Optional[str] = None
-    email: Optional[str] = None
-    email_from_customer: Optional[str] = None
-    typed_custom_fields: list[TypedCustomField] = []
-    custom_field_errors: Any = None
-    salesforce_record_id: Optional[str] = None
-    crm_record_url: Optional[str] = None
-    email_status_unavailable_reason: Optional[str] = None
-    email_true_status: Optional[str] = None
-    updated_email_true_status: bool = True
-    contact_rule_config_statuses: list[RuleConfigStatus] = []
-    source_display_name: Optional[str] = None
-    twitter_url: Optional[str] = None
-    contact_campaign_statuses: list[ContactCampaignStatus] = []
-    state: Optional[str] = None
-    city: Optional[str] = None
-    country: Optional[str] = None
-    account: Optional[Account] = None
-    contact_emails: list[ContactEmail] = []
-    organization: Optional[Organization] = None
-    employment_history: list[EmploymentHistory] = []
-    time_zone: Optional[str] = None
-    intent_strength: Optional[str] = None
-    show_intent: bool = True
-    phone_numbers: list[PhoneNumber] = []
-    account_phone_note: Optional[str] = None
-    free_domain: bool = True
-    is_likely_to_engage: bool = True
-    email_domain_catchall: bool = True
-    contact_job_change_event: Optional[str] = None
-
-
-class SearchOrganizationsRequest(BaseModel):
-    """Request for Apollo's search organizations API"""
-
-    organization_num_empoloyees_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=[],
-    )
-    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=[],
-    )
-    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."""
-    )
-    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."""
-    )
-    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=[],
-    )
-    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,
-    )
-
-    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: list[Breadcrumb] = []
-    partial_results_only: bool = True
-    has_join: bool = True
-    disable_eu_prospecting: bool = True
-    partial_results_limit: 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] = "N/A"
-    derived_params: Optional[str] = "N/A"
-
-
-class SearchPeopleRequest(BaseModel):
-    """Request for Apollo's search people API"""
-
-    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=[],
-        placeholder="marketing manager",
-    )
-    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=[],
-    )
-    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=[],
-    )
-    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=[],
-    )
-    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=[],
-    )
-    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=[],
-    )
-    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=[],
-    )
-    organization_num_empoloyees_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=[],
-    )
-    q_keywords: 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: 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"""
-
-    class Config:
-        extra = "allow"  # Allow extra fields
-        arbitrary_types_allowed = True  # Allow any type
-        from_attributes = True  # Allow from_orm
-        populate_by_name = True  # Allow field aliases to work both ways
-
-    breadcrumbs: list[Breadcrumb] = []
-    partial_results_only: bool = True
-    has_join: bool = True
-    disable_eu_prospecting: bool = True
-    partial_results_limit: 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] = "N/A"
-    derived_params: Optional[str] = "N/A"

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

@@ -1,219 +0,0 @@
-from backend.blocks.apollo._api import ApolloClient
-from backend.blocks.apollo._auth import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    ApolloCredentials,
-    ApolloCredentialsInput,
-)
-from backend.blocks.apollo.models import (
-    Organization,
-    PrimaryPhone,
-    SearchOrganizationsRequest,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-
-class SearchOrganizationsBlock(Block):
-    """Search for organizations in Apollo"""
-
-    class Input(BlockSchema):
-        organization_num_empoloyees_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=[],
-        )
-        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=[],
-        )
-        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=[],
-        )
-        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=[],
-        )
-        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 = SchemaField(
-            description="Apollo credentials",
-        )
-
-    class Output(BlockSchema):
-        organizations: list[Organization] = SchemaField(
-            description="List of organizations found",
-            default=[],
-        )
-        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
-    def search_organizations(
-        query: SearchOrganizationsRequest, credentials: ApolloCredentials
-    ) -> list[Organization]:
-        client = ApolloClient(credentials)
-        return client.search_organizations(query)
-
-    def run(
-        self, input_data: Input, *, credentials: ApolloCredentials, **kwargs
-    ) -> BlockOutput:
-        query = SearchOrganizationsRequest(
-            **input_data.model_dump(exclude={"credentials"})
-        )
-        organizations = self.search_organizations(query, credentials)
-        for organization in organizations:
-            yield "organization", organization
-        yield "organizations", organizations

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

@@ -1,394 +0,0 @@
-from backend.blocks.apollo._api import ApolloClient
-from backend.blocks.apollo._auth import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    ApolloCredentials,
-    ApolloCredentialsInput,
-)
-from backend.blocks.apollo.models import (
-    Contact,
-    ContactEmailStatuses,
-    SearchPeopleRequest,
-    SenorityLevels,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import 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=[],
-            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=[],
-            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=[],
-            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=[],
-            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=[],
-            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=[],
-            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=[],
-            advanced=False,
-        )
-        organization_num_empoloyees_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=[],
-            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 100.""",
-            default=100,
-            ge=1,
-            le=50000,
-            advanced=True,
-        )
-
-        credentials: ApolloCredentialsInput = SchemaField(
-            description="Apollo credentials",
-        )
-
-    class Output(BlockSchema):
-        people: list[Contact] = SchemaField(
-            description="List of people found",
-            default=[],
-        )
-        person: Contact = SchemaField(
-            description="Each found person, one at a time",
-        )
-        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=[
-                (
-                    "person",
-                    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,
-                    ),
-                ),
-                (
-                    "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
-    def search_people(
-        query: SearchPeopleRequest, credentials: ApolloCredentials
-    ) -> list[Contact]:
-        client = ApolloClient(credentials)
-        return client.search_people(query)
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: ApolloCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-
-        query = SearchPeopleRequest(**input_data.model_dump(exclude={"credentials"}))
-        people = self.search_people(query, credentials)
-        for person in people:
-            yield "person", person
-        yield "people", people

autogpt_platform/backend/backend/blocks/basic.py

@@ -3,7 +3,6 @@ from typing import Any, List
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema, BlockType
 from backend.data.model import SchemaField
-from backend.util import json
 from backend.util.file import MediaFile, store_media_file
 from backend.util.mock import MockObject
 from backend.util.text import TextFormatter
@@ -154,9 +153,6 @@ class FindInDictionaryBlock(Block):
         obj = input_data.input
         key = input_data.key
 
-        if isinstance(obj, str):
-            obj = json.loads(obj)
-
         if isinstance(obj, dict) and key in obj:
             yield "output", obj[key]
         elif isinstance(obj, list) and isinstance(key, int) and 0 <= key < len(obj):

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

@@ -51,7 +51,6 @@ class ExaContentsBlock(Block):
             description="List of document contents",
             default=[],
         )
-        error: str = SchemaField(description="Error message if the request failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/example/_api.py

@@ -1,137 +0,0 @@
-"""
-API module for Example API integration.
-
-This module provides a example of how to create a client for an API.
-"""
-
-# We also have a Json Wrapper library available in backend.util.json
-from json import JSONDecodeError
-from typing import Any, Optional
-
-from pydantic import BaseModel
-
-from backend.data.model import APIKeyCredentials
-
-# This is a wrapper around the requests library that is used to make API requests.
-from backend.util.request import Requests
-
-
-class ExampleAPIException(Exception):
-    def __init__(self, message: str, status_code: int):
-        super().__init__(message)
-        self.status_code = status_code
-
-
-class CreateResourceResponse(BaseModel):
-    message: str
-    is_funny: bool
-
-
-class GetResourceResponse(BaseModel):
-    message: str
-    is_funny: bool
-
-
-class ExampleClient:
-    """Client for the Example API"""
-
-    API_BASE_URL = "https://api.example.com/v1"
-
-    def __init__(
-        self,
-        credentials: Optional[APIKeyCredentials] = None,
-        custom_requests: Optional[Requests] = None,
-    ):
-        if custom_requests:
-            self._requests = custom_requests
-        else:
-            headers: dict[str, str] = {
-                "Content-Type": "application/json",
-            }
-            if credentials:
-                headers["Authorization"] = credentials.auth_header()
-
-            self._requests = Requests(
-                extra_headers=headers,
-                raise_for_status=False,
-            )
-
-    @staticmethod
-    def _handle_response(response) -> Any:
-        """
-        Handles API response and checks for errors.
-
-        Args:
-            response: The response object from the request.
-
-        Returns:
-            The parsed JSON response data.
-
-        Raises:
-            ExampleAPIException: If the API request fails.
-        """
-        if not response.ok:
-            try:
-                error_data = response.json()
-                error_message = error_data.get("error", {}).get("message", "")
-            except JSONDecodeError:
-                error_message = response.text
-
-            raise ExampleAPIException(
-                f"Example API request failed ({response.status_code}): {error_message}",
-                response.status_code,
-            )
-
-        response_data = response.json()
-        if "errors" in response_data:
-            # This is an example error and needs to be
-            # replaced with how the real API returns errors
-            error_messages = [
-                error.get("message", "") for error in response_data["errors"]
-            ]
-            raise ExampleAPIException(
-                f"Example API returned errors: {', '.join(error_messages)}",
-                response.status_code,
-            )
-
-        return response_data
-
-    def get_resource(self, resource_id: str) -> GetResourceResponse:
-        """
-        Fetches a resource from the Example API.
-
-        Args:
-            resource_id: The ID of the resource to fetch.
-
-        Returns:
-            The resource data as a GetResourceResponse object.
-
-        Raises:
-            ExampleAPIException: If the API request fails.
-        """
-        try:
-            response = self._requests.get(
-                f"{self.API_BASE_URL}/resources/{resource_id}"
-            )
-            return GetResourceResponse(**self._handle_response(response))
-        except Exception as e:
-            raise ExampleAPIException(f"Failed to get resource: {str(e)}", 500)
-
-    def create_resource(self, data: dict) -> CreateResourceResponse:
-        """
-        Creates a new resource via the Example API.
-
-        Args:
-            data: The resource data to create.
-
-        Returns:
-            The created resource data as a CreateResourceResponse object.
-
-        Raises:
-            ExampleAPIException: If the API request fails.
-        """
-        try:
-            response = self._requests.post(f"{self.API_BASE_URL}/resources", json=data)
-            return CreateResourceResponse(**self._handle_response(response))
-        except Exception as e:
-            raise ExampleAPIException(f"Failed to create resource: {str(e)}", 500)

autogpt_platform/backend/backend/blocks/example/_auth.py

@@ -1,37 +0,0 @@
-"""
-Authentication module for Example API integration.
-
-This module provides credential types and test credentials for the Example API integration.
-It defines the structure for API key credentials used to authenticate with the Example API
-and provides mock credentials for testing purposes.
-"""
-
-from typing import Literal
-
-from pydantic import SecretStr
-
-from backend.data.model import APIKeyCredentials, CredentialsMetaInput
-from backend.integrations.providers import ProviderName
-
-# Define the type of credentials input expected for Example API
-ExampleCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.EXAMPLE_PROVIDER], Literal["api_key"]
-]
-
-
-# Mock credentials for testing Example API integration
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="9191c4f0-498f-4235-a79c-59c0e37454d4",
-    provider="example-provider",
-    api_key=SecretStr("mock-example-api-key"),
-    title="Mock Example API key",
-    expires_at=None,
-)
-
-# Dictionary representation of test credentials for input fields
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.title,
-}

autogpt_platform/backend/backend/blocks/example/example.py

@@ -1,154 +0,0 @@
-import logging
-
-from pydantic import BaseModel
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import APIKeyCredentials, CredentialsField, SchemaField
-
-from ._api import ExampleClient
-from ._auth import TEST_CREDENTIALS, TEST_CREDENTIALS_INPUT, ExampleCredentialsInput
-
-logger = logging.getLogger(__name__)
-
-
-class GreetingMessage(BaseModel):
-    message: str
-    is_funny: bool
-
-
-class ExampleBlock(Block):
-
-    class Input(BlockSchema):
-        name: str = SchemaField(
-            description="The name of the example block", placeholder="Enter a name"
-        )
-        greetings: list[str] = SchemaField(
-            description="The greetings to display", default=["Hello", "Hi", "Hey"]
-        )
-        is_funny: bool = SchemaField(
-            description="Whether the block is funny",
-            placeholder="True",
-            default=True,
-            # Advanced fields are moved to the "Advanced" dropdown in the UI
-            advanced=True,
-        )
-        greeting_context: str = SchemaField(
-            description="The context of the greeting",
-            placeholder="Enter a context",
-            default="The user is looking for an inspirational greeting",
-            # Hidden fields are not shown in the UI at all
-            hidden=True,
-        )
-        # Only if the block needs credentials
-        credentials: ExampleCredentialsInput = CredentialsField(
-            description="The credentials for the example block"
-        )
-
-    class Output(BlockSchema):
-        response: GreetingMessage = SchemaField(
-            description="The response object generated by the example block."
-        )
-        all_responses: list[GreetingMessage] = SchemaField(
-            description="All the responses from the example block."
-        )
-        greeting_count: int = SchemaField(
-            description="The number of greetings in the input."
-        )
-        error: str = SchemaField(description="The error from the example block")
-
-    def __init__(self):
-        super().__init__(
-            # The unique identifier for the block, this value will be persisted in the DB.
-            # It should be unique and constant across the application run.
-            # Use the UUID format for the ID.
-            id="380694d5-3b2e-4130-bced-b43752b70de9",
-            # The description of the block, explaining what the block does.
-            description="The example block",
-            # The set of categories that the block belongs to.
-            # Each category is an instance of BlockCategory Enum.
-            categories={BlockCategory.BASIC},
-            # The schema, defined as a Pydantic model, for the input data.
-            input_schema=ExampleBlock.Input,
-            # The schema, defined as a Pydantic model, for the output data.
-            output_schema=ExampleBlock.Output,
-            # The list or single sample input data for the block, for testing.
-            # This is an instance of the Input schema with sample values.
-            test_input={
-                "name": "Craig",
-                "greetings": ["Hello", "Hi", "Hey"],
-                "is_funny": True,
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            # The list or single expected output if the test_input is run.
-            # Each output is a tuple of (output_name, output_data).
-            test_output=[
-                ("response", GreetingMessage(message="Hello, world!", is_funny=True)),
-                (
-                    "response",
-                    GreetingMessage(message="Hello, world!", is_funny=True),
-                ),  # We mock the function
-                (
-                    "response",
-                    GreetingMessage(message="Hello, world!", is_funny=True),
-                ),  # We mock the function
-                (
-                    "all_responses",
-                    [
-                        GreetingMessage(message="Hello, world!", is_funny=True),
-                        GreetingMessage(message="Hello, world!", is_funny=True),
-                        GreetingMessage(message="Hello, world!", is_funny=True),
-                    ],
-                ),
-                ("greeting_count", 3),
-            ],
-            # Function names on the block implementation to mock on test run.
-            # Each mock is a dictionary with function names as keys and mock implementations as values.
-            test_mock={
-                "my_function_that_can_be_mocked": lambda *args, **kwargs: GreetingMessage(
-                    message="Hello, world!", is_funny=True
-                )
-            },
-            # The credentials required for testing the block.
-            # This is an instance of APIKeyCredentials with sample values.
-            test_credentials=TEST_CREDENTIALS,
-        )
-
-    def my_function_that_can_be_mocked(
-        self, name: str, credentials: APIKeyCredentials
-    ) -> GreetingMessage:
-        logger.info("my_function_that_can_be_mocked called with input: %s", name)
-
-        # Use the ExampleClient from _api.py to make an API call
-        client = ExampleClient(credentials=credentials)
-
-        # Create a sample resource using the client
-        resource_data = {"name": name, "type": "greeting"}
-        # If your API response object matches the return type of the function,
-        # there is no need to convert the object. In this case we have a different
-        # object type for the response and the return type of the function.
-        return GreetingMessage(**client.create_resource(resource_data).model_dump())
-
-    def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        """
-        The run function implements the block's core logic. It processes the input_data
-        and yields the block's output.
-
-        In addition to credentials, the following parameters can be specified:
-            graph_id: The ID of the graph containing this block.
-            node_id: The ID of this block's node in the graph.
-            graph_exec_id: The ID of the current graph execution.
-            node_exec_id: The ID of the current node execution.
-            user_id: The ID of the user executing the block.
-        """
-        rtn_all_responses: list[GreetingMessage] = []
-        # Here we deomonstrate best practice for blocks that need to yield multiple items.
-        # We yield each item from the list to allow for operations on each element.
-        # We also yield the complete list for situations when the full list is needed.
-        for greeting in input_data.greetings:
-            message = self.my_function_that_can_be_mocked(greeting, credentials)
-            rtn_all_responses.append(message)
-            yield "response", message
-        yield "all_responses", rtn_all_responses
-        yield "greeting_count", len(input_data.greetings)

autogpt_platform/backend/backend/blocks/example/triggers.py

@@ -1,65 +0,0 @@
-import logging
-
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockManualWebhookConfig,
-    BlockOutput,
-    BlockSchema,
-)
-from backend.data.model import SchemaField
-from backend.integrations.webhooks.example import ExampleWebhookEventType
-
-logger = logging.getLogger(__name__)
-
-
-class ExampleTriggerBlock(Block):
-    """
-    A trigger block that is activated by an external webhook event.
-
-    Unlike standard blocks that are manually executed, trigger blocks are automatically
-    activated when a webhook event is received from the specified provider.
-    """
-
-    class Input(BlockSchema):
-        # The payload field is hidden because it's automatically populated by the webhook
-        # system rather than being manually entered by the user
-        payload: dict = SchemaField(hidden=True)
-
-    class Output(BlockSchema):
-        event_data: dict = SchemaField(
-            description="The contents of the example webhook event."
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="7c5933ce-d60c-42dd-9c4e-db82496474a3",
-            description="This block will output the contents of an example webhook event.",
-            categories={BlockCategory.BASIC},
-            input_schema=ExampleTriggerBlock.Input,
-            output_schema=ExampleTriggerBlock.Output,
-            # The webhook_config is a key difference from standard blocks
-            # It defines which external service can trigger this block and what type of events it responds to
-            webhook_config=BlockManualWebhookConfig(
-                provider="example_provider",  # The external service that will send webhook events
-                webhook_type=ExampleWebhookEventType.EXAMPLE_EVENT,  # The specific event type this block responds to
-            ),
-            # Test input for trigger blocks should mimic the payload structure that would be received from the webhook
-            test_input=[
-                {
-                    "payload": {
-                        "event_type": "example",
-                        "data": "Sample webhook data",
-                    }
-                }
-            ],
-            test_output=[
-                ("event_data", {"event_type": "example", "data": "Sample webhook data"})
-            ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        # For trigger blocks, the run method is called automatically when a webhook event is received
-        # The payload from the webhook is passed in as input_data.payload
-        logger.info("Example trigger block run with payload: %s", input_data.payload)
-        yield "event_data", input_data.payload

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

@@ -38,59 +38,6 @@ def _get_headers(credentials: GithubCredentials) -> dict[str, str]:
     }
 
 
-def convert_comment_url_to_api_endpoint(comment_url: str) -> str:
-    """
-    Converts a GitHub comment URL (web interface) to the appropriate API endpoint URL.
-
-    Handles:
-    1. Issue/PR comments: #issuecomment-{id}
-    2. PR review comments: #discussion_r{id}
-
-    Returns the appropriate API endpoint path for the comment.
-    """
-    # First, check if this is already an API URL
-    parsed_url = urlparse(comment_url)
-    if parsed_url.hostname == "api.github.com":
-        return comment_url
-
-    # Replace pull with issues for comment endpoints
-    if "/pull/" in comment_url:
-        comment_url = comment_url.replace("/pull/", "/issues/")
-
-    # Handle issue/PR comments (#issuecomment-xxx)
-    if "#issuecomment-" in comment_url:
-        base_url, comment_part = comment_url.split("#issuecomment-")
-        comment_id = comment_part
-
-        # Extract repo information from base URL
-        parsed_url = urlparse(base_url)
-        path_parts = parsed_url.path.strip("/").split("/")
-        owner, repo = path_parts[0], path_parts[1]
-
-        # Construct API URL for issue comments
-        return (
-            f"https://api.github.com/repos/{owner}/{repo}/issues/comments/{comment_id}"
-        )
-
-    # Handle PR review comments (#discussion_r)
-    elif "#discussion_r" in comment_url:
-        base_url, comment_part = comment_url.split("#discussion_r")
-        comment_id = comment_part
-
-        # Extract repo information from base URL
-        parsed_url = urlparse(base_url)
-        path_parts = parsed_url.path.strip("/").split("/")
-        owner, repo = path_parts[0], path_parts[1]
-
-        # Construct API URL for PR review comments
-        return (
-            f"https://api.github.com/repos/{owner}/{repo}/pulls/comments/{comment_id}"
-        )
-
-    # If no specific comment identifiers are found, use the general URL conversion
-    return _convert_to_api_url(comment_url)
-
-
 def get_api(
     credentials: GithubCredentials | GithubFineGrainedAPICredentials,
     convert_urls: bool = True,

autogpt_platform/backend/backend/blocks/github/checks.py

@@ -172,9 +172,7 @@ class GithubCreateCheckRunBlock(Block):
             data.output = output_data
 
         check_runs_url = f"{repo_url}/check-runs"
-        response = api.post(
-            check_runs_url, data=data.model_dump_json(exclude_none=True)
-        )
+        response = api.post(check_runs_url)
         result = response.json()
 
         return {
@@ -325,9 +323,7 @@ class GithubUpdateCheckRunBlock(Block):
             data.output = output_data
 
         check_run_url = f"{repo_url}/check-runs/{check_run_id}"
-        response = api.patch(
-            check_run_url, data=data.model_dump_json(exclude_none=True)
-        )
+        response = api.patch(check_run_url)
         result = response.json()
 
         return {

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

@@ -1,4 +1,3 @@
-import logging
 from urllib.parse import urlparse
 
 from typing_extensions import TypedDict
@@ -6,7 +5,7 @@ from typing_extensions import TypedDict
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
-from ._api import convert_comment_url_to_api_endpoint, get_api
+from ._api import get_api
 from ._auth import (
     TEST_CREDENTIALS,
     TEST_CREDENTIALS_INPUT,
@@ -15,8 +14,6 @@ from ._auth import (
     GithubCredentialsInput,
 )
 
-logger = logging.getLogger(__name__)
-
 
 def is_github_url(url: str) -> bool:
     return urlparse(url).netloc == "github.com"
@@ -111,228 +108,6 @@ class GithubCommentBlock(Block):
 # --8<-- [end:GithubCommentBlockExample]
 
 
-class GithubUpdateCommentBlock(Block):
-    class Input(BlockSchema):
-        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
-        comment_url: str = SchemaField(
-            description="URL of the GitHub comment",
-            placeholder="https://github.com/owner/repo/issues/1#issuecomment-123456789",
-            default="",
-            advanced=False,
-        )
-        issue_url: str = SchemaField(
-            description="URL of the GitHub issue or pull request",
-            placeholder="https://github.com/owner/repo/issues/1",
-            default="",
-        )
-        comment_id: str = SchemaField(
-            description="ID of the GitHub comment",
-            placeholder="123456789",
-            default="",
-        )
-        comment: str = SchemaField(
-            description="Comment to update",
-            placeholder="Enter your comment",
-        )
-
-    class Output(BlockSchema):
-        id: int = SchemaField(description="ID of the updated comment")
-        url: str = SchemaField(description="URL to the comment on GitHub")
-        error: str = SchemaField(
-            description="Error message if the comment update failed"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="b3f4d747-10e3-4e69-8c51-f2be1d99c9a7",
-            description="This block updates a comment on a specified GitHub issue or pull request.",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=GithubUpdateCommentBlock.Input,
-            output_schema=GithubUpdateCommentBlock.Output,
-            test_input={
-                "comment_url": "https://github.com/owner/repo/issues/1#issuecomment-123456789",
-                "comment": "This is an updated comment.",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                ("id", 123456789),
-                (
-                    "url",
-                    "https://github.com/owner/repo/issues/1#issuecomment-123456789",
-                ),
-            ],
-            test_mock={
-                "update_comment": lambda *args, **kwargs: (
-                    123456789,
-                    "https://github.com/owner/repo/issues/1#issuecomment-123456789",
-                )
-            },
-        )
-
-    @staticmethod
-    def update_comment(
-        credentials: GithubCredentials, comment_url: str, body_text: str
-    ) -> tuple[int, str]:
-        api = get_api(credentials, convert_urls=False)
-        data = {"body": body_text}
-        url = convert_comment_url_to_api_endpoint(comment_url)
-
-        logger.info(url)
-        response = api.patch(url, json=data)
-        comment = response.json()
-        return comment["id"], comment["html_url"]
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: GithubCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        if (
-            not input_data.comment_url
-            and input_data.comment_id
-            and input_data.issue_url
-        ):
-            parsed_url = urlparse(input_data.issue_url)
-            path_parts = parsed_url.path.strip("/").split("/")
-            owner, repo = path_parts[0], path_parts[1]
-
-            input_data.comment_url = f"https://api.github.com/repos/{owner}/{repo}/issues/comments/{input_data.comment_id}"
-
-        elif (
-            not input_data.comment_url
-            and not input_data.comment_id
-            and input_data.issue_url
-        ):
-            raise ValueError(
-                "Must provide either comment_url or comment_id and issue_url"
-            )
-        id, url = self.update_comment(
-            credentials,
-            input_data.comment_url,
-            input_data.comment,
-        )
-        yield "id", id
-        yield "url", url
-
-
-class GithubListCommentsBlock(Block):
-    class Input(BlockSchema):
-        credentials: GithubCredentialsInput = GithubCredentialsField("repo")
-        issue_url: str = SchemaField(
-            description="URL of the GitHub issue or pull request",
-            placeholder="https://github.com/owner/repo/issues/1",
-        )
-
-    class Output(BlockSchema):
-        class CommentItem(TypedDict):
-            id: int
-            body: str
-            user: str
-            url: str
-
-        comment: CommentItem = SchemaField(
-            title="Comment", description="Comments with their ID, body, user, and URL"
-        )
-        comments: list[CommentItem] = SchemaField(
-            description="List of comments with their ID, body, user, and URL"
-        )
-        error: str = SchemaField(description="Error message if listing comments failed")
-
-    def __init__(self):
-        super().__init__(
-            id="c4b5fb63-0005-4a11-b35a-0c2467bd6b59",
-            description="This block lists all comments for a specified GitHub issue or pull request.",
-            categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=GithubListCommentsBlock.Input,
-            output_schema=GithubListCommentsBlock.Output,
-            test_input={
-                "issue_url": "https://github.com/owner/repo/issues/1",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                (
-                    "comment",
-                    {
-                        "id": 123456789,
-                        "body": "This is a test comment.",
-                        "user": "test_user",
-                        "url": "https://github.com/owner/repo/issues/1#issuecomment-123456789",
-                    },
-                ),
-                (
-                    "comments",
-                    [
-                        {
-                            "id": 123456789,
-                            "body": "This is a test comment.",
-                            "user": "test_user",
-                            "url": "https://github.com/owner/repo/issues/1#issuecomment-123456789",
-                        }
-                    ],
-                ),
-            ],
-            test_mock={
-                "list_comments": lambda *args, **kwargs: [
-                    {
-                        "id": 123456789,
-                        "body": "This is a test comment.",
-                        "user": "test_user",
-                        "url": "https://github.com/owner/repo/issues/1#issuecomment-123456789",
-                    }
-                ]
-            },
-        )
-
-    @staticmethod
-    def list_comments(
-        credentials: GithubCredentials, issue_url: str
-    ) -> list[Output.CommentItem]:
-        parsed_url = urlparse(issue_url)
-        path_parts = parsed_url.path.strip("/").split("/")
-
-        owner = path_parts[0]
-        repo = path_parts[1]
-
-        # GitHub API uses 'issues' for both issues and pull requests when it comes to comments
-        issue_number = path_parts[3]  # Whether 'issues/123' or 'pull/123'
-
-        # Construct the proper API URL directly
-        api_url = f"https://api.github.com/repos/{owner}/{repo}/issues/{issue_number}/comments"
-
-        # Set convert_urls=False since we're already providing an API URL
-        api = get_api(credentials, convert_urls=False)
-        response = api.get(api_url)
-        comments = response.json()
-        parsed_comments: list[GithubListCommentsBlock.Output.CommentItem] = [
-            {
-                "id": comment["id"],
-                "body": comment["body"],
-                "user": comment["user"]["login"],
-                "url": comment["html_url"],
-            }
-            for comment in comments
-        ]
-        return parsed_comments
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: GithubCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        comments = self.list_comments(
-            credentials,
-            input_data.issue_url,
-        )
-        yield from (("comment", comment) for comment in comments)
-        yield "comments", comments
-
-
 class GithubMakeIssueBlock(Block):
     class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")

autogpt_platform/backend/backend/blocks/github/statuses.py

@@ -144,7 +144,7 @@ class GithubCreateStatusBlock(Block):
             data.description = description
 
         status_url = f"{repo_url}/statuses/{sha}"
-        response = api.post(status_url, data=data.model_dump_json(exclude_none=True))
+        response = api.post(status_url, json=data)
         result = response.json()
 
         return {

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

@@ -8,7 +8,6 @@ from pydantic import BaseModel
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
-from backend.util.settings import Settings
 
 from ._auth import (
     GOOGLE_OAUTH_IS_CONFIGURED,
@@ -151,8 +150,8 @@ class GmailReadBlock(Block):
                 else None
             ),
             token_uri="https://oauth2.googleapis.com/token",
-            client_id=Settings().secrets.google_client_id,
-            client_secret=Settings().secrets.google_client_secret,
+            client_id=kwargs.get("client_id"),
+            client_secret=kwargs.get("client_secret"),
             scopes=credentials.scopes,
         )
         return build("gmail", "v1", credentials=creds)

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

@@ -3,7 +3,6 @@ from googleapiclient.discovery import build
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
-from backend.util.settings import Settings
 
 from ._auth import (
     GOOGLE_OAUTH_IS_CONFIGURED,
@@ -87,8 +86,8 @@ class GoogleSheetsReadBlock(Block):
                 else None
             ),
             token_uri="https://oauth2.googleapis.com/token",
-            client_id=Settings().secrets.google_client_id,
-            client_secret=Settings().secrets.google_client_secret,
+            client_id=kwargs.get("client_id"),
+            client_secret=kwargs.get("client_secret"),
             scopes=credentials.scopes,
         )
         return build("sheets", "v4", credentials=creds)

autogpt_platform/backend/backend/blocks/ideogram.py

@@ -142,16 +142,6 @@ class IdeogramModelBlock(Block):
             title="Color Palette Preset",
             advanced=True,
         )
-        custom_color_palette: Optional[list[str]] = SchemaField(
-            description=(
-                "Only available for model version V_2 or V_2_TURBO. Provide one or more color hex codes "
-                "(e.g., ['#000030', '#1C0C47', '#9900FF', '#4285F4', '#FFFFFF']) to define a custom color "
-                "palette. Only used if 'color_palette_name' is 'NONE'."
-            ),
-            default=None,
-            title="Custom Color Palette",
-            advanced=True,
-        )
 
     class Output(BlockSchema):
         result: str = SchemaField(description="Generated image URL")
@@ -174,13 +164,6 @@ class IdeogramModelBlock(Block):
                 "style_type": StyleType.AUTO,
                 "negative_prompt": None,
                 "color_palette_name": ColorPalettePreset.NONE,
-                "custom_color_palette": [
-                    "#000030",
-                    "#1C0C47",
-                    "#9900FF",
-                    "#4285F4",
-                    "#FFFFFF",
-                ],
                 "credentials": TEST_CREDENTIALS_INPUT,
             },
             test_output=[
@@ -190,7 +173,7 @@ class IdeogramModelBlock(Block):
                 ),
             ],
             test_mock={
-                "run_model": lambda api_key, model_name, prompt, seed, aspect_ratio, magic_prompt_option, style_type, negative_prompt, color_palette_name, custom_colors: "https://ideogram.ai/api/images/test-generated-image-url.png",
+                "run_model": lambda api_key, model_name, prompt, seed, aspect_ratio, magic_prompt_option, style_type, negative_prompt, color_palette_name: "https://ideogram.ai/api/images/test-generated-image-url.png",
                 "upscale_image": lambda api_key, image_url: "https://ideogram.ai/api/images/test-upscaled-image-url.png",
             },
             test_credentials=TEST_CREDENTIALS,
@@ -212,7 +195,6 @@ class IdeogramModelBlock(Block):
             style_type=input_data.style_type.value,
             negative_prompt=input_data.negative_prompt,
             color_palette_name=input_data.color_palette_name.value,
-            custom_colors=input_data.custom_color_palette,
         )
 
         # Step 2: Upscale the image if requested
@@ -235,7 +217,6 @@ class IdeogramModelBlock(Block):
         style_type: str,
         negative_prompt: Optional[str],
         color_palette_name: str,
-        custom_colors: Optional[list[str]],
     ):
         url = "https://api.ideogram.ai/generate"
         headers = {
@@ -260,11 +241,7 @@ class IdeogramModelBlock(Block):
             data["image_request"]["negative_prompt"] = negative_prompt
 
         if color_palette_name != "NONE":
-            data["color_palette"] = {"name": color_palette_name}
-        elif custom_colors:
-            data["color_palette"] = {
-                "members": [{"color_hex": color} for color in custom_colors]
-            }
+            data["image_request"]["color_palette"] = {"name": color_palette_name}
 
         try:
             response = requests.post(url, json=data, headers=headers)
@@ -290,7 +267,9 @@ class IdeogramModelBlock(Block):
             response = requests.post(
                 url,
                 headers=headers,
-                data={"image_request": "{}"},
+                data={
+                    "image_request": "{}",  # Empty JSON object
+                },
                 files=files,
             )
 

autogpt_platform/backend/backend/blocks/llm.py

@@ -4,11 +4,10 @@ from abc import ABC
 from enum import Enum, EnumMeta
 from json import JSONDecodeError
 from types import MappingProxyType
-from typing import TYPE_CHECKING, Any, Iterable, List, Literal, NamedTuple, Optional
+from typing import TYPE_CHECKING, Any, List, Literal, NamedTuple
 
-from pydantic import BaseModel, SecretStr
+from pydantic import SecretStr
 
-from backend.data.model import NodeExecutionStats
 from backend.integrations.providers import ProviderName
 
 if TYPE_CHECKING:
@@ -17,8 +16,6 @@ if TYPE_CHECKING:
 import anthropic
 import ollama
 import openai
-from anthropic._types import NotGiven
-from anthropic.types import ToolParam
 from groq import Groq
 
 from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
@@ -230,299 +227,15 @@ for model in LlmModel:
         raise ValueError(f"Missing MODEL_METADATA metadata for model: {model}")
 
 
-class ToolCall(BaseModel):
-    name: str
-    arguments: str
+class MessageRole(str, Enum):
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
 
 
-class ToolContentBlock(BaseModel):
-    id: str
-    type: str
-    function: ToolCall
-
-
-class LLMResponse(BaseModel):
-    raw_response: Any
-    prompt: List[Any]
-    response: str
-    tool_calls: Optional[List[ToolContentBlock]] | None
-    prompt_tokens: int
-    completion_tokens: int
-
-
-def convert_openai_tool_fmt_to_anthropic(
-    openai_tools: list[dict] | None = None,
-) -> Iterable[ToolParam] | NotGiven:
-    """
-    Convert OpenAI tool format to Anthropic tool format.
-    """
-    if not openai_tools or len(openai_tools) == 0:
-        return anthropic.NOT_GIVEN
-
-    anthropic_tools = []
-    for tool in openai_tools:
-        if "function" in tool:
-            # Handle case where tool is already in OpenAI format with "type" and "function"
-            function_data = tool["function"]
-        else:
-            # Handle case where tool is just the function definition
-            function_data = tool
-
-        anthropic_tool: anthropic.types.ToolParam = {
-            "name": function_data["name"],
-            "description": function_data.get("description", ""),
-            "input_schema": {
-                "type": "object",
-                "properties": function_data.get("parameters", {}).get("properties", {}),
-                "required": function_data.get("parameters", {}).get("required", []),
-            },
-        }
-        anthropic_tools.append(anthropic_tool)
-
-    return anthropic_tools
-
-
-def llm_call(
-    credentials: APIKeyCredentials,
-    llm_model: LlmModel,
-    prompt: list[dict],
-    json_format: bool,
-    max_tokens: int | None,
-    tools: list[dict] | None = None,
-    ollama_host: str = "localhost:11434",
-) -> LLMResponse:
-    """
-    Make a call to a language model.
-
-    Args:
-        credentials: The API key credentials to use.
-        llm_model: The LLM model to use.
-        prompt: The prompt to send to the LLM.
-        json_format: Whether the response should be in JSON format.
-        max_tokens: The maximum number of tokens to generate in the chat completion.
-        tools: The tools to use in the chat completion.
-        ollama_host: The host for ollama to use.
-
-    Returns:
-        LLMResponse object containing:
-            - prompt: The prompt sent to the LLM.
-            - response: The text response from the LLM.
-            - tool_calls: Any tool calls the model made, if applicable.
-            - prompt_tokens: The number of tokens used in the prompt.
-            - completion_tokens: The number of tokens used in the completion.
-    """
-    provider = llm_model.metadata.provider
-    max_tokens = max_tokens or llm_model.max_output_tokens or 4096
-
-    if provider == "openai":
-        tools_param = tools if tools else openai.NOT_GIVEN
-        oai_client = openai.OpenAI(api_key=credentials.api_key.get_secret_value())
-        response_format = None
-
-        if llm_model in [LlmModel.O1_MINI, LlmModel.O1_PREVIEW]:
-            sys_messages = [p["content"] for p in prompt if p["role"] == "system"]
-            usr_messages = [p["content"] for p in prompt if p["role"] != "system"]
-            prompt = [
-                {"role": "user", "content": "\n".join(sys_messages)},
-                {"role": "user", "content": "\n".join(usr_messages)},
-            ]
-        elif json_format:
-            response_format = {"type": "json_object"}
-
-        response = oai_client.chat.completions.create(
-            model=llm_model.value,
-            messages=prompt,  # type: ignore
-            response_format=response_format,  # type: ignore
-            max_completion_tokens=max_tokens,
-            tools=tools_param,  # type: ignore
-        )
-
-        if response.choices[0].message.tool_calls:
-            tool_calls = [
-                ToolContentBlock(
-                    id=tool.id,
-                    type=tool.type,
-                    function=ToolCall(
-                        name=tool.function.name,
-                        arguments=tool.function.arguments,
-                    ),
-                )
-                for tool in response.choices[0].message.tool_calls
-            ]
-        else:
-            tool_calls = None
-
-        return LLMResponse(
-            raw_response=response.choices[0].message,
-            prompt=prompt,
-            response=response.choices[0].message.content or "",
-            tool_calls=tool_calls,
-            prompt_tokens=response.usage.prompt_tokens if response.usage else 0,
-            completion_tokens=response.usage.completion_tokens if response.usage else 0,
-        )
-    elif provider == "anthropic":
-
-        an_tools = convert_openai_tool_fmt_to_anthropic(tools)
-
-        system_messages = [p["content"] for p in prompt if p["role"] == "system"]
-        sysprompt = " ".join(system_messages)
-
-        messages = []
-        last_role = None
-        for p in prompt:
-            if p["role"] in ["user", "assistant"]:
-                if (
-                    p["role"] == last_role
-                    and isinstance(messages[-1]["content"], str)
-                    and isinstance(p["content"], str)
-                ):
-                    # If the role is the same as the last one, combine the content
-                    messages[-1]["content"] += p["content"]
-                else:
-                    messages.append({"role": p["role"], "content": p["content"]})
-                    last_role = p["role"]
-
-        client = anthropic.Anthropic(api_key=credentials.api_key.get_secret_value())
-        try:
-            resp = client.messages.create(
-                model=llm_model.value,
-                system=sysprompt,
-                messages=messages,
-                max_tokens=max_tokens,
-                tools=an_tools,
-            )
-
-            if not resp.content:
-                raise ValueError("No content returned from Anthropic.")
-
-            tool_calls = None
-            for content_block in resp.content:
-                # Antropic is different to openai, need to iterate through
-                # the content blocks to find the tool calls
-                if content_block.type == "tool_use":
-                    if tool_calls is None:
-                        tool_calls = []
-                    tool_calls.append(
-                        ToolContentBlock(
-                            id=content_block.id,
-                            type=content_block.type,
-                            function=ToolCall(
-                                name=content_block.name,
-                                arguments=json.dumps(content_block.input),
-                            ),
-                        )
-                    )
-
-            if not tool_calls and resp.stop_reason == "tool_use":
-                logger.warning(
-                    "Tool use stop reason but no tool calls found in content. %s", resp
-                )
-
-            return LLMResponse(
-                raw_response=resp,
-                prompt=prompt,
-                response=(
-                    resp.content[0].name
-                    if isinstance(resp.content[0], anthropic.types.ToolUseBlock)
-                    else resp.content[0].text
-                ),
-                tool_calls=tool_calls,
-                prompt_tokens=resp.usage.input_tokens,
-                completion_tokens=resp.usage.output_tokens,
-            )
-        except anthropic.APIError as e:
-            error_message = f"Anthropic API error: {str(e)}"
-            logger.error(error_message)
-            raise ValueError(error_message)
-    elif provider == "groq":
-        if tools:
-            raise ValueError("Groq does not support tools.")
-
-        client = Groq(api_key=credentials.api_key.get_secret_value())
-        response_format = {"type": "json_object"} if json_format else None
-        response = client.chat.completions.create(
-            model=llm_model.value,
-            messages=prompt,  # type: ignore
-            response_format=response_format,  # type: ignore
-            max_tokens=max_tokens,
-        )
-        return LLMResponse(
-            raw_response=response.choices[0].message,
-            prompt=prompt,
-            response=response.choices[0].message.content or "",
-            tool_calls=None,
-            prompt_tokens=response.usage.prompt_tokens if response.usage else 0,
-            completion_tokens=response.usage.completion_tokens if response.usage else 0,
-        )
-    elif provider == "ollama":
-        if tools:
-            raise ValueError("Ollama does not support tools.")
-
-        client = ollama.Client(host=ollama_host)
-        sys_messages = [p["content"] for p in prompt if p["role"] == "system"]
-        usr_messages = [p["content"] for p in prompt if p["role"] != "system"]
-        response = client.generate(
-            model=llm_model.value,
-            prompt=f"{sys_messages}\n\n{usr_messages}",
-            stream=False,
-        )
-        return LLMResponse(
-            raw_response=response.get("response") or "",
-            prompt=prompt,
-            response=response.get("response") or "",
-            tool_calls=None,
-            prompt_tokens=response.get("prompt_eval_count") or 0,
-            completion_tokens=response.get("eval_count") or 0,
-        )
-    elif provider == "open_router":
-        tools_param = tools if tools else openai.NOT_GIVEN
-        client = openai.OpenAI(
-            base_url="https://openrouter.ai/api/v1",
-            api_key=credentials.api_key.get_secret_value(),
-        )
-
-        response = client.chat.completions.create(
-            extra_headers={
-                "HTTP-Referer": "https://agpt.co",
-                "X-Title": "AutoGPT",
-            },
-            model=llm_model.value,
-            messages=prompt,  # type: ignore
-            max_tokens=max_tokens,
-            tools=tools_param,  # type: ignore
-        )
-
-        # If there's no response, raise an error
-        if not response.choices:
-            if response:
-                raise ValueError(f"OpenRouter error: {response}")
-            else:
-                raise ValueError("No response from OpenRouter.")
-
-        if response.choices[0].message.tool_calls:
-            tool_calls = [
-                ToolContentBlock(
-                    id=tool.id,
-                    type=tool.type,
-                    function=ToolCall(
-                        name=tool.function.name, arguments=tool.function.arguments
-                    ),
-                )
-                for tool in response.choices[0].message.tool_calls
-            ]
-        else:
-            tool_calls = None
-
-        return LLMResponse(
-            raw_response=response.choices[0].message,
-            prompt=prompt,
-            response=response.choices[0].message.content or "",
-            tool_calls=tool_calls,
-            prompt_tokens=response.usage.prompt_tokens if response.usage else 0,
-            completion_tokens=response.usage.completion_tokens if response.usage else 0,
-        )
-    else:
-        raise ValueError(f"Unsupported LLM provider: {provider}")
+class Message(BlockSchema):
+    role: MessageRole
+    content: str
 
 
 class AIBlockBase(Block, ABC):
@@ -547,7 +260,7 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
         )
         model: LlmModel = SchemaField(
             title="LLM Model",
-            default=LlmModel.GPT4O,
+            default=LlmModel.GPT4_TURBO,
             description="The language model to use for answering the prompt.",
             advanced=False,
         )
@@ -557,7 +270,7 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
             default="",
             description="The system prompt to provide additional context to the model.",
         )
-        conversation_history: list[dict] = SchemaField(
+        conversation_history: list[Message] = SchemaField(
             default=[],
             description="The conversation history to provide context for the prompt.",
         )
@@ -598,7 +311,7 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
             input_schema=AIStructuredResponseGeneratorBlock.Input,
             output_schema=AIStructuredResponseGeneratorBlock.Output,
             test_input={
-                "model": LlmModel.GPT4O,
+                "model": LlmModel.GPT4_TURBO,
                 "credentials": TEST_CREDENTIALS_INPUT,
                 "expected_format": {
                     "key1": "value1",
@@ -612,21 +325,19 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
                 ("prompt", str),
             ],
             test_mock={
-                "llm_call": lambda *args, **kwargs: LLMResponse(
-                    raw_response="",
-                    prompt=[""],
-                    response=json.dumps(
+                "llm_call": lambda *args, **kwargs: (
+                    json.dumps(
                         {
                             "key1": "key1Value",
                             "key2": "key2Value",
                         }
                     ),
-                    tool_calls=None,
-                    prompt_tokens=0,
-                    completion_tokens=0,
+                    0,
+                    0,
                 )
             },
         )
+        self.prompt = ""
 
     def llm_call(
         self,
@@ -635,28 +346,160 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
         prompt: list[dict],
         json_format: bool,
         max_tokens: int | None,
-        tools: list[dict] | None = None,
         ollama_host: str = "localhost:11434",
-    ) -> LLMResponse:
+    ) -> tuple[str, int, int]:
         """
-        Test mocks work only on class functions, this wraps the llm_call function
-        so that it can be mocked withing the block testing framework.
+        Args:
+            credentials: The API key credentials to use.
+            llm_model: The LLM model to use.
+            prompt: The prompt to send to the LLM.
+            json_format: Whether the response should be in JSON format.
+            max_tokens: The maximum number of tokens to generate in the chat completion.
+            ollama_host: The host for ollama to use
+
+        Returns:
+            The response from the LLM.
+            The number of tokens used in the prompt.
+            The number of tokens used in the completion.
         """
-        return llm_call(
-            credentials=credentials,
-            llm_model=llm_model,
-            prompt=prompt,
-            json_format=json_format,
-            max_tokens=max_tokens,
-            tools=tools,
-            ollama_host=ollama_host,
-        )
+        provider = llm_model.metadata.provider
+        max_tokens = max_tokens or llm_model.max_output_tokens or 4096
+
+        if provider == "openai":
+            oai_client = openai.OpenAI(api_key=credentials.api_key.get_secret_value())
+            response_format = None
+
+            if llm_model in [LlmModel.O1_MINI, LlmModel.O1_PREVIEW]:
+                sys_messages = [p["content"] for p in prompt if p["role"] == "system"]
+                usr_messages = [p["content"] for p in prompt if p["role"] != "system"]
+                prompt = [
+                    {"role": "user", "content": "\n".join(sys_messages)},
+                    {"role": "user", "content": "\n".join(usr_messages)},
+                ]
+            elif json_format:
+                response_format = {"type": "json_object"}
+
+            response = oai_client.chat.completions.create(
+                model=llm_model.value,
+                messages=prompt,  # type: ignore
+                response_format=response_format,  # type: ignore
+                max_completion_tokens=max_tokens,
+            )
+            self.prompt = json.dumps(prompt)
+
+            return (
+                response.choices[0].message.content or "",
+                response.usage.prompt_tokens if response.usage else 0,
+                response.usage.completion_tokens if response.usage else 0,
+            )
+        elif provider == "anthropic":
+            system_messages = [p["content"] for p in prompt if p["role"] == "system"]
+            sysprompt = " ".join(system_messages)
+
+            messages = []
+            last_role = None
+            for p in prompt:
+                if p["role"] in ["user", "assistant"]:
+                    if p["role"] != last_role:
+                        messages.append({"role": p["role"], "content": p["content"]})
+                        last_role = p["role"]
+                    else:
+                        # If the role is the same as the last one, combine the content
+                        messages[-1]["content"] += "\n" + p["content"]
+
+            client = anthropic.Anthropic(api_key=credentials.api_key.get_secret_value())
+            try:
+                resp = client.messages.create(
+                    model=llm_model.value,
+                    system=sysprompt,
+                    messages=messages,
+                    max_tokens=max_tokens,
+                )
+                self.prompt = json.dumps(prompt)
+
+                if not resp.content:
+                    raise ValueError("No content returned from Anthropic.")
+
+                return (
+                    (
+                        resp.content[0].name
+                        if isinstance(resp.content[0], anthropic.types.ToolUseBlock)
+                        else resp.content[0].text
+                    ),
+                    resp.usage.input_tokens,
+                    resp.usage.output_tokens,
+                )
+            except anthropic.APIError as e:
+                error_message = f"Anthropic API error: {str(e)}"
+                logger.error(error_message)
+                raise ValueError(error_message)
+        elif provider == "groq":
+            client = Groq(api_key=credentials.api_key.get_secret_value())
+            response_format = {"type": "json_object"} if json_format else None
+            response = client.chat.completions.create(
+                model=llm_model.value,
+                messages=prompt,  # type: ignore
+                response_format=response_format,  # type: ignore
+                max_tokens=max_tokens,
+            )
+            self.prompt = json.dumps(prompt)
+            return (
+                response.choices[0].message.content or "",
+                response.usage.prompt_tokens if response.usage else 0,
+                response.usage.completion_tokens if response.usage else 0,
+            )
+        elif provider == "ollama":
+            client = ollama.Client(host=ollama_host)
+            sys_messages = [p["content"] for p in prompt if p["role"] == "system"]
+            usr_messages = [p["content"] for p in prompt if p["role"] != "system"]
+            response = client.generate(
+                model=llm_model.value,
+                prompt=f"{sys_messages}\n\n{usr_messages}",
+                stream=False,
+            )
+            self.prompt = json.dumps(prompt)
+            return (
+                response.get("response") or "",
+                response.get("prompt_eval_count") or 0,
+                response.get("eval_count") or 0,
+            )
+        elif provider == "open_router":
+            client = openai.OpenAI(
+                base_url="https://openrouter.ai/api/v1",
+                api_key=credentials.api_key.get_secret_value(),
+            )
+
+            response = client.chat.completions.create(
+                extra_headers={
+                    "HTTP-Referer": "https://agpt.co",
+                    "X-Title": "AutoGPT",
+                },
+                model=llm_model.value,
+                messages=prompt,  # type: ignore
+                max_tokens=max_tokens,
+            )
+            self.prompt = json.dumps(prompt)
+
+            # If there's no response, raise an error
+            if not response.choices:
+                if response:
+                    raise ValueError(f"OpenRouter error: {response}")
+                else:
+                    raise ValueError("No response from OpenRouter.")
+
+            return (
+                response.choices[0].message.content or "",
+                response.usage.prompt_tokens if response.usage else 0,
+                response.usage.completion_tokens if response.usage else 0,
+            )
+        else:
+            raise ValueError(f"Unsupported LLM provider: {provider}")
 
     def run(
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
         logger.debug(f"Calling LLM with input data: {input_data}")
-        prompt = [json.to_dict(p) for p in input_data.conversation_history]
+        prompt = [p.model_dump() for p in input_data.conversation_history]
 
         def trim_prompt(s: str) -> str:
             lines = s.strip().split("\n")
@@ -706,7 +549,7 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
 
         for retry_count in range(input_data.retry):
             try:
-                llm_response = self.llm_call(
+                response_text, input_token, output_token = self.llm_call(
                     credentials=credentials,
                     llm_model=llm_model,
                     prompt=prompt,
@@ -714,12 +557,11 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
                     ollama_host=input_data.ollama_host,
                     max_tokens=input_data.max_tokens,
                 )
-                response_text = llm_response.response
                 self.merge_stats(
-                    NodeExecutionStats(
-                        input_token_count=llm_response.prompt_tokens,
-                        output_token_count=llm_response.completion_tokens,
-                    )
+                    {
+                        "input_token_count": input_token,
+                        "output_token_count": output_token,
+                    }
                 )
                 logger.info(f"LLM attempt-{retry_count} response: {response_text}")
 
@@ -762,10 +604,10 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
                 retry_prompt = f"Error calling LLM: {e}"
             finally:
                 self.merge_stats(
-                    NodeExecutionStats(
-                        llm_call_count=retry_count + 1,
-                        llm_retry_count=retry_count,
-                    )
+                    {
+                        "llm_call_count": retry_count + 1,
+                        "llm_retry_count": retry_count,
+                    }
                 )
 
         raise RuntimeError(retry_prompt)
@@ -779,7 +621,7 @@ class AITextGeneratorBlock(AIBlockBase):
         )
         model: LlmModel = SchemaField(
             title="LLM Model",
-            default=LlmModel.GPT4O,
+            default=LlmModel.GPT4_TURBO,
             description="The language model to use for answering the prompt.",
             advanced=False,
         )
@@ -872,7 +714,7 @@ class AITextSummarizerBlock(AIBlockBase):
         )
         model: LlmModel = SchemaField(
             title="LLM Model",
-            default=LlmModel.GPT4O,
+            default=LlmModel.GPT4_TURBO,
             description="The language model to use for summarizing the text.",
         )
         focus: str = SchemaField(
@@ -1033,12 +875,12 @@ class AITextSummarizerBlock(AIBlockBase):
 
 class AIConversationBlock(AIBlockBase):
     class Input(BlockSchema):
-        messages: List[Any] = SchemaField(
+        messages: List[Message] = SchemaField(
             description="List of messages in the conversation.", min_length=1
         )
         model: LlmModel = SchemaField(
             title="LLM Model",
-            default=LlmModel.GPT4O,
+            default=LlmModel.GPT4_TURBO,
             description="The language model to use for the conversation.",
         )
         credentials: AICredentials = AICredentialsField()
@@ -1077,7 +919,7 @@ class AIConversationBlock(AIBlockBase):
                     },
                     {"role": "user", "content": "Where was it played?"},
                 ],
-                "model": LlmModel.GPT4O,
+                "model": LlmModel.GPT4_TURBO,
                 "credentials": TEST_CREDENTIALS_INPUT,
             },
             test_credentials=TEST_CREDENTIALS,
@@ -1139,7 +981,7 @@ class AIListGeneratorBlock(AIBlockBase):
         )
         model: LlmModel = SchemaField(
             title="LLM Model",
-            default=LlmModel.GPT4O,
+            default=LlmModel.GPT4_TURBO,
             description="The language model to use for generating the list.",
             advanced=True,
         )
@@ -1188,7 +1030,7 @@ class AIListGeneratorBlock(AIBlockBase):
                     "drawing explorers to uncover its mysteries. Each planet showcases the limitless possibilities of "
                     "fictional worlds."
                 ),
-                "model": LlmModel.GPT4O,
+                "model": LlmModel.GPT4_TURBO,
                 "credentials": TEST_CREDENTIALS_INPUT,
                 "max_retries": 3,
             },

autogpt_platform/backend/backend/blocks/smart_decision_maker.py

@@ -1,511 +0,0 @@
-import logging
-import re
-from collections import Counter
-from typing import TYPE_CHECKING, Any
-
-from autogpt_libs.utils.cache import thread_cached
-
-import backend.blocks.llm as llm
-from backend.blocks.agent import AgentExecutorBlock
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockInput,
-    BlockOutput,
-    BlockSchema,
-    BlockType,
-    get_block,
-)
-from backend.data.model import SchemaField
-from backend.util import json
-
-if TYPE_CHECKING:
-    from backend.data.graph import Link, Node
-
-logger = logging.getLogger(__name__)
-
-
-@thread_cached
-def get_database_manager_client():
-    from backend.executor import DatabaseManager
-    from backend.util.service import get_service_client
-
-    return get_service_client(DatabaseManager)
-
-
-def _get_tool_requests(entry: dict[str, Any]) -> list[str]:
-    """
-    Return a list of tool_call_ids if the entry is a tool request.
-    Supports both OpenAI and Anthropics formats.
-    """
-    tool_call_ids = []
-    if entry.get("role") != "assistant":
-        return tool_call_ids
-
-    # OpenAI: check for tool_calls in the entry.
-    calls = entry.get("tool_calls")
-    if isinstance(calls, list):
-        for call in calls:
-            if tool_id := call.get("id"):
-                tool_call_ids.append(tool_id)
-
-    # Anthropics: check content items for tool_use type.
-    content = entry.get("content")
-    if isinstance(content, list):
-        for item in content:
-            if item.get("type") != "tool_use":
-                continue
-            if tool_id := item.get("id"):
-                tool_call_ids.append(tool_id)
-
-    return tool_call_ids
-
-
-def _get_tool_responses(entry: dict[str, Any]) -> list[str]:
-    """
-    Return a list of tool_call_ids if the entry is a tool response.
-    Supports both OpenAI and Anthropics formats.
-    """
-    tool_call_ids: list[str] = []
-
-    # OpenAI: a tool response message with role "tool" and key "tool_call_id".
-    if entry.get("role") == "tool":
-        if tool_call_id := entry.get("tool_call_id"):
-            tool_call_ids.append(str(tool_call_id))
-
-    # Anthropics: check content items for tool_result type.
-    if entry.get("role") == "user":
-        content = entry.get("content")
-        if isinstance(content, list):
-            for item in content:
-                if item.get("type") != "tool_result":
-                    continue
-                if tool_call_id := item.get("tool_use_id"):
-                    tool_call_ids.append(tool_call_id)
-
-    return tool_call_ids
-
-
-def _create_tool_response(call_id: str, output: dict[str, Any]) -> dict[str, Any]:
-    """
-    Create a tool response message for either OpenAI or Anthropics,
-    based on the tool_id format.
-    """
-    content = output if isinstance(output, str) else json.dumps(output)
-
-    # Anthropics format: tool IDs typically start with "toolu_"
-    if call_id.startswith("toolu_"):
-        return {
-            "role": "user",
-            "type": "message",
-            "content": [
-                {"tool_use_id": call_id, "type": "tool_result", "content": content}
-            ],
-        }
-
-    # OpenAI format: tool IDs typically start with "call_".
-    # Or default fallback (if the tool_id doesn't match any known prefix)
-    return {"role": "tool", "tool_call_id": call_id, "content": content}
-
-
-def get_pending_tool_calls(conversation_history: list[Any]) -> dict[str, int]:
-    """
-    All the tool calls entry in the conversation history requires a response.
-    This function returns the pending tool calls that has not generated an output yet.
-
-    Return: dict[str, int] - A dictionary of pending tool call IDs with their count.
-    """
-    pending_calls = Counter()
-    for history in conversation_history:
-        for call_id in _get_tool_requests(history):
-            pending_calls[call_id] += 1
-
-        for call_id in _get_tool_responses(history):
-            pending_calls[call_id] -= 1
-
-    return {call_id: count for call_id, count in pending_calls.items() if count > 0}
-
-
-class SmartDecisionMakerBlock(Block):
-    """
-    A block that uses a language model to make smart decisions based on a given prompt.
-    """
-
-    class Input(BlockSchema):
-        prompt: str = SchemaField(
-            description="The prompt to send to the language model.",
-            placeholder="Enter your prompt here...",
-        )
-        model: llm.LlmModel = SchemaField(
-            title="LLM Model",
-            default=llm.LlmModel.GPT4O,
-            description="The language model to use for answering the prompt.",
-            advanced=False,
-        )
-        credentials: llm.AICredentials = llm.AICredentialsField()
-        sys_prompt: str = SchemaField(
-            title="System Prompt",
-            default="Thinking carefully step by step decide which function to call. "
-            "Always choose a function call from the list of function signatures, "
-            "and always provide the complete argument provided with the type "
-            "matching the required jsonschema signature, no missing argument is allowed. "
-            "If you have already completed the task objective, you can end the task "
-            "by providing the end result of your work as a finish message. "
-            "Only provide EXACTLY one function call, multiple tool calls is strictly prohibited.",
-            description="The system prompt to provide additional context to the model.",
-        )
-        conversation_history: list[dict] = SchemaField(
-            default=[],
-            description="The conversation history to provide context for the prompt.",
-        )
-        last_tool_output: Any = SchemaField(
-            default=None,
-            description="The output of the last tool that was called.",
-        )
-        retry: int = SchemaField(
-            title="Retry Count",
-            default=3,
-            description="Number of times to retry the LLM call if the response does not match the expected format.",
-        )
-        prompt_values: dict[str, str] = SchemaField(
-            advanced=False,
-            default={},
-            description="Values used to fill in the prompt. The values can be used in the prompt by putting them in a double curly braces, e.g. {{variable_name}}.",
-        )
-        max_tokens: int | None = SchemaField(
-            advanced=True,
-            default=None,
-            description="The maximum number of tokens to generate in the chat completion.",
-        )
-        ollama_host: str = SchemaField(
-            advanced=True,
-            default="localhost:11434",
-            description="Ollama host for local  models",
-        )
-
-        @classmethod
-        def get_missing_links(cls, data: BlockInput, links: list["Link"]) -> set[str]:
-            # conversation_history & last_tool_output validation is handled differently
-            missing_links = super().get_missing_links(
-                data,
-                [
-                    link
-                    for link in links
-                    if link.sink_name
-                    not in ["conversation_history", "last_tool_output"]
-                ],
-            )
-
-            # Avoid executing the block if the last_tool_output is connected to a static
-            # link, like StoreValueBlock or AgentInputBlock.
-            if any(link.sink_name == "conversation_history" for link in links) and any(
-                link.sink_name == "last_tool_output" and link.is_static
-                for link in links
-            ):
-                raise ValueError(
-                    "Last Tool Output can't be connected to a static (dashed line) "
-                    "link like the output of `StoreValue` or `AgentInput` block"
-                )
-
-            return missing_links
-
-        @classmethod
-        def get_missing_input(cls, data: BlockInput) -> set[str]:
-            if missing_input := super().get_missing_input(data):
-                return missing_input
-
-            conversation_history = data.get("conversation_history", [])
-            pending_tool_calls = get_pending_tool_calls(conversation_history)
-            last_tool_output = data.get("last_tool_output")
-            if not last_tool_output and pending_tool_calls:
-                return {"last_tool_output"}
-            return set()
-
-    class Output(BlockSchema):
-        error: str = SchemaField(description="Error message if the API call failed.")
-        tools: Any = SchemaField(description="The tools that are available to use.")
-        finished: str = SchemaField(
-            description="The finished message to display to the user."
-        )
-        conversations: list[Any] = SchemaField(
-            description="The conversation history to provide context for the prompt."
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="3b191d9f-356f-482d-8238-ba04b6d18381",
-            description="Uses AI to intelligently decide what tool to use.",
-            categories={BlockCategory.AI},
-            block_type=BlockType.AI,
-            input_schema=SmartDecisionMakerBlock.Input,
-            output_schema=SmartDecisionMakerBlock.Output,
-            test_input={
-                "prompt": "Hello, World!",
-                "credentials": llm.TEST_CREDENTIALS_INPUT,
-            },
-            test_output=[],
-            test_credentials=llm.TEST_CREDENTIALS,
-        )
-
-    @staticmethod
-    def _create_block_function_signature(
-        sink_node: "Node", links: list["Link"]
-    ) -> dict[str, Any]:
-        """
-        Creates a function signature for a block node.
-
-        Args:
-            sink_node: The node for which to create a function signature.
-            links: The list of links connected to the sink node.
-
-        Returns:
-            A dictionary representing the function signature in the format expected by LLM tools.
-
-        Raises:
-            ValueError: If the block specified by sink_node.block_id is not found.
-        """
-        block = get_block(sink_node.block_id)
-        if not block:
-            raise ValueError(f"Block not found: {sink_node.block_id}")
-
-        tool_function: dict[str, Any] = {
-            "name": re.sub(r"[^a-zA-Z0-9_-]", "_", block.name).lower(),
-            "description": block.description,
-        }
-
-        properties = {}
-        required = []
-
-        for link in links:
-            sink_block_input_schema = block.input_schema
-            description = (
-                sink_block_input_schema.model_fields[link.sink_name].description
-                if link.sink_name in sink_block_input_schema.model_fields
-                and sink_block_input_schema.model_fields[link.sink_name].description
-                else f"The {link.sink_name} of the tool"
-            )
-            properties[link.sink_name.lower()] = {
-                "type": "string",
-                "description": description,
-            }
-
-        tool_function["parameters"] = {
-            "type": "object",
-            "properties": properties,
-            "required": required,
-            "additionalProperties": False,
-            "strict": True,
-        }
-
-        return {"type": "function", "function": tool_function}
-
-    @staticmethod
-    def _create_agent_function_signature(
-        sink_node: "Node", links: list["Link"]
-    ) -> dict[str, Any]:
-        """
-        Creates a function signature for an agent node.
-
-        Args:
-            sink_node: The agent node for which to create a function signature.
-            links: The list of links connected to the sink node.
-
-        Returns:
-            A dictionary representing the function signature in the format expected by LLM tools.
-
-        Raises:
-            ValueError: If the graph metadata for the specified graph_id and graph_version is not found.
-        """
-        graph_id = sink_node.input_default.get("graph_id")
-        graph_version = sink_node.input_default.get("graph_version")
-        if not graph_id or not graph_version:
-            raise ValueError("Graph ID or Graph Version not found in sink node.")
-
-        db_client = get_database_manager_client()
-        sink_graph_meta = db_client.get_graph_metadata(graph_id, graph_version)
-        if not sink_graph_meta:
-            raise ValueError(
-                f"Sink graph metadata not found: {graph_id} {graph_version}"
-            )
-
-        tool_function: dict[str, Any] = {
-            "name": re.sub(r"[^a-zA-Z0-9_-]", "_", sink_graph_meta.name).lower(),
-            "description": sink_graph_meta.description,
-        }
-
-        properties = {}
-        required = []
-
-        for link in links:
-            sink_block_input_schema = sink_node.input_default["input_schema"]
-            description = (
-                sink_block_input_schema["properties"][link.sink_name]["description"]
-                if "description"
-                in sink_block_input_schema["properties"][link.sink_name]
-                else f"The {link.sink_name} of the tool"
-            )
-            properties[link.sink_name.lower()] = {
-                "type": "string",
-                "description": description,
-            }
-
-        tool_function["parameters"] = {
-            "type": "object",
-            "properties": properties,
-            "required": required,
-            "additionalProperties": False,
-            "strict": True,
-        }
-
-        return {"type": "function", "function": tool_function}
-
-    @staticmethod
-    def _create_function_signature(node_id: str) -> list[dict[str, Any]]:
-        """
-        Creates function signatures for tools linked to a specified node within a graph.
-
-        This method filters the graph links to identify those that are tools and are
-        connected to the given node_id. It then constructs function signatures for each
-        tool based on the metadata and input schema of the linked nodes.
-
-        Args:
-            node_id: The node_id for which to create function signatures.
-
-        Returns:
-            list[dict[str, Any]]: A list of dictionaries, each representing a function signature
-                                  for a tool, including its name, description, and parameters.
-
-        Raises:
-            ValueError: If no tool links are found for the specified node_id, or if a sink node
-                        or its metadata cannot be found.
-        """
-        db_client = get_database_manager_client()
-        tools = [
-            (link, node)
-            for link, node in db_client.get_connected_output_nodes(node_id)
-            if link.source_name.startswith("tools_^_") and link.source_id == node_id
-        ]
-        if not tools:
-            raise ValueError("There is no next node to execute.")
-
-        return_tool_functions = []
-
-        grouped_tool_links: dict[str, tuple["Node", list["Link"]]] = {}
-        for link, node in tools:
-            if link.sink_id not in grouped_tool_links:
-                grouped_tool_links[link.sink_id] = (node, [link])
-            else:
-                grouped_tool_links[link.sink_id][1].append(link)
-
-        for sink_node, links in grouped_tool_links.values():
-            if not sink_node:
-                raise ValueError(f"Sink node not found: {links[0].sink_id}")
-
-            if sink_node.block_id == AgentExecutorBlock().id:
-                return_tool_functions.append(
-                    SmartDecisionMakerBlock._create_agent_function_signature(
-                        sink_node, links
-                    )
-                )
-            else:
-                return_tool_functions.append(
-                    SmartDecisionMakerBlock._create_block_function_signature(
-                        sink_node, links
-                    )
-                )
-
-        return return_tool_functions
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: llm.APIKeyCredentials,
-        graph_id: str,
-        node_id: str,
-        graph_exec_id: str,
-        node_exec_id: str,
-        user_id: str,
-        **kwargs,
-    ) -> BlockOutput:
-        tool_functions = self._create_function_signature(node_id)
-
-        input_data.conversation_history = input_data.conversation_history or []
-        prompt = [json.to_dict(p) for p in input_data.conversation_history if p]
-
-        pending_tool_calls = get_pending_tool_calls(input_data.conversation_history)
-        if pending_tool_calls and not input_data.last_tool_output:
-            raise ValueError(f"Tool call requires an output for {pending_tool_calls}")
-
-        # Prefill all missing tool calls with the last tool output/
-        # TODO: we need a better way to handle this.
-        tool_output = [
-            _create_tool_response(pending_call_id, input_data.last_tool_output)
-            for pending_call_id, count in pending_tool_calls.items()
-            for _ in range(count)
-        ]
-
-        # If the SDM block only calls 1 tool at a time, this should not happen.
-        if len(tool_output) > 1:
-            logger.warning(
-                f"[SmartDecisionMakerBlock-node_exec_id={node_exec_id}] "
-                f"Multiple pending tool calls are prefilled using a single output. "
-                f"Execution may not be accurate."
-            )
-
-        # Fallback on adding tool output in the conversation history as user prompt.
-        if len(tool_output) == 0 and input_data.last_tool_output:
-            logger.warning(
-                f"[SmartDecisionMakerBlock-node_exec_id={node_exec_id}] "
-                f"No pending tool calls found. This may indicate an issue with the "
-                f"conversation history, or an LLM calling two tools at the same time."
-            )
-            tool_output.append(
-                {
-                    "role": "user",
-                    "content": f"Last tool output: {json.dumps(input_data.last_tool_output)}",
-                }
-            )
-
-        prompt.extend(tool_output)
-
-        values = input_data.prompt_values
-        if values:
-            input_data.prompt = llm.fmt.format_string(input_data.prompt, values)
-            input_data.sys_prompt = llm.fmt.format_string(input_data.sys_prompt, values)
-
-        prefix = "[Main Objective Prompt]: "
-
-        if input_data.sys_prompt and not any(
-            p["role"] == "system" and p["content"].startswith(prefix) for p in prompt
-        ):
-            prompt.append({"role": "system", "content": prefix + input_data.sys_prompt})
-
-        if input_data.prompt and not any(
-            p["role"] == "user" and p["content"].startswith(prefix) for p in prompt
-        ):
-            prompt.append({"role": "user", "content": prefix + input_data.prompt})
-
-        response = llm.llm_call(
-            credentials=credentials,
-            llm_model=input_data.model,
-            prompt=prompt,
-            json_format=False,
-            max_tokens=input_data.max_tokens,
-            tools=tool_functions,
-            ollama_host=input_data.ollama_host,
-        )
-
-        if not response.tool_calls:
-            yield "finished", response.response
-            return
-
-        for tool_call in response.tool_calls:
-            tool_name = tool_call.function.name
-            tool_args = json.loads(tool_call.function.arguments)
-
-            for arg_name, arg_value in tool_args.items():
-                yield f"tools_^_{tool_name}_{arg_name}".lower(), arg_value
-
-        response.prompt.append(response.raw_response)
-        yield "conversations", response.prompt

autogpt_platform/backend/backend/blocks/smartlead/_api.py

@@ -1,97 +0,0 @@
-from backend.blocks.smartlead.models import (
-    AddLeadsRequest,
-    AddLeadsToCampaignResponse,
-    CreateCampaignRequest,
-    CreateCampaignResponse,
-    SaveSequencesRequest,
-    SaveSequencesResponse,
-)
-from backend.util.request import Requests
-
-
-class SmartLeadClient:
-    """Client for the SmartLead API"""
-
-    # This api is stupid and requires your api key in the url. DO NOT RAISE ERRORS FOR BAD REQUESTS.
-    # FILTER OUT THE API KEY FROM THE ERROR MESSAGE.
-
-    API_URL = "https://server.smartlead.ai/api/v1"
-
-    def __init__(self, api_key: str):
-        self.api_key = api_key
-        self.requests = Requests()
-
-    def _add_auth_to_url(self, url: str) -> str:
-        return f"{url}?api_key={self.api_key}"
-
-    def _handle_error(self, e: Exception) -> str:
-        return e.__str__().replace(self.api_key, "API KEY")
-
-    def create_campaign(self, request: CreateCampaignRequest) -> CreateCampaignResponse:
-        try:
-            response = self.requests.post(
-                self._add_auth_to_url(f"{self.API_URL}/campaigns/create"),
-                json=request.model_dump(),
-            )
-            response_data = response.json()
-            return CreateCampaignResponse(**response_data)
-        except ValueError as e:
-            raise ValueError(f"Invalid response format: {str(e)}")
-        except Exception as e:
-            raise ValueError(f"Failed to create campaign: {self._handle_error(e)}")
-
-    def add_leads_to_campaign(
-        self, request: AddLeadsRequest
-    ) -> AddLeadsToCampaignResponse:
-        try:
-            response = self.requests.post(
-                self._add_auth_to_url(
-                    f"{self.API_URL}/campaigns/{request.campaign_id}/leads"
-                ),
-                json=request.model_dump(exclude={"campaign_id"}),
-            )
-            response_data = response.json()
-            response_parsed = AddLeadsToCampaignResponse(**response_data)
-            if not response_parsed.ok:
-                raise ValueError(
-                    f"Failed to add leads to campaign: {response_parsed.error}"
-                )
-            return response_parsed
-        except ValueError as e:
-            raise ValueError(f"Invalid response format: {str(e)}")
-        except Exception as e:
-            raise ValueError(
-                f"Failed to add leads to campaign: {self._handle_error(e)}"
-            )
-
-    def save_campaign_sequences(
-        self, campaign_id: int, request: SaveSequencesRequest
-    ) -> SaveSequencesResponse:
-        """
-        Save sequences within a campaign.
-
-        Args:
-            campaign_id: ID of the campaign to save sequences for
-            request: SaveSequencesRequest containing the sequences configuration
-
-        Returns:
-            SaveSequencesResponse with the result of the operation
-
-        Note:
-            For variant_distribution_type:
-            - MANUAL_EQUAL: Equally distributes variants across leads
-            - AI_EQUAL: Requires winning_metric_property and lead_distribution_percentage
-            - MANUAL_PERCENTAGE: Requires variant_distribution_percentage in seq_variants
-        """
-        try:
-            response = self.requests.post(
-                self._add_auth_to_url(
-                    f"{self.API_URL}/campaigns/{campaign_id}/sequences"
-                ),
-                json=request.model_dump(exclude_none=True),
-            )
-            return SaveSequencesResponse(**response.json())
-        except Exception as e:
-            raise ValueError(
-                f"Failed to save campaign sequences: {e.__str__().replace(self.api_key, 'API KEY')}"
-            )

autogpt_platform/backend/backend/blocks/smartlead/_auth.py

@@ -1,35 +0,0 @@
-from typing import Literal
-
-from pydantic import SecretStr
-
-from backend.data.model import APIKeyCredentials, CredentialsField, CredentialsMetaInput
-from backend.integrations.providers import ProviderName
-
-SmartLeadCredentials = APIKeyCredentials
-SmartLeadCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.SMARTLEAD],
-    Literal["api_key"],
-]
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="smartlead",
-    api_key=SecretStr("mock-smartlead-api-key"),
-    title="Mock SmartLead 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 SmartLeadCredentialsField() -> SmartLeadCredentialsInput:
-    """
-    Creates a SmartLead credentials input on a block.
-    """
-    return CredentialsField(
-        description="The SmartLead integration can be used with an API Key.",
-    )

autogpt_platform/backend/backend/blocks/smartlead/campaign.py

@@ -1,326 +0,0 @@
-from backend.blocks.smartlead._api import SmartLeadClient
-from backend.blocks.smartlead._auth import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    SmartLeadCredentials,
-    SmartLeadCredentialsInput,
-)
-from backend.blocks.smartlead.models import (
-    AddLeadsRequest,
-    AddLeadsToCampaignResponse,
-    CreateCampaignRequest,
-    CreateCampaignResponse,
-    LeadInput,
-    LeadUploadSettings,
-    SaveSequencesRequest,
-    SaveSequencesResponse,
-    Sequence,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-
-class CreateCampaignBlock(Block):
-    """Create a campaign in SmartLead"""
-
-    class Input(BlockSchema):
-        name: str = SchemaField(
-            description="The name of the campaign",
-        )
-        credentials: SmartLeadCredentialsInput = SchemaField(
-            description="SmartLead credentials",
-        )
-
-    class Output(BlockSchema):
-        id: int = SchemaField(
-            description="The ID of the created campaign",
-        )
-        name: str = SchemaField(
-            description="The name of the created campaign",
-        )
-        created_at: str = SchemaField(
-            description="The date and time the campaign was created",
-        )
-        error: str = SchemaField(
-            description="Error message if the search failed",
-            default="",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="8865699f-9188-43c4-89b0-79c84cfaa03e",
-            description="Create a campaign in SmartLead",
-            categories={BlockCategory.CRM},
-            input_schema=CreateCampaignBlock.Input,
-            output_schema=CreateCampaignBlock.Output,
-            test_credentials=TEST_CREDENTIALS,
-            test_input={"name": "Test Campaign", "credentials": TEST_CREDENTIALS_INPUT},
-            test_output=[
-                (
-                    "id",
-                    1,
-                ),
-                (
-                    "name",
-                    "Test Campaign",
-                ),
-                (
-                    "created_at",
-                    "2024-01-01T00:00:00Z",
-                ),
-            ],
-            test_mock={
-                "create_campaign": lambda name, credentials: CreateCampaignResponse(
-                    ok=True,
-                    id=1,
-                    name=name,
-                    created_at="2024-01-01T00:00:00Z",
-                )
-            },
-        )
-
-    @staticmethod
-    def create_campaign(
-        name: str, credentials: SmartLeadCredentials
-    ) -> CreateCampaignResponse:
-        client = SmartLeadClient(credentials.api_key.get_secret_value())
-        return client.create_campaign(CreateCampaignRequest(name=name))
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: SmartLeadCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        response = self.create_campaign(input_data.name, credentials)
-
-        yield "id", response.id
-        yield "name", response.name
-        yield "created_at", response.created_at
-        if not response.ok:
-            yield "error", "Failed to create campaign"
-
-
-class AddLeadToCampaignBlock(Block):
-    """Add a lead to a campaign in SmartLead"""
-
-    class Input(BlockSchema):
-        campaign_id: int = SchemaField(
-            description="The ID of the campaign to add the lead to",
-        )
-        lead_list: list[LeadInput] = SchemaField(
-            description="An array of JSON objects, each representing a lead's details. Can hold max 100 leads.",
-            max_length=100,
-            default=[],
-            advanced=False,
-        )
-        settings: LeadUploadSettings = SchemaField(
-            description="Settings for lead upload",
-            default=LeadUploadSettings(),
-        )
-        credentials: SmartLeadCredentialsInput = SchemaField(
-            description="SmartLead credentials",
-        )
-
-    class Output(BlockSchema):
-        campaign_id: int = SchemaField(
-            description="The ID of the campaign the lead was added to (passed through)",
-        )
-        upload_count: int = SchemaField(
-            description="The number of leads added to the campaign",
-        )
-        already_added_to_campaign: int = SchemaField(
-            description="The number of leads that were already added to the campaign",
-        )
-        duplicate_count: int = SchemaField(
-            description="The number of emails that were duplicates",
-        )
-        invalid_email_count: int = SchemaField(
-            description="The number of emails that were invalidly formatted",
-        )
-        is_lead_limit_exhausted: bool = SchemaField(
-            description="Whether the lead limit was exhausted",
-        )
-        lead_import_stopped_count: int = SchemaField(
-            description="The number of leads that were not added to the campaign because the lead import was stopped",
-        )
-        error: str = SchemaField(
-            description="Error message if the lead was not added to the campaign",
-            default="",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="fb8106a4-1a8f-42f9-a502-f6d07e6fe0ec",
-            description="Add a lead to a campaign in SmartLead",
-            categories={BlockCategory.CRM},
-            input_schema=AddLeadToCampaignBlock.Input,
-            output_schema=AddLeadToCampaignBlock.Output,
-            test_credentials=TEST_CREDENTIALS,
-            test_input={
-                "campaign_id": 1,
-                "lead_list": [],
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_output=[
-                (
-                    "campaign_id",
-                    1,
-                ),
-                (
-                    "upload_count",
-                    1,
-                ),
-            ],
-            test_mock={
-                "add_leads_to_campaign": lambda campaign_id, lead_list, credentials: AddLeadsToCampaignResponse(
-                    ok=True,
-                    upload_count=1,
-                    already_added_to_campaign=0,
-                    duplicate_count=0,
-                    invalid_email_count=0,
-                    is_lead_limit_exhausted=False,
-                    lead_import_stopped_count=0,
-                    error="",
-                    total_leads=1,
-                    block_count=0,
-                    invalid_emails=[],
-                    unsubscribed_leads=[],
-                    bounce_count=0,
-                )
-            },
-        )
-
-    @staticmethod
-    def add_leads_to_campaign(
-        campaign_id: int, lead_list: list[LeadInput], credentials: SmartLeadCredentials
-    ) -> AddLeadsToCampaignResponse:
-        client = SmartLeadClient(credentials.api_key.get_secret_value())
-        return client.add_leads_to_campaign(
-            AddLeadsRequest(
-                campaign_id=campaign_id,
-                lead_list=lead_list,
-                settings=LeadUploadSettings(
-                    ignore_global_block_list=False,
-                    ignore_unsubscribe_list=False,
-                    ignore_community_bounce_list=False,
-                    ignore_duplicate_leads_in_other_campaign=False,
-                ),
-            ),
-        )
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: SmartLeadCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        response = self.add_leads_to_campaign(
-            input_data.campaign_id, input_data.lead_list, credentials
-        )
-
-        yield "campaign_id", input_data.campaign_id
-        yield "upload_count", response.upload_count
-        if response.already_added_to_campaign:
-            yield "already_added_to_campaign", response.already_added_to_campaign
-        if response.duplicate_count:
-            yield "duplicate_count", response.duplicate_count
-        if response.invalid_email_count:
-            yield "invalid_email_count", response.invalid_email_count
-        if response.is_lead_limit_exhausted:
-            yield "is_lead_limit_exhausted", response.is_lead_limit_exhausted
-        if response.lead_import_stopped_count:
-            yield "lead_import_stopped_count", response.lead_import_stopped_count
-        if response.error:
-            yield "error", response.error
-        if not response.ok:
-            yield "error", "Failed to add leads to campaign"
-
-
-class SaveCampaignSequencesBlock(Block):
-    """Save sequences within a campaign"""
-
-    class Input(BlockSchema):
-        campaign_id: int = SchemaField(
-            description="The ID of the campaign to save sequences for",
-        )
-        sequences: list[Sequence] = SchemaField(
-            description="The sequences to save",
-            default=[],
-            advanced=False,
-        )
-        credentials: SmartLeadCredentialsInput = SchemaField(
-            description="SmartLead credentials",
-        )
-
-    class Output(BlockSchema):
-        data: dict | str | None = SchemaField(
-            description="Data from the API",
-            default=None,
-        )
-        message: str = SchemaField(
-            description="Message from the API",
-            default="",
-        )
-        error: str = SchemaField(
-            description="Error message if the sequences were not saved",
-            default="",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="e7d9f41c-dc10-4f39-98ba-a432abd128c0",
-            description="Save sequences within a campaign",
-            categories={BlockCategory.CRM},
-            input_schema=SaveCampaignSequencesBlock.Input,
-            output_schema=SaveCampaignSequencesBlock.Output,
-            test_credentials=TEST_CREDENTIALS,
-            test_input={
-                "campaign_id": 1,
-                "sequences": [],
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_output=[
-                (
-                    "message",
-                    "Sequences saved successfully",
-                ),
-            ],
-            test_mock={
-                "save_campaign_sequences": lambda campaign_id, sequences, credentials: SaveSequencesResponse(
-                    ok=True,
-                    message="Sequences saved successfully",
-                )
-            },
-        )
-
-    @staticmethod
-    def save_campaign_sequences(
-        campaign_id: int, sequences: list[Sequence], credentials: SmartLeadCredentials
-    ) -> SaveSequencesResponse:
-        client = SmartLeadClient(credentials.api_key.get_secret_value())
-        return client.save_campaign_sequences(
-            campaign_id=campaign_id, request=SaveSequencesRequest(sequences=sequences)
-        )
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: SmartLeadCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        response = self.save_campaign_sequences(
-            input_data.campaign_id, input_data.sequences, credentials
-        )
-
-        if response.data:
-            yield "data", response.data
-        if response.message:
-            yield "message", response.message
-        if response.error:
-            yield "error", response.error
-        if not response.ok:
-            yield "error", "Failed to save sequences"

autogpt_platform/backend/backend/blocks/smartlead/models.py

@@ -1,147 +0,0 @@
-from enum import Enum
-
-from pydantic import BaseModel
-
-from backend.data.model import SchemaField
-
-
-class CreateCampaignResponse(BaseModel):
-    ok: bool
-    id: int
-    name: str
-    created_at: str
-
-
-class CreateCampaignRequest(BaseModel):
-    name: str
-    client_id: str | None = None
-
-
-class AddLeadsToCampaignResponse(BaseModel):
-    ok: bool
-    upload_count: int
-    total_leads: int
-    block_count: int
-    duplicate_count: int
-    invalid_email_count: int
-    invalid_emails: list[str]
-    already_added_to_campaign: int
-    unsubscribed_leads: list[str]
-    is_lead_limit_exhausted: bool
-    lead_import_stopped_count: int
-    bounce_count: int
-    error: str | None = None
-
-
-class LeadCustomFields(BaseModel):
-    """Custom fields for a lead (max 20 fields)"""
-
-    fields: dict[str, str] = SchemaField(
-        description="Custom fields for a lead (max 20 fields)",
-        max_length=20,
-        default={},
-    )
-
-
-class LeadInput(BaseModel):
-    """Single lead input data"""
-
-    first_name: str
-    last_name: str
-    email: str
-    phone_number: str | None = None  # Changed from int to str for phone numbers
-    company_name: str | None = None
-    website: str | None = None
-    location: str | None = None
-    custom_fields: LeadCustomFields | None = None
-    linkedin_profile: str | None = None
-    company_url: str | None = None
-
-
-class LeadUploadSettings(BaseModel):
-    """Settings for lead upload"""
-
-    ignore_global_block_list: bool = SchemaField(
-        description="Ignore the global block list",
-        default=False,
-    )
-    ignore_unsubscribe_list: bool = SchemaField(
-        description="Ignore the unsubscribe list",
-        default=False,
-    )
-    ignore_community_bounce_list: bool = SchemaField(
-        description="Ignore the community bounce list",
-        default=False,
-    )
-    ignore_duplicate_leads_in_other_campaign: bool = SchemaField(
-        description="Ignore duplicate leads in other campaigns",
-        default=False,
-    )
-
-
-class AddLeadsRequest(BaseModel):
-    """Request body for adding leads to a campaign"""
-
-    lead_list: list[LeadInput] = SchemaField(
-        description="List of leads to add to the campaign",
-        max_length=100,
-        default=[],
-    )
-    settings: LeadUploadSettings
-    campaign_id: int
-
-
-class VariantDistributionType(str, Enum):
-    MANUAL_EQUAL = "MANUAL_EQUAL"
-    MANUAL_PERCENTAGE = "MANUAL_PERCENTAGE"
-    AI_EQUAL = "AI_EQUAL"
-
-
-class WinningMetricProperty(str, Enum):
-    OPEN_RATE = "OPEN_RATE"
-    CLICK_RATE = "CLICK_RATE"
-    REPLY_RATE = "REPLY_RATE"
-    POSITIVE_REPLY_RATE = "POSITIVE_REPLY_RATE"
-
-
-class SequenceDelayDetails(BaseModel):
-    delay_in_days: int
-
-
-class SequenceVariant(BaseModel):
-    subject: str
-    email_body: str
-    variant_label: str
-    id: int | None = None  # Optional for creation, required for updates
-    variant_distribution_percentage: int | None = None
-
-
-class Sequence(BaseModel):
-    seq_number: int = SchemaField(
-        description="The sequence number",
-        default=1,
-    )
-    seq_delay_details: SequenceDelayDetails
-    id: int | None = None
-    variant_distribution_type: VariantDistributionType | None = None
-    lead_distribution_percentage: int | None = SchemaField(
-        None, ge=20, le=100
-    )  # >= 20% for fair calculation
-    winning_metric_property: WinningMetricProperty | None = None
-    seq_variants: list[SequenceVariant] | None = None
-    subject: str = ""  # blank makes the follow up in the same thread
-    email_body: str | None = None
-
-
-class SaveSequencesRequest(BaseModel):
-    sequences: list[Sequence]
-
-
-class SaveSequencesResponse(BaseModel):
-    ok: bool
-    message: str = SchemaField(
-        description="Message from the API",
-        default="",
-    )
-    data: dict | str | None = None
-    error: str | None = None

autogpt_platform/backend/backend/blocks/text.py

@@ -76,8 +76,6 @@ class ExtractTextInformationBlock(Block):
     class Output(BlockSchema):
         positive: str = SchemaField(description="Extracted text")
         negative: str = SchemaField(description="Original text")
-        matched_results: list[str] = SchemaField(description="List of matched results")
-        matched_count: int = SchemaField(description="Number of matched results")
 
     def __init__(self):
         super().__init__(
@@ -105,31 +103,13 @@ class ExtractTextInformationBlock(Block):
                 },
             ],
             test_output=[
-                # Test case 1
                 ("positive", "World!"),
-                ("matched_results", ["World!"]),
-                ("matched_count", 1),
-                # Test case 2
                 ("positive", "Hello, World!"),
-                ("matched_results", ["Hello, World!"]),
-                ("matched_count", 1),
-                # Test case 3
                 ("negative", "Hello, World!"),
-                ("matched_results", []),
-                ("matched_count", 0),
-                # Test case 4
                 ("positive", "Hello,"),
-                ("matched_results", ["Hello,"]),
-                ("matched_count", 1),
-                # Test case 5
                 ("positive", "World!!"),
-                ("matched_results", ["World!!"]),
-                ("matched_count", 1),
-                # Test case 6
                 ("positive", "World!!"),
                 ("positive", "Earth!!"),
-                ("matched_results", ["World!!", "Earth!!"]),
-                ("matched_count", 2),
             ],
         )
 
@@ -150,16 +130,13 @@ class ExtractTextInformationBlock(Block):
             for match in re.finditer(input_data.pattern, txt, flags)
             if input_data.group <= len(match.groups())
         ]
-        if not input_data.find_all:
-            matches = matches[:1]
         for match in matches:
             yield "positive", match
+            if not input_data.find_all:
+                return
         if not matches:
             yield "negative", input_data.text
 
-        yield "matched_results", matches
-        yield "matched_count", len(matches)
-
 
 class FillTextTemplateBlock(Block):
     class Input(BlockSchema):

autogpt_platform/backend/backend/blocks/time_blocks.py

@@ -156,10 +156,6 @@ class CountdownTimerBlock(Block):
         days: Union[int, str] = SchemaField(
             advanced=False, description="Duration in days", default=0
         )
-        repeat: int = SchemaField(
-            description="Number of times to repeat the timer",
-            default=1,
-        )
 
     class Output(BlockSchema):
         output_message: Any = SchemaField(
@@ -191,6 +187,5 @@ class CountdownTimerBlock(Block):
 
         total_seconds = seconds + minutes * 60 + hours * 3600 + days * 86400
 
-        for _ in range(input_data.repeat):
-            time.sleep(total_seconds)
-            yield "output_message", input_data.input_message
+        time.sleep(total_seconds)
+        yield "output_message", input_data.input_message

autogpt_platform/backend/backend/blocks/xml_parser.py

@@ -1,37 +0,0 @@
-from gravitasml.parser import Parser
-from gravitasml.token import tokenize
-
-from backend.data.block import Block, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-
-class XMLParserBlock(Block):
-    class Input(BlockSchema):
-        input_xml: str = SchemaField(description="input xml to be parsed")
-
-    class Output(BlockSchema):
-        parsed_xml: dict = SchemaField(description="output parsed xml to dict")
-        error: str = SchemaField(description="Error in parsing")
-
-    def __init__(self):
-        super().__init__(
-            id="286380af-9529-4b55-8be0-1d7c854abdb5",
-            description="Parses XML using gravitasml to tokenize and coverts it to dict",
-            input_schema=XMLParserBlock.Input,
-            output_schema=XMLParserBlock.Output,
-            test_input={"input_xml": "<tag1><tag2>content</tag2></tag1>"},
-            test_output=[
-                ("parsed_xml", {"tag1": {"tag2": "content"}}),
-            ],
-        )
-
-    def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        try:
-            tokens = tokenize(input_data.input_xml)
-            parser = Parser(tokens)
-            parsed_result = parser.parse()
-            yield "parsed_xml", parsed_result
-        except ValueError as val_e:
-            raise ValueError(f"Validation error for dict:{val_e}") from val_e
-        except SyntaxError as syn_e:
-            raise SyntaxError(f"Error in input xml syntax: {syn_e}") from syn_e

autogpt_platform/backend/backend/blocks/zerobounce/_api.py

@@ -1,10 +0,0 @@
-from zerobouncesdk import ZBValidateResponse, ZeroBounce
-
-
-class ZeroBounceClient:
-    def __init__(self, api_key: str):
-        self.api_key = api_key
-        self.client = ZeroBounce(api_key)
-
-    def validate_email(self, email: str, ip_address: str) -> ZBValidateResponse:
-        return self.client.validate(email, ip_address)

autogpt_platform/backend/backend/blocks/zerobounce/_auth.py

@@ -1,35 +0,0 @@
-from typing import Literal
-
-from pydantic import SecretStr
-
-from backend.data.model import APIKeyCredentials, CredentialsField, CredentialsMetaInput
-from backend.integrations.providers import ProviderName
-
-ZeroBounceCredentials = APIKeyCredentials
-ZeroBounceCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.ZEROBOUNCE],
-    Literal["api_key"],
-]
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="zerobounce",
-    api_key=SecretStr("mock-zerobounce-api-key"),
-    title="Mock ZeroBounce 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 ZeroBounceCredentialsField() -> ZeroBounceCredentialsInput:
-    """
-    Creates a ZeroBounce credentials input on a block.
-    """
-    return CredentialsField(
-        description="The ZeroBounce integration can be used with an API Key.",
-    )

autogpt_platform/backend/backend/blocks/zerobounce/validate_emails.py

@@ -1,175 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel
-from zerobouncesdk.zb_validate_response import (
-    ZBValidateResponse,
-    ZBValidateStatus,
-    ZBValidateSubStatus,
-)
-
-from backend.blocks.zerobounce._api import ZeroBounceClient
-from backend.blocks.zerobounce._auth import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    ZeroBounceCredentials,
-    ZeroBounceCredentialsInput,
-)
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import SchemaField
-
-
-class Response(BaseModel):
-    address: str = SchemaField(
-        description="The email address you are validating.", default="N/A"
-    )
-    status: ZBValidateStatus = SchemaField(
-        description="The status of the email address.", default=ZBValidateStatus.unknown
-    )
-    sub_status: ZBValidateSubStatus = SchemaField(
-        description="The sub-status of the email address.",
-        default=ZBValidateSubStatus.none,
-    )
-    account: Optional[str] = SchemaField(
-        description="The portion of the email address before the '@' symbol.",
-        default="N/A",
-    )
-    domain: Optional[str] = SchemaField(
-        description="The portion of the email address after the '@' symbol."
-    )
-    did_you_mean: Optional[str] = SchemaField(
-        description="Suggestive Fix for an email typo",
-        default=None,
-    )
-    domain_age_days: Optional[str] = SchemaField(
-        description="Age of the email domain in days or [null].",
-        default=None,
-    )
-    free_email: Optional[bool] = SchemaField(
-        description="Whether the email address is a free email provider.", default=False
-    )
-    mx_found: Optional[bool] = SchemaField(
-        description="Whether the MX record was found.", default=False
-    )
-    mx_record: Optional[str] = SchemaField(
-        description="The MX record of the email address.", default=None
-    )
-    smtp_provider: Optional[str] = SchemaField(
-        description="The SMTP provider of the email address.", default=None
-    )
-    firstname: Optional[str] = SchemaField(
-        description="The first name of the email address.", default=None
-    )
-    lastname: Optional[str] = SchemaField(
-        description="The last name of the email address.", default=None
-    )
-    gender: Optional[str] = SchemaField(
-        description="The gender of the email address.", default=None
-    )
-    city: Optional[str] = SchemaField(
-        description="The city of the email address.", default=None
-    )
-    region: Optional[str] = SchemaField(
-        description="The region of the email address.", default=None
-    )
-    zipcode: Optional[str] = SchemaField(
-        description="The zipcode of the email address.", default=None
-    )
-    country: Optional[str] = SchemaField(
-        description="The country of the email address.", default=None
-    )
-
-
-class ValidateEmailsBlock(Block):
-    """Search for people in Apollo"""
-
-    class Input(BlockSchema):
-        email: str = SchemaField(
-            description="Email to validate",
-        )
-        ip_address: str = SchemaField(
-            description="IP address to validate",
-            default="",
-        )
-        credentials: ZeroBounceCredentialsInput = SchemaField(
-            description="ZeroBounce credentials",
-        )
-
-    class Output(BlockSchema):
-        response: Response = SchemaField(
-            description="Response from ZeroBounce",
-        )
-        error: str = SchemaField(
-            description="Error message if the search failed",
-            default="",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="e3950439-fa0b-40e8-b19f-e0dca0bf5853",
-            description="Validate emails",
-            categories={BlockCategory.SEARCH},
-            input_schema=ValidateEmailsBlock.Input,
-            output_schema=ValidateEmailsBlock.Output,
-            test_credentials=TEST_CREDENTIALS,
-            test_input={
-                "credentials": TEST_CREDENTIALS_INPUT,
-                "email": "test@test.com",
-            },
-            test_output=[
-                (
-                    "response",
-                    Response(
-                        address="test@test.com",
-                        status=ZBValidateStatus.valid,
-                        sub_status=ZBValidateSubStatus.allowed,
-                        account="test",
-                        domain="test.com",
-                        did_you_mean=None,
-                        domain_age_days=None,
-                        free_email=False,
-                        mx_found=False,
-                        mx_record=None,
-                        smtp_provider=None,
-                    ),
-                )
-            ],
-            test_mock={
-                "validate_email": lambda email, ip_address, credentials: ZBValidateResponse(
-                    data={
-                        "address": email,
-                        "status": ZBValidateStatus.valid,
-                        "sub_status": ZBValidateSubStatus.allowed,
-                        "account": "test",
-                        "domain": "test.com",
-                        "did_you_mean": None,
-                        "domain_age_days": None,
-                        "free_email": False,
-                        "mx_found": False,
-                        "mx_record": None,
-                        "smtp_provider": None,
-                    }
-                )
-            },
-        )
-
-    @staticmethod
-    def validate_email(
-        email: str, ip_address: str, credentials: ZeroBounceCredentials
-    ) -> ZBValidateResponse:
-        client = ZeroBounceClient(credentials.api_key.get_secret_value())
-        return client.validate_email(email, ip_address)
-
-    def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: ZeroBounceCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        response: ZBValidateResponse = self.validate_email(
-            input_data.email, input_data.ip_address, credentials
-        )
-
-        response_model = Response(**response.__dict__)
-
-        yield "response", response_model

autogpt_platform/backend/backend/cli.py

@@ -221,8 +221,7 @@ def event():
 @test.command()
 @click.argument("server_address")
 @click.argument("graph_id")
-@click.argument("graph_version")
-def websocket(server_address: str, graph_id: str, graph_version: int):
+def websocket(server_address: str, graph_id: str):
     """
     Tests the websocket connection.
     """
@@ -238,9 +237,7 @@ def websocket(server_address: str, graph_id: str, graph_version: int):
             try:
                 msg = WsMessage(
                     method=Methods.SUBSCRIBE,
-                    data=ExecutionSubscription(
-                        graph_id=graph_id, graph_version=graph_version
-                    ).model_dump(),
+                    data=ExecutionSubscription(graph_id=graph_id).model_dump(),
                 ).model_dump_json()
                 await websocket.send(msg)
                 print(f"Sending: {msg}")

autogpt_platform/backend/backend/data/block.py

@@ -2,7 +2,6 @@ import inspect
 from abc import ABC, abstractmethod
 from enum import Enum
 from typing import (
-    TYPE_CHECKING,
     Any,
     ClassVar,
     Generator,
@@ -19,7 +18,6 @@ import jsonschema
 from prisma.models import AgentBlock
 from pydantic import BaseModel
 
-from backend.data.model import NodeExecutionStats
 from backend.util import json
 from backend.util.settings import Config
 
@@ -30,9 +28,6 @@ from .model import (
     is_credentials_field_name,
 )
 
-if TYPE_CHECKING:
-    from .graph import Link
-
 app_config = Config()
 
 BlockData = tuple[str, Any]  # Input & Output data should be a tuple of (name, data).
@@ -49,7 +44,6 @@ class BlockType(Enum):
     WEBHOOK = "Webhook"
     WEBHOOK_MANUAL = "Webhook (manual)"
     AGENT = "Agent"
-    AI = "AI"
 
 
 class BlockCategory(Enum):
@@ -115,10 +109,6 @@ class BlockSchema(BaseModel):
     def validate_data(cls, data: BlockInput) -> str | None:
         return json.validate_with_jsonschema(schema=cls.jsonschema(), data=data)
 
-    @classmethod
-    def get_mismatch_error(cls, data: BlockInput) -> str | None:
-        return cls.validate_data(data)
-
     @classmethod
     def validate_field(cls, field_name: str, data: BlockInput) -> str | None:
         """
@@ -196,19 +186,6 @@ class BlockSchema(BaseModel):
             )
         }
 
-    @classmethod
-    def get_input_defaults(cls, data: BlockInput) -> BlockInput:
-        return data  # Return as is, by default.
-
-    @classmethod
-    def get_missing_links(cls, data: BlockInput, links: list["Link"]) -> set[str]:
-        input_fields_from_nodes = {link.sink_name for link in links}
-        return input_fields_from_nodes - set(data)
-
-    @classmethod
-    def get_missing_input(cls, data: BlockInput) -> set[str]:
-        return cls.get_required_fields() - set(data)
-
 
 BlockSchemaInputType = TypeVar("BlockSchemaInputType", bound=BlockSchema)
 BlockSchemaOutputType = TypeVar("BlockSchemaOutputType", bound=BlockSchema)
@@ -317,7 +294,7 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         self.static_output = static_output
         self.block_type = block_type
         self.webhook_config = webhook_config
-        self.execution_stats: NodeExecutionStats = NodeExecutionStats()
+        self.execution_stats = {}
 
         if self.webhook_config:
             if isinstance(self.webhook_config, BlockWebhookConfig):
@@ -374,14 +351,6 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         Run the block with the given input data.
         Args:
             input_data: The input data with the structure of input_schema.
-
-        Kwargs: Currently 14/02/2025 these include
-            graph_id: The ID of the graph.
-            node_id: The ID of the node.
-            graph_exec_id: The ID of the graph execution.
-            node_exec_id: The ID of the node execution.
-            user_id: The ID of the user.
-
         Returns:
             A Generator that yields (output_name, output_data).
             output_name: One of the output name defined in Block's output_schema.
@@ -395,29 +364,18 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
                 return data
         raise ValueError(f"{self.name} did not produce any output for {output}")
 
-    def merge_stats(self, stats: NodeExecutionStats) -> NodeExecutionStats:
-        stats_dict = stats.model_dump()
-        current_stats = self.execution_stats.model_dump()
-
-        for key, value in stats_dict.items():
-            if key not in current_stats:
-                # Field doesn't exist yet, just set it, but this will probably
-                # not happen, just in case though so we throw for invalid when
-                # converting back in
-                current_stats[key] = value
-            elif isinstance(value, dict) and isinstance(current_stats[key], dict):
-                current_stats[key].update(value)
-            elif isinstance(value, (int, float)) and isinstance(
-                current_stats[key], (int, float)
-            ):
-                current_stats[key] += value
-            elif isinstance(value, list) and isinstance(current_stats[key], list):
-                current_stats[key].extend(value)
+    def merge_stats(self, stats: dict[str, Any]) -> dict[str, Any]:
+        for key, value in stats.items():
+            if isinstance(value, dict):
+                self.execution_stats.setdefault(key, {}).update(value)
+            elif isinstance(value, (int, float)):
+                self.execution_stats.setdefault(key, 0)
+                self.execution_stats[key] += value
+            elif isinstance(value, list):
+                self.execution_stats.setdefault(key, [])
+                self.execution_stats[key].extend(value)
             else:
-                current_stats[key] = value
-
-        self.execution_stats = NodeExecutionStats(**current_stats)
-
+                self.execution_stats[key] = value
         return self.execution_stats
 
     @property
@@ -440,6 +398,7 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         }
 
     def execute(self, input_data: BlockInput, **kwargs) -> BlockOutput:
+        # Merge the input data with the extra execution arguments, preferring the args for security
         if error := self.input_schema.validate_data(input_data):
             raise ValueError(
                 f"Unable to execute block with invalid input data: {error}"

autogpt_platform/backend/backend/data/block_cost_config.py

@@ -2,7 +2,6 @@ from typing import Type
 
 from backend.blocks.ai_music_generator import AIMusicGeneratorBlock
 from backend.blocks.ai_shortform_video_block import AIShortformVideoCreatorBlock
-from backend.blocks.example.example import ExampleBlock
 from backend.blocks.ideogram import IdeogramModelBlock
 from backend.blocks.jina.embeddings import JinaEmbeddingBlock
 from backend.blocks.jina.search import ExtractWebsiteContentBlock, SearchTheWebBlock
@@ -16,7 +15,6 @@ from backend.blocks.llm import (
     LlmModel,
 )
 from backend.blocks.replicate_flux_advanced import ReplicateFluxAdvancedModelBlock
-from backend.blocks.smart_decision_maker import SmartDecisionMakerBlock
 from backend.blocks.talking_head import CreateTalkingAvatarVideoBlock
 from backend.blocks.text_to_speech_block import UnrealTextToSpeechBlock
 from backend.data.block import Block
@@ -24,7 +22,6 @@ from backend.data.cost import BlockCost, BlockCostType
 from backend.integrations.credentials_store import (
     anthropic_credentials,
     did_credentials,
-    example_credentials,
     groq_credentials,
     ideogram_credentials,
     jina_credentials,
@@ -268,17 +265,4 @@ BLOCK_COSTS: dict[Type[Block], list[BlockCost]] = {
             },
         )
     ],
-    SmartDecisionMakerBlock: LLM_COST,
-    ExampleBlock: [
-        BlockCost(
-            cost_amount=1,
-            cost_filter={
-                "credentials": {
-                    "id": example_credentials.id,
-                    "provider": example_credentials.provider,
-                    "type": example_credentials.type,
-                }
-            },
-        )
-    ],
 }

autogpt_platform/backend/backend/data/credit.py

@@ -1,45 +1,28 @@
-import asyncio
 import logging
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from datetime import datetime, timezone
 
 import stripe
-from autogpt_libs.utils.cache import thread_cached
 from prisma import Json
-from prisma.enums import (
-    CreditRefundRequestStatus,
-    CreditTransactionType,
-    NotificationType,
-)
+from prisma.enums import CreditTransactionType
 from prisma.errors import UniqueViolationError
-from prisma.models import CreditRefundRequest, CreditTransaction, User
+from prisma.models import CreditTransaction, User
 from prisma.types import CreditTransactionCreateInput, CreditTransactionWhereInput
 from pydantic import BaseModel
-from tenacity import retry, stop_after_attempt, wait_exponential
 
 from backend.data import db
 from backend.data.block import Block, BlockInput, get_block
 from backend.data.block_cost_config import BLOCK_COSTS
 from backend.data.cost import BlockCost, BlockCostType
 from backend.data.execution import NodeExecutionEntry
-from backend.data.model import (
-    AutoTopUpConfig,
-    RefundRequest,
-    TransactionHistory,
-    UserTransaction,
-)
-from backend.data.notifications import NotificationEventDTO, RefundRequestData
+from backend.data.model import AutoTopUpConfig, TransactionHistory, UserTransaction
 from backend.data.user import get_user_by_id
-from backend.notifications import NotificationManager
-from backend.util.exceptions import InsufficientBalanceError
-from backend.util.service import get_service_client
 from backend.util.settings import Settings
 
 settings = Settings()
 stripe.api_key = settings.secrets.stripe_api_key
 logger = logging.getLogger(__name__)
-base_url = settings.config.frontend_base_url or settings.config.platform_base_url
 
 
 class UserCreditBase(ABC):
@@ -57,37 +40,22 @@ class UserCreditBase(ABC):
     async def get_transaction_history(
         self,
         user_id: str,
+        transaction_time: datetime,
         transaction_count_limit: int,
-        transaction_time_ceiling: datetime | None = None,
-        transaction_type: str | None = None,
     ) -> TransactionHistory:
         """
         Get the credit transactions for the user.
 
         Args:
             user_id (str): The user ID.
+            transaction_time (datetime): The upper bound of the transaction time.
             transaction_count_limit (int): The transaction count limit.
-            transaction_time_ceiling (datetime): The upper bound of the transaction time.
-            transaction_type (str): The transaction type filter.
 
         Returns:
             TransactionHistory: The credit transactions for the user.
         """
         pass
 
-    @abstractmethod
-    async def get_refund_requests(self, user_id: str) -> list[RefundRequest]:
-        """
-        Get the refund requests for the user.
-
-        Args:
-            user_id (str): The user ID.
-
-        Returns:
-            list[RefundRequest]: The refund requests for the user.
-        """
-        pass
-
     @abstractmethod
     async def spend_credits(
         self,
@@ -111,7 +79,7 @@ class UserCreditBase(ABC):
     @abstractmethod
     async def top_up_credits(self, user_id: str, amount: int):
         """
-        Top up the credits for the user.
+        Top up the credits for the user immediately.
 
         Args:
             user_id (str): The user ID.
@@ -133,46 +101,6 @@ class UserCreditBase(ABC):
         """
         pass
 
-    @abstractmethod
-    async def top_up_refund(
-        self, user_id: str, transaction_key: str, metadata: dict[str, str]
-    ) -> int:
-        """
-        Refund the top-up transaction for the user.
-
-        Args:
-            user_id (str): The user ID.
-            transaction_key (str): The top-up transaction key to refund.
-            metadata (dict[str, str]): The metadata of the refund.
-
-        Returns:
-            int: The amount refunded.
-        """
-        pass
-
-    @abstractmethod
-    async def deduct_credits(
-        self,
-        request: stripe.Refund | stripe.Dispute,
-    ):
-        """
-        Deduct the credits for the user based on the dispute or refund of the top-up.
-
-        Args:
-            request (stripe.Refund | stripe.Dispute): The refund or dispute request.
-        """
-        pass
-
-    @abstractmethod
-    async def handle_dispute(self, dispute: stripe.Dispute):
-        """
-        Handle the dispute for the user based on the dispute request.
-
-        Args:
-            dispute (stripe.Dispute): The dispute request.
-        """
-        pass
-
     @abstractmethod
     async def fulfill_checkout(
         self, *, session_id: str | None = None, user_id: str | None = None
@@ -186,14 +114,6 @@ class UserCreditBase(ABC):
         """
         pass
 
-    @staticmethod
-    async def create_billing_portal_session(user_id: str) -> str:
-        session = stripe.billing_portal.Session.create(
-            customer=await get_stripe_customer_id(user_id),
-            return_url=base_url + "/profile/credits",
-        )
-        return session.url
-
     @staticmethod
     def time_now() -> datetime:
         return datetime.now(timezone.utc)
@@ -247,18 +167,10 @@ class UserCreditBase(ABC):
         )
         return transaction_balance, transaction_time
 
-    @retry(
-        stop=stop_after_attempt(5),
-        wait=wait_exponential(multiplier=1, min=1, max=10),
-        reraise=True,
-    )
     async def _enable_transaction(
-        self,
-        transaction_key: str,
-        user_id: str,
-        metadata: Json,
-        new_transaction_key: str | None = None,
+        self, transaction_key: str, user_id: str, metadata: Json
     ):
+
         transaction = await CreditTransaction.prisma().find_first_or_raise(
             where={"transactionKey": transaction_key, "userId": user_id}
         )
@@ -276,7 +188,6 @@ class UserCreditBase(ABC):
                     }
                 },
                 data={
-                    "transactionKey": new_transaction_key or transaction_key,
                     "isActive": True,
                     "runningBalance": user_balance + transaction.amount,
                     "createdAt": self.time_now(),
@@ -292,7 +203,6 @@ class UserCreditBase(ABC):
         is_active: bool = True,
         transaction_key: str | None = None,
         ceiling_balance: int | None = None,
-        fail_insufficient_credits: bool = True,
         metadata: Json = Json({}),
     ) -> tuple[int, str]:
         """
@@ -306,7 +216,6 @@ class UserCreditBase(ABC):
             is_active (bool): Whether the transaction is active or needs to be manually activated through _enable_transaction.
             transaction_key (str | None): The transaction key. Avoids adding transaction if the key already exists.
             ceiling_balance (int | None): The ceiling balance. Avoids adding more credits if the balance is already above the ceiling.
-            fail_insufficient_credits (bool): Whether to fail if the user has insufficient credits.
             metadata (Json): The metadata of the transaction.
 
         Returns:
@@ -316,21 +225,15 @@ class UserCreditBase(ABC):
             # Get latest balance snapshot
             user_balance, _ = await self._get_credits(user_id)
 
-            if ceiling_balance and amount > 0 and user_balance >= ceiling_balance:
+            if ceiling_balance and user_balance >= ceiling_balance:
                 raise ValueError(
-                    f"You already have enough balance of ${user_balance/100}, top-up is not required when you already have at least ${ceiling_balance/100}"
+                    f"You already have enough balance for user {user_id}, balance: {user_balance}, ceiling: {ceiling_balance}"
                 )
 
-            if amount < 0 and user_balance + amount < 0:
-                if fail_insufficient_credits:
-                    raise InsufficientBalanceError(
-                        message=f"Insufficient balance of ${user_balance/100}, where this will cost ${abs(amount)/100}",
-                        user_id=user_id,
-                        balance=user_balance,
-                        amount=amount,
-                    )
-
-                amount = min(-user_balance, 0)
+            if amount < 0 and user_balance < abs(amount):
+                raise ValueError(
+                    f"Insufficient balance of ${user_balance/100} to run the block that costs ${abs(amount)/100}"
+                )
 
             # Create the transaction
             transaction_data: CreditTransactionCreateInput = {
@@ -359,24 +262,6 @@ class UsageTransactionMetadata(BaseModel):
 
 
 class UserCredit(UserCreditBase):
-    @thread_cached
-    def notification_client(self) -> NotificationManager:
-        return get_service_client(NotificationManager)
-
-    async def _send_refund_notification(
-        self,
-        notification_request: RefundRequestData,
-        notification_type: NotificationType,
-    ):
-        await asyncio.to_thread(
-            lambda: self.notification_client().queue_notification(
-                NotificationEventDTO(
-                    user_id=notification_request.user_id,
-                    type=notification_type,
-                    data=notification_request.model_dump(),
-                )
-            )
-        )
 
     def _block_usage_cost(
         self,
@@ -484,182 +369,6 @@ class UserCredit(UserCreditBase):
     async def top_up_credits(self, user_id: str, amount: int):
         await self._top_up_credits(user_id, amount)
 
-    async def top_up_refund(
-        self, user_id: str, transaction_key: str, metadata: dict[str, str]
-    ) -> int:
-        transaction = await CreditTransaction.prisma().find_first_or_raise(
-            where={
-                "transactionKey": transaction_key,
-                "userId": user_id,
-                "isActive": True,
-                "type": CreditTransactionType.TOP_UP,
-            }
-        )
-        balance = await self.get_credits(user_id)
-        amount = transaction.amount
-        refund_key_format = settings.config.refund_request_time_key_format
-        refund_key = f"{transaction.createdAt.strftime(refund_key_format)}-{user_id}"
-
-        try:
-            refund_request = await CreditRefundRequest.prisma().create(
-                data={
-                    "id": refund_key,
-                    "transactionKey": transaction_key,
-                    "userId": user_id,
-                    "amount": amount,
-                    "reason": metadata.get("reason", ""),
-                    "status": CreditRefundRequestStatus.PENDING,
-                    "result": "The refund request is under review.",
-                }
-            )
-        except UniqueViolationError:
-            raise ValueError(
-                "Unable to request a refund for this transaction, the request of the top-up transaction within the same week has already been made."
-            )
-
-        if amount - balance > settings.config.refund_credit_tolerance_threshold:
-            user_data = await get_user_by_id(user_id)
-            await self._send_refund_notification(
-                RefundRequestData(
-                    user_id=user_id,
-                    user_name=user_data.name or "AutoGPT Platform User",
-                    user_email=user_data.email,
-                    transaction_id=transaction_key,
-                    refund_request_id=refund_request.id,
-                    reason=refund_request.reason,
-                    amount=amount,
-                    balance=balance,
-                ),
-                NotificationType.REFUND_REQUEST,
-            )
-            return 0  # Register the refund request for manual approval.
-
-        # Auto refund the top-up.
-        refund = stripe.Refund.create(payment_intent=transaction_key, metadata=metadata)
-        return refund.amount
-
-    async def deduct_credits(self, request: stripe.Refund | stripe.Dispute):
-        if isinstance(request, stripe.Refund) and request.status != "succeeded":
-            logger.warning(
-                f"Skip processing refund #{request.id} with status {request.status}"
-            )
-            return
-
-        if isinstance(request, stripe.Dispute) and request.status != "lost":
-            logger.warning(
-                f"Skip processing dispute #{request.id} with status {request.status}"
-            )
-            return
-
-        transaction = await CreditTransaction.prisma().find_first_or_raise(
-            where={
-                "transactionKey": str(request.payment_intent),
-                "isActive": True,
-                "type": CreditTransactionType.TOP_UP,
-            }
-        )
-        if request.amount <= 0 or request.amount > transaction.amount:
-            raise AssertionError(
-                f"Invalid amount to deduct ${request.amount/100} from ${transaction.amount/100} top-up"
-            )
-
-        balance, _ = await self._add_transaction(
-            user_id=transaction.userId,
-            amount=-request.amount,
-            transaction_type=CreditTransactionType.REFUND,
-            transaction_key=request.id,
-            metadata=Json(request),
-            fail_insufficient_credits=False,
-        )
-
-        # Update the result of the refund request if it exists.
-        await CreditRefundRequest.prisma().update_many(
-            where={
-                "userId": transaction.userId,
-                "transactionKey": transaction.transactionKey,
-            },
-            data={
-                "amount": request.amount,
-                "status": CreditRefundRequestStatus.APPROVED,
-                "result": "The refund request has been approved, the amount will be credited back to your account.",
-            },
-        )
-
-        user_data = await get_user_by_id(transaction.userId)
-        await self._send_refund_notification(
-            RefundRequestData(
-                user_id=user_data.id,
-                user_name=user_data.name or "AutoGPT Platform User",
-                user_email=user_data.email,
-                transaction_id=transaction.transactionKey,
-                refund_request_id=request.id,
-                reason=str(request.reason or "-"),
-                amount=transaction.amount,
-                balance=balance,
-            ),
-            NotificationType.REFUND_PROCESSED,
-        )
-
-    async def handle_dispute(self, dispute: stripe.Dispute):
-        transaction = await CreditTransaction.prisma().find_first_or_raise(
-            where={
-                "transactionKey": str(dispute.payment_intent),
-                "isActive": True,
-                "type": CreditTransactionType.TOP_UP,
-            }
-        )
-        user_id = transaction.userId
-        amount = dispute.amount
-        balance = await self.get_credits(user_id)
-
-        # If the user has enough balance, just let them win the dispute.
-        if balance - amount >= settings.config.refund_credit_tolerance_threshold:
-            logger.warning(f"Accepting dispute from {user_id} for ${amount/100}")
-            dispute.close()
-            return
-
-        logger.warning(
-            f"Adding extra info for dispute from {user_id} for ${amount/100}"
-        )
-        # Retrieve recent transaction history to support our evidence.
-        # This provides a concise timeline that shows service usage and proper credit application.
-        transaction_history = await self.get_transaction_history(
-            user_id, transaction_count_limit=None
-        )
-        user = await get_user_by_id(user_id)
-
-        # Build a comprehensive explanation message that includes:
-        # - Confirmation that the top-up transaction was processed and credits were applied.
-        # - A summary of recent transaction history.
-        # - An explanation that the funds were used to render the agreed service.
-        evidence_text = (
-            f"The top-up transaction of ${transaction.amount / 100:.2f} was processed successfully, and the corresponding credits "
-            "were applied to the user’s account. Our records confirm that the funds were utilized for the intended services. "
-            "Below is a summary of recent transaction activity:\n"
-        )
-        for tx in transaction_history.transactions:
-            if tx.transaction_key == transaction.transactionKey:
-                additional_comment = (
-                    " [This top-up transaction is the subject of the dispute]."
-                )
-            else:
-                additional_comment = ""
-
-            evidence_text += (
-                f"- {tx.description}: Amount ${tx.amount / 100:.2f} on {tx.transaction_time.isoformat()}, "
-                f"resulting balance ${tx.balance / 100:.2f} {additional_comment}\n"
-            )
-        evidence_text += (
-            "\nThis evidence demonstrates that the transaction was authorized and that the charged amount was used to render the service as agreed."
-            "\nAdditionally, we provide an automated refund functionality, so the user could have used it if they were not satisfied with the service. "
-        )
-        evidence: stripe.Dispute.ModifyParamsEvidence = {
-            "product_description": "AutoGPT Platform Credits",
-            "customer_email_address": user.email,
-            "uncategorized_text": evidence_text[:20000],
-        }
-        stripe.Dispute.modify(dispute.id, evidence=evidence)
-
     async def _top_up_credits(
         self,
         user_id: str,
@@ -677,15 +386,10 @@ class UserCredit(UserCreditBase):
         ):
             raise ValueError(f"Transaction key {key} already exists for user {user_id}")
 
-        if amount == 0:
-            transaction_type = CreditTransactionType.CARD_CHECK
-        else:
-            transaction_type = CreditTransactionType.TOP_UP
-
         _, transaction_key = await self._add_transaction(
             user_id=user_id,
             amount=amount,
-            transaction_type=transaction_type,
+            transaction_type=CreditTransactionType.TOP_UP,
             is_active=False,
             transaction_key=key,
             ceiling_balance=ceiling_balance,
@@ -697,10 +401,8 @@ class UserCredit(UserCreditBase):
         if not payment_methods:
             raise ValueError("No payment method found, please add it on the platform.")
 
-        successful_transaction = None
-        new_transaction_key = None
         for payment_method in payment_methods:
-            if transaction_type == CreditTransactionType.CARD_CHECK:
+            if amount == 0:
                 setup_intent = stripe.SetupIntent.create(
                     customer=customer_id,
                     usage="off_session",
@@ -712,9 +414,8 @@ class UserCredit(UserCreditBase):
                     },
                 )
                 if setup_intent.status == "succeeded":
-                    successful_transaction = Json({"setup_intent": setup_intent})
-                    new_transaction_key = setup_intent.id
-                    break
+                    return
+
             else:
                 payment_intent = stripe.PaymentIntent.create(
                     amount=amount,
@@ -730,20 +431,15 @@ class UserCredit(UserCreditBase):
                     },
                 )
                 if payment_intent.status == "succeeded":
-                    successful_transaction = Json({"payment_intent": payment_intent})
-                    new_transaction_key = payment_intent.id
-                    break
+                    await self._enable_transaction(
+                        transaction_key=transaction_key,
+                        user_id=user_id,
+                        metadata=Json({"payment_intent": payment_intent}),
+                    )
+                    return
 
-        if not successful_transaction:
-            raise ValueError(
-                f"Out of {len(payment_methods)} payment methods tried, none is supported"
-            )
-
-        await self._enable_transaction(
-            transaction_key=transaction_key,
-            new_transaction_key=new_transaction_key,
-            user_id=user_id,
-            metadata=successful_transaction,
+        raise ValueError(
+            f"Out of {len(payment_methods)} payment methods tried, none is supported"
         )
 
     async def top_up_intent(self, user_id: str, amount: int) -> str:
@@ -774,8 +470,10 @@ class UserCredit(UserCreditBase):
             ui_mode="hosted",
             payment_intent_data={"setup_future_usage": "off_session"},
             saved_payment_method_options={"payment_method_save": "enabled"},
-            success_url=base_url + "/profile/credits?topup=success",
-            cancel_url=base_url + "/profile/credits?topup=cancel",
+            success_url=settings.config.frontend_base_url
+            + "/marketplace/credits?topup=success",
+            cancel_url=settings.config.frontend_base_url
+            + "/marketplace/credits?topup=cancel",
             allow_promotion_codes=True,
         )
 
@@ -785,7 +483,7 @@ class UserCredit(UserCreditBase):
             transaction_type=CreditTransactionType.TOP_UP,
             transaction_key=checkout_session.id,
             is_active=False,
-            metadata=Json(checkout_session),
+            metadata=Json({"checkout_session": checkout_session}),
         )
 
         return checkout_session.url or ""
@@ -801,7 +499,6 @@ class UserCredit(UserCreditBase):
         find_filter: CreditTransactionWhereInput = {
             "type": CreditTransactionType.TOP_UP,
             "isActive": False,
-            "amount": {"gt": 0},
         }
         if session_id:
             find_filter["transactionKey"] = session_id
@@ -818,25 +515,18 @@ class UserCredit(UserCreditBase):
         if not credit_transaction:
             return
 
-        # If the transaction is not a checkout session, then skip the fulfillment
-        if not credit_transaction.transactionKey.startswith("cs_"):
-            return
-
         # Retrieve the Checkout Session from the API
         checkout_session = stripe.checkout.Session.retrieve(
-            credit_transaction.transactionKey,
-            expand=["payment_intent"],
+            credit_transaction.transactionKey
         )
 
         # Check the Checkout Session's payment_status property
         # to determine if fulfillment should be performed
         if checkout_session.payment_status in ["paid", "no_payment_required"]:
-            assert isinstance(checkout_session.payment_intent, stripe.PaymentIntent)
             await self._enable_transaction(
                 transaction_key=credit_transaction.transactionKey,
-                new_transaction_key=checkout_session.payment_intent.id,
                 user_id=credit_transaction.userId,
-                metadata=Json(checkout_session),
+                metadata=Json({"checkout_session": checkout_session}),
             )
 
     async def get_credits(self, user_id: str) -> int:
@@ -846,23 +536,15 @@ class UserCredit(UserCreditBase):
     async def get_transaction_history(
         self,
         user_id: str,
-        transaction_count_limit: int | None = 100,
-        transaction_time_ceiling: datetime | None = None,
-        transaction_type: str | None = None,
+        transaction_time: datetime,
+        transaction_count_limit: int,
     ) -> TransactionHistory:
-        transactions_filter: CreditTransactionWhereInput = {
-            "userId": user_id,
-            "isActive": True,
-        }
-        if transaction_time_ceiling:
-            transaction_time_ceiling = transaction_time_ceiling.replace(
-                tzinfo=timezone.utc
-            )
-            transactions_filter["createdAt"] = {"lt": transaction_time_ceiling}
-        if transaction_type:
-            transactions_filter["type"] = CreditTransactionType[transaction_type]
         transactions = await CreditTransaction.prisma().find_many(
-            where=transactions_filter,
+            where={
+                "userId": user_id,
+                "createdAt": {"lt": transaction_time},
+                "isActive": True,
+            },
             order={"createdAt": "desc"},
             take=transaction_count_limit,
         )
@@ -877,7 +559,7 @@ class UserCredit(UserCreditBase):
                 if t.metadata
                 else UsageTransactionMetadata()
             )
-            tx_time = t.createdAt.replace(tzinfo=timezone.utc)
+            tx_time = t.createdAt.replace(tzinfo=None)
 
             if t.type == CreditTransactionType.USAGE and metadata.graph_exec_id:
                 gt = grouped_transactions[metadata.graph_exec_id]
@@ -891,7 +573,6 @@ class UserCredit(UserCreditBase):
             else:
                 gt = grouped_transactions[t.transactionKey]
                 gt.description = f"{t.type} Transaction"
-                gt.transaction_key = t.transactionKey
 
             gt.amount += t.amount
             gt.transaction_type = t.type
@@ -907,25 +588,6 @@ class UserCredit(UserCreditBase):
             ),
         )
 
-    async def get_refund_requests(self, user_id: str) -> list[RefundRequest]:
-        return [
-            RefundRequest(
-                id=r.id,
-                user_id=r.userId,
-                transaction_key=r.transactionKey,
-                amount=r.amount,
-                reason=r.reason,
-                result=r.result,
-                status=r.status,
-                created_at=r.createdAt,
-                updated_at=r.updatedAt,
-            )
-            for r in await CreditRefundRequest.prisma().find_many(
-                where={"userId": user_id},
-                order={"createdAt": "desc"},
-            )
-        ]
-
 
 class BetaUserCredit(UserCredit):
     """
@@ -946,7 +608,7 @@ class BetaUserCredit(UserCredit):
             balance, _ = await self._add_transaction(
                 user_id=user_id,
                 amount=max(self.num_user_credits_refill - balance, 0),
-                transaction_type=CreditTransactionType.GRANT,
+                transaction_type=CreditTransactionType.TOP_UP,
                 transaction_key=f"MONTHLY-CREDIT-TOP-UP-{cur_time}",
             )
             return balance
@@ -962,9 +624,6 @@ class DisabledUserCredit(UserCreditBase):
     async def get_transaction_history(self, *args, **kwargs) -> TransactionHistory:
         return TransactionHistory(transactions=[], next_transaction_time=None)
 
-    async def get_refund_requests(self, *args, **kwargs) -> list[RefundRequest]:
-        return []
-
     async def spend_credits(self, *args, **kwargs) -> int:
         return 0
 
@@ -974,15 +633,6 @@ class DisabledUserCredit(UserCreditBase):
     async def top_up_intent(self, *args, **kwargs) -> str:
         return ""
 
-    async def top_up_refund(self, *args, **kwargs) -> int:
-        return 0
-
-    async def deduct_credits(self, *args, **kwargs):
-        pass
-
-    async def handle_dispute(self, *args, **kwargs):
-        pass
-
     async def fulfill_checkout(self, *args, **kwargs):
         pass
 
@@ -1007,11 +657,7 @@ async def get_stripe_customer_id(user_id: str) -> str:
     if user.stripeCustomerId:
         return user.stripeCustomerId
 
-    customer = stripe.Customer.create(
-        name=user.name or "",
-        email=user.email,
-        metadata={"user_id": user_id},
-    )
+    customer = stripe.Customer.create(name=user.name or "", email=user.email)
     await User.prisma().update(
         where={"id": user_id}, data={"stripeCustomerId": customer.id}
     )

autogpt_platform/backend/backend/data/db.py

@@ -2,7 +2,6 @@ import logging
 import os
 import zlib
 from contextlib import asynccontextmanager
-from urllib.parse import parse_qsl, urlencode, urlparse, urlunparse
 from uuid import uuid4
 
 from dotenv import load_dotenv
@@ -16,36 +15,7 @@ load_dotenv()
 PRISMA_SCHEMA = os.getenv("PRISMA_SCHEMA", "schema.prisma")
 os.environ["PRISMA_SCHEMA_PATH"] = PRISMA_SCHEMA
 
-
-def add_param(url: str, key: str, value: str) -> str:
-    p = urlparse(url)
-    qs = dict(parse_qsl(p.query))
-    qs[key] = value
-    return urlunparse(p._replace(query=urlencode(qs)))
-
-
-DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://localhost:5432")
-
-CONN_LIMIT = os.getenv("DB_CONNECTION_LIMIT")
-if CONN_LIMIT:
-    DATABASE_URL = add_param(DATABASE_URL, "connection_limit", CONN_LIMIT)
-
-CONN_TIMEOUT = os.getenv("DB_CONNECT_TIMEOUT")
-if CONN_TIMEOUT:
-    DATABASE_URL = add_param(DATABASE_URL, "connect_timeout", CONN_TIMEOUT)
-
-POOL_TIMEOUT = os.getenv("DB_POOL_TIMEOUT")
-if POOL_TIMEOUT:
-    DATABASE_URL = add_param(DATABASE_URL, "pool_timeout", POOL_TIMEOUT)
-
-HTTP_TIMEOUT = int(POOL_TIMEOUT) if POOL_TIMEOUT else None
-
-prisma = Prisma(
-    auto_register=True,
-    http={"timeout": HTTP_TIMEOUT},
-    datasource={"url": DATABASE_URL},
-)
-
+prisma = Prisma(auto_register=True)
 
 logger = logging.getLogger(__name__)
 

autogpt_platform/backend/backend/data/execution.py

@@ -1,10 +1,10 @@
 from collections import defaultdict
 from datetime import datetime, timezone
 from multiprocessing import Manager
-from typing import Any, AsyncGenerator, Generator, Generic, Type, TypeVar
+from typing import Any, AsyncGenerator, Generator, Generic, Optional, TypeVar
 
-from prisma import Json
 from prisma.enums import AgentExecutionStatus
+from prisma.errors import PrismaError
 from prisma.models import (
     AgentGraphExecution,
     AgentNodeExecution,
@@ -14,10 +14,8 @@ from pydantic import BaseModel
 
 from backend.data.block import BlockData, BlockInput, CompletedBlockOutput
 from backend.data.includes import EXECUTION_RESULT_INCLUDE, GRAPH_EXECUTION_INCLUDE
-from backend.data.model import GraphExecutionStats, NodeExecutionStats
 from backend.data.queue import AsyncRedisEventBus, RedisEventBus
-from backend.server.v2.store.exceptions import DatabaseError
-from backend.util import mock, type
+from backend.util import json, mock
 from backend.util.settings import Config
 
 
@@ -25,7 +23,6 @@ class GraphExecutionEntry(BaseModel):
     user_id: str
     graph_exec_id: str
     graph_id: str
-    graph_version: int
     start_node_execs: list["NodeExecutionEntry"]
 
 
@@ -103,16 +100,16 @@ class ExecutionResult(BaseModel):
     def from_db(execution: AgentNodeExecution):
         if execution.executionData:
             # Execution that has been queued for execution will persist its data.
-            input_data = type.convert(execution.executionData, dict[str, Any])
+            input_data = json.loads(execution.executionData, target_type=dict[str, Any])
         else:
             # For incomplete execution, executionData will not be yet available.
             input_data: BlockInput = defaultdict()
             for data in execution.Input or []:
-                input_data[data.name] = type.convert(data.data, Type[Any])
+                input_data[data.name] = json.loads(data.data)
 
         output_data: CompletedBlockOutput = defaultdict(list)
         for data in execution.Output or []:
-            output_data[data.name].append(type.convert(data.data, Type[Any]))
+            output_data[data.name].append(json.loads(data.data))
 
         graph_execution: AgentGraphExecution | None = execution.AgentGraphExecution
 
@@ -141,7 +138,6 @@ async def create_graph_execution(
     graph_version: int,
     nodes_input: list[tuple[str, BlockInput]],
     user_id: str,
-    preset_id: str | None = None,
 ) -> tuple[str, list[ExecutionResult]]:
     """
     Create a new AgentGraphExecution record.
@@ -160,7 +156,7 @@ async def create_graph_execution(
                         "executionStatus": ExecutionStatus.INCOMPLETE,
                         "Input": {
                             "create": [
-                                {"name": name, "data": Json(data)}
+                                {"name": name, "data": json.dumps(data)}
                                 for name, data in node_input.items()
                             ]
                         },
@@ -169,7 +165,6 @@ async def create_graph_execution(
                 ]
             },
             "userId": user_id,
-            "agentPresetId": preset_id,
         },
         include=GRAPH_EXECUTION_INCLUDE,
     )
@@ -213,7 +208,7 @@ async def upsert_execution_input(
         order={"addedTime": "asc"},
         include={"Input": True},
     )
-    json_input_data = Json(input_data)
+    json_input_data = json.dumps(input_data)
 
     if existing_execution:
         await AgentNodeExecutionInputOutput.prisma().create(
@@ -225,7 +220,7 @@ async def upsert_execution_input(
         )
         return existing_execution.id, {
             **{
-                input_data.name: type.convert(input_data.data, Type[Any])
+                input_data.name: json.loads(input_data.data)
                 for input_data in existing_execution.Input or []
             },
             input_name: input_data,
@@ -259,39 +254,32 @@ async def upsert_execution_output(
     await AgentNodeExecutionInputOutput.prisma().create(
         data={
             "name": output_name,
-            "data": Json(output_data),
+            "data": json.dumps(output_data),
             "referencedByOutputExecId": node_exec_id,
         }
     )
 
 
-async def update_graph_execution_start_time(graph_exec_id: str) -> ExecutionResult:
-    res = await AgentGraphExecution.prisma().update(
+async def update_graph_execution_start_time(graph_exec_id: str):
+    await AgentGraphExecution.prisma().update(
         where={"id": graph_exec_id},
         data={
             "executionStatus": ExecutionStatus.RUNNING,
             "startedAt": datetime.now(tz=timezone.utc),
         },
     )
-    if not res:
-        raise ValueError(f"Execution {graph_exec_id} not found.")
-
-    return ExecutionResult.from_graph(res)
 
 
 async def update_graph_execution_stats(
     graph_exec_id: str,
     status: ExecutionStatus,
-    stats: GraphExecutionStats,
+    stats: dict[str, Any],
 ) -> ExecutionResult:
-    data = stats.model_dump()
-    if isinstance(data["error"], Exception):
-        data["error"] = str(data["error"])
     res = await AgentGraphExecution.prisma().update(
         where={"id": graph_exec_id},
         data={
             "executionStatus": status,
-            "stats": Json(data),
+            "stats": json.dumps(stats),
         },
     )
     if not res:
@@ -300,13 +288,10 @@ async def update_graph_execution_stats(
     return ExecutionResult.from_graph(res)
 
 
-async def update_node_execution_stats(node_exec_id: str, stats: NodeExecutionStats):
-    data = stats.model_dump()
-    if isinstance(data["error"], Exception):
-        data["error"] = str(data["error"])
+async def update_node_execution_stats(node_exec_id: str, stats: dict[str, Any]):
     await AgentNodeExecution.prisma().update(
         where={"id": node_exec_id},
-        data={"stats": Json(data)},
+        data={"stats": json.dumps(stats)},
     )
 
 
@@ -326,8 +311,8 @@ async def update_execution_status(
         **({"startedTime": now} if status == ExecutionStatus.RUNNING else {}),
         **({"endedTime": now} if status == ExecutionStatus.FAILED else {}),
         **({"endedTime": now} if status == ExecutionStatus.COMPLETED else {}),
-        **({"executionData": Json(execution_data)} if execution_data else {}),
-        **({"stats": Json(stats)} if stats else {}),
+        **({"executionData": json.dumps(execution_data)} if execution_data else {}),
+        **({"stats": json.dumps(stats)} if stats else {}),
     }
 
     res = await AgentNodeExecution.prisma().update(
@@ -341,21 +326,28 @@ async def update_execution_status(
     return ExecutionResult.from_db(res)
 
 
-async def delete_execution(
-    graph_exec_id: str, user_id: str, soft_delete: bool = True
-) -> None:
-    if soft_delete:
-        deleted_count = await AgentGraphExecution.prisma().update_many(
-            where={"id": graph_exec_id, "userId": user_id}, data={"isDeleted": True}
-        )
-    else:
-        deleted_count = await AgentGraphExecution.prisma().delete_many(
-            where={"id": graph_exec_id, "userId": user_id}
-        )
-    if deleted_count < 1:
-        raise DatabaseError(
-            f"Could not delete graph execution #{graph_exec_id}: not found"
+async def get_execution(
+    execution_id: str, user_id: str
+) -> Optional[AgentNodeExecution]:
+    """
+    Get an execution by ID. Returns None if not found.
+
+    Args:
+        execution_id: The ID of the execution to retrieve
+
+    Returns:
+        The execution if found, None otherwise
+    """
+    try:
+        execution = await AgentNodeExecution.prisma().find_unique(
+            where={
+                "id": execution_id,
+                "userId": user_id,
+            }
         )
+        return execution
+    except PrismaError:
+        return None
 
 
 async def get_execution_results(graph_exec_id: str) -> list[ExecutionResult]:
@@ -371,66 +363,13 @@ async def get_execution_results(graph_exec_id: str) -> list[ExecutionResult]:
     return res
 
 
-async def get_executions_in_timerange(
-    user_id: str, start_time: str, end_time: str
-) -> list[ExecutionResult]:
-    try:
-        executions = await AgentGraphExecution.prisma().find_many(
-            where={
-                "startedAt": {
-                    "gte": datetime.fromisoformat(start_time),
-                    "lte": datetime.fromisoformat(end_time),
-                },
-                "userId": user_id,
-                "isDeleted": False,
-            },
-            include=GRAPH_EXECUTION_INCLUDE,
-        )
-        return [ExecutionResult.from_graph(execution) for execution in executions]
-    except Exception as e:
-        raise DatabaseError(
-            f"Failed to get executions in timerange {start_time} to {end_time} for user {user_id}: {e}"
-        ) from e
-
-
 LIST_SPLIT = "_$_"
 DICT_SPLIT = "_#_"
 OBJC_SPLIT = "_@_"
 
 
 def parse_execution_output(output: BlockData, name: str) -> Any | None:
-    """
-    Extracts partial output data by name from a given BlockData.
-
-    The function supports extracting data from lists, dictionaries, and objects
-    using specific naming conventions:
-    - For lists: <output_name>_$_<index>
-    - For dictionaries: <output_name>_#_<key>
-    - For objects: <output_name>_@_<attribute>
-
-    Args:
-        output (BlockData): A tuple containing the output name and data.
-        name (str): The name used to extract specific data from the output.
-
-    Returns:
-        Any | None: The extracted data if found, otherwise None.
-
-    Examples:
-        >>> output = ("result", [10, 20, 30])
-        >>> parse_execution_output(output, "result_$_1")
-        20
-
-        >>> output = ("config", {"key1": "value1", "key2": "value2"})
-        >>> parse_execution_output(output, "config_#_key1")
-        'value1'
-
-        >>> class Sample:
-        ...     attr1 = "value1"
-        ...     attr2 = "value2"
-        >>> output = ("object", Sample())
-        >>> parse_execution_output(output, "object_@_attr1")
-        'value1'
-    """
+    # Allow extracting partial output data by name.
     output_name, output_data = output
 
     if name == output_name:
@@ -459,37 +398,11 @@ def parse_execution_output(output: BlockData, name: str) -> Any | None:
 
 def merge_execution_input(data: BlockInput) -> BlockInput:
     """
-    Merges dynamic input pins into a single list, dictionary, or object based on naming patterns.
-
-    This function processes input keys that follow specific patterns to merge them into a unified structure:
-    - `<input_name>_$_<index>` for list inputs.
-    - `<input_name>_#_<index>` for dictionary inputs.
-    - `<input_name>_@_<index>` for object inputs.
-
-    Args:
-        data (BlockInput): A dictionary containing input keys and their corresponding values.
-
-    Returns:
-        BlockInput: A dictionary with merged inputs.
-
-    Raises:
-        ValueError: If a list index is not an integer.
-
-    Examples:
-        >>> data = {
-        ...     "list_$_0": "a",
-        ...     "list_$_1": "b",
-        ...     "dict_#_key1": "value1",
-        ...     "dict_#_key2": "value2",
-        ...     "object_@_attr1": "value1",
-        ...     "object_@_attr2": "value2"
-        ... }
-        >>> merge_execution_input(data)
-        {
-            "list": ["a", "b"],
-            "dict": {"key1": "value1", "key2": "value2"},
-            "object": <MockObject attr1="value1" attr2="value2">
-        }
+    Merge all dynamic input pins which described by the following pattern:
+    - <input_name>_$_<index> for list input.
+    - <input_name>_#_<index> for dict input.
+    - <input_name>_@_<index> for object input.
+    This function will construct pins with the same name into a single list/dict/object.
     """
 
     # Merge all input with <input_name>_$_<index> into a single list.
@@ -533,7 +446,8 @@ async def get_latest_execution(node_id: str, graph_eid: str) -> ExecutionResult
         where={
             "agentNodeId": node_id,
             "agentGraphExecutionId": graph_eid,
-            "executionStatus": {"not": ExecutionStatus.INCOMPLETE},  # type: ignore
+            "executionStatus": {"not": ExecutionStatus.INCOMPLETE},
+            "executionData": {"not": None},  # type: ignore
         },
         order={"queuedTime": "desc"},
         include=EXECUTION_RESULT_INCLUDE,

autogpt_platform/backend/backend/data/graph.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 import uuid
 from collections import defaultdict
@@ -5,7 +6,6 @@ from datetime import datetime, timezone
 from typing import Any, Literal, Optional, Type
 
 import prisma
-from prisma import Json
 from prisma.models import (
     AgentGraph,
     AgentGraphExecution,
@@ -13,24 +13,21 @@ from prisma.models import (
     AgentNodeLink,
     StoreListingVersion,
 )
-from prisma.types import AgentGraphExecutionWhereInput, AgentGraphWhereInput
-from pydantic.fields import Field, computed_field
+from prisma.types import AgentGraphWhereInput
+from pydantic.fields import computed_field
 
 from backend.blocks.agent import AgentExecutorBlock
 from backend.blocks.basic import AgentInputBlock, AgentOutputBlock
-from backend.util import type as type_utils
+from backend.util import json
 
-from .block import Block, BlockInput, BlockSchema, BlockType, get_block, get_blocks
+from .block import BlockInput, BlockType, get_block, get_blocks
 from .db import BaseDbModel, transaction
-from .execution import ExecutionResult, ExecutionStatus
+from .execution import ExecutionStatus
 from .includes import AGENT_GRAPH_INCLUDE, AGENT_NODE_INCLUDE
 from .integrations import Webhook
 
 logger = logging.getLogger(__name__)
 
-_INPUT_BLOCK_ID = AgentInputBlock().id
-_OUTPUT_BLOCK_ID = AgentOutputBlock().id
-
 
 class Link(BaseDbModel):
     source_id: str
@@ -70,20 +67,15 @@ class NodeModel(Node):
 
     webhook: Optional[Webhook] = None
 
-    @property
-    def block(self) -> Block[BlockSchema, BlockSchema]:
-        block = get_block(self.block_id)
-        if not block:
-            raise ValueError(f"Block #{self.block_id} does not exist")
-        return block
-
     @staticmethod
-    def from_db(node: AgentNode, for_export: bool = False) -> "NodeModel":
+    def from_db(node: AgentNode):
+        if not node.AgentBlock:
+            raise ValueError(f"Invalid node {node.id}, invalid AgentBlock.")
         obj = NodeModel(
             id=node.id,
-            block_id=node.agentBlockId,
-            input_default=type_utils.convert(node.constantInput, dict[str, Any]),
-            metadata=type_utils.convert(node.metadata, dict[str, Any]),
+            block_id=node.AgentBlock.id,
+            input_default=json.loads(node.constantInput, target_type=dict[str, Any]),
+            metadata=json.loads(node.metadata, target_type=dict[str, Any]),
             graph_id=node.agentGraphId,
             graph_version=node.agentGraphVersion,
             webhook_id=node.webhookId,
@@ -91,8 +83,6 @@ class NodeModel(Node):
         )
         obj.input_links = [Link.from_db(link) for link in node.Input or []]
         obj.output_links = [Link.from_db(link) for link in node.Output or []]
-        if for_export:
-            return obj.stripped_for_export()
         return obj
 
     def is_triggered_by_event_type(self, event_type: str) -> bool:
@@ -111,152 +101,54 @@ class NodeModel(Node):
             if event_filter[k] is True
         ]
 
-    def stripped_for_export(self) -> "NodeModel":
-        """
-        Returns a copy of the node model, stripped of any non-transferable properties
-        """
-        stripped_node = self.model_copy(deep=True)
-        # Remove credentials from node input
-        if stripped_node.input_default:
-            stripped_node.input_default = NodeModel._filter_secrets_from_node_input(
-                stripped_node.input_default, self.block.input_schema.jsonschema()
-            )
-
-        if (
-            stripped_node.block.block_type == BlockType.INPUT
-            and "value" in stripped_node.input_default
-        ):
-            stripped_node.input_default["value"] = ""
-
-        # Remove webhook info
-        stripped_node.webhook_id = None
-        stripped_node.webhook = None
-
-        return stripped_node
-
-    @staticmethod
-    def _filter_secrets_from_node_input(
-        input_data: dict[str, Any], schema: dict[str, Any] | None
-    ) -> dict[str, Any]:
-        sensitive_keys = ["credentials", "api_key", "password", "token", "secret"]
-        field_schemas = schema.get("properties", {}) if schema else {}
-        result = {}
-        for key, value in input_data.items():
-            field_schema: dict | None = field_schemas.get(key)
-            if (field_schema and field_schema.get("secret", False)) or any(
-                sensitive_key in key.lower() for sensitive_key in sensitive_keys
-            ):
-                # This is a secret value -> filter this key-value pair out
-                continue
-            elif isinstance(value, dict):
-                result[key] = NodeModel._filter_secrets_from_node_input(
-                    value, field_schema
-                )
-            else:
-                result[key] = value
-        return result
-
 
 # Fix 2-way reference Node <-> Webhook
 Webhook.model_rebuild()
 
 
-class GraphExecutionMeta(BaseDbModel):
+class GraphExecution(BaseDbModel):
     execution_id: str
     started_at: datetime
     ended_at: datetime
-    cost: Optional[int] = Field(..., description="Execution cost in credits")
     duration: float
     total_run_time: float
     status: ExecutionStatus
     graph_id: str
     graph_version: int
-    preset_id: Optional[str]
 
     @staticmethod
-    def from_db(_graph_exec: AgentGraphExecution):
+    def from_db(execution: AgentGraphExecution):
         now = datetime.now(timezone.utc)
-        start_time = _graph_exec.startedAt or _graph_exec.createdAt
-        end_time = _graph_exec.updatedAt or now
+        start_time = execution.startedAt or execution.createdAt
+        end_time = execution.updatedAt or now
         duration = (end_time - start_time).total_seconds()
         total_run_time = duration
 
         try:
-            stats = type_utils.convert(_graph_exec.stats or {}, dict[str, Any])
+            stats = json.loads(execution.stats or "{}", target_type=dict[str, Any])
         except ValueError:
             stats = {}
 
         duration = stats.get("walltime", duration)
         total_run_time = stats.get("nodes_walltime", total_run_time)
 
-        return GraphExecutionMeta(
-            id=_graph_exec.id,
-            execution_id=_graph_exec.id,
+        return GraphExecution(
+            id=execution.id,
+            execution_id=execution.id,
             started_at=start_time,
             ended_at=end_time,
-            cost=stats.get("cost", None),
             duration=duration,
             total_run_time=total_run_time,
-            status=ExecutionStatus(_graph_exec.executionStatus),
-            graph_id=_graph_exec.agentGraphId,
-            graph_version=_graph_exec.agentGraphVersion,
-            preset_id=_graph_exec.agentPresetId,
+            status=ExecutionStatus(execution.executionStatus),
+            graph_id=execution.agentGraphId,
+            graph_version=execution.agentGraphVersion,
         )
 
 
-class GraphExecution(GraphExecutionMeta):
-    inputs: dict[str, Any]
-    outputs: dict[str, list[Any]]
-    node_executions: list[ExecutionResult]
-
-    @staticmethod
-    def from_db(_graph_exec: AgentGraphExecution):
-        if _graph_exec.AgentNodeExecutions is None:
-            raise ValueError("Node executions must be included in query")
-
-        graph_exec = GraphExecutionMeta.from_db(_graph_exec)
-
-        node_executions = [
-            ExecutionResult.from_db(ne) for ne in _graph_exec.AgentNodeExecutions
-        ]
-
-        inputs = {
-            **{
-                # inputs from Agent Input Blocks
-                exec.input_data["name"]: exec.input_data["value"]
-                for exec in node_executions
-                if exec.block_id == _INPUT_BLOCK_ID
-            },
-            **{
-                # input from webhook-triggered block
-                "payload": exec.input_data["payload"]
-                for exec in node_executions
-                if (block := get_block(exec.block_id))
-                and block.block_type in [BlockType.WEBHOOK, BlockType.WEBHOOK_MANUAL]
-            },
-        }
-
-        outputs: dict[str, list] = defaultdict(list)
-        for exec in node_executions:
-            if exec.block_id == _OUTPUT_BLOCK_ID:
-                outputs[exec.input_data["name"]].append(
-                    exec.input_data.get("value", None)
-                )
-
-        return GraphExecution(
-            **{
-                field_name: getattr(graph_exec, field_name)
-                for field_name in graph_exec.model_fields
-            },
-            inputs=inputs,
-            outputs=outputs,
-            node_executions=node_executions,
-        )
-
-
-class BaseGraph(BaseDbModel):
+class Graph(BaseDbModel):
     version: int = 1
     is_active: bool = True
+    is_template: bool = False
     name: str
     description: str
     nodes: list[Node] = []
@@ -319,10 +211,6 @@ class BaseGraph(BaseDbModel):
         }
 
 
-class Graph(BaseGraph):
-    sub_graphs: list[BaseGraph] = []  # Flattened sub-graphs, only used in export
-
-
 class GraphModel(Graph):
     user_id: str
     nodes: list[NodeModel] = []  # type: ignore
@@ -346,89 +234,42 @@ class GraphModel(Graph):
         Reassigns all IDs in the graph to new UUIDs.
         This method can be used before storing a new graph to the database.
         """
-        if reassign_graph_id:
-            graph_id_map = {
-                self.id: str(uuid.uuid4()),
-                **{sub_graph.id: str(uuid.uuid4()) for sub_graph in self.sub_graphs},
-            }
-        else:
-            graph_id_map = {}
-
-        self._reassign_ids(self, user_id, graph_id_map)
-        for sub_graph in self.sub_graphs:
-            self._reassign_ids(sub_graph, user_id, graph_id_map)
-
-    @staticmethod
-    def _reassign_ids(
-        graph: BaseGraph,
-        user_id: str,
-        graph_id_map: dict[str, str],
-    ):
 
         # Reassign Graph ID
-        if graph.id in graph_id_map:
-            graph.id = graph_id_map[graph.id]
+        id_map = {node.id: str(uuid.uuid4()) for node in self.nodes}
+        if reassign_graph_id:
+            self.id = str(uuid.uuid4())
 
         # Reassign Node IDs
-        id_map = {node.id: str(uuid.uuid4()) for node in graph.nodes}
-        for node in graph.nodes:
+        for node in self.nodes:
             node.id = id_map[node.id]
 
         # Reassign Link IDs
-        for link in graph.links:
+        for link in self.links:
             link.source_id = id_map[link.source_id]
             link.sink_id = id_map[link.sink_id]
 
         # Reassign User IDs for agent blocks
-        for node in graph.nodes:
+        for node in self.nodes:
             if node.block_id != AgentExecutorBlock().id:
                 continue
             node.input_default["user_id"] = user_id
             node.input_default.setdefault("data", {})
-            if (graph_id := node.input_default.get("graph_id")) in graph_id_map:
-                node.input_default["graph_id"] = graph_id_map[graph_id]
+
+        self.validate_graph()
 
     def validate_graph(self, for_run: bool = False):
-        self._validate_graph(self, for_run)
-        for sub_graph in self.sub_graphs:
-            self._validate_graph(sub_graph, for_run)
-
-    @staticmethod
-    def _validate_graph(graph: BaseGraph, for_run: bool = False):
         def sanitize(name):
-            sanitized_name = name.split("_#_")[0].split("_@_")[0].split("_$_")[0]
-            if sanitized_name.startswith("tools_^_"):
-                return sanitized_name.split("_^_")[0]
-            return sanitized_name
-
-        # Validate smart decision maker nodes
-        smart_decision_maker_nodes = set()
-        agent_nodes = set()
-        nodes_block = {
-            node.id: block
-            for node in graph.nodes
-            if (block := get_block(node.block_id)) is not None
-        }
-
-        for node in graph.nodes:
-            if (block := nodes_block.get(node.id)) is None:
-                raise ValueError(f"Invalid block {node.block_id} for node #{node.id}")
-
-            # Smart decision maker nodes
-            if block.block_type == BlockType.AI:
-                smart_decision_maker_nodes.add(node.id)
-            # Agent nodes
-            elif block.block_type == BlockType.AGENT:
-                agent_nodes.add(node.id)
+            return name.split("_#_")[0].split("_@_")[0].split("_$_")[0]
 
         input_links = defaultdict(list)
-
-        for link in graph.links:
+        for link in self.links:
             input_links[link.sink_id].append(link)
 
         # Nodes: required fields are filled or connected and dependencies are satisfied
-        for node in graph.nodes:
-            if (block := nodes_block.get(node.id)) is None:
+        for node in self.nodes:
+            block = get_block(node.block_id)
+            if block is None:
                 raise ValueError(f"Invalid block {node.block_id} for node #{node.id}")
 
             provided_inputs = set(
@@ -445,12 +286,9 @@ class GraphModel(Graph):
                     )
                     and (
                         for_run  # Skip input completion validation, unless when executing.
-                        or block.block_type
-                        in [
-                            BlockType.INPUT,
-                            BlockType.OUTPUT,
-                            BlockType.AGENT,
-                        ]
+                        or block.block_type == BlockType.INPUT
+                        or block.block_type == BlockType.OUTPUT
+                        or block.block_type == BlockType.AGENT
                     )
                 ):
                     raise ValueError(
@@ -488,7 +326,7 @@ class GraphModel(Graph):
                         f"Node {block.name} #{node.id}: Field `{field_name}` requires [{', '.join(missing_deps)}] to be set"
                     )
 
-        node_map = {v.id: v for v in graph.nodes}
+        node_map = {v.id: v for v in self.nodes}
 
         def is_static_output_block(nid: str) -> bool:
             bid = node_map[nid].block_id
@@ -496,23 +334,23 @@ class GraphModel(Graph):
             return b.static_output if b else False
 
         # Links: links are connected and the connected pin data type are compatible.
-        for link in graph.links:
+        for link in self.links:
             source = (link.source_id, link.source_name)
             sink = (link.sink_id, link.sink_name)
-            prefix = f"Link {source} <-> {sink}"
+            suffix = f"Link {source} <-> {sink}"
 
             for i, (node_id, name) in enumerate([source, sink]):
                 node = node_map.get(node_id)
                 if not node:
                     raise ValueError(
-                        f"{prefix}, {node_id} is invalid node id, available nodes: {node_map.keys()}"
+                        f"{suffix}, {node_id} is invalid node id, available nodes: {node_map.keys()}"
                     )
 
                 block = get_block(node.block_id)
                 if not block:
                     blocks = {v().id: v().name for v in get_blocks().values()}
                     raise ValueError(
-                        f"{prefix}, {node.block_id} is invalid block id, available blocks: {blocks}"
+                        f"{suffix}, {node.block_id} is invalid block id, available blocks: {blocks}"
                     )
 
                 sanitized_name = sanitize(name)
@@ -520,37 +358,35 @@ class GraphModel(Graph):
                 if i == 0:
                     fields = (
                         block.output_schema.get_fields()
-                        if block.block_type not in [BlockType.AGENT]
+                        if block.block_type != BlockType.AGENT
                         else vals.get("output_schema", {}).get("properties", {}).keys()
                     )
                 else:
                     fields = (
                         block.input_schema.get_fields()
-                        if block.block_type not in [BlockType.AGENT]
+                        if block.block_type != BlockType.AGENT
                         else vals.get("input_schema", {}).get("properties", {}).keys()
                     )
-                if sanitized_name not in fields and not name.startswith("tools_^_"):
+                if sanitized_name not in fields:
                     fields_msg = f"Allowed fields: {fields}"
-                    raise ValueError(f"{prefix}, `{name}` invalid, {fields_msg}")
+                    raise ValueError(f"{suffix}, `{name}` invalid, {fields_msg}")
 
             if is_static_output_block(link.source_id):
                 link.is_static = True  # Each value block output should be static.
 
     @staticmethod
-    def from_db(
-        graph: AgentGraph,
-        for_export: bool = False,
-        sub_graphs: list[AgentGraph] | None = None,
-    ):
+    def from_db(graph: AgentGraph, for_export: bool = False):
         return GraphModel(
             id=graph.id,
-            user_id=graph.userId if not for_export else "",
+            user_id=graph.userId,
             version=graph.version,
             is_active=graph.isActive,
+            is_template=graph.isTemplate,
             name=graph.name or "",
             description=graph.description or "",
             nodes=[
-                NodeModel.from_db(node, for_export) for node in graph.AgentNodes or []
+                NodeModel.from_db(GraphModel._process_node(node, for_export))
+                for node in graph.AgentNodes or []
             ],
             links=list(
                 {
@@ -559,12 +395,61 @@ class GraphModel(Graph):
                     for link in (node.Input or []) + (node.Output or [])
                 }
             ),
-            sub_graphs=[
-                GraphModel.from_db(sub_graph, for_export)
-                for sub_graph in sub_graphs or []
-            ],
         )
 
+    @staticmethod
+    def _process_node(node: AgentNode, for_export: bool) -> AgentNode:
+        if for_export:
+            # Remove credentials from node input
+            if node.constantInput:
+                constant_input = json.loads(
+                    node.constantInput, target_type=dict[str, Any]
+                )
+                constant_input = GraphModel._hide_node_input_credentials(constant_input)
+                node.constantInput = json.dumps(constant_input)
+
+            # Remove webhook info
+            node.webhookId = None
+            node.Webhook = None
+
+        return node
+
+    @staticmethod
+    def _hide_node_input_credentials(input_data: dict[str, Any]) -> dict[str, Any]:
+        sensitive_keys = ["credentials", "api_key", "password", "token", "secret"]
+        result = {}
+        for key, value in input_data.items():
+            if isinstance(value, dict):
+                result[key] = GraphModel._hide_node_input_credentials(value)
+            elif isinstance(value, str) and any(
+                sensitive_key in key.lower() for sensitive_key in sensitive_keys
+            ):
+                # Skip this key-value pair in the result
+                continue
+            else:
+                result[key] = value
+        return result
+
+    def clean_graph(self):
+        blocks = [block() for block in get_blocks().values()]
+
+        input_blocks = [
+            node
+            for node in self.nodes
+            if next(
+                (
+                    b
+                    for b in blocks
+                    if b.id == node.block_id and b.block_type == BlockType.INPUT
+                ),
+                None,
+            )
+        ]
+
+        for node in self.nodes:
+            if any(input_block.id == node.id for input_block in input_blocks):
+                node.input_default["value"] = ""
+
 
 # --------------------- CRUD functions --------------------- #
 
@@ -594,14 +479,14 @@ async def set_node_webhook(node_id: str, webhook_id: str | None) -> NodeModel:
 
 async def get_graphs(
     user_id: str,
-    filter_by: Literal["active"] | None = "active",
+    filter_by: Literal["active", "template"] | None = "active",
 ) -> list[GraphModel]:
     """
     Retrieves graph metadata objects.
     Default behaviour is to get all currently active graphs.
 
     Args:
-        filter_by: An optional filter to either select graphs.
+        filter_by: An optional filter to either select templates or active graphs.
         user_id: The ID of the user that owns the graph.
 
     Returns:
@@ -611,6 +496,8 @@ async def get_graphs(
 
     if filter_by == "active":
         where_clause["isActive"] = True
+    elif filter_by == "template":
+        where_clause["isTemplate"] = True
 
     graphs = await AgentGraph.prisma().find_many(
         where=where_clause,
@@ -630,87 +517,32 @@ async def get_graphs(
     return graph_models
 
 
-async def get_graph_executions(
-    graph_id: Optional[str] = None,
-    user_id: Optional[str] = None,
-) -> list[GraphExecutionMeta]:
-    where_filter: AgentGraphExecutionWhereInput = {
-        "isDeleted": False,
-    }
-    if user_id:
-        where_filter["userId"] = user_id
-    if graph_id:
-        where_filter["agentGraphId"] = graph_id
-
+async def get_executions(user_id: str) -> list[GraphExecution]:
     executions = await AgentGraphExecution.prisma().find_many(
-        where=where_filter,
+        where={"userId": user_id},
         order={"createdAt": "desc"},
     )
-    return [GraphExecutionMeta.from_db(execution) for execution in executions]
-
-
-async def get_execution_meta(
-    user_id: str, execution_id: str
-) -> GraphExecutionMeta | None:
-    execution = await AgentGraphExecution.prisma().find_first(
-        where={"id": execution_id, "isDeleted": False, "userId": user_id}
-    )
-    return GraphExecutionMeta.from_db(execution) if execution else None
+    return [GraphExecution.from_db(execution) for execution in executions]
 
 
 async def get_execution(user_id: str, execution_id: str) -> GraphExecution | None:
     execution = await AgentGraphExecution.prisma().find_first(
-        where={"id": execution_id, "isDeleted": False, "userId": user_id},
-        include={
-            "AgentNodeExecutions": {
-                "include": {"AgentNode": True, "Input": True, "Output": True},
-                "order_by": [
-                    {"queuedTime": "asc"},
-                    {  # Fallback: Incomplete execs has no queuedTime.
-                        "addedTime": "asc"
-                    },
-                ],
-            },
-        },
+        where={"id": execution_id, "userId": user_id}
     )
     return GraphExecution.from_db(execution) if execution else None
 
 
-async def get_graph_metadata(graph_id: str, version: int | None = None) -> Graph | None:
-    where_clause: AgentGraphWhereInput = {
-        "id": graph_id,
-    }
-
-    if version is not None:
-        where_clause["version"] = version
-
-    graph = await AgentGraph.prisma().find_first(
-        where=where_clause,
-        include=AGENT_GRAPH_INCLUDE,
-        order={"version": "desc"},
-    )
-
-    if not graph:
-        return None
-
-    return Graph(
-        id=graph.id,
-        name=graph.name or "",
-        description=graph.description or "",
-        version=graph.version,
-        is_active=graph.isActive,
-    )
-
-
 async def get_graph(
     graph_id: str,
     version: int | None = None,
+    template: bool = False,
     user_id: str | None = None,
     for_export: bool = False,
 ) -> GraphModel | None:
     """
     Retrieves a graph from the DB.
-    Defaults to the version with `is_active` if `version` is not passed.
+    Defaults to the version with `is_active` if `version` is not passed,
+    or the latest version with `is_template` if `template=True`.
 
     Returns `None` if the record is not found.
     """
@@ -720,6 +552,8 @@ async def get_graph(
 
     if version is not None:
         where_clause["version"] = version
+    elif not template:
+        where_clause["isActive"] = True
 
     graph = await AgentGraph.prisma().find_first(
         where=where_clause,
@@ -743,74 +577,9 @@ async def get_graph(
     ):
         return None
 
-    if for_export:
-        sub_graphs = await _get_sub_graphs(graph)
-        return GraphModel.from_db(
-            graph=graph,
-            sub_graphs=sub_graphs,
-            for_export=for_export,
-        )
-
     return GraphModel.from_db(graph, for_export)
 
 
-async def _get_sub_graphs(graph: AgentGraph) -> list[AgentGraph]:
-    """
-    Iteratively fetches all sub-graphs of a given graph, and flattens them into a list.
-    This call involves a DB fetch in batch, breadth-first, per-level of graph depth.
-    On each DB fetch we will only fetch the sub-graphs that are not already in the list.
-    """
-    sub_graphs = {graph.id: graph}
-    search_graphs = [graph]
-    agent_block_id = AgentExecutorBlock().id
-
-    while search_graphs:
-        sub_graph_ids = [
-            (graph_id, graph_version)
-            for graph in search_graphs
-            for node in graph.AgentNodes or []
-            if (
-                node.AgentBlock
-                and node.AgentBlock.id == agent_block_id
-                and (graph_id := dict(node.constantInput).get("graph_id"))
-                and (graph_version := dict(node.constantInput).get("graph_version"))
-            )
-        ]
-        if not sub_graph_ids:
-            break
-
-        graphs = await AgentGraph.prisma().find_many(
-            where={
-                "OR": [
-                    {
-                        "id": graph_id,
-                        "version": graph_version,
-                        "userId": graph.userId,  # Ensure the sub-graph is owned by the same user
-                    }
-                    for graph_id, graph_version in sub_graph_ids
-                ]  # type: ignore
-            },
-            include=AGENT_GRAPH_INCLUDE,
-        )
-
-        search_graphs = [graph for graph in graphs if graph.id not in sub_graphs]
-        sub_graphs.update({graph.id: graph for graph in search_graphs})
-
-    return [g for g in sub_graphs.values() if g.id != graph.id]
-
-
-async def get_connected_output_nodes(node_id: str) -> list[tuple[Link, Node]]:
-    links = await AgentNodeLink.prisma().find_many(
-        where={"agentNodeSourceId": node_id},
-        include={"AgentNodeSink": {"include": AGENT_NODE_INCLUDE}},  # type: ignore
-    )
-    return [
-        (Link.from_db(link), NodeModel.from_db(link.AgentNodeSink))
-        for link in links
-        if link.AgentNodeSink
-    ]
-
-
 async def set_graph_active_version(graph_id: str, version: int, user_id: str) -> None:
     # Activate the requested version if it exists and is owned by the user.
     updated_count = await AgentGraph.prisma().update_many(
@@ -862,56 +631,50 @@ async def create_graph(graph: Graph, user_id: str) -> GraphModel:
     async with transaction() as tx:
         await __create_graph(tx, graph, user_id)
 
-    if created_graph := await get_graph(graph.id, graph.version, user_id=user_id):
+    if created_graph := await get_graph(
+        graph.id, graph.version, graph.is_template, user_id=user_id
+    ):
         return created_graph
 
     raise ValueError(f"Created graph {graph.id} v{graph.version} is not in DB")
 
 
 async def __create_graph(tx, graph: Graph, user_id: str):
-    graphs = [graph] + graph.sub_graphs
-
-    await AgentGraph.prisma(tx).create_many(
-        data=[
-            {
-                "id": graph.id,
-                "version": graph.version,
-                "name": graph.name,
-                "description": graph.description,
-                "isActive": graph.is_active,
-                "userId": user_id,
-            }
-            for graph in graphs
-        ]
+    await AgentGraph.prisma(tx).create(
+        data={
+            "id": graph.id,
+            "version": graph.version,
+            "name": graph.name,
+            "description": graph.description,
+            "isTemplate": graph.is_template,
+            "isActive": graph.is_active,
+            "userId": user_id,
+            "AgentNodes": {
+                "create": [
+                    {
+                        "id": node.id,
+                        "agentBlockId": node.block_id,
+                        "constantInput": json.dumps(node.input_default),
+                        "metadata": json.dumps(node.metadata),
+                    }
+                    for node in graph.nodes
+                ]
+            },
+        }
     )
 
-    await AgentNode.prisma(tx).create_many(
-        data=[
-            {
-                "id": node.id,
-                "agentGraphId": graph.id,
-                "agentGraphVersion": graph.version,
-                "agentBlockId": node.block_id,
-                "constantInput": Json(node.input_default),
-                "metadata": Json(node.metadata),
-                "webhookId": node.webhook_id,
-            }
-            for graph in graphs
-            for node in graph.nodes
-        ]
-    )
-
-    await AgentNodeLink.prisma(tx).create_many(
-        data=[
-            {
-                "id": str(uuid.uuid4()),
-                "sourceName": link.source_name,
-                "sinkName": link.sink_name,
-                "agentNodeSourceId": link.source_id,
-                "agentNodeSinkId": link.sink_id,
-                "isStatic": link.is_static,
-            }
-            for graph in graphs
+    await asyncio.gather(
+        *[
+            AgentNodeLink.prisma(tx).create(
+                {
+                    "id": str(uuid.uuid4()),
+                    "sourceName": link.source_name,
+                    "sinkName": link.sink_name,
+                    "agentNodeSourceId": link.source_id,
+                    "agentNodeSinkId": link.sink_id,
+                    "isStatic": link.is_static,
+                }
+            )
             for link in graph.links
         ]
     )
@@ -954,11 +717,9 @@ async def fix_llm_provider_credentials():
 
     store = IntegrationCredentialsStore()
 
-    broken_nodes = []
-    try:
-        broken_nodes = await prisma.get_client().query_raw(
-            """
-            SELECT    graph."userId"       user_id,
+    broken_nodes = await prisma.get_client().query_raw(
+        """
+        SELECT    graph."userId"       user_id,
                   node.id              node_id,
                   node."constantInput" node_preset_input
         FROM      platform."AgentNode"  node
@@ -967,10 +728,8 @@ async def fix_llm_provider_credentials():
         WHERE     node."constantInput"::jsonb->'credentials'->>'provider' = 'llm'
         ORDER BY  graph."userId";
         """
-        )
-        logger.info(f"Fixing LLM credential inputs on {len(broken_nodes)} nodes")
-    except Exception as e:
-        logger.error(f"Error fixing LLM credential inputs: {e}")
+    )
+    logger.info(f"Fixing LLM credential inputs on {len(broken_nodes)} nodes")
 
     user_id: str = ""
     user_integrations = None
@@ -983,7 +742,7 @@ async def fix_llm_provider_credentials():
             raise RuntimeError(f"Impossible state while processing node {node}")
 
         node_id: str = node["node_id"]
-        node_preset_input: dict = node["node_preset_input"]
+        node_preset_input: dict = json.loads(node["node_preset_input"])
         credentials_meta: dict = node_preset_input["credentials"]
 
         credentials = next(
@@ -1019,5 +778,5 @@ async def fix_llm_provider_credentials():
         store.update_creds(user_id, credentials)
         await AgentNode.prisma().update(
             where={"id": node_id},
-            data={"constantInput": Json(node_preset_input)},
+            data={"constantInput": json.dumps(node_preset_input)},
         )

autogpt_platform/backend/backend/data/includes.py

@@ -32,15 +32,3 @@ GRAPH_EXECUTION_INCLUDE: prisma.types.AgentGraphExecutionInclude = {
 INTEGRATION_WEBHOOK_INCLUDE: prisma.types.IntegrationWebhookInclude = {
     "AgentNodes": {"include": AGENT_NODE_INCLUDE}  # type: ignore
 }
-
-
-def library_agent_include(user_id: str) -> prisma.types.LibraryAgentInclude:
-    return {
-        "Agent": {
-            "include": {
-                **AGENT_GRAPH_INCLUDE,
-                "AgentGraphExecution": {"where": {"userId": user_id}},
-            }
-        },
-        "Creator": True,
-    }

autogpt_platform/backend/backend/data/model.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import base64
 import logging
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import (
     TYPE_CHECKING,
     Annotated,
@@ -375,8 +375,7 @@ class AutoTopUpConfig(BaseModel):
 
 
 class UserTransaction(BaseModel):
-    transaction_key: str = ""
-    transaction_time: datetime = datetime.min.replace(tzinfo=timezone.utc)
+    transaction_time: datetime = datetime.min
     transaction_type: CreditTransactionType = CreditTransactionType.USAGE
     amount: int = 0
     balance: int = 0
@@ -384,55 +383,9 @@ class UserTransaction(BaseModel):
     usage_graph_id: str | None = None
     usage_execution_id: str | None = None
     usage_node_count: int = 0
-    usage_start_time: datetime = datetime.max.replace(tzinfo=timezone.utc)
+    usage_start_time: datetime = datetime.max
 
 
 class TransactionHistory(BaseModel):
     transactions: list[UserTransaction]
     next_transaction_time: datetime | None
-
-
-class RefundRequest(BaseModel):
-    id: str
-    user_id: str
-    transaction_key: str
-    amount: int
-    reason: str
-    result: str | None = None
-    status: str
-    created_at: datetime
-    updated_at: datetime
-
-
-class NodeExecutionStats(BaseModel):
-    """Execution statistics for a node execution."""
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    error: Optional[Exception | str] = None
-    walltime: float = 0
-    cputime: float = 0
-    cost: float = 0
-    input_size: int = 0
-    output_size: int = 0
-    llm_call_count: int = 0
-    llm_retry_count: int = 0
-    input_token_count: int = 0
-    output_token_count: int = 0
-
-
-class GraphExecutionStats(BaseModel):
-    """Execution statistics for a graph execution."""
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    error: Optional[Exception | str] = None
-    walltime: float = 0
-    cputime: float = 0
-    nodes_walltime: float = 0
-    nodes_cputime: float = 0
-    node_count: int = 0
-    node_error_count: int = 0
-    cost: float = 0

autogpt_platform/backend/backend/data/notifications.py

@@ -1,547 +0,0 @@
-import logging
-from datetime import datetime, timedelta, timezone
-from enum import Enum
-from typing import Annotated, Any, Generic, Optional, TypeVar, Union
-
-from prisma import Json
-from prisma.enums import NotificationType
-from prisma.models import NotificationEvent, UserNotificationBatch
-from prisma.types import UserNotificationBatchWhereInput
-
-# from backend.notifications.models import NotificationEvent
-from pydantic import BaseModel, EmailStr, Field, field_validator
-
-from backend.server.v2.store.exceptions import DatabaseError
-
-from .db import transaction
-
-logger = logging.getLogger(__name__)
-
-
-NotificationDataType_co = TypeVar(
-    "NotificationDataType_co", bound="BaseNotificationData", covariant=True
-)
-SummaryParamsType_co = TypeVar(
-    "SummaryParamsType_co", bound="BaseSummaryParams", covariant=True
-)
-
-
-class QueueType(Enum):
-    IMMEDIATE = "immediate"  # Send right away (errors, critical notifications)
-    BATCH = "batch"  # Batch for up to an hour (usage reports)
-    SUMMARY = "summary"  # Daily digest (summary notifications)
-    BACKOFF = "backoff"  # Backoff strategy (exponential backoff)
-    ADMIN = "admin"  # Admin notifications (errors, critical notifications)
-
-
-class BaseNotificationData(BaseModel):
-    class Config:
-        extra = "allow"
-
-
-class AgentRunData(BaseNotificationData):
-    agent_name: str
-    credits_used: float
-    execution_time: float
-    node_count: int = Field(..., description="Number of nodes executed")
-    graph_id: str
-    outputs: list[dict[str, Any]] = Field(..., description="Outputs of the agent")
-
-
-class ZeroBalanceData(BaseNotificationData):
-    last_transaction: float
-    last_transaction_time: datetime
-    top_up_link: str
-
-    @field_validator("last_transaction_time")
-    @classmethod
-    def validate_timezone(cls, value: datetime):
-        if value.tzinfo is None:
-            raise ValueError("datetime must have timezone information")
-        return value
-
-
-class LowBalanceData(BaseNotificationData):
-    agent_name: str = Field(..., description="Name of the agent")
-    current_balance: float = Field(
-        ..., description="Current balance in credits (100 = $1)"
-    )
-    billing_page_link: str = Field(..., description="Link to billing page")
-    shortfall: float = Field(..., description="Amount of credits needed to continue")
-
-
-class BlockExecutionFailedData(BaseNotificationData):
-    block_name: str
-    block_id: str
-    error_message: str
-    graph_id: str
-    node_id: str
-    execution_id: str
-
-
-class ContinuousAgentErrorData(BaseNotificationData):
-    agent_name: str
-    error_message: str
-    graph_id: str
-    execution_id: str
-    start_time: datetime
-    error_time: datetime
-    attempts: int = Field(..., description="Number of retry attempts made")
-
-    @field_validator("start_time", "error_time")
-    @classmethod
-    def validate_timezone(cls, value: datetime):
-        if value.tzinfo is None:
-            raise ValueError("datetime must have timezone information")
-        return value
-
-
-class BaseSummaryData(BaseNotificationData):
-    total_credits_used: float
-    total_executions: int
-    most_used_agent: str
-    total_execution_time: float
-    successful_runs: int
-    failed_runs: int
-    average_execution_time: float
-    cost_breakdown: dict[str, float]
-
-
-class BaseSummaryParams(BaseModel):
-    pass
-
-
-class DailySummaryParams(BaseSummaryParams):
-    date: datetime
-
-    @field_validator("date")
-    def validate_timezone(cls, value):
-        if value.tzinfo is None:
-            raise ValueError("datetime must have timezone information")
-        return value
-
-
-class WeeklySummaryParams(BaseSummaryParams):
-    start_date: datetime
-    end_date: datetime
-
-    @field_validator("start_date", "end_date")
-    def validate_timezone(cls, value):
-        if value.tzinfo is None:
-            raise ValueError("datetime must have timezone information")
-        return value
-
-
-class DailySummaryData(BaseSummaryData):
-    date: datetime
-
-    @field_validator("date")
-    def validate_timezone(cls, value):
-        if value.tzinfo is None:
-            raise ValueError("datetime must have timezone information")
-        return value
-
-
-class WeeklySummaryData(BaseSummaryData):
-    start_date: datetime
-    end_date: datetime
-
-    @field_validator("start_date", "end_date")
-    def validate_timezone(cls, value):
-        if value.tzinfo is None:
-            raise ValueError("datetime must have timezone information")
-        return value
-
-
-class MonthlySummaryData(BaseNotificationData):
-    month: int
-    year: int
-
-
-class RefundRequestData(BaseNotificationData):
-    user_id: str
-    user_name: str
-    user_email: str
-    transaction_id: str
-    refund_request_id: str
-    reason: str
-    amount: float
-    balance: int
-
-
-NotificationData = Annotated[
-    Union[
-        AgentRunData,
-        ZeroBalanceData,
-        LowBalanceData,
-        BlockExecutionFailedData,
-        ContinuousAgentErrorData,
-        MonthlySummaryData,
-        WeeklySummaryData,
-        DailySummaryData,
-        RefundRequestData,
-        BaseSummaryData,
-    ],
-    Field(discriminator="type"),
-]
-
-
-class NotificationEventDTO(BaseModel):
-    user_id: str
-    type: NotificationType
-    data: dict
-    created_at: datetime = Field(default_factory=lambda: datetime.now(tz=timezone.utc))
-    retry_count: int = 0
-
-
-class SummaryParamsEventDTO(BaseModel):
-    user_id: str
-    type: NotificationType
-    data: dict
-    created_at: datetime = Field(default_factory=lambda: datetime.now(tz=timezone.utc))
-
-
-class NotificationEventModel(BaseModel, Generic[NotificationDataType_co]):
-    user_id: str
-    type: NotificationType
-    data: NotificationDataType_co
-    created_at: datetime = Field(default_factory=lambda: datetime.now(tz=timezone.utc))
-
-    @property
-    def strategy(self) -> QueueType:
-        return NotificationTypeOverride(self.type).strategy
-
-    @field_validator("type", mode="before")
-    def uppercase_type(cls, v):
-        if isinstance(v, str):
-            return v.upper()
-        return v
-
-    @property
-    def template(self) -> str:
-        return NotificationTypeOverride(self.type).template
-
-
-class SummaryParamsEventModel(BaseModel, Generic[SummaryParamsType_co]):
-    user_id: str
-    type: NotificationType
-    data: SummaryParamsType_co
-    created_at: datetime = Field(default_factory=lambda: datetime.now(tz=timezone.utc))
-
-
-def get_notif_data_type(
-    notification_type: NotificationType,
-) -> type[BaseNotificationData]:
-    return {
-        NotificationType.AGENT_RUN: AgentRunData,
-        NotificationType.ZERO_BALANCE: ZeroBalanceData,
-        NotificationType.LOW_BALANCE: LowBalanceData,
-        NotificationType.BLOCK_EXECUTION_FAILED: BlockExecutionFailedData,
-        NotificationType.CONTINUOUS_AGENT_ERROR: ContinuousAgentErrorData,
-        NotificationType.DAILY_SUMMARY: DailySummaryData,
-        NotificationType.WEEKLY_SUMMARY: WeeklySummaryData,
-        NotificationType.MONTHLY_SUMMARY: MonthlySummaryData,
-        NotificationType.REFUND_REQUEST: RefundRequestData,
-        NotificationType.REFUND_PROCESSED: RefundRequestData,
-    }[notification_type]
-
-
-def get_summary_params_type(
-    notification_type: NotificationType,
-) -> type[BaseSummaryParams]:
-    return {
-        NotificationType.DAILY_SUMMARY: DailySummaryParams,
-        NotificationType.WEEKLY_SUMMARY: WeeklySummaryParams,
-    }[notification_type]
-
-
-class NotificationBatch(BaseModel):
-    user_id: str
-    events: list[NotificationEvent]
-    strategy: QueueType
-    last_update: datetime = Field(default_factory=lambda: datetime.now(tz=timezone.utc))
-
-
-class NotificationResult(BaseModel):
-    success: bool
-    message: Optional[str] = None
-
-
-class NotificationTypeOverride:
-    def __init__(self, notification_type: NotificationType):
-        self.notification_type = notification_type
-
-    @property
-    def strategy(self) -> QueueType:
-        BATCHING_RULES = {
-            # These are batched by the notification service
-            NotificationType.AGENT_RUN: QueueType.BATCH,
-            # These are batched by the notification service, but with a backoff strategy
-            NotificationType.ZERO_BALANCE: QueueType.BACKOFF,
-            NotificationType.LOW_BALANCE: QueueType.IMMEDIATE,
-            NotificationType.BLOCK_EXECUTION_FAILED: QueueType.BACKOFF,
-            NotificationType.CONTINUOUS_AGENT_ERROR: QueueType.BACKOFF,
-            NotificationType.DAILY_SUMMARY: QueueType.SUMMARY,
-            NotificationType.WEEKLY_SUMMARY: QueueType.SUMMARY,
-            NotificationType.MONTHLY_SUMMARY: QueueType.SUMMARY,
-            NotificationType.REFUND_REQUEST: QueueType.ADMIN,
-            NotificationType.REFUND_PROCESSED: QueueType.ADMIN,
-        }
-        return BATCHING_RULES.get(self.notification_type, QueueType.IMMEDIATE)
-
-    @property
-    def template(self) -> str:
-        """Returns template name for this notification type"""
-        return {
-            NotificationType.AGENT_RUN: "agent_run.html",
-            NotificationType.ZERO_BALANCE: "zero_balance.html",
-            NotificationType.LOW_BALANCE: "low_balance.html",
-            NotificationType.BLOCK_EXECUTION_FAILED: "block_failed.html",
-            NotificationType.CONTINUOUS_AGENT_ERROR: "agent_error.html",
-            NotificationType.DAILY_SUMMARY: "daily_summary.html",
-            NotificationType.WEEKLY_SUMMARY: "weekly_summary.html",
-            NotificationType.MONTHLY_SUMMARY: "monthly_summary.html",
-            NotificationType.REFUND_REQUEST: "refund_request.html",
-            NotificationType.REFUND_PROCESSED: "refund_processed.html",
-        }[self.notification_type]
-
-    @property
-    def subject(self) -> str:
-        return {
-            NotificationType.AGENT_RUN: "Agent Run Report",
-            NotificationType.ZERO_BALANCE: "You're out of credits!",
-            NotificationType.LOW_BALANCE: "Low Balance Warning!",
-            NotificationType.BLOCK_EXECUTION_FAILED: "Uh oh! Block Execution Failed",
-            NotificationType.CONTINUOUS_AGENT_ERROR: "Shoot! Continuous Agent Error",
-            NotificationType.DAILY_SUMMARY: "Here's your daily summary!",
-            NotificationType.WEEKLY_SUMMARY: "Look at all the cool stuff you did last week!",
-            NotificationType.MONTHLY_SUMMARY: "We did a lot this month!",
-            NotificationType.REFUND_REQUEST: "[ACTION REQUIRED] You got a ${{data.amount / 100}} refund request from {{data.user_name}}",
-            NotificationType.REFUND_PROCESSED: "Refund for ${{data.amount / 100}} to {{data.user_name}} has been processed",
-        }[self.notification_type]
-
-
-class NotificationPreferenceDTO(BaseModel):
-    email: EmailStr = Field(..., description="User's email address")
-    preferences: dict[NotificationType, bool] = Field(
-        ..., description="Which notifications the user wants"
-    )
-    daily_limit: int = Field(..., description="Max emails per day")
-
-
-class NotificationPreference(BaseModel):
-    user_id: str
-    email: EmailStr
-    preferences: dict[NotificationType, bool] = Field(
-        default_factory=dict, description="Which notifications the user wants"
-    )
-    daily_limit: int = 10  # Max emails per day
-    emails_sent_today: int = 0
-    last_reset_date: datetime = Field(
-        default_factory=lambda: datetime.now(timezone.utc)
-    )
-
-
-class UserNotificationEventDTO(BaseModel):
-    type: NotificationType
-    data: dict
-    created_at: datetime
-    updated_at: datetime
-
-    @staticmethod
-    def from_db(model: NotificationEvent) -> "UserNotificationEventDTO":
-        return UserNotificationEventDTO(
-            type=model.type,
-            data=dict(model.data),
-            created_at=model.createdAt,
-            updated_at=model.updatedAt,
-        )
-
-
-class UserNotificationBatchDTO(BaseModel):
-    user_id: str
-    type: NotificationType
-    notifications: list[UserNotificationEventDTO]
-    created_at: datetime
-    updated_at: datetime
-
-    @staticmethod
-    def from_db(model: UserNotificationBatch) -> "UserNotificationBatchDTO":
-        return UserNotificationBatchDTO(
-            user_id=model.userId,
-            type=model.type,
-            notifications=[
-                UserNotificationEventDTO.from_db(notification)
-                for notification in model.notifications or []
-            ],
-            created_at=model.createdAt,
-            updated_at=model.updatedAt,
-        )
-
-
-def get_batch_delay(notification_type: NotificationType) -> timedelta:
-    return {
-        NotificationType.AGENT_RUN: timedelta(minutes=60),
-        NotificationType.ZERO_BALANCE: timedelta(minutes=60),
-        NotificationType.LOW_BALANCE: timedelta(minutes=60),
-        NotificationType.BLOCK_EXECUTION_FAILED: timedelta(minutes=60),
-        NotificationType.CONTINUOUS_AGENT_ERROR: timedelta(minutes=60),
-    }[notification_type]
-
-
-async def create_or_add_to_user_notification_batch(
-    user_id: str,
-    notification_type: NotificationType,
-    notification_data: NotificationEventModel,
-) -> UserNotificationBatchDTO:
-    try:
-        logger.info(
-            f"Creating or adding to notification batch for {user_id} with type {notification_type} and data {notification_data}"
-        )
-
-        # Serialize the data
-        json_data: Json = Json(notification_data.data.model_dump())
-
-        # First try to find existing batch
-        existing_batch = await UserNotificationBatch.prisma().find_unique(
-            where={
-                "userId_type": {
-                    "userId": user_id,
-                    "type": notification_type,
-                }
-            },
-            include={"notifications": True},
-        )
-
-        if not existing_batch:
-            async with transaction() as tx:
-                notification_event = await tx.notificationevent.create(
-                    data={
-                        "type": notification_type,
-                        "data": json_data,
-                    }
-                )
-
-                # Create new batch
-                resp = await tx.usernotificationbatch.create(
-                    data={
-                        "userId": user_id,
-                        "type": notification_type,
-                        "notifications": {"connect": [{"id": notification_event.id}]},
-                    },
-                    include={"notifications": True},
-                )
-                return UserNotificationBatchDTO.from_db(resp)
-        else:
-            async with transaction() as tx:
-                notification_event = await tx.notificationevent.create(
-                    data={
-                        "type": notification_type,
-                        "data": json_data,
-                        "UserNotificationBatch": {"connect": {"id": existing_batch.id}},
-                    }
-                )
-                # Add to existing batch
-                resp = await tx.usernotificationbatch.update(
-                    where={"id": existing_batch.id},
-                    data={
-                        "notifications": {"connect": [{"id": notification_event.id}]}
-                    },
-                    include={"notifications": True},
-                )
-            if not resp:
-                raise DatabaseError(
-                    f"Failed to add notification event {notification_event.id} to existing batch {existing_batch.id}"
-                )
-            return UserNotificationBatchDTO.from_db(resp)
-    except Exception as e:
-        raise DatabaseError(
-            f"Failed to create or add to notification batch for user {user_id} and type {notification_type}: {e}"
-        ) from e
-
-
-async def get_user_notification_oldest_message_in_batch(
-    user_id: str,
-    notification_type: NotificationType,
-) -> UserNotificationEventDTO | None:
-    try:
-        batch = await UserNotificationBatch.prisma().find_first(
-            where={"userId": user_id, "type": notification_type},
-            include={"notifications": True},
-        )
-        if not batch:
-            return None
-        if not batch.notifications:
-            return None
-        sorted_notifications = sorted(batch.notifications, key=lambda x: x.createdAt)
-
-        return (
-            UserNotificationEventDTO.from_db(sorted_notifications[0])
-            if sorted_notifications
-            else None
-        )
-    except Exception as e:
-        raise DatabaseError(
-            f"Failed to get user notification last message in batch for user {user_id} and type {notification_type}: {e}"
-        ) from e
-
-
-async def empty_user_notification_batch(
-    user_id: str, notification_type: NotificationType
-) -> None:
-    try:
-        async with transaction() as tx:
-            await tx.notificationevent.delete_many(
-                where={
-                    "UserNotificationBatch": {
-                        "is": {"userId": user_id, "type": notification_type}
-                    }
-                }
-            )
-
-            await tx.usernotificationbatch.delete_many(
-                where=UserNotificationBatchWhereInput(
-                    userId=user_id,
-                    type=notification_type,
-                )
-            )
-    except Exception as e:
-        raise DatabaseError(
-            f"Failed to empty user notification batch for user {user_id} and type {notification_type}: {e}"
-        ) from e
-
-
-async def get_user_notification_batch(
-    user_id: str,
-    notification_type: NotificationType,
-) -> UserNotificationBatchDTO | None:
-    try:
-        batch = await UserNotificationBatch.prisma().find_first(
-            where={"userId": user_id, "type": notification_type},
-            include={"notifications": True},
-        )
-        return UserNotificationBatchDTO.from_db(batch) if batch else None
-    except Exception as e:
-        raise DatabaseError(
-            f"Failed to get user notification batch for user {user_id} and type {notification_type}: {e}"
-        ) from e
-
-
-async def get_all_batches_by_type(
-    notification_type: NotificationType,
-) -> list[UserNotificationBatchDTO]:
-    try:
-        batches = await UserNotificationBatch.prisma().find_many(
-            where={
-                "type": notification_type,
-                "notifications": {
-                    "some": {}  # Only return batches with at least one notification
-                },
-            },
-            include={"notifications": True},
-        )
-        return [UserNotificationBatchDTO.from_db(batch) for batch in batches]
-    except Exception as e:
-        raise DatabaseError(
-            f"Failed to get all batches by type {notification_type}: {e}"
-        ) from e

autogpt_platform/backend/backend/data/onboarding.py

@@ -1,247 +0,0 @@
-import re
-from typing import Any, Optional
-
-import prisma
-import pydantic
-from prisma import Json
-from prisma.models import (
-    AgentGraph,
-    AgentGraphExecution,
-    StoreListingVersion,
-    UserOnboarding,
-)
-from prisma.types import UserOnboardingUpdateInput
-
-from backend.server.v2.library.db import set_is_deleted_for_library_agent
-from backend.server.v2.store.db import get_store_agent_details
-from backend.server.v2.store.model import StoreAgentDetails
-
-# Mapping from user reason id to categories to search for when choosing agent to show
-REASON_MAPPING: dict[str, list[str]] = {
-    "content_marketing": ["writing", "marketing", "creative"],
-    "business_workflow_automation": ["business", "productivity"],
-    "data_research": ["data", "research"],
-    "ai_innovation": ["development", "research"],
-    "personal_productivity": ["personal", "productivity"],
-}
-
-
-class UserOnboardingUpdate(pydantic.BaseModel):
-    step: int
-    usageReason: Optional[str] = None
-    integrations: list[str] = pydantic.Field(default_factory=list)
-    otherIntegrations: Optional[str] = None
-    selectedAgentCreator: Optional[str] = None
-    selectedAgentSlug: Optional[str] = None
-    agentInput: Optional[dict[str, Any]] = None
-    isCompleted: bool = False
-
-
-async def get_user_onboarding(user_id: str):
-    return await UserOnboarding.prisma().upsert(
-        where={"userId": user_id},
-        data={
-            "create": {"userId": user_id},  # type: ignore
-            "update": {},
-        },
-    )
-
-
-async def update_user_onboarding(user_id: str, data: UserOnboardingUpdate):
-    # Get the user onboarding data
-    user_onboarding = await get_user_onboarding(user_id)
-    update: UserOnboardingUpdateInput = {
-        "step": data.step,
-        "isCompleted": data.isCompleted,
-    }
-    if data.usageReason:
-        update["usageReason"] = data.usageReason
-    if data.integrations:
-        update["integrations"] = data.integrations
-    if data.otherIntegrations:
-        update["otherIntegrations"] = data.otherIntegrations
-    if data.selectedAgentSlug and data.selectedAgentCreator:
-        update["selectedAgentSlug"] = data.selectedAgentSlug
-        update["selectedAgentCreator"] = data.selectedAgentCreator
-        # Check if slug changes
-        if (
-            user_onboarding.selectedAgentCreator
-            and user_onboarding.selectedAgentSlug
-            and user_onboarding.selectedAgentSlug != data.selectedAgentSlug
-        ):
-            store_agent = await get_store_agent_details(
-                user_onboarding.selectedAgentCreator, user_onboarding.selectedAgentSlug
-            )
-            store_listing = await StoreListingVersion.prisma().find_unique_or_raise(
-                where={"id": store_agent.store_listing_version_id}
-            )
-            agent_graph = await AgentGraph.prisma().find_first(
-                where={"id": store_listing.agentId, "version": store_listing.version}
-            )
-            execution_count = await AgentGraphExecution.prisma().count(
-                where={
-                    "userId": user_id,
-                    "agentGraphId": store_listing.agentId,
-                    "agentGraphVersion": store_listing.version,
-                }
-            )
-            # If there was no execution and graph doesn't belong to the user,
-            # mark the agent as deleted
-            if execution_count == 0 and agent_graph and agent_graph.userId != user_id:
-                await set_is_deleted_for_library_agent(
-                    user_id, store_listing.agentId, store_listing.agentVersion, True
-                )
-    if data.agentInput:
-        update["agentInput"] = Json(data.agentInput)
-
-    return await UserOnboarding.prisma().upsert(
-        where={"userId": user_id},
-        data={
-            "create": {"userId": user_id, **update},  # type: ignore
-            "update": update,
-        },
-    )
-
-
-def clean_and_split(text: str) -> list[str]:
-    """
-    Removes all special characters from a string, truncates it to 100 characters,
-    and splits it by whitespace and commas.
-
-    Args:
-        text (str): The input string.
-
-    Returns:
-        list[str]: A list of cleaned words.
-    """
-    # Remove all special characters (keep only alphanumeric and whitespace)
-    cleaned_text = re.sub(r"[^a-zA-Z0-9\s,]", "", text.strip()[:100])
-
-    # Split by whitespace and commas
-    words = re.split(r"[\s,]+", cleaned_text)
-
-    # Remove empty strings from the list
-    words = [word.lower() for word in words if word]
-
-    return words
-
-
-def calculate_points(
-    agent, categories: list[str], custom: list[str], integrations: list[str]
-) -> int:
-    """
-    Calculates the total points for an agent based on the specified criteria.
-
-    Args:
-        agent: The agent object.
-        categories (list[str]): List of categories to match.
-        words (list[str]): List of words to match in the description.
-
-    Returns:
-        int: Total points for the agent.
-    """
-    points = 0
-
-    # 1. Category Matches
-    matched_categories = sum(
-        1 for category in categories if category in agent.categories
-    )
-    points += matched_categories * 100
-
-    # 2. Description Word Matches
-    description_words = agent.description.split()  # Split description into words
-    matched_words = sum(1 for word in custom if word in description_words)
-    points += matched_words * 100
-
-    matched_words = sum(1 for word in integrations if word in description_words)
-    points += matched_words * 50
-
-    # 3. Featured Bonus
-    if agent.featured:
-        points += 50
-
-    # 4. Rating Bonus
-    points += agent.rating * 10
-
-    # 5. Runs Bonus
-    runs_points = min(agent.runs / 1000 * 100, 100)  # Cap at 100 points
-    points += runs_points
-
-    return int(points)
-
-
-async def get_recommended_agents(user_id: str) -> list[StoreAgentDetails]:
-    user_onboarding = await get_user_onboarding(user_id)
-    categories = REASON_MAPPING.get(user_onboarding.usageReason or "", [])
-
-    where_clause: dict[str, Any] = {}
-
-    custom = clean_and_split((user_onboarding.usageReason or "").lower())
-
-    if categories:
-        where_clause["OR"] = [
-            {"categories": {"has": category}} for category in categories
-        ]
-    else:
-        where_clause["OR"] = [
-            {"description": {"contains": word, "mode": "insensitive"}}
-            for word in custom
-        ]
-
-    where_clause["OR"] += [
-        {"description": {"contains": word, "mode": "insensitive"}}
-        for word in user_onboarding.integrations
-    ]
-
-    agents = await prisma.models.StoreAgent.prisma().find_many(
-        where=prisma.types.StoreAgentWhereInput(**where_clause),
-        order=[
-            {"featured": "desc"},
-            {"runs": "desc"},
-            {"rating": "desc"},
-        ],
-    )
-
-    if len(agents) < 2:
-        agents += await prisma.models.StoreAgent.prisma().find_many(
-            where={
-                "listing_id": {"not_in": [agent.listing_id for agent in agents]},
-            },
-            order=[
-                {"featured": "desc"},
-                {"runs": "desc"},
-                {"rating": "desc"},
-            ],
-            take=2 - len(agents),
-        )
-
-    # Calculate points for the first 30 agents and choose the top 2
-    agent_points = []
-    for agent in agents[:50]:
-        points = calculate_points(
-            agent, categories, custom, user_onboarding.integrations
-        )
-        agent_points.append((agent, points))
-
-    agent_points.sort(key=lambda x: x[1], reverse=True)
-    recommended_agents = [agent for agent, _ in agent_points[:2]]
-
-    return [
-        StoreAgentDetails(
-            store_listing_version_id=agent.storeListingVersionId,
-            slug=agent.slug,
-            agent_name=agent.agent_name,
-            agent_video=agent.agent_video or "",
-            agent_image=agent.agent_image,
-            creator=agent.creator_username,
-            creator_avatar=agent.creator_avatar,
-            sub_heading=agent.sub_heading,
-            description=agent.description,
-            categories=agent.categories,
-            runs=agent.runs,
-            rating=agent.rating,
-            versions=agent.versions,
-            last_updated=agent.updated_at,
-        )
-        for agent in recommended_agents
-    ]

autogpt_platform/backend/backend/data/queue.py

@@ -35,7 +35,7 @@ class BaseRedisEventBus(Generic[M], ABC):
     def _serialize_message(self, item: M, channel_key: str) -> tuple[str, str]:
         message = json.dumps(item.model_dump(), cls=DateTimeEncoder)
         channel_name = f"{self.event_bus_name}/{channel_key}"
-        logger.debug(f"[{channel_name}] Publishing an event to Redis {message}")
+        logger.info(f"[{channel_name}] Publishing an event to Redis {message}")
         return message, channel_name
 
     def _deserialize_message(self, msg: Any, channel_key: str) -> M | None:
@@ -44,7 +44,7 @@ class BaseRedisEventBus(Generic[M], ABC):
             return None
         try:
             data = json.loads(msg["data"])
-            logger.debug(f"Consuming an event from Redis {data}")
+            logger.info(f"Consuming an event from Redis {data}")
             return self.Model(**data)
         except Exception as e:
             logger.error(f"Failed to parse event result from Redis {msg} {e}")

autogpt_platform/backend/backend/data/rabbitmq.py

@@ -1,296 +0,0 @@
-import logging
-from abc import ABC, abstractmethod
-from enum import Enum
-from typing import Awaitable, Optional
-
-import aio_pika
-import pika
-import pika.adapters.blocking_connection
-from pika.spec import BasicProperties
-from pydantic import BaseModel
-
-from backend.util.retry import conn_retry
-from backend.util.settings import Settings
-
-logger = logging.getLogger(__name__)
-
-
-class ExchangeType(str, Enum):
-    DIRECT = "direct"
-    FANOUT = "fanout"
-    TOPIC = "topic"
-    HEADERS = "headers"
-
-
-class Exchange(BaseModel):
-    name: str
-    type: ExchangeType
-    durable: bool = True
-    auto_delete: bool = False
-
-
-class Queue(BaseModel):
-    name: str
-    durable: bool = True
-    auto_delete: bool = False
-    # Optional exchange binding configuration
-    exchange: Optional[Exchange] = None
-    routing_key: Optional[str] = None
-    arguments: Optional[dict] = None
-
-
-class RabbitMQConfig(BaseModel):
-    """Configuration for a RabbitMQ service instance"""
-
-    vhost: str = "/"
-    exchanges: list[Exchange]
-    queues: list[Queue]
-
-
-class RabbitMQBase(ABC):
-    """Base class for RabbitMQ connections with shared configuration"""
-
-    def __init__(self, config: RabbitMQConfig):
-        settings = Settings()
-        self.host = settings.config.rabbitmq_host
-        self.port = settings.config.rabbitmq_port
-        self.username = settings.secrets.rabbitmq_default_user
-        self.password = settings.secrets.rabbitmq_default_pass
-        self.config = config
-
-        self._connection = None
-        self._channel = None
-
-    @property
-    def is_connected(self) -> bool:
-        """Check if we have a valid connection"""
-        return bool(self._connection)
-
-    @property
-    def is_ready(self) -> bool:
-        """Check if we have a valid channel"""
-        return bool(self.is_connected and self._channel)
-
-    @abstractmethod
-    def connect(self) -> None | Awaitable[None]:
-        """Establish connection to RabbitMQ"""
-        pass
-
-    @abstractmethod
-    def disconnect(self) -> None | Awaitable[None]:
-        """Close connection to RabbitMQ"""
-        pass
-
-    @abstractmethod
-    def declare_infrastructure(self) -> None | Awaitable[None]:
-        """Declare exchanges and queues for this service"""
-        pass
-
-
-class SyncRabbitMQ(RabbitMQBase):
-    """Synchronous RabbitMQ client"""
-
-    @property
-    def is_connected(self) -> bool:
-        return bool(self._connection and self._connection.is_open)
-
-    @property
-    def is_ready(self) -> bool:
-        return bool(self.is_connected and self._channel and self._channel.is_open)
-
-    @conn_retry("RabbitMQ", "Acquiring connection")
-    def connect(self) -> None:
-        if self.is_connected:
-            return
-
-        credentials = pika.PlainCredentials(self.username, self.password)
-        parameters = pika.ConnectionParameters(
-            host=self.host,
-            port=self.port,
-            virtual_host=self.config.vhost,
-            credentials=credentials,
-            heartbeat=600,
-            blocked_connection_timeout=300,
-        )
-
-        self._connection = pika.BlockingConnection(parameters)
-        self._channel = self._connection.channel()
-        self._channel.basic_qos(prefetch_count=1)
-
-        self.declare_infrastructure()
-
-    def disconnect(self) -> None:
-        if self._channel:
-            if self._channel.is_open:
-                self._channel.close()
-            self._channel = None
-        if self._connection:
-            if self._connection.is_open:
-                self._connection.close()
-            self._connection = None
-
-    def declare_infrastructure(self) -> None:
-        """Declare exchanges and queues for this service"""
-        if not self.is_ready:
-            self.connect()
-
-        if self._channel is None:
-            raise RuntimeError("Channel should be established after connect")
-
-        # Declare exchanges
-        for exchange in self.config.exchanges:
-            self._channel.exchange_declare(
-                exchange=exchange.name,
-                exchange_type=exchange.type.value,
-                durable=exchange.durable,
-                auto_delete=exchange.auto_delete,
-            )
-
-        # Declare queues and bind them to exchanges
-        for queue in self.config.queues:
-            self._channel.queue_declare(
-                queue=queue.name,
-                durable=queue.durable,
-                auto_delete=queue.auto_delete,
-                arguments=queue.arguments,
-            )
-            if queue.exchange:
-                self._channel.queue_bind(
-                    queue=queue.name,
-                    exchange=queue.exchange.name,
-                    routing_key=queue.routing_key or queue.name,
-                )
-
-    def publish_message(
-        self,
-        routing_key: str,
-        message: str,
-        exchange: Optional[Exchange] = None,
-        properties: Optional[BasicProperties] = None,
-        mandatory: bool = True,
-    ) -> None:
-        if not self.is_ready:
-            self.connect()
-
-        if self._channel is None:
-            raise RuntimeError("Channel should be established after connect")
-
-        self._channel.basic_publish(
-            exchange=exchange.name if exchange else "",
-            routing_key=routing_key,
-            body=message.encode(),
-            properties=properties or BasicProperties(delivery_mode=2),
-            mandatory=mandatory,
-        )
-
-    def get_channel(self) -> pika.adapters.blocking_connection.BlockingChannel:
-        if not self.is_ready:
-            self.connect()
-        if self._channel is None:
-            raise RuntimeError("Channel should be established after connect")
-        return self._channel
-
-
-class AsyncRabbitMQ(RabbitMQBase):
-    """Asynchronous RabbitMQ client"""
-
-    @property
-    def is_connected(self) -> bool:
-        return bool(self._connection and not self._connection.is_closed)
-
-    @property
-    def is_ready(self) -> bool:
-        return bool(self.is_connected and self._channel and not self._channel.is_closed)
-
-    @conn_retry("AsyncRabbitMQ", "Acquiring async connection")
-    async def connect(self):
-        if self.is_connected:
-            return
-
-        self._connection = await aio_pika.connect_robust(
-            host=self.host,
-            port=self.port,
-            login=self.username,
-            password=self.password,
-            virtualhost=self.config.vhost.lstrip("/"),
-        )
-        self._channel = await self._connection.channel()
-        await self._channel.set_qos(prefetch_count=1)
-
-        await self.declare_infrastructure()
-
-    async def disconnect(self):
-        if self._channel:
-            await self._channel.close()
-            self._channel = None
-        if self._connection:
-            await self._connection.close()
-            self._connection = None
-
-    async def declare_infrastructure(self):
-        """Declare exchanges and queues for this service"""
-        if not self.is_ready:
-            await self.connect()
-
-        if self._channel is None:
-            raise RuntimeError("Channel should be established after connect")
-
-        # Declare exchanges
-        for exchange in self.config.exchanges:
-            await self._channel.declare_exchange(
-                name=exchange.name,
-                type=exchange.type.value,
-                durable=exchange.durable,
-                auto_delete=exchange.auto_delete,
-            )
-
-        # Declare queues and bind them to exchanges
-        for queue in self.config.queues:
-            queue_obj = await self._channel.declare_queue(
-                name=queue.name,
-                durable=queue.durable,
-                auto_delete=queue.auto_delete,
-                arguments=queue.arguments,
-            )
-            if queue.exchange:
-                exchange = await self._channel.get_exchange(queue.exchange.name)
-                await queue_obj.bind(
-                    exchange, routing_key=queue.routing_key or queue.name
-                )
-
-    async def publish_message(
-        self,
-        routing_key: str,
-        message: str,
-        exchange: Optional[Exchange] = None,
-        persistent: bool = True,
-    ) -> None:
-        if not self.is_ready:
-            await self.connect()
-
-        if self._channel is None:
-            raise RuntimeError("Channel should be established after connect")
-
-        if exchange:
-            exchange_obj = await self._channel.get_exchange(exchange.name)
-        else:
-            exchange_obj = self._channel.default_exchange
-
-        await exchange_obj.publish(
-            aio_pika.Message(
-                body=message.encode(),
-                delivery_mode=(
-                    aio_pika.DeliveryMode.PERSISTENT
-                    if persistent
-                    else aio_pika.DeliveryMode.NOT_PERSISTENT
-                ),
-            ),
-            routing_key=routing_key,
-        )
-
-    async def get_channel(self) -> aio_pika.abc.AbstractChannel:
-        if not self.is_ready:
-            await self.connect()
-        if self._channel is None:
-            raise RuntimeError("Channel should be established after connect")
-        return self._channel

autogpt_platform/backend/backend/data/user.py

@@ -1,51 +1,37 @@
-import base64
-import hashlib
-import hmac
 import logging
-from datetime import datetime, timedelta
 from typing import Optional, cast
-from urllib.parse import quote_plus
 
 from autogpt_libs.auth.models import DEFAULT_USER_ID
 from fastapi import HTTPException
 from prisma import Json
-from prisma.enums import NotificationType
 from prisma.models import User
-from prisma.types import UserUpdateInput
 
 from backend.data.db import prisma
 from backend.data.model import UserIntegrations, UserMetadata, UserMetadataRaw
-from backend.data.notifications import NotificationPreference, NotificationPreferenceDTO
-from backend.server.v2.store.exceptions import DatabaseError
 from backend.util.encryption import JSONCryptor
-from backend.util.settings import Settings
 
 logger = logging.getLogger(__name__)
 
 
 async def get_or_create_user(user_data: dict) -> User:
-    try:
-        user_id = user_data.get("sub")
-        if not user_id:
-            raise HTTPException(status_code=401, detail="User ID not found in token")
+    user_id = user_data.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="User ID not found in token")
 
-        user_email = user_data.get("email")
-        if not user_email:
-            raise HTTPException(status_code=401, detail="Email not found in token")
+    user_email = user_data.get("email")
+    if not user_email:
+        raise HTTPException(status_code=401, detail="Email not found in token")
 
-        user = await prisma.user.find_unique(where={"id": user_id})
-        if not user:
-            user = await prisma.user.create(
-                data={
-                    "id": user_id,
-                    "email": user_email,
-                    "name": user_data.get("user_metadata", {}).get("name"),
-                }
-            )
-
-        return User.model_validate(user)
-    except Exception as e:
-        raise DatabaseError(f"Failed to get or create user {user_data}: {e}") from e
+    user = await prisma.user.find_unique(where={"id": user_id})
+    if not user:
+        user = await prisma.user.create(
+            data={
+                "id": user_id,
+                "email": user_email,
+                "name": user_data.get("user_metadata", {}).get("name"),
+            }
+        )
+    return User.model_validate(user)
 
 
 async def get_user_by_id(user_id: str) -> User:
@@ -55,31 +41,6 @@ async def get_user_by_id(user_id: str) -> User:
     return User.model_validate(user)
 
 
-async def get_user_email_by_id(user_id: str) -> Optional[str]:
-    try:
-        user = await prisma.user.find_unique(where={"id": user_id})
-        return user.email if user else None
-    except Exception as e:
-        raise DatabaseError(f"Failed to get user email for user {user_id}: {e}") from e
-
-
-async def get_user_by_email(email: str) -> Optional[User]:
-    try:
-        user = await prisma.user.find_unique(where={"email": email})
-        return User.model_validate(user) if user else None
-    except Exception as e:
-        raise DatabaseError(f"Failed to get user by email {email}: {e}") from e
-
-
-async def update_user_email(user_id: str, email: str):
-    try:
-        await prisma.user.update(where={"id": user_id}, data={"email": email})
-    except Exception as e:
-        raise DatabaseError(
-            f"Failed to update user email for user {user_id}: {e}"
-        ) from e
-
-
 async def create_default_user() -> Optional[User]:
     user = await prisma.user.find_unique(where={"id": DEFAULT_USER_ID})
     if not user:
@@ -169,229 +130,3 @@ async def migrate_and_encrypt_user_integrations():
             where={"id": user.id},
             data={"metadata": Json(raw_metadata)},
         )
-
-
-async def get_active_user_ids_in_timerange(start_time: str, end_time: str) -> list[str]:
-    try:
-        users = await User.prisma().find_many(
-            where={
-                "AgentGraphExecutions": {
-                    "some": {
-                        "createdAt": {
-                            "gte": datetime.fromisoformat(start_time),
-                            "lte": datetime.fromisoformat(end_time),
-                        }
-                    }
-                }
-            },
-        )
-        return [user.id for user in users]
-
-    except Exception as e:
-        raise DatabaseError(
-            f"Failed to get active user ids in timerange {start_time} to {end_time}: {e}"
-        ) from e
-
-
-async def get_active_users_ids() -> list[str]:
-    user_ids = await get_active_user_ids_in_timerange(
-        (datetime.now() - timedelta(days=30)).isoformat(),
-        datetime.now().isoformat(),
-    )
-    return user_ids
-
-
-async def get_user_notification_preference(user_id: str) -> NotificationPreference:
-    try:
-        user = await User.prisma().find_unique_or_raise(
-            where={"id": user_id},
-        )
-
-        # enable notifications by default if user has no notification preference (shouldn't ever happen though)
-        preferences: dict[NotificationType, bool] = {
-            NotificationType.AGENT_RUN: user.notifyOnAgentRun or False,
-            NotificationType.ZERO_BALANCE: user.notifyOnZeroBalance or False,
-            NotificationType.LOW_BALANCE: user.notifyOnLowBalance or False,
-            NotificationType.BLOCK_EXECUTION_FAILED: user.notifyOnBlockExecutionFailed
-            or False,
-            NotificationType.CONTINUOUS_AGENT_ERROR: user.notifyOnContinuousAgentError
-            or False,
-            NotificationType.DAILY_SUMMARY: user.notifyOnDailySummary or False,
-            NotificationType.WEEKLY_SUMMARY: user.notifyOnWeeklySummary or False,
-            NotificationType.MONTHLY_SUMMARY: user.notifyOnMonthlySummary or False,
-        }
-        daily_limit = user.maxEmailsPerDay or 3
-        notification_preference = NotificationPreference(
-            user_id=user.id,
-            email=user.email,
-            preferences=preferences,
-            daily_limit=daily_limit,
-            # TODO with other changes later, for now we just will email them
-            emails_sent_today=0,
-            last_reset_date=datetime.now(),
-        )
-        return NotificationPreference.model_validate(notification_preference)
-
-    except Exception as e:
-        raise DatabaseError(
-            f"Failed to upsert user notification preference for user {user_id}: {e}"
-        ) from e
-
-
-async def update_user_notification_preference(
-    user_id: str, data: NotificationPreferenceDTO
-) -> NotificationPreference:
-    try:
-        update_data: UserUpdateInput = {}
-        if data.email:
-            update_data["email"] = data.email
-        if NotificationType.AGENT_RUN in data.preferences:
-            update_data["notifyOnAgentRun"] = data.preferences[
-                NotificationType.AGENT_RUN
-            ]
-        if NotificationType.ZERO_BALANCE in data.preferences:
-            update_data["notifyOnZeroBalance"] = data.preferences[
-                NotificationType.ZERO_BALANCE
-            ]
-        if NotificationType.LOW_BALANCE in data.preferences:
-            update_data["notifyOnLowBalance"] = data.preferences[
-                NotificationType.LOW_BALANCE
-            ]
-        if NotificationType.BLOCK_EXECUTION_FAILED in data.preferences:
-            update_data["notifyOnBlockExecutionFailed"] = data.preferences[
-                NotificationType.BLOCK_EXECUTION_FAILED
-            ]
-        if NotificationType.CONTINUOUS_AGENT_ERROR in data.preferences:
-            update_data["notifyOnContinuousAgentError"] = data.preferences[
-                NotificationType.CONTINUOUS_AGENT_ERROR
-            ]
-        if NotificationType.DAILY_SUMMARY in data.preferences:
-            update_data["notifyOnDailySummary"] = data.preferences[
-                NotificationType.DAILY_SUMMARY
-            ]
-        if NotificationType.WEEKLY_SUMMARY in data.preferences:
-            update_data["notifyOnWeeklySummary"] = data.preferences[
-                NotificationType.WEEKLY_SUMMARY
-            ]
-        if NotificationType.MONTHLY_SUMMARY in data.preferences:
-            update_data["notifyOnMonthlySummary"] = data.preferences[
-                NotificationType.MONTHLY_SUMMARY
-            ]
-        if data.daily_limit:
-            update_data["maxEmailsPerDay"] = data.daily_limit
-
-        user = await User.prisma().update(
-            where={"id": user_id},
-            data=update_data,
-        )
-        if not user:
-            raise ValueError(f"User not found with ID: {user_id}")
-        preferences: dict[NotificationType, bool] = {
-            NotificationType.AGENT_RUN: user.notifyOnAgentRun or True,
-            NotificationType.ZERO_BALANCE: user.notifyOnZeroBalance or True,
-            NotificationType.LOW_BALANCE: user.notifyOnLowBalance or True,
-            NotificationType.BLOCK_EXECUTION_FAILED: user.notifyOnBlockExecutionFailed
-            or True,
-            NotificationType.CONTINUOUS_AGENT_ERROR: user.notifyOnContinuousAgentError
-            or True,
-            NotificationType.DAILY_SUMMARY: user.notifyOnDailySummary or True,
-            NotificationType.WEEKLY_SUMMARY: user.notifyOnWeeklySummary or True,
-            NotificationType.MONTHLY_SUMMARY: user.notifyOnMonthlySummary or True,
-        }
-        notification_preference = NotificationPreference(
-            user_id=user.id,
-            email=user.email,
-            preferences=preferences,
-            daily_limit=user.maxEmailsPerDay or 3,
-            # TODO with other changes later, for now we just will email them
-            emails_sent_today=0,
-            last_reset_date=datetime.now(),
-        )
-        return NotificationPreference.model_validate(notification_preference)
-
-    except Exception as e:
-        raise DatabaseError(
-            f"Failed to update user notification preference for user {user_id}: {e}"
-        ) from e
-
-
-async def set_user_email_verification(user_id: str, verified: bool) -> None:
-    """Set the email verification status for a user."""
-    try:
-        await User.prisma().update(
-            where={"id": user_id},
-            data={"emailVerified": verified},
-        )
-    except Exception as e:
-        raise DatabaseError(
-            f"Failed to set email verification status for user {user_id}: {e}"
-        ) from e
-
-
-async def get_user_email_verification(user_id: str) -> bool:
-    """Get the email verification status for a user."""
-    try:
-        user = await User.prisma().find_unique_or_raise(
-            where={"id": user_id},
-        )
-        return user.emailVerified
-    except Exception as e:
-        raise DatabaseError(
-            f"Failed to get email verification status for user {user_id}: {e}"
-        ) from e
-
-
-def generate_unsubscribe_link(user_id: str) -> str:
-    """Generate a link to unsubscribe from all notifications"""
-    # Create an HMAC using a secret key
-    secret_key = Settings().secrets.unsubscribe_secret_key
-    signature = hmac.new(
-        secret_key.encode("utf-8"), user_id.encode("utf-8"), hashlib.sha256
-    ).digest()
-
-    # Create a token that combines the user_id and signature
-    token = base64.urlsafe_b64encode(
-        f"{user_id}:{signature.hex()}".encode("utf-8")
-    ).decode("utf-8")
-    logger.info(f"Generating unsubscribe link for user {user_id}")
-
-    base_url = Settings().config.platform_base_url
-    return f"{base_url}/api/email/unsubscribe?token={quote_plus(token)}"
-
-
-async def unsubscribe_user_by_token(token: str) -> None:
-    """Unsubscribe a user from all notifications using the token"""
-    try:
-        # Decode the token
-        decoded = base64.urlsafe_b64decode(token).decode("utf-8")
-        user_id, received_signature_hex = decoded.split(":", 1)
-
-        # Verify the signature
-        secret_key = Settings().secrets.unsubscribe_secret_key
-        expected_signature = hmac.new(
-            secret_key.encode("utf-8"), user_id.encode("utf-8"), hashlib.sha256
-        ).digest()
-
-        if not hmac.compare_digest(expected_signature.hex(), received_signature_hex):
-            raise ValueError("Invalid token signature")
-
-        user = await get_user_by_id(user_id)
-        await update_user_notification_preference(
-            user.id,
-            NotificationPreferenceDTO(
-                email=user.email,
-                daily_limit=0,
-                preferences={
-                    NotificationType.AGENT_RUN: False,
-                    NotificationType.ZERO_BALANCE: False,
-                    NotificationType.LOW_BALANCE: False,
-                    NotificationType.BLOCK_EXECUTION_FAILED: False,
-                    NotificationType.CONTINUOUS_AGENT_ERROR: False,
-                    NotificationType.DAILY_SUMMARY: False,
-                    NotificationType.WEEKLY_SUMMARY: False,
-                    NotificationType.MONTHLY_SUMMARY: False,
-                },
-            ),
-        )
-    except Exception as e:
-        raise DatabaseError(f"Failed to unsubscribe user by token {token}: {e}") from e

autogpt_platform/backend/backend/executor/__init__.py

@@ -1,9 +1,9 @@
 from .database import DatabaseManager
 from .manager import ExecutionManager
-from .scheduler import Scheduler
+from .scheduler import ExecutionScheduler
 
 __all__ = [
     "DatabaseManager",
     "ExecutionManager",
-    "Scheduler",
+    "ExecutionScheduler",
 ]

autogpt_platform/backend/backend/executor/database.py

@@ -1,3 +1,6 @@
+from functools import wraps
+from typing import Any, Callable, Concatenate, Coroutine, ParamSpec, TypeVar, cast
+
 from backend.data.credit import get_user_credit_model
 from backend.data.execution import (
     ExecutionResult,
@@ -8,44 +11,24 @@ from backend.data.execution import (
     get_incomplete_executions,
     get_latest_execution,
     update_execution_status,
-    update_graph_execution_start_time,
     update_graph_execution_stats,
     update_node_execution_stats,
     upsert_execution_input,
     upsert_execution_output,
 )
-from backend.data.graph import (
-    get_connected_output_nodes,
-    get_graph,
-    get_graph_metadata,
-    get_node,
-)
-from backend.data.notifications import (
-    create_or_add_to_user_notification_batch,
-    empty_user_notification_batch,
-    get_all_batches_by_type,
-    get_user_notification_batch,
-    get_user_notification_oldest_message_in_batch,
-)
+from backend.data.graph import get_graph, get_node
 from backend.data.user import (
-    get_active_user_ids_in_timerange,
-    get_user_email_by_id,
-    get_user_email_verification,
     get_user_integrations,
     get_user_metadata,
-    get_user_notification_preference,
     update_user_integrations,
     update_user_metadata,
 )
-from backend.util.service import AppService, expose, exposed_run_and_wait
+from backend.util.service import AppService, expose, register_pydantic_serializers
 from backend.util.settings import Config
 
+P = ParamSpec("P")
+R = TypeVar("R")
 config = Config()
-_user_credit_model = get_user_credit_model()
-
-
-async def _spend_credits(entry: NodeExecutionEntry) -> int:
-    return await _user_credit_model.spend_credits(entry, 0, 0)
 
 
 class DatabaseManager(AppService):
@@ -63,15 +46,28 @@ class DatabaseManager(AppService):
     def send_execution_update(self, execution_result: ExecutionResult):
         self.event_queue.publish(execution_result)
 
+    @staticmethod
+    def exposed_run_and_wait(
+        f: Callable[P, Coroutine[None, None, R]]
+    ) -> Callable[Concatenate[object, P], R]:
+        @expose
+        @wraps(f)
+        def wrapper(self, *args: P.args, **kwargs: P.kwargs) -> R:
+            coroutine = f(*args, **kwargs)
+            res = self.run_and_wait(coroutine)
+            return res
+
+        # Register serializers for annotations on bare function
+        register_pydantic_serializers(f)
+
+        return wrapper
+
     # Executions
     create_graph_execution = exposed_run_and_wait(create_graph_execution)
     get_execution_results = exposed_run_and_wait(get_execution_results)
     get_incomplete_executions = exposed_run_and_wait(get_incomplete_executions)
     get_latest_execution = exposed_run_and_wait(get_latest_execution)
     update_execution_status = exposed_run_and_wait(update_execution_status)
-    update_graph_execution_start_time = exposed_run_and_wait(
-        update_graph_execution_start_time
-    )
     update_graph_execution_stats = exposed_run_and_wait(update_graph_execution_stats)
     update_node_execution_stats = exposed_run_and_wait(update_node_execution_stats)
     upsert_execution_input = exposed_run_and_wait(upsert_execution_input)
@@ -80,35 +76,16 @@ class DatabaseManager(AppService):
     # Graphs
     get_node = exposed_run_and_wait(get_node)
     get_graph = exposed_run_and_wait(get_graph)
-    get_connected_output_nodes = exposed_run_and_wait(get_connected_output_nodes)
-    get_graph_metadata = exposed_run_and_wait(get_graph_metadata)
 
     # Credits
-    spend_credits = exposed_run_and_wait(_spend_credits)
+    user_credit_model = get_user_credit_model()
+    spend_credits = cast(
+        Callable[[Any, NodeExecutionEntry, float, float], int],
+        exposed_run_and_wait(user_credit_model.spend_credits),
+    )
 
     # User + User Metadata + User Integrations
     get_user_metadata = exposed_run_and_wait(get_user_metadata)
     update_user_metadata = exposed_run_and_wait(update_user_metadata)
     get_user_integrations = exposed_run_and_wait(get_user_integrations)
     update_user_integrations = exposed_run_and_wait(update_user_integrations)
-
-    # User Comms - async
-    get_active_user_ids_in_timerange = exposed_run_and_wait(
-        get_active_user_ids_in_timerange
-    )
-    get_user_email_by_id = exposed_run_and_wait(get_user_email_by_id)
-    get_user_email_verification = exposed_run_and_wait(get_user_email_verification)
-    get_user_notification_preference = exposed_run_and_wait(
-        get_user_notification_preference
-    )
-
-    # Notifications - async
-    create_or_add_to_user_notification_batch = exposed_run_and_wait(
-        create_or_add_to_user_notification_batch
-    )
-    empty_user_notification_batch = exposed_run_and_wait(empty_user_notification_batch)
-    get_all_batches_by_type = exposed_run_and_wait(get_all_batches_by_type)
-    get_user_notification_batch = exposed_run_and_wait(get_user_notification_batch)
-    get_user_notification_oldest_message_in_batch = exposed_run_and_wait(
-        get_user_notification_oldest_message_in_batch
-    )

autogpt_platform/backend/backend/executor/manager.py

@@ -12,19 +12,8 @@ from typing import TYPE_CHECKING, Any, Generator, Optional, TypeVar, cast
 
 from redis.lock import Lock as RedisLock
 
-from backend.blocks.basic import AgentOutputBlock
-from backend.data.model import GraphExecutionStats, NodeExecutionStats
-from backend.data.notifications import (
-    AgentRunData,
-    LowBalanceData,
-    NotificationEventDTO,
-    NotificationType,
-)
-from backend.util.exceptions import InsufficientBalanceError
-
 if TYPE_CHECKING:
     from backend.executor import DatabaseManager
-    from backend.notifications.notifications import NotificationManager
 
 from autogpt_libs.utils.cache import thread_cached
 
@@ -109,10 +98,7 @@ class LogMetadata:
         logger.exception(msg, extra={"json_fields": {**self.metadata, **extra}})
 
     def _wrap(self, msg: str, **extra):
-        extra_msg = str(extra or "")
-        if len(extra_msg) > 1000:
-            extra_msg = extra_msg[:1000] + "..."
-        return f"{self.prefix} {msg} {extra_msg}"
+        return f"{self.prefix} {msg} {extra}"
 
 
 T = TypeVar("T")
@@ -123,7 +109,7 @@ def execute_node(
     db_client: "DatabaseManager",
     creds_manager: IntegrationCredentialsManager,
     data: NodeExecutionEntry,
-    execution_stats: NodeExecutionStats | None = None,
+    execution_stats: dict[str, Any] | None = None,
 ) -> ExecutionStream:
     """
     Execute a node in the graph. This will trigger a block execution on a node,
@@ -206,20 +192,19 @@ def execute_node(
         extra_exec_kwargs[field_name] = credentials
 
     output_size = 0
-    cost = 0
     try:
         # Charge the user for the execution before running the block.
-        cost = db_client.spend_credits(data)
+        # TODO: We assume the block is executed within 0 seconds.
+        #       This is fine because for now, there is no block that is charged by time.
+        db_client.spend_credits(data, input_size + output_size, 0)
 
-        outputs: dict[str, Any] = {}
         for output_name, output_data in node_block.execute(
             input_data, **extra_exec_kwargs
         ):
-            output_data = json.convert_pydantic_to_json(output_data)
             output_size += len(json.dumps(output_data))
             log_metadata.info("Node produced output", **{output_name: output_data})
             db_client.upsert_execution_output(node_exec_id, output_name, output_data)
-            outputs[output_name] = output_data
+
             for execution in _enqueue_next_nodes(
                 db_client=db_client,
                 node=node,
@@ -231,7 +216,6 @@ def execute_node(
             ):
                 yield execution
 
-        # Update execution status and spend credits
         update_execution(ExecutionStatus.COMPLETED)
 
     except Exception as e:
@@ -253,7 +237,7 @@ def execute_node(
         raise e
     finally:
         # Ensure credentials are released even if execution fails
-        if creds_lock and creds_lock.locked():
+        if creds_lock:
             try:
                 creds_lock.release()
             except Exception as e:
@@ -261,12 +245,9 @@ def execute_node(
 
         # Update execution stats
         if execution_stats is not None:
-            execution_stats = execution_stats.model_copy(
-                update=node_block.execution_stats.model_dump()
-            )
-            execution_stats.input_size = input_size
-            execution_stats.output_size = output_size
-            execution_stats.cost = cost
+            execution_stats.update(node_block.execution_stats)
+            execution_stats["input_size"] = input_size
+            execution_stats["output_size"] = output_size
 
 
 def _enqueue_next_nodes(
@@ -419,30 +400,46 @@ def validate_exec(
     node_block: Block | None = get_block(node.block_id)
     if not node_block:
         return None, f"Block for {node.block_id} not found."
-    schema = node_block.input_schema
 
-    # Convert non-matching data types to the expected input schema.
-    for name, data_type in schema.__annotations__.items():
-        if (value := data.get(name)) and (type(value) is not data_type):
-            data[name] = convert(value, data_type)
+    if isinstance(node_block, AgentExecutorBlock):
+        # Validate the execution metadata for the agent executor block.
+        try:
+            exec_data = AgentExecutorBlock.Input(**node.input_default)
+        except Exception as e:
+            return None, f"Input data doesn't match {node_block.name}: {str(e)}"
+
+        # Validation input
+        input_schema = exec_data.input_schema
+        required_fields = set(input_schema["required"])
+        input_default = exec_data.data
+    else:
+        # Convert non-matching data types to the expected input schema.
+        for name, data_type in node_block.input_schema.__annotations__.items():
+            if (value := data.get(name)) and (type(value) is not data_type):
+                data[name] = convert(value, data_type)
+
+        # Validation input
+        input_schema = node_block.input_schema.jsonschema()
+        required_fields = node_block.input_schema.get_required_fields()
+        input_default = node.input_default
 
     # Input data (without default values) should contain all required fields.
     error_prefix = f"Input data missing or mismatch for `{node_block.name}`:"
-    if missing_links := schema.get_missing_links(data, node.input_links):
-        return None, f"{error_prefix} unpopulated links {missing_links}"
+    input_fields_from_nodes = {link.sink_name for link in node.input_links}
+    if not input_fields_from_nodes.issubset(data):
+        return None, f"{error_prefix} {input_fields_from_nodes - set(data)}"
 
     # Merge input data with default values and resolve dynamic dict/list/object pins.
-    input_default = schema.get_input_defaults(node.input_default)
     data = {**input_default, **data}
     if resolve_input:
         data = merge_execution_input(data)
 
     # Input data post-merge should contain all required fields from the schema.
-    if missing_input := schema.get_missing_input(data):
-        return None, f"{error_prefix} missing input {missing_input}"
+    if not required_fields.issubset(data):
+        return None, f"{error_prefix} {required_fields - set(data)}"
 
     # Last validation: Validate the input values against the schema.
-    if error := schema.get_mismatch_error(data):
+    if error := json.validate_with_jsonschema(schema=input_schema, data=data):
         error_message = f"{error_prefix} {error}"
         logger.error(error_message)
         return None, error_message
@@ -523,7 +520,7 @@ class Executor:
         cls,
         q: ExecutionQueue[NodeExecutionEntry],
         node_exec: NodeExecutionEntry,
-    ) -> NodeExecutionStats:
+    ) -> dict[str, Any]:
         log_metadata = LogMetadata(
             user_id=node_exec.user_id,
             graph_eid=node_exec.graph_exec_id,
@@ -533,15 +530,13 @@ class Executor:
             block_name="-",
         )
 
-        execution_stats = NodeExecutionStats()
+        execution_stats = {}
         timing_info, _ = cls._on_node_execution(
             q, node_exec, log_metadata, execution_stats
         )
-        execution_stats.walltime = timing_info.wall_time
-        execution_stats.cputime = timing_info.cpu_time
+        execution_stats["walltime"] = timing_info.wall_time
+        execution_stats["cputime"] = timing_info.cpu_time
 
-        if isinstance(execution_stats.error, Exception):
-            execution_stats.error = str(execution_stats.error)
         cls.db_client.update_node_execution_stats(
             node_exec.node_exec_id, execution_stats
         )
@@ -554,15 +549,12 @@ class Executor:
         q: ExecutionQueue[NodeExecutionEntry],
         node_exec: NodeExecutionEntry,
         log_metadata: LogMetadata,
-        stats: NodeExecutionStats | None = None,
+        stats: dict[str, Any] | None = None,
     ):
         try:
             log_metadata.info(f"Start node execution {node_exec.node_exec_id}")
             for execution in execute_node(
-                db_client=cls.db_client,
-                creds_manager=cls.creds_manager,
-                data=node_exec,
-                execution_stats=stats,
+                cls.db_client, cls.creds_manager, node_exec, stats
             ):
                 q.add(execution)
             log_metadata.info(f"Finished node execution {node_exec.node_exec_id}")
@@ -577,9 +569,6 @@ class Executor:
                     f"Failed node execution {node_exec.node_exec_id}: {e}"
                 )
 
-            if stats is not None:
-                stats.error = e
-
     @classmethod
     def on_graph_executor_start(cls):
         configure_logging()
@@ -588,7 +577,6 @@ class Executor:
         cls.db_client = get_db_client()
         cls.pool_size = settings.config.num_node_workers
         cls.pid = os.getpid()
-        cls.notification_service = get_notification_service()
         cls._init_node_executor_pool()
         logger.info(
             f"Graph executor {cls.pid} started with {cls.pool_size} node workers"
@@ -626,16 +614,12 @@ class Executor:
             node_eid="*",
             block_name="-",
         )
-        cls.db_client.update_graph_execution_start_time(graph_exec.graph_exec_id)
         timing_info, (exec_stats, status, error) = cls._on_graph_execution(
             graph_exec, cancel, log_metadata
         )
-        exec_stats.walltime = timing_info.wall_time
-        exec_stats.cputime = timing_info.cpu_time
-        exec_stats.error = error
-
-        if isinstance(exec_stats.error, Exception):
-            exec_stats.error = str(exec_stats.error)
+        exec_stats["walltime"] = timing_info.wall_time
+        exec_stats["cputime"] = timing_info.cpu_time
+        exec_stats["error"] = str(error) if error else None
         result = cls.db_client.update_graph_execution_stats(
             graph_exec_id=graph_exec.graph_exec_id,
             status=status,
@@ -643,8 +627,6 @@ class Executor:
         )
         cls.db_client.send_execution_update(result)
 
-        cls._handle_agent_run_notif(graph_exec, exec_stats)
-
     @classmethod
     @time_measured
     def _on_graph_execution(
@@ -652,7 +634,7 @@ class Executor:
         graph_exec: GraphExecutionEntry,
         cancel: threading.Event,
         log_metadata: LogMetadata,
-    ) -> tuple[GraphExecutionStats, ExecutionStatus, Exception | None]:
+    ) -> tuple[dict[str, Any], ExecutionStatus, Exception | None]:
         """
         Returns:
             dict: The execution statistics of the graph execution.
@@ -660,7 +642,11 @@ class Executor:
             Exception | None: The error that occurred during the execution, if any.
         """
         log_metadata.info(f"Start graph execution {graph_exec.graph_exec_id}")
-        exec_stats = GraphExecutionStats()
+        exec_stats = {
+            "nodes_walltime": 0,
+            "nodes_cputime": 0,
+            "node_count": 0,
+        }
         error = None
         finished = False
 
@@ -686,26 +672,17 @@ class Executor:
                 queue.add(node_exec)
 
             running_executions: dict[str, AsyncResult] = {}
-            low_balance_error: Optional[InsufficientBalanceError] = None
 
             def make_exec_callback(exec_data: NodeExecutionEntry):
+                node_id = exec_data.node_id
 
                 def callback(result: object):
-                    running_executions.pop(exec_data.node_id)
-
-                    if not isinstance(result, NodeExecutionStats):
-                        return
-
-                    nonlocal exec_stats, low_balance_error
-                    exec_stats.node_count += 1
-                    exec_stats.nodes_cputime += result.cputime
-                    exec_stats.nodes_walltime += result.walltime
-                    exec_stats.cost += result.cost
-                    if (err := result.error) and isinstance(err, Exception):
-                        exec_stats.node_error_count += 1
-
-                        if isinstance(err, InsufficientBalanceError):
-                            low_balance_error = err
+                    running_executions.pop(node_id)
+                    nonlocal exec_stats
+                    if isinstance(result, dict):
+                        exec_stats["node_count"] += 1
+                        exec_stats["nodes_cputime"] += result.get("cputime", 0)
+                        exec_stats["nodes_walltime"] += result.get("walltime", 0)
 
                 return callback
 
@@ -750,16 +727,6 @@ class Executor:
                         execution.wait(3)
 
             log_metadata.info(f"Finished graph execution {graph_exec.graph_exec_id}")
-
-            if isinstance(low_balance_error, InsufficientBalanceError):
-                cls._handle_low_balance_notif(
-                    graph_exec.user_id,
-                    graph_exec.graph_id,
-                    exec_stats,
-                    low_balance_error,
-                )
-                raise low_balance_error
-
         except Exception as e:
             log_metadata.exception(
                 f"Failed graph execution {graph_exec.graph_exec_id}: {e}"
@@ -778,67 +745,6 @@ class Executor:
             error,
         )
 
-    @classmethod
-    def _handle_agent_run_notif(
-        cls,
-        graph_exec: GraphExecutionEntry,
-        exec_stats: GraphExecutionStats,
-    ):
-        metadata = cls.db_client.get_graph_metadata(
-            graph_exec.graph_id, graph_exec.graph_version
-        )
-        outputs = cls.db_client.get_execution_results(graph_exec.graph_exec_id)
-
-        named_outputs = [
-            {
-                key: value[0] if key == "name" else value
-                for key, value in output.output_data.items()
-            }
-            for output in outputs
-            if output.block_id == AgentOutputBlock().id
-        ]
-
-        event = NotificationEventDTO(
-            user_id=graph_exec.user_id,
-            type=NotificationType.AGENT_RUN,
-            data=AgentRunData(
-                outputs=named_outputs,
-                agent_name=metadata.name if metadata else "Unknown Agent",
-                credits_used=exec_stats.cost,
-                execution_time=exec_stats.walltime,
-                graph_id=graph_exec.graph_id,
-                node_count=exec_stats.node_count,
-            ).model_dump(),
-        )
-
-        cls.notification_service.queue_notification(event)
-
-    @classmethod
-    def _handle_low_balance_notif(
-        cls,
-        user_id: str,
-        graph_id: str,
-        exec_stats: GraphExecutionStats,
-        e: InsufficientBalanceError,
-    ):
-        shortfall = e.balance - e.amount
-        metadata = cls.db_client.get_graph_metadata(graph_id)
-        base_url = (
-            settings.config.frontend_base_url or settings.config.platform_base_url
-        )
-        cls.notification_service.queue_notification(
-            NotificationEventDTO(
-                user_id=user_id,
-                type=NotificationType.LOW_BALANCE,
-                data=LowBalanceData(
-                    current_balance=exec_stats.cost,
-                    billing_page_link=f"{base_url}/profile/credits",
-                    shortfall=shortfall,
-                    agent_name=metadata.name if metadata else "Unknown Agent",
-                ).model_dump(),
-            )
-        )
-
 
 class ExecutionManager(AppService):
     def __init__(self):
@@ -897,7 +803,6 @@ class ExecutionManager(AppService):
         data: BlockInput,
         user_id: str,
         graph_version: Optional[int] = None,
-        preset_id: str | None = None,
     ) -> GraphExecutionEntry:
         graph: GraphModel | None = self.db_client.get_graph(
             graph_id=graph_id, user_id=user_id, version=graph_version
@@ -919,9 +824,9 @@ class ExecutionManager(AppService):
 
             # Extract request input data, and assign it to the input pin.
             if block.block_type == BlockType.INPUT:
-                input_name = node.input_default.get("name")
-                if input_name and input_name in data:
-                    input_data = {"value": data[input_name]}
+                name = node.input_default.get("name")
+                if name in data.get("node_input", {}):
+                    input_data = {"value": data["node_input"][name]}
 
             # Extract webhook payload, and assign it to the input pin
             webhook_payload_key = f"webhook_{node.webhook_id}_payload"
@@ -941,17 +846,11 @@ class ExecutionManager(AppService):
             else:
                 nodes_input.append((node.id, input_data))
 
-        if not nodes_input:
-            raise ValueError(
-                "No starting nodes found for the graph, make sure an AgentInput or blocks with no inbound links are present as starting nodes."
-            )
-
         graph_exec_id, node_execs = self.db_client.create_graph_execution(
             graph_id=graph_id,
             graph_version=graph.version,
             nodes_input=nodes_input,
             user_id=user_id,
-            preset_id=preset_id,
         )
 
         starting_node_execs = []
@@ -971,7 +870,6 @@ class ExecutionManager(AppService):
         graph_exec = GraphExecutionEntry(
             user_id=user_id,
             graph_id=graph_id,
-            graph_version=graph_version or 0,
             graph_exec_id=graph_exec_id,
             start_node_execs=starting_node_execs,
         )
@@ -1067,13 +965,6 @@ def get_db_client() -> "DatabaseManager":
     return get_service_client(DatabaseManager)
 
 
-@thread_cached
-def get_notification_service() -> "NotificationManager":
-    from backend.notifications import NotificationManager
-
-    return get_service_client(NotificationManager)
-
-
 @contextmanager
 def synchronized(key: str, timeout: int = 60):
     lock: RedisLock = redis.get_redis().lock(f"lock:{key}", timeout=timeout)

autogpt_platform/backend/backend/executor/scheduler.py

@@ -1,23 +1,19 @@
 import logging
 import os
-from enum import Enum
 from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
 
 from apscheduler.events import EVENT_JOB_ERROR, EVENT_JOB_EXECUTED
 from apscheduler.job import Job as JobObj
-from apscheduler.jobstores.memory import MemoryJobStore
 from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
 from apscheduler.schedulers.blocking import BlockingScheduler
 from apscheduler.triggers.cron import CronTrigger
 from autogpt_libs.utils.cache import thread_cached
 from dotenv import load_dotenv
-from prisma.enums import NotificationType
 from pydantic import BaseModel
 from sqlalchemy import MetaData, create_engine
 
 from backend.data.block import BlockInput
 from backend.executor.manager import ExecutionManager
-from backend.notifications.notifications import NotificationManager
 from backend.util.service import AppService, expose, get_service_client
 from backend.util.settings import Config
 
@@ -46,7 +42,7 @@ config = Config()
 
 
 def log(msg, **kwargs):
-    logger.info("[Scheduler] " + msg, **kwargs)
+    logger.info("[ExecutionScheduler] " + msg, **kwargs)
 
 
 def job_listener(event):
@@ -62,15 +58,8 @@ def get_execution_client() -> ExecutionManager:
     return get_service_client(ExecutionManager)
 
 
-@thread_cached
-def get_notification_client():
-    from backend.notifications import NotificationManager
-
-    return get_service_client(NotificationManager)
-
-
 def execute_graph(**kwargs):
-    args = ExecutionJobArgs(**kwargs)
+    args = JobArgs(**kwargs)
     try:
         log(f"Executing recurring job for graph #{args.graph_id}")
         get_execution_client().add_execution(
@@ -83,32 +72,7 @@ def execute_graph(**kwargs):
         logger.exception(f"Error executing graph {args.graph_id}: {e}")
 
 
-def process_existing_batches(**kwargs):
-    args = NotificationJobArgs(**kwargs)
-    try:
-        log(
-            f"Processing existing batches for notification type {args.notification_types}"
-        )
-        get_notification_client().process_existing_batches(args.notification_types)
-    except Exception as e:
-        logger.exception(f"Error processing existing batches: {e}")
-
-
-def process_weekly_summary(**kwargs):
-    try:
-        log("Processing weekly summary")
-        get_notification_client().queue_weekly_summary()
-    except Exception as e:
-        logger.exception(f"Error processing weekly summary: {e}")
-
-
-class Jobstores(Enum):
-    EXECUTION = "execution"
-    BATCHED_NOTIFICATIONS = "batched_notifications"
-    WEEKLY_NOTIFICATIONS = "weekly_notifications"
-
-
-class ExecutionJobArgs(BaseModel):
+class JobArgs(BaseModel):
     graph_id: str
     input_data: BlockInput
     user_id: str
@@ -116,14 +80,14 @@ class ExecutionJobArgs(BaseModel):
     cron: str
 
 
-class ExecutionJobInfo(ExecutionJobArgs):
+class JobInfo(JobArgs):
     id: str
     name: str
     next_run_time: str
 
     @staticmethod
-    def from_db(job_args: ExecutionJobArgs, job_obj: JobObj) -> "ExecutionJobInfo":
-        return ExecutionJobInfo(
+    def from_db(job_args: JobArgs, job_obj: JobObj) -> "JobInfo":
+        return JobInfo(
             id=job_obj.id,
             name=job_obj.name,
             next_run_time=job_obj.next_run_time.isoformat(),
@@ -131,29 +95,7 @@ class ExecutionJobInfo(ExecutionJobArgs):
         )
 
 
-class NotificationJobArgs(BaseModel):
-    notification_types: list[NotificationType]
-    cron: str
-
-
-class NotificationJobInfo(NotificationJobArgs):
-    id: str
-    name: str
-    next_run_time: str
-
-    @staticmethod
-    def from_db(
-        job_args: NotificationJobArgs, job_obj: JobObj
-    ) -> "NotificationJobInfo":
-        return NotificationJobInfo(
-            id=job_obj.id,
-            name=job_obj.name,
-            next_run_time=job_obj.next_run_time.isoformat(),
-            **job_args.model_dump(),
-        )
-
-
-class Scheduler(AppService):
+class ExecutionScheduler(AppService):
     scheduler: BlockingScheduler
 
     @classmethod
@@ -169,38 +111,19 @@ class Scheduler(AppService):
     def execution_client(self) -> ExecutionManager:
         return get_service_client(ExecutionManager)
 
-    @property
-    @thread_cached
-    def notification_client(self) -> NotificationManager:
-        return get_service_client(NotificationManager)
-
     def run_service(self):
         load_dotenv()
         db_schema, db_url = _extract_schema_from_url(os.getenv("DATABASE_URL"))
         self.scheduler = BlockingScheduler(
             jobstores={
-                Jobstores.EXECUTION.value: SQLAlchemyJobStore(
+                "default": SQLAlchemyJobStore(
                     engine=create_engine(
                         url=db_url,
                         pool_size=self.db_pool_size(),
                         max_overflow=0,
                     ),
                     metadata=MetaData(schema=db_schema),
-                    # this one is pre-existing so it keeps the
-                    # default table name.
-                    tablename="apscheduler_jobs",
-                ),
-                Jobstores.BATCHED_NOTIFICATIONS.value: SQLAlchemyJobStore(
-                    engine=create_engine(
-                        url=db_url,
-                        pool_size=self.db_pool_size(),
-                        max_overflow=0,
-                    ),
-                    metadata=MetaData(schema=db_schema),
-                    tablename="apscheduler_jobs_batched_notifications",
-                ),
-                # These don't really need persistence
-                Jobstores.WEEKLY_NOTIFICATIONS.value: MemoryJobStore(),
+                )
             }
         )
         self.scheduler.add_listener(job_listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)
@@ -214,8 +137,8 @@ class Scheduler(AppService):
         cron: str,
         input_data: BlockInput,
         user_id: str,
-    ) -> ExecutionJobInfo:
-        job_args = ExecutionJobArgs(
+    ) -> JobInfo:
+        job_args = JobArgs(
             graph_id=graph_id,
             input_data=input_data,
             user_id=user_id,
@@ -227,80 +150,37 @@ class Scheduler(AppService):
             CronTrigger.from_crontab(cron),
             kwargs=job_args.model_dump(),
             replace_existing=True,
-            jobstore=Jobstores.EXECUTION.value,
         )
         log(f"Added job {job.id} with cron schedule '{cron}' input data: {input_data}")
-        return ExecutionJobInfo.from_db(job_args, job)
+        return JobInfo.from_db(job_args, job)
 
     @expose
-    def delete_schedule(self, schedule_id: str, user_id: str) -> ExecutionJobInfo:
-        job = self.scheduler.get_job(schedule_id, jobstore=Jobstores.EXECUTION.value)
+    def delete_schedule(self, schedule_id: str, user_id: str) -> JobInfo:
+        job = self.scheduler.get_job(schedule_id)
         if not job:
             log(f"Job {schedule_id} not found.")
             raise ValueError(f"Job #{schedule_id} not found.")
 
-        job_args = ExecutionJobArgs(**job.kwargs)
+        job_args = JobArgs(**job.kwargs)
         if job_args.user_id != user_id:
             raise ValueError("User ID does not match the job's user ID.")
 
         log(f"Deleting job {schedule_id}")
         job.remove()
 
-        return ExecutionJobInfo.from_db(job_args, job)
+        return JobInfo.from_db(job_args, job)
 
     @expose
     def get_execution_schedules(
         self, graph_id: str | None = None, user_id: str | None = None
-    ) -> list[ExecutionJobInfo]:
+    ) -> list[JobInfo]:
         schedules = []
-        for job in self.scheduler.get_jobs(jobstore=Jobstores.EXECUTION.value):
-            logger.info(
-                f"Found job {job.id} with cron schedule {job.trigger} and args {job.kwargs}"
-            )
-            job_args = ExecutionJobArgs(**job.kwargs)
+        for job in self.scheduler.get_jobs():
+            job_args = JobArgs(**job.kwargs)
             if (
                 job.next_run_time is not None
                 and (graph_id is None or job_args.graph_id == graph_id)
                 and (user_id is None or job_args.user_id == user_id)
             ):
-                schedules.append(ExecutionJobInfo.from_db(job_args, job))
+                schedules.append(JobInfo.from_db(job_args, job))
         return schedules
-
-    @expose
-    def add_batched_notification_schedule(
-        self,
-        notification_types: list[NotificationType],
-        data: dict,
-        cron: str,
-    ) -> NotificationJobInfo:
-        job_args = NotificationJobArgs(
-            notification_types=notification_types,
-            cron=cron,
-        )
-        job = self.scheduler.add_job(
-            process_existing_batches,
-            CronTrigger.from_crontab(cron),
-            kwargs=job_args.model_dump(),
-            replace_existing=True,
-            jobstore=Jobstores.BATCHED_NOTIFICATIONS.value,
-        )
-        log(f"Added job {job.id} with cron schedule '{cron}' input data: {data}")
-        return NotificationJobInfo.from_db(job_args, job)
-
-    @expose
-    def add_weekly_notification_schedule(self, cron: str) -> NotificationJobInfo:
-
-        job = self.scheduler.add_job(
-            process_weekly_summary,
-            CronTrigger.from_crontab(cron),
-            kwargs={},
-            replace_existing=True,
-            jobstore=Jobstores.WEEKLY_NOTIFICATIONS.value,
-        )
-        log(f"Added job {job.id} with cron schedule '{cron}'")
-        return NotificationJobInfo.from_db(
-            NotificationJobArgs(
-                cron=cron, notification_types=[NotificationType.WEEKLY_SUMMARY]
-            ),
-            job,
-        )

autogpt_platform/backend/backend/integrations/credentials_store.py

@@ -145,40 +145,8 @@ mem0_credentials = APIKeyCredentials(
     expires_at=None,
 )
 
-apollo_credentials = APIKeyCredentials(
-    id="544c62b5-1d0f-4156-8fb4-9525f11656eb",
-    provider="apollo",
-    api_key=SecretStr(settings.secrets.apollo_api_key),
-    title="Use Credits for Apollo",
-    expires_at=None,
-)
-
-smartlead_credentials = APIKeyCredentials(
-    id="3bcdbda3-84a3-46af-8fdb-bfd2472298b8",
-    provider="smartlead",
-    api_key=SecretStr(settings.secrets.smartlead_api_key),
-    title="Use Credits for SmartLead",
-    expires_at=None,
-)
-
-zerobounce_credentials = APIKeyCredentials(
-    id="63a6e279-2dc2-448e-bf57-85776f7176dc",
-    provider="zerobounce",
-    api_key=SecretStr(settings.secrets.zerobounce_api_key),
-    title="Use Credits for ZeroBounce",
-    expires_at=None,
-)
-
-example_credentials = APIKeyCredentials(
-    id="a2b7f68f-aa6a-4995-99ec-b45b40d33498",
-    provider="example-provider",
-    api_key=SecretStr(settings.secrets.example_api_key),
-    title="Use Credits for Example",
-    expires_at=None,
-)
 
 DEFAULT_CREDENTIALS = [
-    example_credentials,
     ollama_credentials,
     revid_credentials,
     ideogram_credentials,
@@ -196,9 +164,6 @@ DEFAULT_CREDENTIALS = [
     mem0_credentials,
     nvidia_credentials,
     screenshotone_credentials,
-    apollo_credentials,
-    smartlead_credentials,
-    zerobounce_credentials,
 ]
 
 
@@ -234,8 +199,6 @@ class IntegrationCredentialsStore:
         all_credentials.append(ollama_credentials)
 
         # These will only be added if the API key is set
-        if settings.secrets.example_api_key:
-            all_credentials.append(example_credentials)
         if settings.secrets.revid_api_key:
             all_credentials.append(revid_credentials)
         if settings.secrets.ideogram_api_key:
@@ -268,12 +231,6 @@ class IntegrationCredentialsStore:
             all_credentials.append(screenshotone_credentials)
         if settings.secrets.mem0_api_key:
             all_credentials.append(mem0_credentials)
-        if settings.secrets.apollo_api_key:
-            all_credentials.append(apollo_credentials)
-        if settings.secrets.smartlead_api_key:
-            all_credentials.append(smartlead_credentials)
-        if settings.secrets.zerobounce_api_key:
-            all_credentials.append(zerobounce_credentials)
         return all_credentials
 
     def get_creds_by_id(self, user_id: str, credentials_id: str) -> Credentials | None:

autogpt_platform/backend/backend/integrations/providers.py

@@ -4,13 +4,11 @@ from enum import Enum
 # --8<-- [start:ProviderName]
 class ProviderName(str, Enum):
     ANTHROPIC = "anthropic"
-    APOLLO = "apollo"
     COMPASS = "compass"
     DISCORD = "discord"
     D_ID = "d_id"
     E2B = "e2b"
     EXA = "exa"
-    EXAMPLE_PROVIDER = "example-provider"
     FAL = "fal"
     GITHUB = "github"
     GOOGLE = "google"
@@ -34,10 +32,8 @@ class ProviderName(str, Enum):
     REVID = "revid"
     SCREENSHOTONE = "screenshotone"
     SLANT3D = "slant3d"
-    SMARTLEAD = "smartlead"
     SMTP = "smtp"
     TWITTER = "twitter"
     TODOIST = "todoist"
     UNREAL_SPEECH = "unreal_speech"
-    ZEROBOUNCE = "zerobounce"
     # --8<-- [end:ProviderName]

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

@@ -1,7 +1,6 @@
 from typing import TYPE_CHECKING
 
 from .compass import CompassWebhookManager
-from .example import ExampleWebhookManager
 from .github import GithubWebhooksManager
 from .slant3d import Slant3DWebhooksManager
 
@@ -16,7 +15,6 @@ WEBHOOK_MANAGERS_BY_NAME: dict["ProviderName", type["BaseWebhooksManager"]] = {
         CompassWebhookManager,
         GithubWebhooksManager,
         Slant3DWebhooksManager,
-        ExampleWebhookManager,
     ]
 }
 # --8<-- [end:WEBHOOK_MANAGERS_BY_NAME]

autogpt_platform/backend/backend/integrations/webhooks/example.py

@@ -1,147 +0,0 @@
-import logging
-
-import requests
-from fastapi import Request
-from strenum import StrEnum
-
-from backend.data import integrations
-from backend.data.model import APIKeyCredentials, Credentials
-from backend.integrations.providers import ProviderName
-
-from ._manual_base import ManualWebhookManagerBase
-
-logger = logging.getLogger(__name__)
-
-
-class ExampleWebhookEventType(StrEnum):
-    EXAMPLE_EVENT = "example_event"
-    ANOTHER_EXAMPLE_EVENT = "another_example_event"
-
-
-# ExampleWebhookManager is a class that manages webhooks for a hypothetical provider.
-# It extends ManualWebhookManagerBase, which provides base functionality for manual webhook management.
-class ExampleWebhookManager(ManualWebhookManagerBase):
-    # Define the provider name for this webhook manager.
-    PROVIDER_NAME = ProviderName.EXAMPLE_PROVIDER
-    # Define the types of webhooks this manager can handle.
-    WebhookEventType = ExampleWebhookEventType
-
-    BASE_URL = "https://api.example.com"
-
-    @classmethod
-    async def validate_payload(
-        cls, webhook: integrations.Webhook, request: Request
-    ) -> tuple[dict, str]:
-        """
-        Validate the incoming webhook payload.
-
-        Args:
-            webhook (integrations.Webhook): The webhook object.
-            request (Request): The incoming request object.
-
-        Returns:
-            tuple: A tuple containing the payload as a dictionary and the event type as a string.
-        """
-        # Extract the JSON payload from the request.
-        payload = await request.json()
-        # Set the event type based on the webhook type in the payload.
-        event_type = payload.get("webhook_type", ExampleWebhookEventType.EXAMPLE_EVENT)
-
-        # For the payload its better to return a pydantic model
-        # rather than a weakly typed dict here
-        return payload, 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 a new webhook with the provider.
-
-        Args:
-            credentials (Credentials): The credentials required for authentication.
-            webhook_type (str): The type of webhook to register.
-            resource (str): The resource associated with the webhook.
-            events (list[str]): The list of events to subscribe to.
-            ingress_url (str): The URL where the webhook will send data.
-            secret (str): A secret for securing the webhook.
-
-        Returns:
-            tuple: A tuple containing the provider's webhook ID, if any, and the webhook configuration as a dictionary.
-        """
-        # Ensure the credentials are of the correct type.
-        if not isinstance(credentials, APIKeyCredentials):
-            raise ValueError("API key is required to register a webhook")
-
-        # Prepare the headers for the request, including the API key.
-        headers = {
-            "api-key": credentials.api_key.get_secret_value(),
-            "Content-Type": "application/json",
-        }
-
-        # Prepare the payload for the request. Note that the events list is not used.
-        # This is just a fake example
-        payload = {"endPoint": ingress_url}
-
-        # Send a POST request to register the webhook.
-        response = requests.post(
-            f"{self.BASE_URL}/example/webhookSubscribe", headers=headers, json=payload
-        )
-
-        # Check if the response indicates a failure.
-        if not response.ok:
-            error = response.json().get("error", "Unknown error")
-            raise RuntimeError(f"Failed to register webhook: {error}")
-
-        # Prepare the webhook configuration to return.
-        webhook_config = {
-            "endpoint": ingress_url,
-            "provider": self.PROVIDER_NAME,
-            "events": ["example_event"],
-            "type": webhook_type,
-        }
-
-        return "", webhook_config
-
-    async def _deregister_webhook(
-        self, webhook: integrations.Webhook, credentials: Credentials
-    ) -> None:
-        """
-        Deregister a webhook with the provider.
-
-        Args:
-            webhook (integrations.Webhook): The webhook object to deregister.
-            credentials (Credentials): The credentials associated with the webhook.
-
-        Raises:
-            ValueError: If the webhook doesn't belong to the credentials or if deregistration fails.
-        """
-        if webhook.credentials_id != credentials.id:
-            raise ValueError(
-                f"Webhook #{webhook.id} does not belong to credentials {credentials.id}"
-            )
-
-        if not isinstance(credentials, APIKeyCredentials):
-            raise ValueError("API key is required to deregister a webhook")
-
-        headers = {
-            "api-key": credentials.api_key.get_secret_value(),
-            "Content-Type": "application/json",
-        }
-
-        # Construct the delete URL based on the webhook information
-        delete_url = f"{self.BASE_URL}/example/webhooks/{webhook.provider_webhook_id}"
-
-        response = requests.delete(delete_url, headers=headers)
-
-        if response.status_code not in [204, 404]:
-            # 204 means successful deletion, 404 means the webhook was already deleted
-            error = response.json().get("error", "Unknown error")
-            raise ValueError(f"Failed to delete webhook: {error}")
-
-        # If we reach here, the webhook was successfully deleted or didn't exist

autogpt_platform/backend/backend/notifications/__init__.py

@@ -1,5 +0,0 @@
-from .notifications import NotificationManager
-
-__all__ = [
-    "NotificationManager",
-]

autogpt_platform/backend/backend/notifications/email.py

@@ -1,136 +0,0 @@
-import logging
-import pathlib
-
-from postmarker.core import PostmarkClient
-from postmarker.models.emails import EmailManager
-from prisma.enums import NotificationType
-from pydantic import BaseModel
-
-from backend.data.notifications import (
-    NotificationDataType_co,
-    NotificationEventModel,
-    NotificationTypeOverride,
-)
-from backend.util.settings import Settings
-from backend.util.text import TextFormatter
-
-logger = logging.getLogger(__name__)
-settings = Settings()
-
-
-# The following is a workaround to get the type checker to recognize the EmailManager type
-# This is a temporary solution and should be removed once the Postmark library is updated
-# to support type annotations.
-class TypedPostmarkClient(PostmarkClient):
-    emails: EmailManager
-
-
-class Template(BaseModel):
-    subject_template: str
-    body_template: str
-    base_template: str
-
-
-class EmailSender:
-    def __init__(self):
-        if settings.secrets.postmark_server_api_token:
-            self.postmark = TypedPostmarkClient(
-                server_token=settings.secrets.postmark_server_api_token
-            )
-        else:
-            logger.warning(
-                "Postmark server API token not found, email sending disabled"
-            )
-            self.postmark = None
-        self.formatter = TextFormatter()
-
-    def send_templated(
-        self,
-        notification: NotificationType,
-        user_email: str,
-        data: (
-            NotificationEventModel[NotificationDataType_co]
-            | list[NotificationEventModel[NotificationDataType_co]]
-        ),
-        user_unsub_link: str | None = None,
-    ):
-        """Send an email to a user using a template pulled from the notification type"""
-        if not self.postmark:
-            logger.warning("Postmark client not initialized, email not sent")
-            return
-        template = self._get_template(notification)
-
-        base_url = (
-            settings.config.frontend_base_url or settings.config.platform_base_url
-        )
-
-        # Handle the case when data is a list
-        template_data = data
-        if isinstance(data, list):
-            # Create a dictionary with a 'notifications' key containing the list
-            template_data = {"notifications": data}
-
-        try:
-            subject, full_message = self.formatter.format_email(
-                base_template=template.base_template,
-                subject_template=template.subject_template,
-                content_template=template.body_template,
-                data=template_data,
-                unsubscribe_link=f"{base_url}/profile/settings",
-            )
-        except Exception as e:
-            logger.error(f"Error formatting full message: {e}")
-            raise e
-
-        self._send_email(
-            user_email=user_email,
-            user_unsubscribe_link=user_unsub_link,
-            subject=subject,
-            body=full_message,
-        )
-
-    def _get_template(self, notification: NotificationType):
-        # convert the notification type to a notification type override
-        notification_type_override = NotificationTypeOverride(notification)
-        # find the template in templates/name.html (the .template returns with the .html)
-        template_path = f"templates/{notification_type_override.template}.jinja2"
-        logger.debug(
-            f"Template full path: {pathlib.Path(__file__).parent / template_path}"
-        )
-        base_template_path = "templates/base.html.jinja2"
-        with open(pathlib.Path(__file__).parent / base_template_path, "r") as file:
-            base_template = file.read()
-        with open(pathlib.Path(__file__).parent / template_path, "r") as file:
-            template = file.read()
-        return Template(
-            subject_template=notification_type_override.subject,
-            body_template=template,
-            base_template=base_template,
-        )
-
-    def _send_email(
-        self,
-        user_email: str,
-        subject: str,
-        body: str,
-        user_unsubscribe_link: str | None = None,
-    ):
-        if not self.postmark:
-            logger.warning("Email tried to send without postmark configured")
-            return
-        logger.debug(f"Sending email to {user_email} with subject {subject}")
-        self.postmark.emails.send(
-            From=settings.config.postmark_sender_email,
-            To=user_email,
-            Subject=subject,
-            HtmlBody=body,
-            # Headers default to None internally so this is fine
-            Headers=(
-                {
-                    "List-Unsubscribe-Post": "List-Unsubscribe=One-Click",
-                    "List-Unsubscribe": f"<{user_unsubscribe_link}>",
-                }
-                if user_unsubscribe_link
-                else None
-            ),
-        )

autogpt_platform/backend/backend/notifications/notifications.py

@@ -1,747 +0,0 @@
-import logging
-import time
-from datetime import datetime, timedelta, timezone
-from typing import Callable
-
-import aio_pika
-from aio_pika.exceptions import QueueEmpty
-from autogpt_libs.utils.cache import thread_cached
-from prisma.enums import NotificationType
-from pydantic import BaseModel
-
-from backend.data.notifications import (
-    BaseSummaryData,
-    BaseSummaryParams,
-    DailySummaryData,
-    DailySummaryParams,
-    NotificationEventDTO,
-    NotificationEventModel,
-    NotificationResult,
-    NotificationTypeOverride,
-    QueueType,
-    SummaryParamsEventDTO,
-    SummaryParamsEventModel,
-    WeeklySummaryData,
-    WeeklySummaryParams,
-    get_batch_delay,
-    get_notif_data_type,
-    get_summary_params_type,
-)
-from backend.data.rabbitmq import Exchange, ExchangeType, Queue, RabbitMQConfig
-from backend.data.user import generate_unsubscribe_link
-from backend.notifications.email import EmailSender
-from backend.util.service import AppService, expose, get_service_client
-from backend.util.settings import Settings
-
-logger = logging.getLogger(__name__)
-settings = Settings()
-
-
-class NotificationEvent(BaseModel):
-    event: NotificationEventDTO
-    model: NotificationEventModel
-
-
-def create_notification_config() -> RabbitMQConfig:
-    """Create RabbitMQ configuration for notifications"""
-    notification_exchange = Exchange(name="notifications", type=ExchangeType.TOPIC)
-
-    dead_letter_exchange = Exchange(name="dead_letter", type=ExchangeType.TOPIC)
-
-    queues = [
-        # Main notification queues
-        Queue(
-            name="immediate_notifications",
-            exchange=notification_exchange,
-            routing_key="notification.immediate.#",
-            arguments={
-                "x-dead-letter-exchange": dead_letter_exchange.name,
-                "x-dead-letter-routing-key": "failed.immediate",
-            },
-        ),
-        Queue(
-            name="admin_notifications",
-            exchange=notification_exchange,
-            routing_key="notification.admin.#",
-            arguments={
-                "x-dead-letter-exchange": dead_letter_exchange.name,
-                "x-dead-letter-routing-key": "failed.admin",
-            },
-        ),
-        # Summary notification queues
-        Queue(
-            name="summary_notifications",
-            exchange=notification_exchange,
-            routing_key="notification.summary.#",
-            arguments={
-                "x-dead-letter-exchange": dead_letter_exchange.name,
-                "x-dead-letter-routing-key": "failed.summary",
-            },
-        ),
-        # Batch Queue
-        Queue(
-            name="batch_notifications",
-            exchange=notification_exchange,
-            routing_key="notification.batch.#",
-            arguments={
-                "x-dead-letter-exchange": dead_letter_exchange.name,
-                "x-dead-letter-routing-key": "failed.batch",
-            },
-        ),
-        # Failed notifications queue
-        Queue(
-            name="failed_notifications",
-            exchange=dead_letter_exchange,
-            routing_key="failed.#",
-        ),
-    ]
-
-    return RabbitMQConfig(
-        exchanges=[
-            notification_exchange,
-            dead_letter_exchange,
-        ],
-        queues=queues,
-    )
-
-
-@thread_cached
-def get_scheduler():
-    from backend.executor import Scheduler
-
-    return get_service_client(Scheduler)
-
-
-@thread_cached
-def get_db():
-    from backend.executor.database import DatabaseManager
-
-    return get_service_client(DatabaseManager)
-
-
-class NotificationManager(AppService):
-    """Service for handling notifications with batching support"""
-
-    def __init__(self):
-        super().__init__()
-        self.rabbitmq_config = create_notification_config()
-        self.running = True
-        self.email_sender = EmailSender()
-
-    @classmethod
-    def get_port(cls) -> int:
-        return settings.config.notification_service_port
-
-    def get_routing_key(self, event_type: NotificationType) -> str:
-        strategy = NotificationTypeOverride(event_type).strategy
-        """Get the appropriate routing key for an event"""
-        if strategy == QueueType.IMMEDIATE:
-            return f"notification.immediate.{event_type.value}"
-        elif strategy == QueueType.BACKOFF:
-            return f"notification.backoff.{event_type.value}"
-        elif strategy == QueueType.ADMIN:
-            return f"notification.admin.{event_type.value}"
-        elif strategy == QueueType.BATCH:
-            return f"notification.batch.{event_type.value}"
-        elif strategy == QueueType.SUMMARY:
-            return f"notification.summary.{event_type.value}"
-        return f"notification.{event_type.value}"
-
-    @expose
-    def queue_weekly_summary(self):
-        """Process weekly summary for specified notification types"""
-        try:
-            logger.info("Processing weekly summary queuing operation")
-            processed_count = 0
-            current_time = datetime.now(tz=timezone.utc)
-            start_time = current_time - timedelta(days=7)
-            users = get_db().get_active_user_ids_in_timerange(
-                end_time=current_time.isoformat(),
-                start_time=start_time.isoformat(),
-            )
-            for user in users:
-
-                self._queue_scheduled_notification(
-                    SummaryParamsEventDTO(
-                        user_id=user,
-                        type=NotificationType.WEEKLY_SUMMARY,
-                        data=WeeklySummaryParams(
-                            start_date=start_time,
-                            end_date=current_time,
-                        ).model_dump(),
-                    ),
-                )
-                processed_count += 1
-
-            logger.info(f"Processed {processed_count} weekly summaries into queue")
-
-        except Exception as e:
-            logger.exception(f"Error processing weekly summary: {e}")
-
-    @expose
-    def process_existing_batches(self, notification_types: list[NotificationType]):
-        """Process existing batches for specified notification types"""
-        try:
-            processed_count = 0
-            current_time = datetime.now(tz=timezone.utc)
-
-            for notification_type in notification_types:
-                # Get all batches for this notification type
-                batches = get_db().get_all_batches_by_type(notification_type)
-
-                for batch in batches:
-                    # Check if batch has aged out
-                    oldest_message = (
-                        get_db().get_user_notification_oldest_message_in_batch(
-                            batch.user_id, notification_type
-                        )
-                    )
-
-                    if not oldest_message:
-                        # this should never happen
-                        logger.error(
-                            f"Batch for user {batch.user_id} and type {notification_type} has no oldest message whichshould never happen!!!!!!!!!!!!!!!!"
-                        )
-                        continue
-
-                    max_delay = get_batch_delay(notification_type)
-
-                    # If batch has aged out, process it
-                    if oldest_message.created_at + max_delay < current_time:
-                        recipient_email = get_db().get_user_email_by_id(batch.user_id)
-
-                        if not recipient_email:
-                            logger.error(
-                                f"User email not found for user {batch.user_id}"
-                            )
-                            continue
-
-                        should_send = self._should_email_user_based_on_preference(
-                            batch.user_id, notification_type
-                        )
-
-                        if not should_send:
-                            logger.debug(
-                                f"User {batch.user_id} does not want to receive {notification_type} notifications"
-                            )
-                            # Clear the batch
-                            get_db().empty_user_notification_batch(
-                                batch.user_id, notification_type
-                            )
-                            continue
-
-                        batch_data = get_db().get_user_notification_batch(
-                            batch.user_id, notification_type
-                        )
-
-                        if not batch_data or not batch_data.notifications:
-                            logger.error(
-                                f"Batch data not found for user {batch.user_id}"
-                            )
-                            # Clear the batch
-                            get_db().empty_user_notification_batch(
-                                batch.user_id, notification_type
-                            )
-                            continue
-
-                        unsub_link = generate_unsubscribe_link(batch.user_id)
-
-                        events = [
-                            NotificationEventModel[
-                                get_notif_data_type(db_event.type)
-                            ].model_validate(
-                                {
-                                    "user_id": batch.user_id,
-                                    "type": db_event.type,
-                                    "data": db_event.data,
-                                    "created_at": db_event.created_at,
-                                }
-                            )
-                            for db_event in batch_data.notifications
-                        ]
-                        logger.info(f"{events=}")
-
-                        self.email_sender.send_templated(
-                            notification=notification_type,
-                            user_email=recipient_email,
-                            data=events,
-                            user_unsub_link=unsub_link,
-                        )
-
-                        # Clear the batch
-                        get_db().empty_user_notification_batch(
-                            batch.user_id, notification_type
-                        )
-
-                        processed_count += 1
-
-            logger.info(f"Processed {processed_count} aged batches")
-            return {
-                "success": True,
-                "processed_count": processed_count,
-                "notification_types": [nt.value for nt in notification_types],
-                "timestamp": current_time.isoformat(),
-            }
-
-        except Exception as e:
-            logger.exception(f"Error processing batches: {e}")
-            return {
-                "success": False,
-                "error": str(e),
-                "notification_types": [nt.value for nt in notification_types],
-                "timestamp": datetime.now(tz=timezone.utc).isoformat(),
-            }
-
-    @expose
-    def queue_notification(self, event: NotificationEventDTO) -> NotificationResult:
-        """Queue a notification - exposed method for other services to call"""
-        try:
-            logger.info(f"Received Request to queue {event=}")
-            # Workaround for not being able to serialize generics over the expose bus
-            parsed_event = NotificationEventModel[
-                get_notif_data_type(event.type)
-            ].model_validate(event.model_dump())
-            routing_key = self.get_routing_key(parsed_event.type)
-            message = parsed_event.model_dump_json()
-
-            logger.info(f"Received Request to queue {message=}")
-
-            exchange = "notifications"
-
-            # Publish to RabbitMQ
-            self.run_and_wait(
-                self.rabbit.publish_message(
-                    routing_key=routing_key,
-                    message=message,
-                    exchange=next(
-                        ex for ex in self.rabbit_config.exchanges if ex.name == exchange
-                    ),
-                )
-            )
-
-            return NotificationResult(
-                success=True,
-                message=f"Notification queued with routing key: {routing_key}",
-            )
-
-        except Exception as e:
-            logger.exception(f"Error queueing notification: {e}")
-            return NotificationResult(success=False, message=str(e))
-
-    def _queue_scheduled_notification(self, event: SummaryParamsEventDTO):
-        """Queue a scheduled notification - exposed method for other services to call"""
-        try:
-            logger.info(f"Received Request to queue scheduled notification {event=}")
-
-            parsed_event = SummaryParamsEventModel[
-                get_summary_params_type(event.type)
-            ].model_validate(event.model_dump())
-
-            routing_key = self.get_routing_key(event.type)
-            message = parsed_event.model_dump_json()
-
-            logger.info(f"Received Request to queue {message=}")
-
-            exchange = "notifications"
-
-            # Publish to RabbitMQ
-            self.run_and_wait(
-                self.rabbit.publish_message(
-                    routing_key=routing_key,
-                    message=message,
-                    exchange=next(
-                        ex for ex in self.rabbit_config.exchanges if ex.name == exchange
-                    ),
-                )
-            )
-
-        except Exception as e:
-            logger.exception(f"Error queueing notification: {e}")
-
-    def _should_email_user_based_on_preference(
-        self, user_id: str, event_type: NotificationType
-    ) -> bool:
-        """Check if a user wants to receive a notification based on their preferences and email verification status"""
-        validated_email = get_db().get_user_email_verification(user_id)
-        preference = (
-            get_db()
-            .get_user_notification_preference(user_id)
-            .preferences.get(event_type, True)
-        )
-        # only if both are true, should we email this person
-        return validated_email and preference
-
-    def _gather_summary_data(
-        self, user_id: str, event_type: NotificationType, params: BaseSummaryParams
-    ) -> BaseSummaryData:
-        """Gathers the data to build a summary notification"""
-
-        logger.info(
-            f"Gathering summary data for {user_id} and {event_type} wiht {params=}"
-        )
-
-        # total_credits_used = self.run_and_wait(
-        #     get_total_credits_used(user_id, start_time, end_time)
-        # )
-
-        # total_executions = self.run_and_wait(
-        #     get_total_executions(user_id, start_time, end_time)
-        # )
-
-        # most_used_agent = self.run_and_wait(
-        #     get_most_used_agent(user_id, start_time, end_time)
-        # )
-
-        # execution_times = self.run_and_wait(
-        #     get_execution_time(user_id, start_time, end_time)
-        # )
-
-        # runs = self.run_and_wait(
-        #     get_runs(user_id, start_time, end_time)
-        # )
-        total_credits_used = 3.0
-        total_executions = 2
-        most_used_agent = {"name": "Some"}
-        execution_times = [1, 2, 3]
-        runs = [{"status": "COMPLETED"}, {"status": "FAILED"}]
-
-        successful_runs = len([run for run in runs if run["status"] == "COMPLETED"])
-        failed_runs = len([run for run in runs if run["status"] != "COMPLETED"])
-        average_execution_time = (
-            sum(execution_times) / len(execution_times) if execution_times else 0
-        )
-        # cost_breakdown = self.run_and_wait(
-        #     get_cost_breakdown(user_id, start_time, end_time)
-        # )
-
-        cost_breakdown = {
-            "agent1": 1.0,
-            "agent2": 2.0,
-        }
-
-        if event_type == NotificationType.DAILY_SUMMARY and isinstance(
-            params, DailySummaryParams
-        ):
-            return DailySummaryData(
-                total_credits_used=total_credits_used,
-                total_executions=total_executions,
-                most_used_agent=most_used_agent["name"],
-                total_execution_time=sum(execution_times),
-                successful_runs=successful_runs,
-                failed_runs=failed_runs,
-                average_execution_time=average_execution_time,
-                cost_breakdown=cost_breakdown,
-                date=params.date,
-            )
-        elif event_type == NotificationType.WEEKLY_SUMMARY and isinstance(
-            params, WeeklySummaryParams
-        ):
-            return WeeklySummaryData(
-                total_credits_used=total_credits_used,
-                total_executions=total_executions,
-                most_used_agent=most_used_agent["name"],
-                total_execution_time=sum(execution_times),
-                successful_runs=successful_runs,
-                failed_runs=failed_runs,
-                average_execution_time=average_execution_time,
-                cost_breakdown=cost_breakdown,
-                start_date=params.start_date,
-                end_date=params.end_date,
-            )
-        else:
-            raise ValueError("Invalid event type or params")
-
-    def _should_batch(
-        self, user_id: str, event_type: NotificationType, event: NotificationEventModel
-    ) -> bool:
-
-        get_db().create_or_add_to_user_notification_batch(user_id, event_type, event)
-
-        oldest_message = get_db().get_user_notification_oldest_message_in_batch(
-            user_id, event_type
-        )
-        if not oldest_message:
-            logger.error(
-                f"Batch for user {user_id} and type {event_type} has no oldest message whichshould never happen!!!!!!!!!!!!!!!!"
-            )
-            return False
-        oldest_age = oldest_message.created_at
-
-        max_delay = get_batch_delay(event_type)
-
-        if oldest_age + max_delay < datetime.now(tz=timezone.utc):
-            logger.info(f"Batch for user {user_id} and type {event_type} is old enough")
-            return True
-        logger.info(
-            f"Batch for user {user_id} and type {event_type} is not old enough: {oldest_age + max_delay} < {datetime.now(tz=timezone.utc)} max_delay={max_delay}"
-        )
-        return False
-
-    def _parse_message(self, message: str) -> NotificationEvent | None:
-        try:
-            event = NotificationEventDTO.model_validate_json(message)
-            model = NotificationEventModel[
-                get_notif_data_type(event.type)
-            ].model_validate_json(message)
-            return NotificationEvent(event=event, model=model)
-        except Exception as e:
-            logger.error(f"Error parsing message due to non matching schema {e}")
-            return None
-
-    def _process_admin_message(self, message: str) -> bool:
-        """Process a single notification, sending to an admin, returning whether to put into the failed queue"""
-        try:
-            parsed = self._parse_message(message)
-            if not parsed:
-                return False
-            event = parsed.event
-            model = parsed.model
-            logger.debug(f"Processing notification for admin: {model}")
-            recipient_email = settings.config.refund_notification_email
-            self.email_sender.send_templated(event.type, recipient_email, model)
-            return True
-        except Exception as e:
-            logger.exception(f"Error processing notification for admin queue: {e}")
-            return False
-
-    def _process_immediate(self, message: str) -> bool:
-        """Process a single notification immediately, returning whether to put into the failed queue"""
-        try:
-            parsed = self._parse_message(message)
-            if not parsed:
-                return False
-            event = parsed.event
-            model = parsed.model
-            logger.debug(f"Processing immediate notification: {model}")
-
-            recipient_email = get_db().get_user_email_by_id(event.user_id)
-            if not recipient_email:
-                logger.error(f"User email not found for user {event.user_id}")
-                return False
-
-            should_send = self._should_email_user_based_on_preference(
-                event.user_id, event.type
-            )
-            if not should_send:
-                logger.debug(
-                    f"User {event.user_id} does not want to receive {event.type} notifications"
-                )
-                return True
-
-            unsub_link = generate_unsubscribe_link(event.user_id)
-
-            self.email_sender.send_templated(
-                notification=event.type,
-                user_email=recipient_email,
-                data=model,
-                user_unsub_link=unsub_link,
-            )
-            return True
-        except Exception as e:
-            logger.exception(f"Error processing notification for immediate queue: {e}")
-            return False
-
-    def _process_batch(self, message: str) -> bool:
-        """Process a single notification with a batching strategy, returning whether to put into the failed queue"""
-        try:
-            parsed = self._parse_message(message)
-            if not parsed:
-                return False
-            event = parsed.event
-            model = parsed.model
-            logger.info(f"Processing batch notification: {model}")
-
-            recipient_email = get_db().get_user_email_by_id(event.user_id)
-            if not recipient_email:
-                logger.error(f"User email not found for user {event.user_id}")
-                return False
-
-            should_send = self._should_email_user_based_on_preference(
-                event.user_id, event.type
-            )
-            if not should_send:
-                logger.info(
-                    f"User {event.user_id} does not want to receive {event.type} notifications"
-                )
-                return True
-
-            should_send = self._should_batch(event.user_id, event.type, model)
-
-            if not should_send:
-                logger.info("Batch not old enough to send")
-                return False
-            batch = get_db().get_user_notification_batch(event.user_id, event.type)
-            if not batch or not batch.notifications:
-                logger.error(f"Batch not found for user {event.user_id}")
-                return False
-            unsub_link = generate_unsubscribe_link(event.user_id)
-
-            batch_messages = [
-                NotificationEventModel[
-                    get_notif_data_type(db_event.type)
-                ].model_validate(
-                    {
-                        "user_id": event.user_id,
-                        "type": db_event.type,
-                        "data": db_event.data,
-                        "created_at": db_event.created_at,
-                    }
-                )
-                for db_event in batch.notifications
-            ]
-
-            self.email_sender.send_templated(
-                notification=event.type,
-                user_email=recipient_email,
-                data=batch_messages,
-                user_unsub_link=unsub_link,
-            )
-            # only empty the batch if we sent the email successfully
-            get_db().empty_user_notification_batch(event.user_id, event.type)
-            return True
-        except Exception as e:
-            logger.exception(f"Error processing notification for batch queue: {e}")
-            return False
-
-    def _process_summary(self, message: str) -> bool:
-        """Process a single notification with a summary strategy, returning whether to put into the failed queue"""
-        try:
-            logger.info(f"Processing summary notification: {message}")
-            event = SummaryParamsEventDTO.model_validate_json(message)
-            model = SummaryParamsEventModel[
-                get_summary_params_type(event.type)
-            ].model_validate_json(message)
-
-            logger.info(f"Processing summary notification: {model}")
-
-            recipient_email = get_db().get_user_email_by_id(event.user_id)
-            if not recipient_email:
-                logger.error(f"User email not found for user {event.user_id}")
-                return False
-            should_send = self._should_email_user_based_on_preference(
-                event.user_id, event.type
-            )
-            if not should_send:
-                logger.info(
-                    f"User {event.user_id} does not want to receive {event.type} notifications"
-                )
-                return True
-
-            summary_data = self._gather_summary_data(
-                event.user_id, event.type, model.data
-            )
-
-            unsub_link = generate_unsubscribe_link(event.user_id)
-
-            data = NotificationEventModel(
-                user_id=event.user_id,
-                type=event.type,
-                data=summary_data,
-            )
-
-            self.email_sender.send_templated(
-                notification=event.type,
-                user_email=recipient_email,
-                data=data,
-                user_unsub_link=unsub_link,
-            )
-            return True
-        except Exception as e:
-            logger.exception(f"Error processing notification for summary queue: {e}")
-            return False
-
-    def _run_queue(
-        self,
-        queue: aio_pika.abc.AbstractQueue,
-        process_func: Callable[[str], bool],
-        error_queue_name: str,
-    ):
-        message: aio_pika.abc.AbstractMessage | None = None
-        try:
-            # This parameter "no_ack" is named like shit, think of it as "auto_ack"
-            message = self.run_and_wait(queue.get(timeout=1.0, no_ack=False))
-            result = process_func(message.body.decode())
-            if result:
-                self.run_and_wait(message.ack())
-            else:
-                self.run_and_wait(message.reject(requeue=False))
-
-        except QueueEmpty:
-            logger.debug(f"Queue {error_queue_name} empty")
-        except Exception as e:
-            if message:
-                logger.error(
-                    f"Error in notification service loop, message rejected {e}"
-                )
-                self.run_and_wait(message.reject(requeue=False))
-            else:
-                logger.error(
-                    f"Error in notification service loop, message unable to be rejected, and will have to be manually removed to free space in the queue: {e}"
-                )
-
-    def run_service(self):
-        logger.info(f"[{self.service_name}] Started notification service")
-
-        # Set up scheduler for batch processing of all notification types
-        # this can be changed later to spawn differnt cleanups on different schedules
-        try:
-            get_scheduler().add_batched_notification_schedule(
-                notification_types=list(NotificationType),
-                data={},
-                cron="0 * * * *",
-            )
-            # get_scheduler().add_weekly_notification_schedule(
-            #     # weekly on Friday at 12pm
-            #     cron="0 12 * * 5",
-            # )
-            logger.info("Scheduled notification cleanup")
-        except Exception as e:
-            logger.error(f"Error scheduling notification cleanup: {e}")
-
-        # Set up queue consumers
-        channel = self.run_and_wait(self.rabbit.get_channel())
-
-        immediate_queue = self.run_and_wait(
-            channel.get_queue("immediate_notifications")
-        )
-        batch_queue = self.run_and_wait(channel.get_queue("batch_notifications"))
-
-        admin_queue = self.run_and_wait(channel.get_queue("admin_notifications"))
-
-        summary_queue = self.run_and_wait(channel.get_queue("summary_notifications"))
-
-        while self.running:
-            try:
-                self._run_queue(
-                    queue=immediate_queue,
-                    process_func=self._process_immediate,
-                    error_queue_name="immediate_notifications",
-                )
-                self._run_queue(
-                    queue=admin_queue,
-                    process_func=self._process_admin_message,
-                    error_queue_name="admin_notifications",
-                )
-                self._run_queue(
-                    queue=batch_queue,
-                    process_func=self._process_batch,
-                    error_queue_name="batch_notifications",
-                )
-
-                self._run_queue(
-                    queue=summary_queue,
-                    process_func=self._process_summary,
-                    error_queue_name="summary_notifications",
-                )
-
-                time.sleep(0.1)
-
-            except QueueEmpty as e:
-                logger.debug(f"Queue empty: {e}")
-            except Exception as e:
-                logger.error(f"Error in notification service loop: {e}")
-
-    def cleanup(self):
-        """Cleanup service resources"""
-        self.running = False
-        super().cleanup()

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

@@ -1,142 +0,0 @@
-{# Agent Run #}
-{# Template variables:
-notification.data: the stuff below but a list of them
-data.agent_name: the name of the agent
-data.credits_used: the number of credits used by the agent
-data.node_count: the number of nodes the agent ran on
-data.execution_time: the time it took to run the agent
-data.graph_id: the id of the graph the agent ran on
-data.outputs: the list of outputs of the agent
-#}
-{% if notifications is defined %}
-  {# BATCH MODE #}
-  <div style="font-family: 'Poppins', sans-serif; color: #070629;">
-    <h2 style="color: #5D23BB; margin-bottom: 15px;">Agent Run Summary</h2>
-    <p style="font-size: 16px; line-height: 165%; margin-top: 0; margin-bottom: 15px;">
-      <strong>{{ notifications|length }}</strong> agent runs have completed!
-    </p>
-    
-    {# Calculate summary stats #}
-    {% set total_time = 0 %}
-    {% set total_nodes = 0 %}
-    {% set total_credits = 0 %}
-    {% set agent_names = [] %}
-    
-    {% for notification in notifications %}
-      {% set total_time = total_time + notification.data.execution_time %}
-      {% set total_nodes = total_nodes + notification.data.node_count %}
-      {% set total_credits = total_credits + notification.data.credits_used %}
-      {% if notification.data.agent_name not in agent_names %}
-        {% set agent_names = agent_names + [notification.data.agent_name] %}
-      {% endif %}
-    {% endfor %}
-    
-    <div style="background-color: #f8f7ff; border-radius: 8px; padding: 15px; margin-bottom: 25px;">
-      <h3 style="margin-top: 0; margin-bottom: 10px; color: #5D23BB;">Summary</h3>
-      <p style="margin: 5px 0;"><strong>Agents:</strong> {{ agent_names|join(", ") }}</p>
-      <p style="margin: 5px 0;"><strong>Total Time:</strong> {{ total_time | int }} seconds</p>
-      <p style="margin: 5px 0;"><strong>Total Nodes:</strong> {{ total_nodes }}</p>
-      <p style="margin: 5px 0;"><strong>Total Cost:</strong> ${{ "{:.2f}".format((total_credits|float)/100) }}</p>
-    </div>
-    
-    <h3 style="margin-top: 25px; margin-bottom: 15px; color: #5D23BB;">Individual Runs</h3>
-    
-    {% for notification in notifications %}
-      <div style="margin-bottom: 30px; border-left: 3px solid #5D23BB; padding-left: 15px;">
-        <p style="font-size: 16px; font-weight: 600; margin-top: 0; margin-bottom: 10px;">
-          Agent: <strong>{{ notification.data.agent_name }}</strong>
-        </p>
-        
-        <div style="margin-left: 10px;">
-          <p style="margin: 5px 0;"><strong>Time:</strong> {{ notification.data.execution_time | int }} seconds</p>
-          <p style="margin: 5px 0;"><strong>Nodes:</strong> {{ notification.data.node_count }}</p>
-          <p style="margin: 5px 0;"><strong>Cost:</strong> ${{ "{:.2f}".format((notification.data.credits_used|float)/100) }}</p>
-        </div>
-        
-        {% if notification.data.outputs and notification.data.outputs|length > 0 %}
-        <div style="margin-left: 10px; margin-top: 15px;">
-          <p style="font-weight: 600; margin-bottom: 10px;">Results:</p>
-          
-          {% for output in notification.data.outputs %}
-          <div style="margin-left: 10px; margin-bottom: 12px;">
-            <p style="color: #5D23BB; font-weight: 500; margin-top: 0; margin-bottom: 5px;">
-              {{ output.name }}
-            </p>
-            
-            {% for key, value in output.items() %}
-              {% if key != 'name' %}
-              <div style="margin-left: 10px; background-color: #f5f5ff; padding: 8px 12px; border-radius: 4px; 
-                          font-family: 'Roboto Mono', monospace; white-space: pre-wrap; word-break: break-word; 
-                          overflow-wrap: break-word; max-width: 100%; overflow-x: auto; margin-top: 3px; 
-                          margin-bottom: 8px; line-height: 1.4;">
-              {% if value is iterable and value is not string %}
-                {% if value|length == 1 %}
-                  {{ value[0] }}
-                {% else %}
-                  [{% for item in value %}{{ item }}{% if not loop.last %}, {% endif %}{% endfor %}]
-                {% endif %}
-              {% else %}
-                {{ value }}
-              {% endif %}
-              </div>
-              {% endif %}
-            {% endfor %}
-          </div>
-          {% endfor %}
-        </div>
-        {% endif %}
-      </div>
-    {% endfor %}
-  </div>
-
-{% else %}
-  {# SINGLE NOTIFICATION MODE - Original template #}
-  <p style="font-family: 'Poppins', sans-serif; color: #070629; font-size: 16px; line-height: 165%; 
-            margin-top: 0; margin-bottom: 10px;">
-    Your agent, <strong>{{ data.agent_name }}</strong>, has completed its run!
-  </p>
-  
-  <p style="font-family: 'Poppins', sans-serif; color: #070629; font-size: 16px; line-height: 165%; 
-            margin-top: 0; margin-bottom: 20px; padding-left: 20px;">
-    <p style="margin-bottom: 10px;"><strong>Time Taken:</strong> {{ data.execution_time | int }} seconds</p>
-    <p style="margin-bottom: 10px;"><strong>Nodes Used:</strong> {{ data.node_count }}</p>
-    <p style="margin-bottom: 10px;"><strong>Cost:</strong> ${{ "{:.2f}".format((data.credits_used|float)/100) }}</p>
-  </p>
-  
-  {% if data.outputs and data.outputs|length > 0 %}
-  <div style="margin-left: 15px; margin-bottom: 20px;">
-    <p style="font-family: 'Poppins', sans-serif; color: #070629; font-weight: 600; 
-              font-size: 16px; margin-bottom: 10px;">
-      Results:
-    </p>
-  
-    {% for output in data.outputs %}
-    <div style="margin-left: 15px; margin-bottom: 15px;">
-      <p style="font-family: 'Poppins', sans-serif; color: #5D23BB; font-weight: 500; 
-                font-size: 16px; margin-top: 0; margin-bottom: 8px;">
-        {{ output.name }}
-      </p>
-      
-      {% for key, value in output.items() %}
-        {% if key != 'name' %}
-        <div style="margin-left: 15px; background-color: #f5f5ff; padding: 8px 12px; border-radius: 4px; 
-                    font-family: 'Roboto Mono', monospace; white-space: pre-wrap; word-break: break-word; 
-                    overflow-wrap: break-word; max-width: 100%; overflow-x: auto; margin-top: 5px; 
-                    margin-bottom: 10px; line-height: 1.4;">
-        {% if value is iterable and value is not string %}
-          {% if value|length == 1 %}
-            {{ value[0] }}
-          {% else %}
-            [{% for item in value %}{{ item }}{% if not loop.last %}, {% endif %}{% endfor %}]
-          {% endif %}
-        {% else %}
-          {{ value }}
-        {% endif %}
-        </div>
-        {% endif %}
-      {% endfor %}
-    </div>
-    {% endfor %}
-  </div>
-  {% endif %}
-{% endif %}

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

@@ -1,343 +0,0 @@
-{# Base Template #}
-{# Template variables:
-    data.message: the message to display in the email
-    data.title: the title of the email
-    data.unsubscribe_link: the link to unsubscribe from the email
-#}
-<!doctype html>
-<html lang="ltr" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office">
-
-<head>
-  <meta charset="utf-8">
-  <meta http-equiv="X-UA-Compatible" content="IE=edge">
-  <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=yes">
-  <meta name="format-detection" content="telephone=no, date=no, address=no, email=no, url=no">
-  <meta name="x-apple-disable-message-reformatting">
-  <!--[if !mso]>
-    <meta http-equiv="X-UA-Compatible" content="IE=edge">
-    <![endif]-->
-  <!--[if mso]>
-    <style>
-        * { font-family: sans-serif !important; }
-    </style>
-    <noscript>
-        <xml>
-            <o:OfficeDocumentSettings>
-                <o:PixelsPerInch>96</o:PixelsPerInch>
-            </o:OfficeDocumentSettings>
-        </xml>
-    </noscript>
-    <![endif]-->
-  <style type="text/css">
-    /* RESET STYLES */
-    html,
-    body {
-      margin: 0 !important;
-      padding: 0 !important;
-      width: 100% !important;
-      height: 100% !important;
-    }
-
-    body {
-      -webkit-font-smoothing: antialiased;
-      -moz-osx-font-smoothing: grayscale;
-      text-rendering: optimizeLegibility;
-    }
-
-    .document {
-      margin: 0 !important;
-      padding: 0 !important;
-      width: 100% !important;
-    }
-
-    img {
-      border: 0;
-      outline: none;
-      text-decoration: none;
-      -ms-interpolation-mode: bicubic;
-    }
-
-    table {
-      border-collapse: collapse;
-    }
-
-    table,
-    td {
-      mso-table-lspace: 0pt;
-      mso-table-rspace: 0pt;
-    }
-
-    body,
-    table,
-    td,
-    a {
-      -webkit-text-size-adjust: 100%;
-      -ms-text-size-adjust: 100%;
-    }
-
-    h1,
-    h2,
-    h3,
-    h4,
-    h5,
-    p {
-      margin: 0;
-      word-break: break-word;
-    }
-
-    /* iOS BLUE LINKS */
-    a[x-apple-data-detectors] {
-      color: inherit !important;
-      text-decoration: none !important;
-      font-size: inherit !important;
-      font-family: inherit !important;
-      font-weight: inherit !important;
-      line-height: inherit !important;
-    }
-
-    /* ANDROID CENTER FIX */
-    div[style*="margin: 16px 0;"] {
-      margin: 0 !important;
-    }
-
-    /* MEDIA QUERIES */
-    @media all and (max-width:639px) {
-      .wrapper {
-        width: 100% !important;
-      }
-
-      .container {
-        width: 100% !important;
-        min-width: 100% !important;
-        padding: 0 !important;
-      }
-
-      .row {
-        padding-left: 20px !important;
-        padding-right: 20px !important;
-      }
-
-      .col-mobile {
-        width: 20px !important;
-      }
-
-      .col {
-        display: block !important;
-        width: 100% !important;
-      }
-
-      .mobile-center {
-        text-align: center !important;
-        float: none !important;
-      }
-
-      .mobile-mx-auto {
-        margin: 0 auto !important;
-        float: none !important;
-      }
-
-      .mobile-left {
-        text-align: center !important;
-        float: left !important;
-      }
-
-      .mobile-hide {
-        display: none !important;
-      }
-
-      .img {
-        width: 100% !important;
-        height: auto !important;
-      }
-
-      .ml-btn {
-        width: 100% !important;
-        max-width: 100% !important;
-      }
-
-      .ml-btn-container {
-        width: 100% !important;
-        max-width: 100% !important;
-      }
-    }
-  </style>
-  <style type="text/css">
-    @import url("https://assets.mlcdn.com/fonts-v2.css?version=1729862");
-  </style>
-  <style type="text/css">
-    @media screen {
-      body {
-        font-family: 'Poppins', sans-serif;
-      }
-    }
-  </style>
-  <title>{{data.title}}</title>
-</head>
-
-<body style="margin: 0 !important; padding: 0 !important; background-color:#070629;">
-  <div class="document" role="article" aria-roledescription="email" aria-label lang dir="ltr"
-    style="background-color:#070629; line-height: 100%; font-size:medium; font-size:max(16px, 1rem);">
-    <!-- Main Content -->
-    <table width="100%" align="center" cellspacing="0" cellpadding="0" border="0">
-      <tr>
-        <td class="background" bgcolor="#070629" align="center" valign="top" style="padding: 0 8px;">
-          <!-- Email Content -->
-          <table class="container" align="center" width="640" cellpadding="0" cellspacing="0" border="0"
-            style="max-width: 640px;">
-            <tr>
-              <td align="center">
-                <!-- Logo Section -->
-                <table class="container ml-4 ml-default-border" width="640" bgcolor="#E2ECFD" align="center" border="0"
-                  cellspacing="0" cellpadding="0" style="width: 640px; min-width: 640px;">
-                  <tr>
-                    <td class="ml-default-border container" height="40" style="line-height: 40px; min-width: 640px;">
-                    </td>
-                  </tr>
-                  <tr>
-                    <td>
-                      <table align="center" width="100%" border="0" cellspacing="0" cellpadding="0">
-                        <tr>
-                          <td class="row" align="center" style="padding: 0 50px;">
-                            <img
-                              src="https://storage.mlcdn.com/account_image/597379/8QJ8kOjXakVvfe1kJLY2wWCObU1mp5EiDLfBlbQa.png"
-                              border="0" alt="" width="120" class="logo"
-                              style="max-width: 120px; display: inline-block;">
-                          </td>
-                        </tr>
-                      </table>
-                    </td>
-                  </tr>
-                </table>
-
-                <!-- Main Content Section -->
-                <table class="container ml-6 ml-default-border" width="640" bgcolor="#E2ECFD" align="center" border="0"
-                  cellspacing="0" cellpadding="0" style="color: #070629; width: 640px; min-width: 640px;">
-                  <tr>
-                    <td class="row" style="padding: 0 50px;">
-                      {{data.message|safe}}
-                    </td>
-                  </tr>
-                </table>
-
-                <!-- Signature Section -->
-                <table class="container ml-8 ml-default-border" width="640" bgcolor="#E2ECFD" align="center" border="0"
-                  cellspacing="0" cellpadding="0" style="color: #070629; width: 640px; min-width: 640px;">
-                  <tr>
-                    <td class="row mobile-center" align="left" style="padding: 0 50px;">
-                      <table class="ml-8 wrapper" border="0" cellspacing="0" cellpadding="0"
-                        style="color: #070629; text-align: left;">
-                        <tr>
-                          <td class="col center mobile-center" align>
-                            <p
-                              style="font-family: 'Poppins', sans-serif; color: #070629; font-size: 16px; line-height: 165%; margin-top: 0; margin-bottom: 0;">
-                              Thank you for being a part of the AutoGPT community! Join the conversation on our Discord <a href="https://discord.gg/autogpt" style="color: #4285F4; text-decoration: underline;">here</a> and share your thoughts with us anytime.
-                            </p>
-                          </td>
-                        </tr>
-                      </table>
-                    </td>
-                  </tr>
-                </table>
-
-                <!-- Footer Section -->
-                <table class="container ml-10 ml-default-border" width="640" bgcolor="#ffffff" align="center" border="0"
-                  cellspacing="0" cellpadding="0" style="width: 640px; min-width: 640px;">
-                  <tr>
-                    <td class="row" style="padding: 0 50px;">
-                      <table align="center" width="100%" border="0" cellspacing="0" cellpadding="0">
-                        <tr>
-                          <td>
-                            <!-- Footer Content -->
-                            <table align="center" width="100%" border="0" cellspacing="0" cellpadding="0">
-                              <tr>
-                                <td class="col" align="left" valign="middle" width="120">
-                                  <img
-                                    src="https://storage.mlcdn.com/account_image/597379/8QJ8kOjXakVvfe1kJLY2wWCObU1mp5EiDLfBlbQa.png"
-                                    border="0" alt="" width="120" class="logo"
-                                    style="max-width: 120px; display: inline-block;">
-                                </td>
-                                <td class="col" width="40" height="30" style="line-height: 30px;"></td>
-                                <td class="col mobile-left" align="right" valign="middle" width="250">
-                                  <table role="presentation" cellpadding="0" cellspacing="0" border="0">
-                                    <tr>
-                                      <td align="center" valign="middle" width="18" style="padding: 0 5px 0 0;">
-                                        <a href="https://x.com/auto_gpt" target="blank" style="text-decoration: none;">
-                                          <img
-                                            src="https://assets.mlcdn.com/ml/images/icons/default/rounded_corners/black/x.png"
-                                            width="18" alt="x">
-                                        </a>
-                                      </td>
-                                      <td align="center" valign="middle" width="18" style="padding: 0 5px;">
-                                        <a href="https://discord.gg/autogpt" target="blank"
-                                          style="text-decoration: none;">
-                                          <img
-                                            src="https://assets.mlcdn.com/ml/images/icons/default/rounded_corners/black/discord.png"
-                                            width="18" alt="discord">
-                                        </a>
-                                      </td>
-                                      <td align="center" valign="middle" width="18" style="padding: 0 0 0 5px;">
-                                        <a href="https://agpt.co/" target="blank" style="text-decoration: none;">
-                                          <img
-                                            src="https://assets.mlcdn.com/ml/images/icons/default/rounded_corners/black/website.png"
-                                            width="18" alt="website">
-                                        </a>
-                                      </td>
-                                    </tr>
-                                  </table>
-                                </td>
-                              </tr>
-                            </table>
-                          </td>
-                        </tr>
-                        <tr>
-                          <td align="center" style="text-align: left!important;">
-                            <h5
-                              style="font-family: 'Poppins', sans-serif; color: #070629; font-size: 15px; line-height: 125%; font-weight: bold; font-style: normal; text-decoration: none; margin-bottom: 6px;">
-                              AutoGPT
-                            </h5>
-                          </td>
-                        </tr>
-                        <tr>
-                          <td align="center" style="text-align: left!important;">
-                            <p
-                              style="font-family: 'Poppins', sans-serif; color: #070629; font-size: 14px; line-height: 150%; display: inline-block; margin-bottom: 0;">
-                              3rd Floor 1 Ashley Road, Cheshire, United Kingdom, WA14 2DT, Altrincham<br>United Kingdom
-                            </p>
-                          </td>
-                        </tr>
-                        <tr>
-                          <td height="8" style="line-height: 8px;"></td>
-                        </tr>
-                        <tr>
-                          <td align="left" style="text-align: left!important;">
-                            <p
-                              style="font-family: 'Poppins', sans-serif; color: #070629; font-size: 14px; line-height: 150%; display: inline-block; margin-bottom: 0;">
-                              You received this email because you signed up on our website.</p>
-                          </td>
-                        </tr>
-                        <tr>
-                          <td height="1" style="line-height: 12px;"></td>
-                        </tr>
-                        <tr>
-                          <td align="left">
-                            <p
-                              style="font-family: 'Poppins', sans-serif; color: #070629; font-size: 14px; line-height: 150%; display: inline-block; margin-bottom: 0;">
-                              <a href="{{data.unsubscribe_link}}"
-                                style="color: #4285F4; font-weight: normal; font-style: normal; text-decoration: underline;">Unsubscribe</a>
-                            </p>
-                          </td>
-                        </tr>
-                      </table>
-                    </td>
-                  </tr>
-                </table>
-              </td>
-            </tr>
-          </table>
-        </td>
-      </tr>
-    </table>
-  </div>
-</body>
-
-</html>

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

@@ -1,114 +0,0 @@
-{# Low Balance Notification Email Template #}
-{# Template variables:
-data.agent_name: the name of the agent
-data.current_balance: the current balance of the user
-data.billing_page_link: the link to the billing page
-data.shortfall: the shortfall amount
-#}
-
-<p style="
-    font-family: 'Poppins', sans-serif;
-    color: #070629;
-    font-size: 16px;
-    line-height: 165%;
-    margin-top: 0;
-    margin-bottom: 10px;
-  ">
-  <strong>Low Balance Warning</strong>
-</p>
-
-<p style="
-    font-family: 'Poppins', sans-serif;
-    color: #070629;
-    font-size: 16px;
-    line-height: 165%;
-    margin-top: 0;
-    margin-bottom: 20px;
-  ">
-  Your agent "<strong>{{ data.agent_name }}</strong>" has been stopped due to low balance.
-</p>
-
-<div style="
-    margin-left: 15px;
-    margin-bottom: 20px;
-    padding: 15px;
-    border-left: 4px solid #5D23BB;
-    background-color: #f8f8ff;
-  ">
-  <p style="
-    font-family: 'Poppins', sans-serif;
-    color: #070629;
-    font-size: 16px;
-    margin-top: 0;
-    margin-bottom: 10px;
-  ">
-    <strong>Current Balance:</strong> ${{ "{:.2f}".format((data.current_balance|float)/100) }}
-  </p>
-  <p style="
-    font-family: 'Poppins', sans-serif;
-    color: #070629;
-    font-size: 16px;
-    margin-top: 0;
-    margin-bottom: 10px;
-  ">
-    <strong>Shortfall:</strong> ${{ "{:.2f}".format((data.shortfall|float)/100) }}
-  </p>
-</div>
-
-
-<div style="
-    margin-left: 15px;
-    margin-bottom: 20px;
-    padding: 15px;
-    border-left: 4px solid #FF6B6B;
-    background-color: #FFF0F0;
-  ">
-  <p style="
-    font-family: 'Poppins', sans-serif;
-    color: #070629;
-    font-size: 16px;
-    margin-top: 0;
-    margin-bottom: 10px;
-  ">
-    <strong>Low Balance:</strong>
-  </p>
-  <p style="
-    font-family: 'Poppins', sans-serif;
-    color: #070629;
-    font-size: 16px;
-    margin-top: 0;
-    margin-bottom: 5px;
-  ">
-    Your agent "<strong>{{ data.agent_name }}</strong>" requires additional credits to continue running. The current operation has been canceled until your balance is replenished.
-  </p>
-</div>
-
-<div style="
-    text-align: center;
-    margin: 30px 0;
-  ">
-  <a href="{{ data.billing_page_link }}" style="
-    font-family: 'Poppins', sans-serif;
-    background-color: #5D23BB;
-    color: white;
-    padding: 12px 24px;
-    text-decoration: none;
-    border-radius: 4px;
-    font-weight: 500;
-    display: inline-block;
-  ">
-    Manage Billing
-  </a>
-</div>
-
-<p style="
-    font-family: 'Poppins', sans-serif;
-    color: #070629;
-    font-size: 16px;
-    line-height: 150%;
-    margin-top: 30px;
-    margin-bottom: 10px;
-    font-style: italic;
-  ">
-  This is an automated notification. Your agent is stopped and will need manually restarted unless set to trigger automatically.
-</p>

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

@@ -1,51 +0,0 @@
-{# Refund Processed Notification Email Template #}
-{#
-  Template variables:
-  data.user_id: the ID of the user
-  data.user_name: the user's name
-  data.user_email: the user's email address
-  data.transaction_id: the transaction ID for the refund request
-  data.refund_request_id: the refund request ID
-  data.reason: the reason for the refund request
-  data.amount: the refund amount in cents (divide by 100 for dollars)
-  data.balance: the user's latest balance in cents (after the refund deduction)
-
-  Subject: Refund for ${{ data.amount / 100 }} to {{ data.user_name }} has been processed
-#}
-
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="UTF-8">
-    <title>Refund Processed Notification</title>
-  </head>
-  <body style="font-family: 'Poppins', sans-serif; color: #070629; font-size: 16px; line-height: 1.65; margin: 0; padding: 20px;">
-    <p style="margin-bottom: 10px;">Hello Administrator,</p>
-
-    <p style="margin-bottom: 10px;">
-      This is to notify you that the refund for <strong>${{ data.amount / 100 }}</strong> to <strong>{{ data.user_name }}</strong> has been processed successfully.
-    </p>
-
-    <h2 style="margin-bottom: 10px;">Refund Details</h2>
-    <ul style="margin-bottom: 10px;">
-      <li><strong>User ID:</strong> {{ data.user_id }}</li>
-      <li><strong>User Name:</strong> {{ data.user_name }}</li>
-      <li><strong>User Email:</strong> {{ data.user_email }}</li>
-      <li><strong>Transaction ID:</strong> {{ data.transaction_id }}</li>
-      <li><strong>Refund Request ID:</strong> {{ data.refund_request_id }}</li>
-      <li><strong>Refund Amount:</strong> ${{ data.amount / 100 }}</li>
-      <li><strong>Reason for Refund:</strong> {{ data.reason }}</li>
-      <li><strong>Latest User Balance:</strong> ${{ data.balance / 100 }}</li>
-    </ul>
-
-    <p style="margin-bottom: 10px;">
-      The user's balance has been updated accordingly after the deduction.
-    </p>
-
-    <p style="margin-bottom: 10px;">
-      Please contact the support team if you have any questions or need further assistance regarding this refund.
-    </p>
-
-    <p style="margin-bottom: 0;">Best regards,<br>Your Notification System</p>
-  </body>
-</html>

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

@@ -1,72 +0,0 @@
-{# Refund Request Email Template #}
-{#
-  Template variables:
-  data.user_id: the ID of the user
-  data.user_name: the user's name
-  data.user_email: the user's email address
-  data.transaction_id: the transaction ID for the refund request
-  data.refund_request_id: the refund request ID
-  data.reason: the reason for the refund request
-  data.amount: the refund amount in cents (divide by 100 for dollars)
-  data.balance: the user's balance in cents (divide by 100 for dollars)
-
-  Subject: [ACTION REQUIRED] You got a ${{ data.amount / 100 }} refund request from {{ data.user_name }}
-#}
-
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="UTF-8">
-    <title>Refund Request Approval Needed</title>
-  </head>
-  <body style="font-family: 'Poppins', sans-serif; color: #070629; font-size: 16px; line-height: 1.65; margin: 0; padding: 20px;">
-    <p style="margin-bottom: 10px;">Hello Administrator,</p>
-    <p style="margin-bottom: 10px;">
-      A refund request has been submitted by a user and requires your approval.
-    </p>
-
-    <h2 style="margin-bottom: 10px;">Refund Request Details</h2>
-    <ul style="margin-bottom: 10px;">
-      <li><strong>User ID:</strong> {{ data.user_id }}</li>
-      <li><strong>User Name:</strong> {{ data.user_name }}</li>
-      <li><strong>User Email:</strong> {{ data.user_email }}</li>
-      <li><strong>Transaction ID:</strong> {{ data.transaction_id }}</li>
-      <li><strong>Refund Request ID:</strong> {{ data.refund_request_id }}</li>
-      <li><strong>Refund Amount:</strong> ${{ data.amount / 100 }}</li>
-      <li><strong>User Balance:</strong> ${{ data.balance / 100 }}</li>
-      <li><strong>Reason for Refund:</strong> {{ data.reason }}</li>
-    </ul>
-
-    <p style="margin-bottom: 10px;">
-      To approve this refund, please click on the following Stripe link:
-      https://dashboard.stripe.com/test/payments/{{data.transaction_id}}
-      <br/>
-      And then click on the "Refund" button.
-    </p>
-
-    <p style="margin-bottom: 10px;">
-      To reject this refund, please follow these steps:
-    </p>
-    <ol style="margin-bottom: 10px;">
-      <li>
-        Visit the Supabase Dashboard:
-        https://supabase.com/dashboard/project/bgwpwdsxblryihinutbx/editor
-      </li>
-      <li>
-        Navigate to the <strong>RefundRequest</strong> table.
-      </li>
-      <li>
-        Filter the <code>transactionKey</code> column with the Transaction ID: <strong>{{ data.transaction_id }}</strong>.
-      </li>
-      <li>
-        Update the <code>status</code> field to <strong>REJECTED</strong> and enter the rejection reason in the <code>result</code> column.
-      </li>
-    </ol>
-
-    <p style="margin-bottom: 10px;">
-      Please take the necessary action at your earliest convenience.
-    </p>
-    <p style="margin-bottom: 10px;">Thank you for your prompt attention.</p>
-    <p style="margin-bottom: 0;">Best regards,<br>Your Notification System</p>
-  </body>
-</html>

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

@@ -1,27 +0,0 @@
-{# Weekly Summary #}
-{# Template variables:
-data: the stuff below
-data.start_date: the start date of the summary
-data.end_date: the end date of the summary
-data.total_credits_used: the total credits used during the summary
-data.total_executions: the total number of executions during the summary
-data.most_used_agent: the most used agent's nameduring the summary
-data.total_execution_time: the total execution time during the summary
-data.successful_runs: the total number of successful runs during the summary
-data.failed_runs: the total number of failed runs during the summary
-data.average_execution_time: the average execution time during the summary
-data.cost_breakdown: the cost breakdown during the summary
-#}
-
-<h1>Weekly Summary</h1>
-
-<p>Start Date: {{ data.start_date }}</p>
-<p>End Date: {{ data.end_date }}</p>
-<p>Total Credits Used: {{ data.total_credits_used }}</p>
-<p>Total Executions: {{ data.total_executions }}</p>
-<p>Most Used Agent: {{ data.most_used_agent }}</p>
-<p>Total Execution Time: {{ data.total_execution_time }}</p>
-<p>Successful Runs: {{ data.successful_runs }}</p>
-<p>Failed Runs: {{ data.failed_runs }}</p>
-<p>Average Execution Time: {{ data.average_execution_time }}</p>
-<p>Cost Breakdown: {{ data.cost_breakdown }}</p>

autogpt_platform/backend/backend/rest.py

@@ -1,6 +1,5 @@
 from backend.app import run_processes
-from backend.executor import DatabaseManager, Scheduler
-from backend.notifications.notifications import NotificationManager
+from backend.executor import DatabaseManager, ExecutionScheduler
 from backend.server.rest_api import AgentServer
 
 
@@ -9,9 +8,8 @@ def main():
     Run all the processes required for the AutoGPT-server REST API.
     """
     run_processes(
-        NotificationManager(),
         DatabaseManager(),
-        Scheduler(),
+        ExecutionScheduler(),
         AgentServer(),
     )
 

autogpt_platform/backend/backend/server/conn_manager.py

@@ -20,28 +20,24 @@ class ConnectionManager:
         for subscribers in self.subscriptions.values():
             subscribers.discard(websocket)
 
-    async def subscribe(self, graph_id: str, graph_version: int, websocket: WebSocket):
-        key = f"{graph_id}_{graph_version}"
-        if key not in self.subscriptions:
-            self.subscriptions[key] = set()
-        self.subscriptions[key].add(websocket)
+    async def subscribe(self, graph_id: str, websocket: WebSocket):
+        if graph_id not in self.subscriptions:
+            self.subscriptions[graph_id] = set()
+        self.subscriptions[graph_id].add(websocket)
 
-    async def unsubscribe(
-        self, graph_id: str, graph_version: int, websocket: WebSocket
-    ):
-        key = f"{graph_id}_{graph_version}"
-        if key in self.subscriptions:
-            self.subscriptions[key].discard(websocket)
-            if not self.subscriptions[key]:
-                del self.subscriptions[key]
+    async def unsubscribe(self, graph_id: str, websocket: WebSocket):
+        if graph_id in self.subscriptions:
+            self.subscriptions[graph_id].discard(websocket)
+            if not self.subscriptions[graph_id]:
+                del self.subscriptions[graph_id]
 
     async def send_execution_result(self, result: execution.ExecutionResult):
-        key = f"{result.graph_id}_{result.graph_version}"
-        if key in self.subscriptions:
+        graph_id = result.graph_id
+        if graph_id in self.subscriptions:
             message = WsMessage(
                 method=Methods.EXECUTION_EVENT,
-                channel=key,
+                channel=graph_id,
                 data=result.model_dump(),
             ).model_dump_json()
-            for connection in self.subscriptions[key]:
+            for connection in self.subscriptions[graph_id]:
                 await connection.send_text(message)

autogpt_platform/backend/backend/server/external/routes/v1.py

@@ -1,9 +1,9 @@
 import logging
 from collections import defaultdict
-from typing import Annotated, Any, Dict, List, Optional, Sequence
+from typing import Any, Dict, List, Optional, Sequence
 
 from autogpt_libs.utils.cache import thread_cached
-from fastapi import APIRouter, Body, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException
 from prisma.enums import AgentExecutionStatus, APIKeyPermission
 from typing_extensions import TypedDict
 
@@ -95,25 +95,21 @@ def execute_graph_block(
 
 
 @v1_router.post(
-    path="/graphs/{graph_id}/execute/{graph_version}",
+    path="/graphs/{graph_id}/execute",
     tags=["graphs"],
 )
 def execute_graph(
     graph_id: str,
-    graph_version: int,
-    node_input: Annotated[dict[str, Any], Body(..., embed=True, default_factory=dict)],
+    node_input: dict[Any, Any],
     api_key: APIKey = Depends(require_permission(APIKeyPermission.EXECUTE_GRAPH)),
 ) -> dict[str, Any]:
     try:
         graph_exec = execution_manager_client().add_execution(
-            graph_id,
-            graph_version=graph_version,
-            data=node_input,
-            user_id=api_key.user_id,
+            graph_id, node_input, user_id=api_key.user_id
         )
         return {"id": graph_exec.graph_exec_id}
     except Exception as e:
-        msg = str(e).encode().decode("unicode_escape")
+        msg = e.__str__().encode().decode("unicode_escape")
         raise HTTPException(status_code=400, detail=msg)
 
 

autogpt_platform/backend/backend/server/model.py

@@ -25,15 +25,18 @@ class WsMessage(pydantic.BaseModel):
 
 class ExecutionSubscription(pydantic.BaseModel):
     graph_id: str
-    graph_version: int
 
 
-class ExecuteGraphResponse(pydantic.BaseModel):
-    graph_exec_id: str
+class SubscriptionDetails(pydantic.BaseModel):
+    event_type: str
+    channel: str
+    graph_id: str
 
 
 class CreateGraph(pydantic.BaseModel):
-    graph: backend.data.graph.Graph
+    template_id: str | None = None
+    template_version: int | None = None
+    graph: backend.data.graph.Graph | None = None
 
 
 class CreateAPIKeyRequest(pydantic.BaseModel):
@@ -55,20 +58,5 @@ class UpdatePermissionsRequest(pydantic.BaseModel):
     permissions: List[APIKeyPermission]
 
 
-class Pagination(pydantic.BaseModel):
-    total_items: int = pydantic.Field(
-        description="Total number of items.", examples=[42]
-    )
-    total_pages: int = pydantic.Field(
-        description="Total number of pages.", examples=[2]
-    )
-    current_page: int = pydantic.Field(
-        description="Current_page page number.", examples=[1]
-    )
-    page_size: int = pydantic.Field(
-        description="Number of items per page.", examples=[25]
-    )
-
-
 class RequestTopUp(pydantic.BaseModel):
     credit_amount: int

autogpt_platform/backend/backend/server/rest_api.py

@@ -16,19 +16,12 @@ import backend.data.block
 import backend.data.db
 import backend.data.graph
 import backend.data.user
-import backend.server.integrations.router
 import backend.server.routers.v1
-import backend.server.v2.library.db
-import backend.server.v2.library.model
 import backend.server.v2.library.routes
-import backend.server.v2.otto.routes
-import backend.server.v2.postmark.postmark
 import backend.server.v2.store.model
 import backend.server.v2.store.routes
 import backend.util.service
 import backend.util.settings
-from backend.data.model import Credentials
-from backend.integrations.providers import ProviderName
 from backend.server.external.api import external_app
 
 settings = backend.util.settings.Settings()
@@ -69,7 +62,8 @@ docs_url = (
 app = fastapi.FastAPI(
     title="AutoGPT Agent Server",
     description=(
-        "This server is used to execute agents that are created by the AutoGPT system."
+        "This server is used to execute agents that are created by the "
+        "AutoGPT system."
     ),
     summary="AutoGPT Agent Server",
     version="0.1",
@@ -102,15 +96,6 @@ app.include_router(
 app.include_router(
     backend.server.v2.library.routes.router, tags=["v2"], prefix="/api/library"
 )
-app.include_router(
-    backend.server.v2.otto.routes.router, tags=["v2"], prefix="/api/otto"
-)
-
-app.include_router(
-    backend.server.v2.postmark.postmark.router,
-    tags=["v2", "email"],
-    prefix="/api/email",
-)
 
 app.mount("/external-api", external_app)
 
@@ -138,15 +123,15 @@ class AgentServer(backend.util.service.AppProcess):
     @staticmethod
     async def test_execute_graph(
         graph_id: str,
+        node_input: dict[str, Any],
         user_id: str,
         graph_version: Optional[int] = None,
-        node_input: Optional[dict[str, Any]] = None,
     ):
         return backend.server.routers.v1.execute_graph(
             user_id=user_id,
             graph_id=graph_id,
             graph_version=graph_version,
-            node_input=node_input or {},
+            node_input=node_input,
         )
 
     @staticmethod
@@ -154,10 +139,9 @@ class AgentServer(backend.util.service.AppProcess):
         graph_id: str,
         graph_version: int,
         user_id: str,
-        for_export: bool = False,
     ):
         return await backend.server.routers.v1.get_graph(
-            graph_id, user_id, graph_version, for_export
+            graph_id, user_id, graph_version
         )
 
     @staticmethod
@@ -169,7 +153,7 @@ class AgentServer(backend.util.service.AppProcess):
 
     @staticmethod
     async def test_get_graph_run_status(graph_exec_id: str, user_id: str):
-        execution = await backend.data.graph.get_execution_meta(
+        execution = await backend.data.graph.get_execution(
             user_id=user_id, execution_id=graph_exec_id
         )
         if not execution:
@@ -177,73 +161,17 @@ class AgentServer(backend.util.service.AppProcess):
         return execution.status
 
     @staticmethod
-    async def test_get_graph_run_results(
+    async def test_get_graph_run_node_execution_results(
         graph_id: str, graph_exec_id: str, user_id: str
     ):
-        return await backend.server.routers.v1.get_graph_execution(
+        return await backend.server.routers.v1.get_graph_run_node_execution_results(
             graph_id, graph_exec_id, user_id
         )
 
     @staticmethod
     async def test_delete_graph(graph_id: str, user_id: str):
-        await backend.server.v2.library.db.delete_library_agent_by_graph_id(
-            graph_id=graph_id, user_id=user_id
-        )
         return await backend.server.routers.v1.delete_graph(graph_id, user_id)
 
-    @staticmethod
-    async def test_get_presets(user_id: str, page: int = 1, page_size: int = 10):
-        return await backend.server.v2.library.routes.presets.get_presets(
-            user_id=user_id, page=page, page_size=page_size
-        )
-
-    @staticmethod
-    async def test_get_preset(preset_id: str, user_id: str):
-        return await backend.server.v2.library.routes.presets.get_preset(
-            preset_id=preset_id, user_id=user_id
-        )
-
-    @staticmethod
-    async def test_create_preset(
-        preset: backend.server.v2.library.model.CreateLibraryAgentPresetRequest,
-        user_id: str,
-    ):
-        return await backend.server.v2.library.routes.presets.create_preset(
-            preset=preset, user_id=user_id
-        )
-
-    @staticmethod
-    async def test_update_preset(
-        preset_id: str,
-        preset: backend.server.v2.library.model.CreateLibraryAgentPresetRequest,
-        user_id: str,
-    ):
-        return await backend.server.v2.library.routes.presets.update_preset(
-            preset_id=preset_id, preset=preset, user_id=user_id
-        )
-
-    @staticmethod
-    async def test_delete_preset(preset_id: str, user_id: str):
-        return await backend.server.v2.library.routes.presets.delete_preset(
-            preset_id=preset_id, user_id=user_id
-        )
-
-    @staticmethod
-    async def test_execute_preset(
-        graph_id: str,
-        graph_version: int,
-        preset_id: str,
-        user_id: str,
-        node_input: Optional[dict[str, Any]] = None,
-    ):
-        return await backend.server.v2.library.routes.presets.execute_preset(
-            graph_id=graph_id,
-            graph_version=graph_version,
-            preset_id=preset_id,
-            node_input=node_input or {},
-            user_id=user_id,
-        )
-
     @staticmethod
     async def test_create_store_listing(
         request: backend.server.v2.store.model.StoreSubmissionRequest, user_id: str
@@ -257,15 +185,5 @@ class AgentServer(backend.util.service.AppProcess):
     ):
         return await backend.server.v2.store.routes.review_submission(request, user)
 
-    @staticmethod
-    def test_create_credentials(
-        user_id: str,
-        provider: ProviderName,
-        credentials: Credentials,
-    ) -> Credentials:
-        return backend.server.integrations.router.create_credentials(
-            user_id=user_id, provider=provider, credentials=credentials
-        )
-
     def set_test_dependency_overrides(self, overrides: dict):
         app.dependency_overrides.update(overrides)

autogpt_platform/backend/backend/server/routers/v1.py

@@ -9,14 +9,12 @@ import stripe
 from autogpt_libs.auth.middleware import auth_middleware
 from autogpt_libs.feature_flag.client import feature_flag
 from autogpt_libs.utils.cache import thread_cached
-from fastapi import APIRouter, Body, Depends, HTTPException, Request, Response
-from starlette.status import HTTP_204_NO_CONTENT
+from fastapi import APIRouter, Depends, HTTPException, Request, Response
 from typing_extensions import Optional, TypedDict
 
 import backend.data.block
 import backend.server.integrations.router
 import backend.server.routers.analytics
-import backend.server.v2.library.db as library_db
 from backend.data import execution as execution_db
 from backend.data import graph as graph_db
 from backend.data.api_key import (
@@ -34,27 +32,15 @@ from backend.data.api_key import (
 from backend.data.block import BlockInput, CompletedBlockOutput
 from backend.data.credit import (
     AutoTopUpConfig,
-    RefundRequest,
     TransactionHistory,
     get_auto_top_up,
     get_block_costs,
+    get_stripe_customer_id,
     get_user_credit_model,
     set_auto_top_up,
 )
-from backend.data.notifications import NotificationPreference, NotificationPreferenceDTO
-from backend.data.onboarding import (
-    UserOnboardingUpdate,
-    get_recommended_agents,
-    get_user_onboarding,
-    update_user_onboarding,
-)
-from backend.data.user import (
-    get_or_create_user,
-    get_user_notification_preference,
-    update_user_email,
-    update_user_notification_preference,
-)
-from backend.executor import ExecutionManager, Scheduler, scheduler
+from backend.data.user import get_or_create_user
+from backend.executor import ExecutionManager, ExecutionScheduler, scheduler
 from backend.integrations.creds_manager import IntegrationCredentialsManager
 from backend.integrations.webhooks.graph_lifecycle_hooks import (
     on_graph_activate,
@@ -64,7 +50,6 @@ from backend.server.model import (
     CreateAPIKeyRequest,
     CreateAPIKeyResponse,
     CreateGraph,
-    ExecuteGraphResponse,
     RequestTopUp,
     SetGraphActiveVersion,
     UpdatePermissionsRequest,
@@ -83,8 +68,8 @@ def execution_manager_client() -> ExecutionManager:
 
 
 @thread_cached
-def execution_scheduler_client() -> Scheduler:
-    return get_service_client(Scheduler)
+def execution_scheduler_client() -> ExecutionScheduler:
+    return get_service_client(ExecutionScheduler)
 
 
 settings = Settings()
@@ -121,74 +106,6 @@ async def get_or_create_user_route(user_data: dict = Depends(auth_middleware)):
     return user.model_dump()
 
 
-@v1_router.post(
-    "/auth/user/email", tags=["auth"], dependencies=[Depends(auth_middleware)]
-)
-async def update_user_email_route(
-    user_id: Annotated[str, Depends(get_user_id)], email: str = Body(...)
-) -> dict[str, str]:
-    await update_user_email(user_id, email)
-
-    return {"email": email}
-
-
-@v1_router.get(
-    "/auth/user/preferences",
-    tags=["auth"],
-    dependencies=[Depends(auth_middleware)],
-)
-async def get_preferences(
-    user_id: Annotated[str, Depends(get_user_id)],
-) -> NotificationPreference:
-    preferences = await get_user_notification_preference(user_id)
-    return preferences
-
-
-@v1_router.post(
-    "/auth/user/preferences",
-    tags=["auth"],
-    dependencies=[Depends(auth_middleware)],
-)
-async def update_preferences(
-    user_id: Annotated[str, Depends(get_user_id)],
-    preferences: NotificationPreferenceDTO = Body(...),
-) -> NotificationPreference:
-    output = await update_user_notification_preference(user_id, preferences)
-    return output
-
-
-########################################################
-##################### Onboarding #######################
-########################################################
-
-
-@v1_router.get(
-    "/onboarding", tags=["onboarding"], dependencies=[Depends(auth_middleware)]
-)
-async def get_onboarding(user_id: Annotated[str, Depends(get_user_id)]):
-    return await get_user_onboarding(user_id)
-
-
-@v1_router.patch(
-    "/onboarding", tags=["onboarding"], dependencies=[Depends(auth_middleware)]
-)
-async def update_onboarding(
-    user_id: Annotated[str, Depends(get_user_id)], data: UserOnboardingUpdate
-):
-    return await update_user_onboarding(user_id, data)
-
-
-@v1_router.get(
-    "/onboarding/agents",
-    tags=["onboarding"],
-    dependencies=[Depends(auth_middleware)],
-)
-async def get_onboarding_agents(
-    user_id: Annotated[str, Depends(get_user_id)],
-):
-    return await get_recommended_agents(user_id)
-
-
 ########################################################
 ##################### Blocks ###########################
 ########################################################
@@ -226,7 +143,8 @@ def execute_graph_block(block_id: str, data: BlockInput) -> CompletedBlockOutput
 async def get_user_credits(
     user_id: Annotated[str, Depends(get_user_id)],
 ) -> dict[str, int]:
-    return {"credits": await _user_credit_model.get_credits(user_id)}
+    # Credits can go negative, so ensure it's at least 0 for user to see.
+    return {"credits": max(await _user_credit_model.get_credits(user_id), 0)}
 
 
 @v1_router.post(
@@ -241,19 +159,6 @@ async def request_top_up(
     return {"checkout_url": checkout_url}
 
 
-@v1_router.post(
-    path="/credits/{transaction_key}/refund",
-    tags=["credits"],
-    dependencies=[Depends(auth_middleware)],
-)
-async def refund_top_up(
-    user_id: Annotated[str, Depends(get_user_id)],
-    transaction_key: str,
-    metadata: dict[str, str],
-) -> int:
-    return await _user_credit_model.top_up_refund(user_id, transaction_key, metadata)
-
-
 @v1_router.patch(
     path="/credits", tags=["credits"], dependencies=[Depends(auth_middleware)]
 )
@@ -327,12 +232,6 @@ async def stripe_webhook(request: Request):
             session_id=event["data"]["object"]["id"]
         )
 
-    if event["type"] == "charge.dispute.created":
-        await _user_credit_model.handle_dispute(event["data"]["object"])
-
-    if event["type"] == "refund.created" or event["type"] == "charge.dispute.closed":
-        await _user_credit_model.deduct_credits(event["data"]["object"])
-
     return Response(status_code=200)
 
 
@@ -340,14 +239,21 @@ async def stripe_webhook(request: Request):
 async def manage_payment_method(
     user_id: Annotated[str, Depends(get_user_id)],
 ) -> dict[str, str]:
-    return {"url": await _user_credit_model.create_billing_portal_session(user_id)}
+    session = stripe.billing_portal.Session.create(
+        customer=await get_stripe_customer_id(user_id),
+        return_url=settings.config.frontend_base_url + "/marketplace/credits",
+    )
+    if not session:
+        raise HTTPException(
+            status_code=400, detail="Failed to create billing portal session"
+        )
+    return {"url": session.url}
 
 
 @v1_router.get(path="/credits/transactions", dependencies=[Depends(auth_middleware)])
 async def get_credit_history(
     user_id: Annotated[str, Depends(get_user_id)],
     transaction_time: datetime | None = None,
-    transaction_type: str | None = None,
     transaction_count_limit: int = 100,
 ) -> TransactionHistory:
     if transaction_count_limit < 1 or transaction_count_limit > 1000:
@@ -355,19 +261,11 @@ async def get_credit_history(
 
     return await _user_credit_model.get_transaction_history(
         user_id=user_id,
-        transaction_time_ceiling=transaction_time,
+        transaction_time=transaction_time or datetime.max,
         transaction_count_limit=transaction_count_limit,
-        transaction_type=transaction_type,
     )
 
 
-@v1_router.get(path="/credits/refunds", dependencies=[Depends(auth_middleware)])
-async def get_refund_requests(
-    user_id: Annotated[str, Depends(get_user_id)]
-) -> list[RefundRequest]:
-    return await _user_credit_model.get_refund_requests(user_id)
-
-
 ########################################################
 ##################### Graphs ###########################
 ########################################################
@@ -396,10 +294,10 @@ async def get_graph(
     graph_id: str,
     user_id: Annotated[str, Depends(get_user_id)],
     version: int | None = None,
-    for_export: bool = False,
+    hide_credentials: bool = False,
 ) -> graph_db.GraphModel:
     graph = await graph_db.get_graph(
-        graph_id, version, user_id=user_id, for_export=for_export
+        graph_id, version, user_id=user_id, for_export=hide_credentials
     )
     if not graph:
         raise HTTPException(status_code=404, detail=f"Graph #{graph_id} not found.")
@@ -411,6 +309,11 @@ async def get_graph(
     tags=["graphs"],
     dependencies=[Depends(auth_middleware)],
 )
+@v1_router.get(
+    path="/templates/{graph_id}/versions",
+    tags=["templates", "graphs"],
+    dependencies=[Depends(auth_middleware)],
+)
 async def get_graph_all_versions(
     graph_id: str, user_id: Annotated[str, Depends(get_user_id)]
 ) -> Sequence[graph_db.GraphModel]:
@@ -424,21 +327,43 @@ async def get_graph_all_versions(
     path="/graphs", tags=["graphs"], dependencies=[Depends(auth_middleware)]
 )
 async def create_new_graph(
-    create_graph: CreateGraph,
-    user_id: Annotated[str, Depends(get_user_id)],
+    create_graph: CreateGraph, user_id: Annotated[str, Depends(get_user_id)]
 ) -> graph_db.GraphModel:
-    graph = graph_db.make_graph_model(create_graph.graph, user_id)
+    return await do_create_graph(create_graph, is_template=False, user_id=user_id)
+
+
+async def do_create_graph(
+    create_graph: CreateGraph,
+    is_template: bool,
+    # user_id doesn't have to be annotated like on other endpoints,
+    # because create_graph isn't used directly as an endpoint
+    user_id: str,
+) -> graph_db.GraphModel:
+    if create_graph.graph:
+        graph = graph_db.make_graph_model(create_graph.graph, user_id)
+    elif create_graph.template_id:
+        # Create a new graph from a template
+        graph = await graph_db.get_graph(
+            create_graph.template_id,
+            create_graph.template_version,
+            template=True,
+            user_id=user_id,
+        )
+        if not graph:
+            raise HTTPException(
+                400, detail=f"Template #{create_graph.template_id} not found"
+            )
+        graph.version = 1
+    else:
+        raise HTTPException(
+            status_code=400, detail="Either graph or template_id must be provided."
+        )
+
+    graph.is_template = is_template
+    graph.is_active = not is_template
     graph.reassign_ids(user_id=user_id, reassign_graph_id=True)
-    graph.validate_graph(for_run=False)
 
     graph = await graph_db.create_graph(graph, user_id=user_id)
-
-    # Create a library agent for the new graph
-    library_agent = await library_db.create_library_agent(graph, user_id)
-    _ = asyncio.create_task(
-        library_db.add_generated_agent_image(graph, library_agent.id)
-    )
-
     graph = await on_graph_activate(
         graph,
         get_credentials=lambda id: integration_creds_manager.get(user_id, id),
@@ -465,6 +390,11 @@ async def delete_graph(
 @v1_router.put(
     path="/graphs/{graph_id}", tags=["graphs"], dependencies=[Depends(auth_middleware)]
 )
+@v1_router.put(
+    path="/templates/{graph_id}",
+    tags=["templates", "graphs"],
+    dependencies=[Depends(auth_middleware)],
+)
 async def update_graph(
     graph_id: str,
     graph: graph_db.Graph,
@@ -481,18 +411,21 @@ async def update_graph(
     latest_version_number = max(g.version for g in existing_versions)
     graph.version = latest_version_number + 1
 
+    latest_version_graph = next(
+        v for v in existing_versions if v.version == latest_version_number
+    )
     current_active_version = next((v for v in existing_versions if v.is_active), None)
+    if latest_version_graph.is_template != graph.is_template:
+        raise HTTPException(
+            400, detail="Changing is_template on an existing graph is forbidden"
+        )
+    graph.is_active = not graph.is_template
     graph = graph_db.make_graph_model(graph, user_id)
-    graph.reassign_ids(user_id=user_id, reassign_graph_id=False)
-    graph.validate_graph(for_run=False)
+    graph.reassign_ids(user_id=user_id)
 
     new_graph_version = await graph_db.create_graph(graph, user_id=user_id)
 
     if new_graph_version.is_active:
-        # Keep the library agent up to date with the new active version
-        await library_db.update_agent_version_in_library(
-            user_id, graph.id, graph.version
-        )
 
         def get_credentials(credentials_id: str) -> "Credentials | None":
             return integration_creds_manager.get(user_id, credentials_id)
@@ -549,12 +482,6 @@ async def set_graph_active_version(
         version=new_active_version,
         user_id=user_id,
     )
-
-    # Keep the library agent up to date with the new active version
-    await library_db.update_agent_version_in_library(
-        user_id, new_active_graph.id, new_active_graph.version
-    )
-
     if current_active_graph and current_active_graph.version != new_active_version:
         # Handle deactivation of the previously active version
         await on_graph_deactivate(
@@ -564,20 +491,24 @@ async def set_graph_active_version(
 
 
 @v1_router.post(
-    path="/graphs/{graph_id}/execute/{graph_version}",
+    path="/graphs/{graph_id}/execute",
     tags=["graphs"],
     dependencies=[Depends(auth_middleware)],
 )
 def execute_graph(
     graph_id: str,
-    node_input: Annotated[dict[str, Any], Body(..., default_factory=dict)],
+    node_input: dict[Any, Any],
     user_id: Annotated[str, Depends(get_user_id)],
     graph_version: Optional[int] = None,
-) -> ExecuteGraphResponse:
-    graph_exec = execution_manager_client().add_execution(
-        graph_id, node_input, user_id=user_id, graph_version=graph_version
-    )
-    return ExecuteGraphResponse(graph_exec_id=graph_exec.graph_exec_id)
+) -> dict[str, Any]:  # FIXME: add proper return type
+    try:
+        graph_exec = execution_manager_client().add_execution(
+            graph_id, node_input, user_id=user_id, graph_version=graph_version
+        )
+        return {"id": graph_exec.graph_exec_id}
+    except Exception as e:
+        msg = e.__str__().encode().decode("unicode_escape")
+        raise HTTPException(status_code=400, detail=msg)
 
 
 @v1_router.post(
@@ -587,10 +518,8 @@ def execute_graph(
 )
 async def stop_graph_run(
     graph_exec_id: str, user_id: Annotated[str, Depends(get_user_id)]
-) -> graph_db.GraphExecution:
-    if not await graph_db.get_execution_meta(
-        user_id=user_id, execution_id=graph_exec_id
-    ):
+) -> Sequence[execution_db.ExecutionResult]:
+    if not await graph_db.get_execution(user_id=user_id, execution_id=graph_exec_id):
         raise HTTPException(404, detail=f"Agent execution #{graph_exec_id} not found")
 
     await asyncio.to_thread(
@@ -598,13 +527,7 @@ async def stop_graph_run(
     )
 
     # Retrieve & return canceled graph execution in its final state
-    result = await graph_db.get_execution(execution_id=graph_exec_id, user_id=user_id)
-    if not result:
-        raise HTTPException(
-            500,
-            detail=f"Could not fetch graph execution #{graph_exec_id} after stopping",
-        )
-    return result
+    return await execution_db.get_execution_results(graph_exec_id)
 
 
 @v1_router.get(
@@ -612,22 +535,10 @@ async def stop_graph_run(
     tags=["graphs"],
     dependencies=[Depends(auth_middleware)],
 )
-async def get_graphs_executions(
+async def get_executions(
     user_id: Annotated[str, Depends(get_user_id)],
-) -> list[graph_db.GraphExecutionMeta]:
-    return await graph_db.get_graph_executions(user_id=user_id)
-
-
-@v1_router.get(
-    path="/graphs/{graph_id}/executions",
-    tags=["graphs"],
-    dependencies=[Depends(auth_middleware)],
-)
-async def get_graph_executions(
-    graph_id: str,
-    user_id: Annotated[str, Depends(get_user_id)],
-) -> list[graph_db.GraphExecutionMeta]:
-    return await graph_db.get_graph_executions(graph_id=graph_id, user_id=user_id)
+) -> list[graph_db.GraphExecution]:
+    return await graph_db.get_executions(user_id=user_id)
 
 
 @v1_router.get(
@@ -635,35 +546,57 @@ async def get_graph_executions(
     tags=["graphs"],
     dependencies=[Depends(auth_middleware)],
 )
-async def get_graph_execution(
+async def get_graph_run_node_execution_results(
     graph_id: str,
     graph_exec_id: str,
     user_id: Annotated[str, Depends(get_user_id)],
-) -> graph_db.GraphExecution:
+) -> Sequence[execution_db.ExecutionResult]:
     graph = await graph_db.get_graph(graph_id, user_id=user_id)
     if not graph:
         raise HTTPException(status_code=404, detail=f"Graph #{graph_id} not found.")
 
-    result = await graph_db.get_execution(execution_id=graph_exec_id, user_id=user_id)
-    if not result:
-        raise HTTPException(
-            status_code=404, detail=f"Graph execution #{graph_exec_id} not found."
-        )
-
-    return result
+    return await execution_db.get_execution_results(graph_exec_id)
 
 
-@v1_router.delete(
-    path="/executions/{graph_exec_id}",
-    tags=["graphs"],
+########################################################
+##################### Templates ########################
+########################################################
+
+
+@v1_router.get(
+    path="/templates",
+    tags=["graphs", "templates"],
     dependencies=[Depends(auth_middleware)],
-    status_code=HTTP_204_NO_CONTENT,
 )
-async def delete_graph_execution(
-    graph_exec_id: str,
-    user_id: Annotated[str, Depends(get_user_id)],
-) -> None:
-    await execution_db.delete_execution(graph_exec_id=graph_exec_id, user_id=user_id)
+async def get_templates(
+    user_id: Annotated[str, Depends(get_user_id)]
+) -> Sequence[graph_db.GraphModel]:
+    return await graph_db.get_graphs(filter_by="template", user_id=user_id)
+
+
+@v1_router.get(
+    path="/templates/{graph_id}",
+    tags=["templates", "graphs"],
+    dependencies=[Depends(auth_middleware)],
+)
+async def get_template(
+    graph_id: str, version: int | None = None
+) -> graph_db.GraphModel:
+    graph = await graph_db.get_graph(graph_id, version, template=True)
+    if not graph:
+        raise HTTPException(status_code=404, detail=f"Template #{graph_id} not found.")
+    return graph
+
+
+@v1_router.post(
+    path="/templates",
+    tags=["templates", "graphs"],
+    dependencies=[Depends(auth_middleware)],
+)
+async def create_new_template(
+    create_graph: CreateGraph, user_id: Annotated[str, Depends(get_user_id)]
+) -> graph_db.GraphModel:
+    return await do_create_graph(create_graph, is_template=True, user_id=user_id)
 
 
 ########################################################
@@ -675,7 +608,6 @@ class ScheduleCreationRequest(pydantic.BaseModel):
     cron: str
     input_data: dict[Any, Any]
     graph_id: str
-    graph_version: int
 
 
 @v1_router.post(
@@ -686,14 +618,11 @@ class ScheduleCreationRequest(pydantic.BaseModel):
 async def create_schedule(
     user_id: Annotated[str, Depends(get_user_id)],
     schedule: ScheduleCreationRequest,
-) -> scheduler.ExecutionJobInfo:
-    graph = await graph_db.get_graph(
-        schedule.graph_id, schedule.graph_version, user_id=user_id
-    )
+) -> scheduler.JobInfo:
+    graph = await graph_db.get_graph(schedule.graph_id, user_id=user_id)
     if not graph:
         raise HTTPException(
-            status_code=404,
-            detail=f"Graph #{schedule.graph_id} v.{schedule.graph_version} not found.",
+            status_code=404, detail=f"Graph #{schedule.graph_id} not found."
         )
 
     return await asyncio.to_thread(
@@ -728,7 +657,7 @@ def delete_schedule(
 def get_execution_schedules(
     user_id: Annotated[str, Depends(get_user_id)],
     graph_id: str | None = None,
-) -> list[scheduler.ExecutionJobInfo]:
+) -> list[scheduler.JobInfo]:
     return execution_scheduler_client().get_execution_schedules(
         user_id=user_id,
         graph_id=graph_id,

autogpt_platform/backend/backend/server/v2/library/db.py

@@ -1,664 +1,165 @@
 import logging
-from typing import Optional
+from typing import List
 
-import fastapi
 import prisma.errors
-import prisma.fields
 import prisma.models
 import prisma.types
 
 import backend.data.graph
-import backend.server.model
-import backend.server.v2.library.model as library_model
-import backend.server.v2.store.exceptions as store_exceptions
-import backend.server.v2.store.image_gen as store_image_gen
-import backend.server.v2.store.media as store_media
-from backend.data.db import locked_transaction
-from backend.data.includes import library_agent_include
-from backend.util.settings import Config
+import backend.data.includes
+import backend.server.v2.library.model
+import backend.server.v2.store.exceptions
 
 logger = logging.getLogger(__name__)
-config = Config()
 
 
-async def list_library_agents(
+async def get_library_agents(
     user_id: str,
-    search_term: Optional[str] = None,
-    sort_by: library_model.LibraryAgentSort = library_model.LibraryAgentSort.UPDATED_AT,
-    page: int = 1,
-    page_size: int = 50,
-) -> library_model.LibraryAgentResponse:
+) -> List[backend.server.v2.library.model.LibraryAgent]:
     """
-    Retrieves a paginated list of LibraryAgent records for a given user.
-
-    Args:
-        user_id: The ID of the user whose LibraryAgents we want to retrieve.
-        search_term: Optional string to filter agents by name/description.
-        sort_by: Sorting field (createdAt, updatedAt, isFavorite, isCreatedByUser).
-        page: Current page (1-indexed).
-        page_size: Number of items per page.
-
-    Returns:
-        A LibraryAgentResponse containing the list of agents and pagination details.
-
-    Raises:
-        DatabaseError: If there is an issue fetching from Prisma.
+    Returns all agents (AgentGraph) that belong to the user and all agents in their library (UserAgent table)
     """
-    logger.debug(
-        f"Fetching library agents for user_id={user_id}, "
-        f"search_term={repr(search_term)}, "
-        f"sort_by={sort_by}, page={page}, page_size={page_size}"
-    )
+    logger.debug(f"Getting library agents for user {user_id}")
 
-    if page < 1 or page_size < 1:
-        logger.warning(f"Invalid pagination: page={page}, page_size={page_size}")
-        raise store_exceptions.DatabaseError("Invalid pagination input")
+    try:
+        # Get agents created by user with nodes and links
+        user_created = await prisma.models.AgentGraph.prisma().find_many(
+            where=prisma.types.AgentGraphWhereInput(userId=user_id, isActive=True),
+            include=backend.data.includes.AGENT_GRAPH_INCLUDE,
+        )
 
-    if search_term and len(search_term.strip()) > 100:
-        logger.warning(f"Search term too long: {repr(search_term)}")
-        raise store_exceptions.DatabaseError("Search term is too long")
-
-    where_clause: prisma.types.LibraryAgentWhereInput = {
-        "userId": user_id,
-        "isDeleted": False,
-        "isArchived": False,
-    }
-
-    # Build search filter if applicable
-    if search_term:
-        where_clause["OR"] = [
-            {
+        # Get agents in user's library with nodes and links
+        library_agents = await prisma.models.UserAgent.prisma().find_many(
+            where=prisma.types.UserAgentWhereInput(
+                userId=user_id, isDeleted=False, isArchived=False
+            ),
+            include={
                 "Agent": {
-                    "is": {"name": {"contains": search_term, "mode": "insensitive"}}
-                }
-            },
-            {
-                "Agent": {
-                    "is": {
-                        "description": {"contains": search_term, "mode": "insensitive"}
+                    "include": {
+                        "AgentNodes": {
+                            "include": {
+                                "Input": True,
+                                "Output": True,
+                                "Webhook": True,
+                                "AgentBlock": True,
+                            }
+                        }
                     }
                 }
             },
-        ]
-
-    # Determine sorting
-    order_by: prisma.types.LibraryAgentOrderByInput | None = None
-
-    if sort_by == library_model.LibraryAgentSort.CREATED_AT:
-        order_by = {"createdAt": "asc"}
-    elif sort_by == library_model.LibraryAgentSort.UPDATED_AT:
-        order_by = {"updatedAt": "desc"}
-
-    try:
-        library_agents = await prisma.models.LibraryAgent.prisma().find_many(
-            where=where_clause,
-            include=library_agent_include(user_id),
-            order=order_by,
-            skip=(page - 1) * page_size,
-            take=page_size,
-        )
-        agent_count = await prisma.models.LibraryAgent.prisma().count(
-            where=where_clause
         )
 
-        logger.debug(
-            f"Retrieved {len(library_agents)} library agents for user #{user_id}"
-        )
+        # Convert to Graph models first
+        graphs = []
 
-        # Only pass valid agents to the response
-        valid_library_agents: list[library_model.LibraryAgent] = []
-
-        for agent in library_agents:
+        # Add user created agents
+        for agent in user_created:
             try:
-                library_agent = library_model.LibraryAgent.from_db(agent)
-                valid_library_agents.append(library_agent)
+                graphs.append(backend.data.graph.GraphModel.from_db(agent))
             except Exception as e:
-                # Skip this agent if there was an error
-                logger.error(
-                    f"Error parsing LibraryAgent when getting library agents from db: {e}"
-                )
+                logger.error(f"Error processing user created agent {agent.id}: {e}")
                 continue
 
-        # Return the response with only valid agents
-        return library_model.LibraryAgentResponse(
-            agents=valid_library_agents,
-            pagination=backend.server.model.Pagination(
-                total_items=agent_count,
-                total_pages=(agent_count + page_size - 1) // page_size,
-                current_page=page,
-                page_size=page_size,
-            ),
-        )
+        # Add library agents
+        for agent in library_agents:
+            if agent.Agent:
+                try:
+                    graphs.append(backend.data.graph.GraphModel.from_db(agent.Agent))
+                except Exception as e:
+                    logger.error(f"Error processing library agent {agent.agentId}: {e}")
+                    continue
 
-    except prisma.errors.PrismaError as e:
-        logger.error(f"Database error fetching library agents: {e}")
-        raise store_exceptions.DatabaseError("Failed to fetch library agents") from e
-
-
-async def get_library_agent(id: str, user_id: str) -> library_model.LibraryAgent:
-    """
-    Get a specific agent from the user's library.
-
-    Args:
-        library_agent_id: ID of the library agent to retrieve.
-        user_id: ID of the authenticated user.
-
-    Returns:
-        The requested LibraryAgent.
-
-    Raises:
-        AgentNotFoundError: If the specified agent does not exist.
-        DatabaseError: If there's an error during retrieval.
-    """
-    try:
-        library_agent = await prisma.models.LibraryAgent.prisma().find_first(
-            where={
-                "id": id,
-                "userId": user_id,
-                "isDeleted": False,
-            },
-            include=library_agent_include(user_id),
-        )
-
-        if not library_agent:
-            raise store_exceptions.AgentNotFoundError(f"Library agent #{id} not found")
-
-        return library_model.LibraryAgent.from_db(library_agent)
-
-    except prisma.errors.PrismaError as e:
-        logger.error(f"Database error fetching library agent: {e}")
-        raise store_exceptions.DatabaseError("Failed to fetch library agent") from e
-
-
-async def add_generated_agent_image(
-    graph: backend.data.graph.GraphModel,
-    library_agent_id: str,
-) -> Optional[prisma.models.LibraryAgent]:
-    """
-    Generates an image for the specified LibraryAgent and updates its record.
-    """
-    user_id = graph.user_id
-    graph_id = graph.id
-
-    # Use .jpeg here since we are generating JPEG images
-    filename = f"agent_{graph_id}.jpeg"
-    try:
-        if not (image_url := await store_media.check_media_exists(user_id, filename)):
-            # Generate agent image as JPEG
-            image = await store_image_gen.generate_agent_image(graph)
-
-            # Create UploadFile with the correct filename and content_type
-            image_file = fastapi.UploadFile(file=image, filename=filename)
-
-            image_url = await store_media.upload_media(
-                user_id=user_id, file=image_file, use_file_name=True
+        # Convert Graph models to LibraryAgent models
+        result = []
+        for graph in graphs:
+            result.append(
+                backend.server.v2.library.model.LibraryAgent(
+                    id=graph.id,
+                    version=graph.version,
+                    is_active=graph.is_active,
+                    name=graph.name,
+                    description=graph.description,
+                    isCreatedByUser=any(a.id == graph.id for a in user_created),
+                    input_schema=graph.input_schema,
+                    output_schema=graph.output_schema,
+                )
             )
-    except Exception as e:
-        logger.warning(f"Error generating and uploading agent image: {e}")
-        return None
 
-    return await prisma.models.LibraryAgent.prisma().update(
-        where={"id": library_agent_id},
-        data={"imageUrl": image_url},
-    )
+        logger.debug(f"Found {len(result)} library agents")
+        return result
+
+    except prisma.errors.PrismaError as e:
+        logger.error(f"Database error getting library agents: {str(e)}")
+        raise backend.server.v2.store.exceptions.DatabaseError(
+            "Failed to fetch library agents"
+        ) from e
 
 
-async def create_library_agent(
-    graph: backend.data.graph.GraphModel,
-    user_id: str,
-) -> prisma.models.LibraryAgent:
+async def add_agent_to_library(store_listing_version_id: str, user_id: str) -> None:
     """
-    Adds an agent to the user's library (LibraryAgent table).
-
-    Args:
-        agent: The agent/Graph to add to the library.
-        user_id: The user to whom the agent will be added.
-
-    Returns:
-        The newly created LibraryAgent record.
-
-    Raises:
-        AgentNotFoundError: If the specified agent does not exist.
-        DatabaseError: If there's an error during creation or if image generation fails.
+    Finds the agent from the store listing version and adds it to the user's library (UserAgent table)
+    if they don't already have it
     """
-    logger.info(
-        f"Creating library agent for graph #{graph.id} v{graph.version}; "
-        f"user #{user_id}"
+    logger.debug(
+        f"Adding agent from store listing version {store_listing_version_id} to library for user {user_id}"
     )
 
     try:
-        return await prisma.models.LibraryAgent.prisma().create(
-            data={
-                "isCreatedByUser": (user_id == graph.user_id),
-                "useGraphIsActiveVersion": True,
-                "User": {"connect": {"id": user_id}},
-                "Agent": {
-                    "connect": {
-                        "graphVersionId": {"id": graph.id, "version": graph.version}
-                    }
-                },
+        # Get store listing version to find agent
+        store_listing_version = (
+            await prisma.models.StoreListingVersion.prisma().find_unique(
+                where={"id": store_listing_version_id}, include={"Agent": True}
+            )
+        )
+
+        if not store_listing_version or not store_listing_version.Agent:
+            logger.warning(
+                f"Store listing version not found: {store_listing_version_id}"
+            )
+            raise backend.server.v2.store.exceptions.AgentNotFoundError(
+                f"Store listing version {store_listing_version_id} not found"
+            )
+
+        agent = store_listing_version.Agent
+
+        if agent.userId == user_id:
+            logger.warning(
+                f"User {user_id} cannot add their own agent to their library"
+            )
+            raise backend.server.v2.store.exceptions.DatabaseError(
+                "Cannot add own agent to library"
+            )
+
+        # Check if user already has this agent
+        existing_user_agent = await prisma.models.UserAgent.prisma().find_first(
+            where={
+                "userId": user_id,
+                "agentId": agent.id,
+                "agentVersion": agent.version,
             }
         )
-    except prisma.errors.PrismaError as e:
-        logger.error(f"Database error creating agent in library: {e}")
-        raise store_exceptions.DatabaseError("Failed to create agent in library") from e
 
-
-async def update_agent_version_in_library(
-    user_id: str,
-    agent_id: str,
-    agent_version: int,
-) -> None:
-    """
-    Updates the agent version in the library if useGraphIsActiveVersion is True.
-
-    Args:
-        user_id: Owner of the LibraryAgent.
-        agent_id: The agent's ID to update.
-        agent_version: The new version of the agent.
-
-    Raises:
-        DatabaseError: If there's an error with the update.
-    """
-    logger.debug(
-        f"Updating agent version in library for user #{user_id}, "
-        f"agent #{agent_id} v{agent_version}"
-    )
-    try:
-        library_agent = await prisma.models.LibraryAgent.prisma().find_first_or_raise(
-            where={
-                "userId": user_id,
-                "agentId": agent_id,
-                "useGraphIsActiveVersion": True,
-            },
-        )
-        await prisma.models.LibraryAgent.prisma().update(
-            where={"id": library_agent.id},
-            data={
-                "Agent": {
-                    "connect": {
-                        "graphVersionId": {"id": agent_id, "version": agent_version}
-                    },
-                },
-            },
-        )
-    except prisma.errors.PrismaError as e:
-        logger.error(f"Database error updating agent version in library: {e}")
-        raise store_exceptions.DatabaseError(
-            "Failed to update agent version in library"
-        ) from e
-
-
-async def update_library_agent(
-    library_agent_id: str,
-    user_id: str,
-    auto_update_version: Optional[bool] = None,
-    is_favorite: Optional[bool] = None,
-    is_archived: Optional[bool] = None,
-    is_deleted: Optional[bool] = None,
-) -> None:
-    """
-    Updates the specified LibraryAgent record.
-
-    Args:
-        library_agent_id: The ID of the LibraryAgent to update.
-        user_id: The owner of this LibraryAgent.
-        auto_update_version: Whether the agent should auto-update to active version.
-        is_favorite: Whether this agent is marked as a favorite.
-        is_archived: Whether this agent is archived.
-        is_deleted: Whether this agent is deleted.
-
-    Raises:
-        DatabaseError: If there's an error in the update operation.
-    """
-    logger.debug(
-        f"Updating library agent {library_agent_id} for user {user_id} with "
-        f"auto_update_version={auto_update_version}, is_favorite={is_favorite}, "
-        f"is_archived={is_archived}, is_deleted={is_deleted}"
-    )
-    update_fields: prisma.types.LibraryAgentUpdateManyMutationInput = {}
-    if auto_update_version is not None:
-        update_fields["useGraphIsActiveVersion"] = auto_update_version
-    if is_favorite is not None:
-        update_fields["isFavorite"] = is_favorite
-    if is_archived is not None:
-        update_fields["isArchived"] = is_archived
-    if is_deleted is not None:
-        update_fields["isDeleted"] = is_deleted
-
-    try:
-        await prisma.models.LibraryAgent.prisma().update_many(
-            where={"id": library_agent_id, "userId": user_id}, data=update_fields
-        )
-    except prisma.errors.PrismaError as e:
-        logger.error(f"Database error updating library agent: {str(e)}")
-        raise store_exceptions.DatabaseError("Failed to update library agent") from e
-
-
-async def delete_library_agent_by_graph_id(graph_id: str, user_id: str) -> None:
-    """
-    Deletes a library agent for the given user
-    """
-    try:
-        await prisma.models.LibraryAgent.prisma().delete_many(
-            where={"agentId": graph_id, "userId": user_id}
-        )
-    except prisma.errors.PrismaError as e:
-        logger.error(f"Database error deleting library agent: {e}")
-        raise store_exceptions.DatabaseError("Failed to delete library agent") from e
-
-
-async def add_store_agent_to_library(
-    store_listing_version_id: str, user_id: str
-) -> library_model.LibraryAgent:
-    """
-    Adds an agent from a store listing version to the user's library if they don't already have it.
-
-    Args:
-        store_listing_version_id: The ID of the store listing version containing the agent.
-        user_id: The user’s library to which the agent is being added.
-
-    Returns:
-        The newly created LibraryAgent if successfully added, the existing corresponding one if any.
-
-    Raises:
-        AgentNotFoundError: If the store listing or associated agent is not found.
-        DatabaseError: If there's an issue creating the LibraryAgent record.
-    """
-    logger.debug(
-        f"Adding agent from store listing version #{store_listing_version_id} "
-        f"to library for user #{user_id}"
-    )
-
-    try:
-        async with locked_transaction(f"user_trx_{user_id}"):
-            store_listing_version = (
-                await prisma.models.StoreListingVersion.prisma().find_unique(
-                    where={"id": store_listing_version_id}, include={"Agent": True}
-                )
-            )
-            if not store_listing_version or not store_listing_version.Agent:
-                logger.warning(
-                    f"Store listing version not found: {store_listing_version_id}"
-                )
-                raise store_exceptions.AgentNotFoundError(
-                    f"Store listing version {store_listing_version_id} not found or invalid"
-                )
-
-            graph = store_listing_version.Agent
-            if graph.userId == user_id:
-                logger.warning(
-                    f"User #{user_id} attempted to add their own agent to their library"
-                )
-                raise store_exceptions.DatabaseError("Cannot add own agent to library")
-
-            # Check if user already has this agent
-            existing_library_agent = (
-                await prisma.models.LibraryAgent.prisma().find_first(
-                    where={
-                        "userId": user_id,
-                        "agentId": graph.id,
-                        "agentVersion": graph.version,
-                    },
-                    include=library_agent_include(user_id),
-                )
-            )
-            if existing_library_agent:
-                if existing_library_agent.isDeleted:
-                    # Even if agent exists it needs to be marked as not deleted
-                    await set_is_deleted_for_library_agent(
-                        user_id, graph.id, graph.version, False
-                    )
-                else:
-                    logger.debug(
-                        f"User #{user_id} already has graph #{graph.id} "
-                        "in their library"
-                    )
-                return library_model.LibraryAgent.from_db(existing_library_agent)
-
-            # Create LibraryAgent entry
-            added_agent = await prisma.models.LibraryAgent.prisma().create(
-                data={
-                    "userId": user_id,
-                    "agentId": graph.id,
-                    "agentVersion": graph.version,
-                    "isCreatedByUser": False,
-                },
-                include=library_agent_include(user_id),
-            )
+        if existing_user_agent:
             logger.debug(
-                f"Added graph  #{graph.id} "
-                f"for store listing #{store_listing_version.id} "
-                f"to library for user #{user_id}"
+                f"User {user_id} already has agent {agent.id} in their library"
             )
-            return library_model.LibraryAgent.from_db(added_agent)
+            return
 
-    except store_exceptions.AgentNotFoundError:
-        # Reraise for external handling.
+        # Create UserAgent entry
+        await prisma.models.UserAgent.prisma().create(
+            data=prisma.types.UserAgentCreateInput(
+                userId=user_id,
+                agentId=agent.id,
+                agentVersion=agent.version,
+                isCreatedByUser=False,
+            )
+        )
+        logger.debug(f"Added agent {agent.id} to library for user {user_id}")
+
+    except backend.server.v2.store.exceptions.AgentNotFoundError:
         raise
     except prisma.errors.PrismaError as e:
-        logger.error(f"Database error adding agent to library: {e}")
-        raise store_exceptions.DatabaseError("Failed to add agent to library") from e
-
-
-async def set_is_deleted_for_library_agent(
-    user_id: str, agent_id: str, agent_version: int, is_deleted: bool
-) -> None:
-    """
-    Changes the isDeleted flag for a library agent.
-
-    Args:
-        user_id: The user's library from which the agent is being removed.
-        agent_id: The ID of the agent to remove.
-        agent_version: The version of the agent to remove.
-        is_deleted: Whether the agent is being marked as deleted.
-
-    Raises:
-        DatabaseError: If there's an issue updating the Library
-    """
-    logger.debug(
-        f"Setting isDeleted={is_deleted} for agent {agent_id} v{agent_version} "
-        f"in library for user {user_id}"
-    )
-    try:
-        logger.warning(
-            f"Setting isDeleted={is_deleted} for agent {agent_id} v{agent_version} in library for user {user_id}"
-        )
-        count = await prisma.models.LibraryAgent.prisma().update_many(
-            where={
-                "userId": user_id,
-                "agentId": agent_id,
-                "agentVersion": agent_version,
-            },
-            data={"isDeleted": is_deleted},
-        )
-        logger.warning(f"Updated {count} isDeleted library agents")
-    except prisma.errors.PrismaError as e:
-        logger.error(f"Database error setting agent isDeleted: {e}")
-        raise store_exceptions.DatabaseError(
-            "Failed to set agent isDeleted in library"
+        logger.error(f"Database error adding agent to library: {str(e)}")
+        raise backend.server.v2.store.exceptions.DatabaseError(
+            "Failed to add agent to library"
         ) from e
-
-
-##############################################
-########### Presets DB Functions #############
-##############################################
-
-
-async def get_presets(
-    user_id: str, page: int, page_size: int
-) -> library_model.LibraryAgentPresetResponse:
-    """
-    Retrieves a paginated list of AgentPresets for the specified user.
-
-    Args:
-        user_id: The user ID whose presets are being retrieved.
-        page: The current page index (0-based or 1-based, clarify in your domain).
-        page_size: Number of items to retrieve per page.
-
-    Returns:
-        A LibraryAgentPresetResponse containing a list of presets and pagination info.
-
-    Raises:
-        DatabaseError: If there's a database error during the operation.
-    """
-    logger.debug(
-        f"Fetching presets for user #{user_id}, page={page}, page_size={page_size}"
-    )
-
-    if page < 0 or page_size < 1:
-        logger.warning(
-            "Invalid pagination input: page=%d, page_size=%d", page, page_size
-        )
-        raise store_exceptions.DatabaseError("Invalid pagination parameters")
-
-    try:
-        presets_records = await prisma.models.AgentPreset.prisma().find_many(
-            where={"userId": user_id},
-            skip=page * page_size,
-            take=page_size,
-        )
-        total_items = await prisma.models.AgentPreset.prisma().count(
-            where={"userId": user_id}
-        )
-        total_pages = (total_items + page_size - 1) // page_size
-
-        presets = [
-            library_model.LibraryAgentPreset.from_db(preset)
-            for preset in presets_records
-        ]
-
-        return library_model.LibraryAgentPresetResponse(
-            presets=presets,
-            pagination=backend.server.model.Pagination(
-                total_items=total_items,
-                total_pages=total_pages,
-                current_page=page,
-                page_size=page_size,
-            ),
-        )
-
-    except prisma.errors.PrismaError as e:
-        logger.error(f"Database error getting presets: {e}")
-        raise store_exceptions.DatabaseError("Failed to fetch presets") from e
-
-
-async def get_preset(
-    user_id: str, preset_id: str
-) -> library_model.LibraryAgentPreset | None:
-    """
-    Retrieves a single AgentPreset by its ID for a given user.
-
-    Args:
-        user_id: The user that owns the preset.
-        preset_id: The ID of the preset.
-
-    Returns:
-        A LibraryAgentPreset if it exists and matches the user, otherwise None.
-
-    Raises:
-        DatabaseError: If there's a database error during the fetch.
-    """
-    logger.debug(f"Fetching preset #{preset_id} for user #{user_id}")
-    try:
-        preset = await prisma.models.AgentPreset.prisma().find_unique(
-            where={"id": preset_id},
-            include={"InputPresets": True},
-        )
-        if not preset or preset.userId != user_id:
-            return None
-        return library_model.LibraryAgentPreset.from_db(preset)
-    except prisma.errors.PrismaError as e:
-        logger.error(f"Database error getting preset: {e}")
-        raise store_exceptions.DatabaseError("Failed to fetch preset") from e
-
-
-async def upsert_preset(
-    user_id: str,
-    preset: library_model.CreateLibraryAgentPresetRequest,
-    preset_id: Optional[str] = None,
-) -> library_model.LibraryAgentPreset:
-    """
-    Creates or updates an AgentPreset for a user.
-
-    Args:
-        user_id: The ID of the user creating/updating the preset.
-        preset: The preset data used for creation or update.
-        preset_id: An optional preset ID to update; if None, a new preset is created.
-
-    Returns:
-        The newly created or updated LibraryAgentPreset.
-
-    Raises:
-        DatabaseError: If there's a database error in creating or updating the preset.
-        ValueError: If attempting to update a non-existent preset.
-    """
-    logger.debug(
-        f"Upserting preset #{preset_id} ({repr(preset.name)}) for user #{user_id}",
-    )
-    try:
-        if preset_id:
-            # Update existing preset
-            updated = await prisma.models.AgentPreset.prisma().update(
-                where={"id": preset_id},
-                data={
-                    "name": preset.name,
-                    "description": preset.description,
-                    "isActive": preset.is_active,
-                    "InputPresets": {
-                        "create": [
-                            {"name": name, "data": prisma.fields.Json(data)}
-                            for name, data in preset.inputs.items()
-                        ]
-                    },
-                },
-                include={"InputPresets": True},
-            )
-            if not updated:
-                raise ValueError(f"AgentPreset #{preset_id} not found")
-            return library_model.LibraryAgentPreset.from_db(updated)
-        else:
-            # Create new preset
-            new_preset = await prisma.models.AgentPreset.prisma().create(
-                data={
-                    "userId": user_id,
-                    "name": preset.name,
-                    "description": preset.description,
-                    "agentId": preset.agent_id,
-                    "agentVersion": preset.agent_version,
-                    "isActive": preset.is_active,
-                    "InputPresets": {
-                        "create": [
-                            {"name": name, "data": prisma.fields.Json(data)}
-                            for name, data in preset.inputs.items()
-                        ]
-                    },
-                },
-                include={"InputPresets": True},
-            )
-        return library_model.LibraryAgentPreset.from_db(new_preset)
-    except prisma.errors.PrismaError as e:
-        logger.error(f"Database error upserting preset: {e}")
-        raise store_exceptions.DatabaseError("Failed to create preset") from e
-
-
-async def delete_preset(user_id: str, preset_id: str) -> None:
-    """
-    Soft-deletes a preset by marking it as isDeleted = True.
-
-    Args:
-        user_id: The user that owns the preset.
-        preset_id: The ID of the preset to delete.
-
-    Raises:
-        DatabaseError: If there's a database error during deletion.
-    """
-    logger.info(f"Deleting preset {preset_id} for user {user_id}")
-    try:
-        await prisma.models.AgentPreset.prisma().update_many(
-            where={"id": preset_id, "userId": user_id},
-            data={"isDeleted": True},
-        )
-    except prisma.errors.PrismaError as e:
-        logger.error(f"Database error deleting preset: {e}")
-        raise store_exceptions.DatabaseError("Failed to delete preset") from e

autogpt_platform/backend/backend/server/v2/library/db_test.py

@@ -3,11 +3,21 @@ from datetime import datetime
 import prisma.errors
 import prisma.models
 import pytest
+from prisma import Prisma
 
+import backend.data.includes
 import backend.server.v2.library.db as db
 import backend.server.v2.store.exceptions
-from backend.data.db import connect
-from backend.data.includes import library_agent_include
+
+
+@pytest.fixture(autouse=True)
+async def setup_prisma():
+    # Don't register client if already registered
+    try:
+        Prisma()
+    except prisma.errors.ClientAlreadyRegisteredError:
+        pass
+    yield
 
 
 @pytest.mark.asyncio
@@ -22,11 +32,12 @@ async def test_get_library_agents(mocker):
             userId="test-user",
             isActive=True,
             createdAt=datetime.now(),
+            isTemplate=False,
         )
     ]
 
     mock_library_agents = [
-        prisma.models.LibraryAgent(
+        prisma.models.UserAgent(
             id="ua1",
             userId="test-user",
             agentId="agent2",
@@ -37,7 +48,6 @@ async def test_get_library_agents(mocker):
             createdAt=datetime.now(),
             updatedAt=datetime.now(),
             isFavorite=False,
-            useGraphIsActiveVersion=True,
             Agent=prisma.models.AgentGraph(
                 id="agent2",
                 version=1,
@@ -46,6 +56,7 @@ async def test_get_library_agents(mocker):
                 userId="other-user",
                 isActive=True,
                 createdAt=datetime.now(),
+                isTemplate=False,
             ),
         )
     ]
@@ -56,35 +67,55 @@ async def test_get_library_agents(mocker):
         return_value=mock_user_created
     )
 
-    mock_library_agent = mocker.patch("prisma.models.LibraryAgent.prisma")
-    mock_library_agent.return_value.find_many = mocker.AsyncMock(
+    mock_user_agent = mocker.patch("prisma.models.UserAgent.prisma")
+    mock_user_agent.return_value.find_many = mocker.AsyncMock(
         return_value=mock_library_agents
     )
-    mock_library_agent.return_value.count = mocker.AsyncMock(return_value=1)
 
     # Call function
-    result = await db.list_library_agents("test-user")
+    result = await db.get_library_agents("test-user")
 
     # Verify results
-    assert len(result.agents) == 1
-    assert result.agents[0].id == "ua1"
-    assert result.agents[0].name == "Test Agent 2"
-    assert result.agents[0].description == "Test Description 2"
-    assert result.agents[0].agent_id == "agent2"
-    assert result.agents[0].agent_version == 1
-    assert result.agents[0].can_access_graph is False
-    assert result.agents[0].is_latest_version is True
-    assert result.pagination.total_items == 1
-    assert result.pagination.total_pages == 1
-    assert result.pagination.current_page == 1
-    assert result.pagination.page_size == 50
+    assert len(result) == 2
+    assert result[0].id == "agent1"
+    assert result[0].name == "Test Agent 1"
+    assert result[0].description == "Test Description 1"
+    assert result[0].isCreatedByUser is True
+    assert result[1].id == "agent2"
+    assert result[1].name == "Test Agent 2"
+    assert result[1].description == "Test Description 2"
+    assert result[1].isCreatedByUser is False
+
+    # Verify mocks called correctly
+    mock_agent_graph.return_value.find_many.assert_called_once_with(
+        where=prisma.types.AgentGraphWhereInput(userId="test-user", isActive=True),
+        include=backend.data.includes.AGENT_GRAPH_INCLUDE,
+    )
+    mock_user_agent.return_value.find_many.assert_called_once_with(
+        where=prisma.types.UserAgentWhereInput(
+            userId="test-user", isDeleted=False, isArchived=False
+        ),
+        include={
+            "Agent": {
+                "include": {
+                    "AgentNodes": {
+                        "include": {
+                            "Input": True,
+                            "Output": True,
+                            "Webhook": True,
+                            "AgentBlock": True,
+                        }
+                    }
+                }
+            }
+        },
+    )
 
 
-@pytest.mark.asyncio(scope="session")
+@pytest.mark.asyncio
 async def test_add_agent_to_library(mocker):
-    await connect()
     # Mock data
-    mock_store_listing_data = prisma.models.StoreListingVersion(
+    mock_store_listing = prisma.models.StoreListingVersion(
         id="version123",
         version=1,
         createdAt=datetime.now(),
@@ -109,64 +140,45 @@ async def test_add_agent_to_library(mocker):
             userId="creator",
             isActive=True,
             createdAt=datetime.now(),
+            isTemplate=False,
         ),
     )
 
-    mock_library_agent_data = prisma.models.LibraryAgent(
-        id="ua1",
-        userId="test-user",
-        agentId=mock_store_listing_data.agentId,
-        agentVersion=1,
-        isCreatedByUser=False,
-        isDeleted=False,
-        isArchived=False,
-        createdAt=datetime.now(),
-        updatedAt=datetime.now(),
-        isFavorite=False,
-        useGraphIsActiveVersion=True,
-        Agent=mock_store_listing_data.Agent,
-    )
-
     # Mock prisma calls
     mock_store_listing_version = mocker.patch(
         "prisma.models.StoreListingVersion.prisma"
     )
     mock_store_listing_version.return_value.find_unique = mocker.AsyncMock(
-        return_value=mock_store_listing_data
+        return_value=mock_store_listing
     )
 
-    mock_library_agent = mocker.patch("prisma.models.LibraryAgent.prisma")
-    mock_library_agent.return_value.find_first = mocker.AsyncMock(return_value=None)
-    mock_library_agent.return_value.create = mocker.AsyncMock(
-        return_value=mock_library_agent_data
-    )
+    mock_user_agent = mocker.patch("prisma.models.UserAgent.prisma")
+    mock_user_agent.return_value.find_first = mocker.AsyncMock(return_value=None)
+    mock_user_agent.return_value.create = mocker.AsyncMock()
 
     # Call function
-    await db.add_store_agent_to_library("version123", "test-user")
+    await db.add_agent_to_library("version123", "test-user")
 
     # Verify mocks called correctly
     mock_store_listing_version.return_value.find_unique.assert_called_once_with(
         where={"id": "version123"}, include={"Agent": True}
     )
-    mock_library_agent.return_value.find_first.assert_called_once_with(
+    mock_user_agent.return_value.find_first.assert_called_once_with(
         where={
             "userId": "test-user",
             "agentId": "agent1",
             "agentVersion": 1,
-        },
-        include=library_agent_include("test-user"),
+        }
     )
-    mock_library_agent.return_value.create.assert_called_once_with(
-        data=prisma.types.LibraryAgentCreateInput(
+    mock_user_agent.return_value.create.assert_called_once_with(
+        data=prisma.types.UserAgentCreateInput(
             userId="test-user", agentId="agent1", agentVersion=1, isCreatedByUser=False
-        ),
-        include=library_agent_include("test-user"),
+        )
     )
 
 
-@pytest.mark.asyncio(scope="session")
+@pytest.mark.asyncio
 async def test_add_agent_to_library_not_found(mocker):
-    await connect()
     # Mock prisma calls
     mock_store_listing_version = mocker.patch(
         "prisma.models.StoreListingVersion.prisma"
@@ -177,7 +189,7 @@ async def test_add_agent_to_library_not_found(mocker):
 
     # Call function and verify exception
     with pytest.raises(backend.server.v2.store.exceptions.AgentNotFoundError):
-        await db.add_store_agent_to_library("version123", "test-user")
+        await db.add_agent_to_library("version123", "test-user")
 
     # Verify mock called correctly
     mock_store_listing_version.return_value.find_unique.assert_called_once_with(

autogpt_platform/backend/backend/server/v2/library/model.py

@@ -1,259 +1,16 @@
-import datetime
-from enum import Enum
-from typing import Any, Optional
+import typing
 
-import prisma.enums
-import prisma.models
 import pydantic
 
-import backend.data.block as block_model
-import backend.data.graph as graph_model
-import backend.server.model as server_model
-
-
-class LibraryAgentStatus(str, Enum):
-    COMPLETED = "COMPLETED"  # All runs completed
-    HEALTHY = "HEALTHY"  # Agent is running (not all runs have completed)
-    WAITING = "WAITING"  # Agent is queued or waiting to start
-    ERROR = "ERROR"  # Agent is in an error state
-
 
 class LibraryAgent(pydantic.BaseModel):
-    """
-    Represents an agent in the library, including metadata for display and
-    user interaction within the system.
-    """
-
-    id: str
-    agent_id: str
-    agent_version: int
-
-    image_url: str | None
-
-    creator_name: str
-    creator_image_url: str
-
-    status: LibraryAgentStatus
-
-    updated_at: datetime.datetime
-
+    id: str  # Changed from agent_id to match GraphMeta
+    version: int  # Changed from agent_version to match GraphMeta
+    is_active: bool  # Added to match GraphMeta
     name: str
     description: str
 
+    isCreatedByUser: bool
     # Made input_schema and output_schema match GraphMeta's type
-    input_schema: dict[str, Any]  # Should be BlockIOObjectSubSchema in frontend
-
-    # Indicates whether there's a new output (based on recent runs)
-    new_output: bool
-
-    # Whether the user can access the underlying graph
-    can_access_graph: bool
-
-    # Indicates if this agent is the latest version
-    is_latest_version: bool
-
-    @staticmethod
-    def from_db(agent: prisma.models.LibraryAgent) -> "LibraryAgent":
-        """
-        Factory method that constructs a LibraryAgent from a Prisma LibraryAgent
-        model instance.
-        """
-        if not agent.Agent:
-            raise ValueError("Associated Agent record is required.")
-
-        graph = graph_model.GraphModel.from_db(agent.Agent)
-
-        agent_updated_at = agent.Agent.updatedAt
-        lib_agent_updated_at = agent.updatedAt
-
-        # Compute updated_at as the latest between library agent and graph
-        updated_at = (
-            max(agent_updated_at, lib_agent_updated_at)
-            if agent_updated_at
-            else lib_agent_updated_at
-        )
-
-        creator_name = "Unknown"
-        creator_image_url = ""
-        if agent.Creator:
-            creator_name = agent.Creator.name or "Unknown"
-            creator_image_url = agent.Creator.avatarUrl or ""
-
-        # Logic to calculate status and new_output
-        week_ago = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(
-            days=7
-        )
-        executions = agent.Agent.AgentGraphExecution or []
-        status_result = _calculate_agent_status(executions, week_ago)
-        status = status_result.status
-        new_output = status_result.new_output
-
-        # Check if user can access the graph
-        can_access_graph = agent.Agent.userId == agent.userId
-
-        # Hard-coded to True until a method to check is implemented
-        is_latest_version = True
-
-        return LibraryAgent(
-            id=agent.id,
-            agent_id=agent.agentId,
-            agent_version=agent.agentVersion,
-            image_url=agent.imageUrl,
-            creator_name=creator_name,
-            creator_image_url=creator_image_url,
-            status=status,
-            updated_at=updated_at,
-            name=graph.name,
-            description=graph.description,
-            input_schema=graph.input_schema,
-            new_output=new_output,
-            can_access_graph=can_access_graph,
-            is_latest_version=is_latest_version,
-        )
-
-
-class AgentStatusResult(pydantic.BaseModel):
-    status: LibraryAgentStatus
-    new_output: bool
-
-
-def _calculate_agent_status(
-    executions: list[prisma.models.AgentGraphExecution],
-    recent_threshold: datetime.datetime,
-) -> AgentStatusResult:
-    """
-    Helper function to determine the overall agent status and whether there
-    is new output (i.e., completed runs within the recent threshold).
-
-    :param executions: A list of AgentGraphExecution objects.
-    :param recent_threshold: A datetime; any execution after this indicates new output.
-    :return: (AgentStatus, new_output_flag)
-    """
-
-    if not executions:
-        return AgentStatusResult(status=LibraryAgentStatus.COMPLETED, new_output=False)
-
-    # Track how many times each execution status appears
-    status_counts = {status: 0 for status in prisma.enums.AgentExecutionStatus}
-    new_output = False
-
-    for execution in executions:
-        # Check if there's a completed run more recent than `recent_threshold`
-        if execution.createdAt >= recent_threshold:
-            if execution.executionStatus == prisma.enums.AgentExecutionStatus.COMPLETED:
-                new_output = True
-        status_counts[execution.executionStatus] += 1
-
-    # Determine the final status based on counts
-    if status_counts[prisma.enums.AgentExecutionStatus.FAILED] > 0:
-        return AgentStatusResult(status=LibraryAgentStatus.ERROR, new_output=new_output)
-    elif status_counts[prisma.enums.AgentExecutionStatus.QUEUED] > 0:
-        return AgentStatusResult(
-            status=LibraryAgentStatus.WAITING, new_output=new_output
-        )
-    elif status_counts[prisma.enums.AgentExecutionStatus.RUNNING] > 0:
-        return AgentStatusResult(
-            status=LibraryAgentStatus.HEALTHY, new_output=new_output
-        )
-    else:
-        return AgentStatusResult(
-            status=LibraryAgentStatus.COMPLETED, new_output=new_output
-        )
-
-
-class LibraryAgentResponse(pydantic.BaseModel):
-    """Response schema for a list of library agents and pagination info."""
-
-    agents: list[LibraryAgent]
-    pagination: server_model.Pagination
-
-
-class LibraryAgentPreset(pydantic.BaseModel):
-    """Represents a preset configuration for a library agent."""
-
-    id: str
-    updated_at: datetime.datetime
-
-    agent_id: str
-    agent_version: int
-
-    name: str
-    description: str
-
-    is_active: bool
-
-    inputs: block_model.BlockInput
-
-    @classmethod
-    def from_db(cls, preset: prisma.models.AgentPreset) -> "LibraryAgentPreset":
-        input_data: block_model.BlockInput = {}
-
-        for preset_input in preset.InputPresets or []:
-            input_data[preset_input.name] = preset_input.data
-
-        return cls(
-            id=preset.id,
-            updated_at=preset.updatedAt,
-            agent_id=preset.agentId,
-            agent_version=preset.agentVersion,
-            name=preset.name,
-            description=preset.description,
-            is_active=preset.isActive,
-            inputs=input_data,
-        )
-
-
-class LibraryAgentPresetResponse(pydantic.BaseModel):
-    """Response schema for a list of agent presets and pagination info."""
-
-    presets: list[LibraryAgentPreset]
-    pagination: server_model.Pagination
-
-
-class CreateLibraryAgentPresetRequest(pydantic.BaseModel):
-    """
-    Request model used when creating a new preset for a library agent.
-    """
-
-    name: str
-    description: str
-    inputs: block_model.BlockInput
-    agent_id: str
-    agent_version: int
-    is_active: bool
-
-
-class LibraryAgentFilter(str, Enum):
-    """Possible filters for searching library agents."""
-
-    IS_FAVOURITE = "isFavourite"
-    IS_CREATED_BY_USER = "isCreatedByUser"
-
-
-class LibraryAgentSort(str, Enum):
-    """Possible sort options for sorting library agents."""
-
-    CREATED_AT = "createdAt"
-    UPDATED_AT = "updatedAt"
-
-
-class LibraryAgentUpdateRequest(pydantic.BaseModel):
-    """
-    Schema for updating a library agent via PUT.
-
-    Includes flags for auto-updating version, marking as favorite,
-    archiving, or deleting.
-    """
-
-    auto_update_version: Optional[bool] = pydantic.Field(
-        default=None, description="Auto-update the agent version"
-    )
-    is_favorite: Optional[bool] = pydantic.Field(
-        default=None, description="Mark the agent as a favorite"
-    )
-    is_archived: Optional[bool] = pydantic.Field(
-        default=None, description="Archive the agent"
-    )
-    is_deleted: Optional[bool] = pydantic.Field(
-        default=None, description="Delete the agent"
-    )
+    input_schema: dict[str, typing.Any]  # Should be BlockIOObjectSubSchema in frontend
+    output_schema: dict[str, typing.Any]  # Should be BlockIOObjectSubSchema in frontend

autogpt_platform/backend/backend/server/v2/library/model_test.py

@@ -1,43 +1,43 @@
-import datetime
-
-import prisma.fields
-import prisma.models
-import pytest
-
-import backend.server.v2.library.model as library_model
-from backend.util import json
+import backend.server.v2.library.model
 
 
-@pytest.mark.asyncio
-async def test_agent_preset_from_db():
-    # Create mock DB agent
-    db_agent = prisma.models.AgentPreset(
+def test_library_agent():
+    agent = backend.server.v2.library.model.LibraryAgent(
         id="test-agent-123",
-        createdAt=datetime.datetime.now(),
-        updatedAt=datetime.datetime.now(),
-        agentId="agent-123",
-        agentVersion=1,
+        version=1,
+        is_active=True,
         name="Test Agent",
-        description="Test agent description",
-        isActive=True,
-        userId="test-user-123",
-        isDeleted=False,
-        InputPresets=[
-            prisma.models.AgentNodeExecutionInputOutput(
-                id="input-123",
-                time=datetime.datetime.now(),
-                name="input1",
-                data=json.dumps({"type": "string", "value": "test value"}),  # type: ignore
-            )
-        ],
+        description="Test description",
+        isCreatedByUser=False,
+        input_schema={"type": "object", "properties": {}},
+        output_schema={"type": "object", "properties": {}},
     )
-
-    # Convert to LibraryAgentPreset
-    agent = library_model.LibraryAgentPreset.from_db(db_agent)
-
     assert agent.id == "test-agent-123"
-    assert agent.agent_version == 1
+    assert agent.version == 1
     assert agent.is_active is True
     assert agent.name == "Test Agent"
-    assert agent.description == "Test agent description"
-    assert agent.inputs == {"input1": {"type": "string", "value": "test value"}}
+    assert agent.description == "Test description"
+    assert agent.isCreatedByUser is False
+    assert agent.input_schema == {"type": "object", "properties": {}}
+    assert agent.output_schema == {"type": "object", "properties": {}}
+
+
+def test_library_agent_with_user_created():
+    agent = backend.server.v2.library.model.LibraryAgent(
+        id="user-agent-456",
+        version=2,
+        is_active=True,
+        name="User Created Agent",
+        description="An agent created by the user",
+        isCreatedByUser=True,
+        input_schema={"type": "object", "properties": {}},
+        output_schema={"type": "object", "properties": {}},
+    )
+    assert agent.id == "user-agent-456"
+    assert agent.version == 2
+    assert agent.is_active is True
+    assert agent.name == "User Created Agent"
+    assert agent.description == "An agent created by the user"
+    assert agent.isCreatedByUser is True
+    assert agent.input_schema == {"type": "object", "properties": {}}
+    assert agent.output_schema == {"type": "object", "properties": {}}

autogpt_platform/backend/backend/server/v2/library/routes.py

@@ -0,0 +1,123 @@
+import logging
+import typing
+
+import autogpt_libs.auth.depends
+import autogpt_libs.auth.middleware
+import fastapi
+import prisma
+
+import backend.data.graph
+import backend.integrations.creds_manager
+import backend.integrations.webhooks.graph_lifecycle_hooks
+import backend.server.v2.library.db
+import backend.server.v2.library.model
+
+logger = logging.getLogger(__name__)
+
+router = fastapi.APIRouter()
+integration_creds_manager = (
+    backend.integrations.creds_manager.IntegrationCredentialsManager()
+)
+
+
+@router.get(
+    "/agents",
+    tags=["library", "private"],
+    dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],
+)
+async def get_library_agents(
+    user_id: typing.Annotated[
+        str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)
+    ]
+) -> typing.Sequence[backend.server.v2.library.model.LibraryAgent]:
+    """
+    Get all agents in the user's library, including both created and saved agents.
+    """
+    try:
+        agents = await backend.server.v2.library.db.get_library_agents(user_id)
+        return agents
+    except Exception:
+        logger.exception("Exception occurred whilst getting library agents")
+        raise fastapi.HTTPException(
+            status_code=500, detail="Failed to get library agents"
+        )
+
+
+@router.post(
+    "/agents/{store_listing_version_id}",
+    tags=["library", "private"],
+    dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],
+    status_code=201,
+)
+async def add_agent_to_library(
+    store_listing_version_id: str,
+    user_id: typing.Annotated[
+        str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)
+    ],
+) -> fastapi.Response:
+    """
+    Add an agent from the store to the user's library.
+
+    Args:
+        store_listing_version_id (str): ID of the store listing version to add
+        user_id (str): ID of the authenticated user
+
+    Returns:
+        fastapi.Response: 201 status code on success
+
+    Raises:
+        HTTPException: If there is an error adding the agent to the library
+    """
+    try:
+        # Get the graph from the store listing
+        store_listing_version = (
+            await prisma.models.StoreListingVersion.prisma().find_unique(
+                where={"id": store_listing_version_id}, include={"Agent": True}
+            )
+        )
+
+        if not store_listing_version or not store_listing_version.Agent:
+            raise fastapi.HTTPException(
+                status_code=404,
+                detail=f"Store listing version {store_listing_version_id} not found",
+            )
+
+        agent = store_listing_version.Agent
+
+        if agent.userId == user_id:
+            raise fastapi.HTTPException(
+                status_code=400, detail="Cannot add own agent to library"
+            )
+
+        # Create a new graph from the template
+        graph = await backend.data.graph.get_graph(
+            agent.id, agent.version, user_id=user_id
+        )
+
+        if not graph:
+            raise fastapi.HTTPException(
+                status_code=404, detail=f"Agent {agent.id} not found"
+            )
+
+        # Create a deep copy with new IDs
+        graph.version = 1
+        graph.is_template = False
+        graph.is_active = True
+        graph.reassign_ids(user_id=user_id, reassign_graph_id=True)
+
+        # Save the new graph
+        graph = await backend.data.graph.create_graph(graph, user_id=user_id)
+        graph = (
+            await backend.integrations.webhooks.graph_lifecycle_hooks.on_graph_activate(
+                graph,
+                get_credentials=lambda id: integration_creds_manager.get(user_id, id),
+            )
+        )
+
+        return fastapi.Response(status_code=201)
+
+    except Exception:
+        logger.exception("Exception occurred whilst adding agent to library")
+        raise fastapi.HTTPException(
+            status_code=500, detail="Failed to add agent to library"
+        )

autogpt_platform/backend/backend/server/v2/library/routes/__init__.py

@@ -1,9 +0,0 @@
-import fastapi
-
-from .agents import router as agents_router
-from .presets import router as presets_router
-
-router = fastapi.APIRouter()
-
-router.include_router(presets_router)
-router.include_router(agents_router)

autogpt_platform/backend/backend/server/v2/library/routes/agents.py

@@ -1,192 +0,0 @@
-import logging
-from typing import Optional
-
-import autogpt_libs.auth as autogpt_auth_lib
-from fastapi import APIRouter, Body, Depends, HTTPException, Query, status
-from fastapi.responses import JSONResponse
-
-import backend.server.v2.library.db as library_db
-import backend.server.v2.library.model as library_model
-import backend.server.v2.store.exceptions as store_exceptions
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(
-    prefix="/agents",
-    tags=["library", "private"],
-    dependencies=[Depends(autogpt_auth_lib.auth_middleware)],
-)
-
-
-@router.get(
-    "",
-    responses={
-        500: {"description": "Server error", "content": {"application/json": {}}},
-    },
-)
-async def list_library_agents(
-    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
-    search_term: Optional[str] = Query(
-        None, description="Search term to filter agents"
-    ),
-    sort_by: library_model.LibraryAgentSort = Query(
-        library_model.LibraryAgentSort.UPDATED_AT,
-        description="Criteria to sort results by",
-    ),
-    page: int = Query(
-        1,
-        ge=1,
-        description="Page number to retrieve (must be >= 1)",
-    ),
-    page_size: int = Query(
-        15,
-        ge=1,
-        description="Number of agents per page (must be >= 1)",
-    ),
-) -> library_model.LibraryAgentResponse:
-    """
-    Get all agents in the user's library (both created and saved).
-
-    Args:
-        user_id: ID of the authenticated user.
-        search_term: Optional search term to filter agents by name/description.
-        filter_by: List of filters to apply (favorites, created by user).
-        sort_by: List of sorting criteria (created date, updated date).
-        page: Page number to retrieve.
-        page_size: Number of agents per page.
-
-    Returns:
-        A LibraryAgentResponse containing agents and pagination metadata.
-
-    Raises:
-        HTTPException: If a server/database error occurs.
-    """
-    try:
-        return await library_db.list_library_agents(
-            user_id=user_id,
-            search_term=search_term,
-            sort_by=sort_by,
-            page=page,
-            page_size=page_size,
-        )
-    except Exception as e:
-        logger.error(f"Could not fetch library agents: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to get library agents",
-        ) from e
-
-
-@router.get("/{library_agent_id}")
-async def get_library_agent(
-    library_agent_id: str,
-    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
-) -> library_model.LibraryAgent:
-    return await library_db.get_library_agent(id=library_agent_id, user_id=user_id)
-
-
-@router.post(
-    "",
-    status_code=status.HTTP_201_CREATED,
-    responses={
-        201: {"description": "Agent added successfully"},
-        404: {"description": "Store listing version not found"},
-        500: {"description": "Server error"},
-    },
-)
-async def add_marketplace_agent_to_library(
-    store_listing_version_id: str = Body(embed=True),
-    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
-) -> library_model.LibraryAgent:
-    """
-    Add an agent from the marketplace to the user's library.
-
-    Args:
-        store_listing_version_id: ID of the store listing version to add.
-        user_id: ID of the authenticated user.
-
-    Returns:
-        library_model.LibraryAgent: Agent added to the library
-
-    Raises:
-        HTTPException(404): If the listing version is not found.
-        HTTPException(500): If a server/database error occurs.
-    """
-    try:
-        return await library_db.add_store_agent_to_library(
-            store_listing_version_id=store_listing_version_id,
-            user_id=user_id,
-        )
-
-    except store_exceptions.AgentNotFoundError:
-        logger.warning(f"Agent not found: {store_listing_version_id}")
-        raise HTTPException(
-            status_code=404,
-            detail=f"Store listing version {store_listing_version_id} not found",
-        )
-    except store_exceptions.DatabaseError as e:
-        logger.error(f"Database error occurred whilst adding agent to library: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to add agent to library",
-        ) from e
-    except Exception as e:
-        logger.error(f"Unexpected error while adding agent: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to add agent to library",
-        ) from e
-
-
-@router.put(
-    "/{library_agent_id}",
-    status_code=status.HTTP_204_NO_CONTENT,
-    responses={
-        204: {"description": "Agent updated successfully"},
-        500: {"description": "Server error"},
-    },
-)
-async def update_library_agent(
-    library_agent_id: str,
-    payload: library_model.LibraryAgentUpdateRequest,
-    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
-) -> JSONResponse:
-    """
-    Update the library agent with the given fields.
-
-    Args:
-        library_agent_id: ID of the library agent to update.
-        payload: Fields to update (auto_update_version, is_favorite, etc.).
-        user_id: ID of the authenticated user.
-
-    Returns:
-        204 (No Content) on success.
-
-    Raises:
-        HTTPException(500): If a server/database error occurs.
-    """
-    try:
-        await library_db.update_library_agent(
-            library_agent_id=library_agent_id,
-            user_id=user_id,
-            auto_update_version=payload.auto_update_version,
-            is_favorite=payload.is_favorite,
-            is_archived=payload.is_archived,
-            is_deleted=payload.is_deleted,
-        )
-        return JSONResponse(
-            status_code=status.HTTP_204_NO_CONTENT,
-            content={"message": "Agent updated successfully"},
-        )
-    except store_exceptions.DatabaseError as e:
-        logger.exception(f"Database error while updating library agent: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to update library agent",
-        ) from e
-    except Exception as e:
-        logger.exception(f"Unexpected error while updating library agent: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to update library agent",
-        ) from e

autogpt_platform/backend/backend/server/v2/library/routes/presets.py

@@ -1,247 +0,0 @@
-import logging
-from typing import Annotated, Any
-
-import autogpt_libs.auth as autogpt_auth_lib
-import autogpt_libs.utils.cache
-from fastapi import APIRouter, Body, Depends, HTTPException, status
-
-import backend.executor
-import backend.server.v2.library.db as db
-import backend.server.v2.library.model as models
-import backend.util.service
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-
-@autogpt_libs.utils.cache.thread_cached
-def execution_manager_client() -> backend.executor.ExecutionManager:
-    """Return a cached instance of ExecutionManager client."""
-    return backend.util.service.get_service_client(backend.executor.ExecutionManager)
-
-
-@router.get(
-    "/presets",
-    summary="List presets",
-    description="Retrieve a paginated list of presets for the current user.",
-)
-async def get_presets(
-    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
-    page: int = 1,
-    page_size: int = 10,
-) -> models.LibraryAgentPresetResponse:
-    """
-    Retrieve a paginated list of presets for the current user.
-
-    Args:
-        user_id (str): ID of the authenticated user.
-        page (int): Page number for pagination.
-        page_size (int): Number of items per page.
-
-    Returns:
-        models.LibraryAgentPresetResponse: A response containing the list of presets.
-    """
-    try:
-        return await db.get_presets(user_id, page, page_size)
-    except Exception as e:
-        logger.exception(f"Exception occurred while getting presets: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to get presets",
-        )
-
-
-@router.get(
-    "/presets/{preset_id}",
-    summary="Get a specific preset",
-    description="Retrieve details for a specific preset by its ID.",
-)
-async def get_preset(
-    preset_id: str,
-    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
-) -> models.LibraryAgentPreset:
-    """
-    Retrieve details for a specific preset by its ID.
-
-    Args:
-        preset_id (str): ID of the preset to retrieve.
-        user_id (str): ID of the authenticated user.
-
-    Returns:
-        models.LibraryAgentPreset: The preset details.
-
-    Raises:
-        HTTPException: If the preset is not found or an error occurs.
-    """
-    try:
-        preset = await db.get_preset(user_id, preset_id)
-        if not preset:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Preset {preset_id} not found",
-            )
-        return preset
-    except Exception as e:
-        logger.exception(f"Exception occurred whilst getting preset: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to get preset",
-        )
-
-
-@router.post(
-    "/presets",
-    summary="Create a new preset",
-    description="Create a new preset for the current user.",
-)
-async def create_preset(
-    preset: models.CreateLibraryAgentPresetRequest,
-    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
-) -> models.LibraryAgentPreset:
-    """
-    Create a new library agent preset. Automatically corrects node_input format if needed.
-
-    Args:
-        preset (models.CreateLibraryAgentPresetRequest): The preset data to create.
-        user_id (str): ID of the authenticated user.
-
-    Returns:
-        models.LibraryAgentPreset: The created preset.
-
-    Raises:
-        HTTPException: If an error occurs while creating the preset.
-    """
-    try:
-        return await db.upsert_preset(user_id, preset)
-    except Exception as e:
-        logger.exception(f"Exception occurred while creating preset: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to create preset",
-        )
-
-
-@router.put(
-    "/presets/{preset_id}",
-    summary="Update an existing preset",
-    description="Update an existing preset by its ID.",
-)
-async def update_preset(
-    preset_id: str,
-    preset: models.CreateLibraryAgentPresetRequest,
-    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
-) -> models.LibraryAgentPreset:
-    """
-    Update an existing library agent preset. If the preset doesn't exist, it may be created.
-
-    Args:
-        preset_id (str): ID of the preset to update.
-        preset (models.CreateLibraryAgentPresetRequest): The preset data to update.
-        user_id (str): ID of the authenticated user.
-
-    Returns:
-        models.LibraryAgentPreset: The updated preset.
-
-    Raises:
-        HTTPException: If an error occurs while updating the preset.
-    """
-    try:
-        return await db.upsert_preset(user_id, preset, preset_id)
-    except Exception as e:
-        logger.exception(f"Exception occurred whilst updating preset: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to update preset",
-        )
-
-
-@router.delete(
-    "/presets/{preset_id}",
-    status_code=status.HTTP_204_NO_CONTENT,
-    summary="Delete a preset",
-    description="Delete an existing preset by its ID.",
-)
-async def delete_preset(
-    preset_id: str,
-    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
-) -> None:
-    """
-    Delete a preset by its ID. Returns 204 No Content on success.
-
-    Args:
-        preset_id (str): ID of the preset to delete.
-        user_id (str): ID of the authenticated user.
-
-    Raises:
-        HTTPException: If an error occurs while deleting the preset.
-    """
-    try:
-        await db.delete_preset(user_id, preset_id)
-    except Exception as e:
-        logger.exception(f"Exception occurred whilst deleting preset: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to delete preset",
-        )
-
-
-@router.post(
-    "/presets/{preset_id}/execute",
-    tags=["presets"],
-    summary="Execute a preset",
-    description="Execute a preset with the given graph and node input for the current user.",
-)
-async def execute_preset(
-    graph_id: str,
-    graph_version: int,
-    preset_id: str,
-    node_input: Annotated[dict[str, Any], Body(..., embed=True, default_factory=dict)],
-    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
-) -> dict[str, Any]:  # FIXME: add proper return type
-    """
-    Execute a preset given graph parameters, returning the execution ID on success.
-
-    Args:
-        graph_id (str): ID of the graph to execute.
-        graph_version (int): Version of the graph to execute.
-        preset_id (str): ID of the preset to execute.
-        node_input (Dict[Any, Any]): Input data for the node.
-        user_id (str): ID of the authenticated user.
-
-    Returns:
-        Dict[str, Any]: A response containing the execution ID.
-
-    Raises:
-        HTTPException: If the preset is not found or an error occurs while executing the preset.
-    """
-    try:
-        preset = await db.get_preset(user_id, preset_id)
-        if not preset:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="Preset not found",
-            )
-
-        # Merge input overrides with preset inputs
-        merged_node_input = preset.inputs | node_input
-
-        execution = execution_manager_client().add_execution(
-            graph_id=graph_id,
-            graph_version=graph_version,
-            data=merged_node_input,
-            user_id=user_id,
-            preset_id=preset_id,
-        )
-
-        logger.debug(f"Execution added: {execution} with input: {merged_node_input}")
-
-        return {"id": execution.graph_exec_id}
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.exception(f"Exception occurred while executing preset: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=str(e),
-        )

autogpt_platform/backend/backend/server/v2/library/routes_test.py

@@ -1,16 +1,16 @@
-import datetime
-
-import autogpt_libs.auth as autogpt_auth_lib
+import autogpt_libs.auth.depends
+import autogpt_libs.auth.middleware
+import fastapi
 import fastapi.testclient
 import pytest
 import pytest_mock
 
-import backend.server.model as server_model
-import backend.server.v2.library.model as library_model
-from backend.server.v2.library.routes import router as library_router
+import backend.server.v2.library.db
+import backend.server.v2.library.model
+import backend.server.v2.library.routes
 
 app = fastapi.FastAPI()
-app.include_router(library_router)
+app.include_router(backend.server.v2.library.routes.router)
 
 client = fastapi.testclient.TestClient(app)
 
@@ -25,85 +25,60 @@ def override_get_user_id():
     return "test-user-id"
 
 
-app.dependency_overrides[autogpt_auth_lib.auth_middleware] = override_auth_middleware
-app.dependency_overrides[autogpt_auth_lib.depends.get_user_id] = override_get_user_id
+app.dependency_overrides[autogpt_libs.auth.middleware.auth_middleware] = (
+    override_auth_middleware
+)
+app.dependency_overrides[autogpt_libs.auth.depends.get_user_id] = override_get_user_id
 
 
-@pytest.mark.asyncio
-async def test_get_library_agents_success(mocker: pytest_mock.MockFixture):
-    mocked_value = library_model.LibraryAgentResponse(
-        agents=[
-            library_model.LibraryAgent(
-                id="test-agent-1",
-                agent_id="test-agent-1",
-                agent_version=1,
-                name="Test Agent 1",
-                description="Test Description 1",
-                image_url=None,
-                creator_name="Test Creator",
-                creator_image_url="",
-                input_schema={"type": "object", "properties": {}},
-                status=library_model.LibraryAgentStatus.COMPLETED,
-                new_output=False,
-                can_access_graph=True,
-                is_latest_version=True,
-                updated_at=datetime.datetime(2023, 1, 1, 0, 0, 0),
-            ),
-            library_model.LibraryAgent(
-                id="test-agent-2",
-                agent_id="test-agent-2",
-                agent_version=1,
-                name="Test Agent 2",
-                description="Test Description 2",
-                image_url=None,
-                creator_name="Test Creator",
-                creator_image_url="",
-                input_schema={"type": "object", "properties": {}},
-                status=library_model.LibraryAgentStatus.COMPLETED,
-                new_output=False,
-                can_access_graph=False,
-                is_latest_version=True,
-                updated_at=datetime.datetime(2023, 1, 1, 0, 0, 0),
-            ),
-        ],
-        pagination=server_model.Pagination(
-            total_items=2, total_pages=1, current_page=1, page_size=50
+def test_get_library_agents_success(mocker: pytest_mock.MockFixture):
+    mocked_value = [
+        backend.server.v2.library.model.LibraryAgent(
+            id="test-agent-1",
+            version=1,
+            is_active=True,
+            name="Test Agent 1",
+            description="Test Description 1",
+            isCreatedByUser=True,
+            input_schema={"type": "object", "properties": {}},
+            output_schema={"type": "object", "properties": {}},
         ),
-    )
-    mock_db_call = mocker.patch("backend.server.v2.library.db.list_library_agents")
+        backend.server.v2.library.model.LibraryAgent(
+            id="test-agent-2",
+            version=1,
+            is_active=True,
+            name="Test Agent 2",
+            description="Test Description 2",
+            isCreatedByUser=False,
+            input_schema={"type": "object", "properties": {}},
+            output_schema={"type": "object", "properties": {}},
+        ),
+    ]
+    mock_db_call = mocker.patch("backend.server.v2.library.db.get_library_agents")
     mock_db_call.return_value = mocked_value
 
-    response = client.get("/agents?search_term=test")
+    response = client.get("/agents")
     assert response.status_code == 200
 
-    data = library_model.LibraryAgentResponse.model_validate(response.json())
-    assert len(data.agents) == 2
-    assert data.agents[0].agent_id == "test-agent-1"
-    assert data.agents[0].can_access_graph is True
-    assert data.agents[1].agent_id == "test-agent-2"
-    assert data.agents[1].can_access_graph is False
-    mock_db_call.assert_called_once_with(
-        user_id="test-user-id",
-        search_term="test",
-        sort_by=library_model.LibraryAgentSort.UPDATED_AT,
-        page=1,
-        page_size=15,
-    )
+    data = [
+        backend.server.v2.library.model.LibraryAgent.model_validate(agent)
+        for agent in response.json()
+    ]
+    assert len(data) == 2
+    assert data[0].id == "test-agent-1"
+    assert data[0].isCreatedByUser is True
+    assert data[1].id == "test-agent-2"
+    assert data[1].isCreatedByUser is False
+    mock_db_call.assert_called_once_with("test-user-id")
 
 
 def test_get_library_agents_error(mocker: pytest_mock.MockFixture):
-    mock_db_call = mocker.patch("backend.server.v2.library.db.list_library_agents")
+    mock_db_call = mocker.patch("backend.server.v2.library.db.get_library_agents")
     mock_db_call.side_effect = Exception("Test error")
 
-    response = client.get("/agents?search_term=test")
+    response = client.get("/agents")
     assert response.status_code == 500
-    mock_db_call.assert_called_once_with(
-        user_id="test-user-id",
-        search_term="test",
-        sort_by=library_model.LibraryAgentSort.UPDATED_AT,
-        page=1,
-        page_size=15,
-    )
+    mock_db_call.assert_called_once_with("test-user-id")
 
 
 @pytest.mark.skip(reason="Mocker Not implemented")

autogpt_platform/backend/backend/server/v2/otto/models.py

@@ -1,34 +0,0 @@
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel
-
-
-class Document(BaseModel):
-    url: str
-    relevance_score: float
-
-
-class ApiResponse(BaseModel):
-    answer: str
-    documents: list[Document]
-    success: bool
-
-
-class GraphData(BaseModel):
-    nodes: list[Dict[str, Any]]
-    edges: list[Dict[str, Any]]
-    graph_name: Optional[str] = None
-    graph_description: Optional[str] = None
-
-
-class Message(BaseModel):
-    query: str
-    response: str
-
-
-class ChatRequest(BaseModel):
-    query: str
-    conversation_history: list[Message]
-    message_id: str
-    include_graph_data: bool = False
-    graph_id: Optional[str] = None

autogpt_platform/backend/backend/server/v2/otto/routes.py

@@ -1,26 +0,0 @@
-import logging
-
-from autogpt_libs.auth.middleware import auth_middleware
-from fastapi import APIRouter, Depends
-
-from backend.server.utils import get_user_id
-
-from .models import ApiResponse, ChatRequest
-from .service import OttoService
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-
-@router.post(
-    "/ask", response_model=ApiResponse, dependencies=[Depends(auth_middleware)]
-)
-async def proxy_otto_request(
-    request: ChatRequest, user_id: str = Depends(get_user_id)
-) -> ApiResponse:
-    """
-    Proxy requests to Otto API while adding necessary security headers and logging.
-    Requires an authenticated user.
-    """
-    return await OttoService.ask(request, user_id)

autogpt_platform/backend/backend/server/v2/otto/service.py

@@ -1,138 +0,0 @@
-import asyncio
-import logging
-from typing import Optional
-
-import aiohttp
-from fastapi import HTTPException
-
-from backend.data import graph as graph_db
-from backend.data.block import get_block
-from backend.util.settings import Settings
-
-from .models import ApiResponse, ChatRequest, GraphData
-
-logger = logging.getLogger(__name__)
-settings = Settings()
-
-OTTO_API_URL = settings.config.otto_api_url
-
-
-class OttoService:
-    @staticmethod
-    async def _fetch_graph_data(
-        request: ChatRequest, user_id: str
-    ) -> Optional[GraphData]:
-        """Fetch graph data if requested and available."""
-        if not (request.include_graph_data and request.graph_id):
-            return None
-
-        try:
-            graph = await graph_db.get_graph(request.graph_id, user_id=user_id)
-            if not graph:
-                return None
-
-            nodes_data = []
-            for node in graph.nodes:
-                block = get_block(node.block_id)
-                if not block:
-                    continue
-
-                node_data = {
-                    "id": node.id,
-                    "block_id": node.block_id,
-                    "block_name": block.name,
-                    "block_type": (
-                        block.block_type.value if hasattr(block, "block_type") else None
-                    ),
-                    "data": {
-                        k: v
-                        for k, v in (node.input_default or {}).items()
-                        if k not in ["credentials"]  # Exclude sensitive data
-                    },
-                }
-                nodes_data.append(node_data)
-
-            # Create a GraphData object with the required fields
-            return GraphData(
-                nodes=nodes_data,
-                edges=[],
-                graph_name=graph.name,
-                graph_description=graph.description,
-            )
-        except Exception as e:
-            logger.error(f"Failed to fetch graph data: {str(e)}")
-            return None
-
-    @staticmethod
-    async def ask(request: ChatRequest, user_id: str) -> ApiResponse:
-        """
-        Send request to Otto API and handle the response.
-        """
-        # Check if Otto API URL is configured
-        if not OTTO_API_URL:
-            logger.error("Otto API URL is not configured")
-            raise HTTPException(
-                status_code=503, detail="Otto service is not configured"
-            )
-
-        try:
-            async with aiohttp.ClientSession() as session:
-                headers = {
-                    "Content-Type": "application/json",
-                    "Accept": "application/json",
-                }
-
-                # If graph data is requested, fetch it
-                graph_data = await OttoService._fetch_graph_data(request, user_id)
-
-                # Prepare the payload with optional graph data
-                payload = {
-                    "query": request.query,
-                    "conversation_history": [
-                        msg.model_dump() for msg in request.conversation_history
-                    ],
-                    "user_id": user_id,
-                    "message_id": request.message_id,
-                }
-
-                if graph_data:
-                    payload["graph_data"] = graph_data.model_dump()
-
-                logger.info(f"Sending request to Otto API for user {user_id}")
-                logger.debug(f"Request payload: {payload}")
-
-                async with session.post(
-                    OTTO_API_URL,
-                    json=payload,
-                    headers=headers,
-                    timeout=aiohttp.ClientTimeout(total=60),
-                ) as response:
-                    if response.status != 200:
-                        error_text = await response.text()
-                        logger.error(f"Otto API error: {error_text}")
-                        raise HTTPException(
-                            status_code=response.status,
-                            detail=f"Otto API request failed: {error_text}",
-                        )
-
-                    data = await response.json()
-                    logger.info(
-                        f"Successfully received response from Otto API for user {user_id}"
-                    )
-                    return ApiResponse(**data)
-
-        except aiohttp.ClientError as e:
-            logger.error(f"Connection error to Otto API: {str(e)}")
-            raise HTTPException(
-                status_code=503, detail="Failed to connect to Otto service"
-            )
-        except asyncio.TimeoutError:
-            logger.error("Timeout error connecting to Otto API after 60 seconds")
-            raise HTTPException(
-                status_code=504, detail="Request to Otto service timed out"
-            )
-        except Exception as e:
-            logger.error(f"Unexpected error in Otto API proxy: {str(e)}")
-            raise HTTPException(
-                status_code=500, detail="Internal server error in Otto proxy"
-            )