Merge branch 'dev' into gmail-reply-draft

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

@@ -201,7 +201,7 @@ jobs:
           DIRECT_URL: ${{ steps.supabase.outputs.DB_URL }}
           SUPABASE_URL: ${{ steps.supabase.outputs.API_URL }}
           SUPABASE_SERVICE_ROLE_KEY: ${{ steps.supabase.outputs.SERVICE_ROLE_KEY }}
-          JWT_VERIFY_KEY: ${{ steps.supabase.outputs.JWT_SECRET }}
+          SUPABASE_JWT_SECRET: ${{ steps.supabase.outputs.JWT_SECRET }}
           REDIS_HOST: "localhost"
           REDIS_PORT: "6379"
           REDIS_PASSWORD: "testpassword"

autogpt_platform/CLAUDE.md

@@ -149,21 +149,12 @@ Key models (defined in `/backend/schema.prisma`):
 
 **Adding a new block:**
 
-Follow the comprehensive [Block SDK Guide](../../../docs/content/platform/block-sdk-guide.md) which covers:
-- Provider configuration with `ProviderBuilder`
-- Block schema definition
-- Authentication (API keys, OAuth, webhooks)
-- Testing and validation
-- File organization
-
-Quick steps:
 1. Create new file in `/backend/backend/blocks/`
-2. Configure provider using `ProviderBuilder` in `_config.py`
-3. Inherit from `Block` base class
-4. Define input/output schemas using `BlockSchema`
-5. Implement async `run` method
-6. Generate unique block ID using `uuid.uuid4()`
-7. Test with `poetry run pytest backend/blocks/test/test_block.py`
+2. Inherit from `Block` base class
+3. Define input/output schemas
+4. Implement `run` method
+5. Register in block registry
+6. Generate the block uuid using `uuid.uuid4()`
 
 Note: when making many new blocks analyze the interfaces for each of these blocks and picture if they would go well together in a graph based editor or would they struggle to connect productively?
 ex: do the inputs and outputs tie well together?

autogpt_platform/autogpt_libs/autogpt_libs/auth/__init__.py

@@ -1,13 +1,13 @@
-from .config import verify_settings
-from .dependencies import get_user_id, requires_admin_user, requires_user
-from .helpers import add_auth_responses_to_openapi
+from .depends import requires_admin_user, requires_user
+from .jwt_utils import parse_jwt_token
+from .middleware import APIKeyValidator, auth_middleware
 from .models import User
 
 __all__ = [
-    "verify_settings",
-    "get_user_id",
-    "requires_admin_user",
+    "parse_jwt_token",
     "requires_user",
-    "add_auth_responses_to_openapi",
+    "requires_admin_user",
+    "APIKeyValidator",
+    "auth_middleware",
     "User",
 ]

autogpt_platform/autogpt_libs/autogpt_libs/auth/config.py

@@ -1,90 +1,11 @@
-import logging
 import os
 
-from jwt.algorithms import get_default_algorithms, has_crypto
-
-logger = logging.getLogger(__name__)
-
-
-class AuthConfigError(ValueError):
-    """Raised when authentication configuration is invalid."""
-
-    pass
-
-
-ALGO_RECOMMENDATION = (
-    "We highly recommend using an asymmetric algorithm such as ES256, "
-    "because when leaked, a shared secret would allow anyone to "
-    "forge valid tokens and impersonate users. "
-    "More info: https://supabase.com/docs/guides/auth/signing-keys#choosing-the-right-signing-algorithm"  # noqa
-)
-
 
 class Settings:
     def __init__(self):
-        self.JWT_VERIFY_KEY: str = os.getenv(
-            "JWT_VERIFY_KEY", os.getenv("SUPABASE_JWT_SECRET", "")
-        ).strip()
-        self.JWT_ALGORITHM: str = os.getenv("JWT_SIGN_ALGORITHM", "HS256").strip()
-
-        self.validate()
-
-    def validate(self):
-        if not self.JWT_VERIFY_KEY:
-            raise AuthConfigError(
-                "JWT_VERIFY_KEY must be set. "
-                "An empty JWT secret would allow anyone to forge valid tokens."
-            )
-
-        if len(self.JWT_VERIFY_KEY) < 32:
-            logger.warning(
-                "⚠️ JWT_VERIFY_KEY appears weak (less than 32 characters). "
-                "Consider using a longer, cryptographically secure secret."
-            )
-
-        supported_algorithms = get_default_algorithms().keys()
-
-        if not has_crypto:
-            logger.warning(
-                "⚠️ Asymmetric JWT verification is not available "
-                "because the 'cryptography' package is not installed. "
-                + ALGO_RECOMMENDATION
-            )
-
-        if (
-            self.JWT_ALGORITHM not in supported_algorithms
-            or self.JWT_ALGORITHM == "none"
-        ):
-            raise AuthConfigError(
-                f"Invalid JWT_SIGN_ALGORITHM: '{self.JWT_ALGORITHM}'. "
-                "Supported algorithms are listed on "
-                "https://pyjwt.readthedocs.io/en/stable/algorithms.html"
-            )
-
-        if self.JWT_ALGORITHM.startswith("HS"):
-            logger.warning(
-                f"⚠️ JWT_SIGN_ALGORITHM is set to '{self.JWT_ALGORITHM}', "
-                "a symmetric shared-key signature algorithm. " + ALGO_RECOMMENDATION
-            )
+        self.JWT_SECRET_KEY: str = os.getenv("SUPABASE_JWT_SECRET", "")
+        self.ENABLE_AUTH: bool = os.getenv("ENABLE_AUTH", "false").lower() == "true"
+        self.JWT_ALGORITHM: str = "HS256"
 
 
-_settings: Settings = None  # type: ignore
-
-
-def get_settings() -> Settings:
-    global _settings
-
-    if not _settings:
-        _settings = Settings()
-
-    return _settings
-
-
-def verify_settings() -> None:
-    global _settings
-
-    if not _settings:
-        _settings = Settings()  # calls validation indirectly
-        return
-
-    _settings.validate()
+settings = Settings()

autogpt_platform/autogpt_libs/autogpt_libs/auth/config_test.py

@@ -1,306 +0,0 @@
-"""
-Comprehensive tests for auth configuration to ensure 100% line and branch coverage.
-These tests verify critical security checks preventing JWT token forgery.
-"""
-
-import logging
-import os
-
-import pytest
-from pytest_mock import MockerFixture
-
-from autogpt_libs.auth.config import AuthConfigError, Settings
-
-
-def test_environment_variable_precedence(mocker: MockerFixture):
-    """Test that environment variables take precedence over defaults."""
-    secret = "environment-secret-key-with-proper-length-123456"
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": secret}, clear=True)
-
-    settings = Settings()
-    assert settings.JWT_VERIFY_KEY == secret
-
-
-def test_environment_variable_backwards_compatible(mocker: MockerFixture):
-    """Test that SUPABASE_JWT_SECRET is read if JWT_VERIFY_KEY is not set."""
-    secret = "environment-secret-key-with-proper-length-123456"
-    mocker.patch.dict(os.environ, {"SUPABASE_JWT_SECRET": secret}, clear=True)
-
-    settings = Settings()
-    assert settings.JWT_VERIFY_KEY == secret
-
-
-def test_auth_config_error_inheritance():
-    """Test that AuthConfigError is properly defined as an Exception."""
-    assert issubclass(AuthConfigError, Exception)
-    error = AuthConfigError("test message")
-    assert str(error) == "test message"
-
-
-def test_settings_static_after_creation(mocker: MockerFixture):
-    """Test that settings maintain their values after creation."""
-    secret = "immutable-secret-key-with-proper-length-12345"
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": secret}, clear=True)
-
-    settings = Settings()
-    original_secret = settings.JWT_VERIFY_KEY
-
-    # Changing environment after creation shouldn't affect settings
-    os.environ["JWT_VERIFY_KEY"] = "different-secret"
-
-    assert settings.JWT_VERIFY_KEY == original_secret
-
-
-def test_settings_load_with_valid_secret(mocker: MockerFixture):
-    """Test auth enabled with a valid JWT secret."""
-    valid_secret = "a" * 32  # 32 character secret
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": valid_secret}, clear=True)
-
-    settings = Settings()
-    assert settings.JWT_VERIFY_KEY == valid_secret
-
-
-def test_settings_load_with_strong_secret(mocker: MockerFixture):
-    """Test auth enabled with a cryptographically strong secret."""
-    strong_secret = "super-secret-jwt-token-with-at-least-32-characters-long"
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": strong_secret}, clear=True)
-
-    settings = Settings()
-    assert settings.JWT_VERIFY_KEY == strong_secret
-    assert len(settings.JWT_VERIFY_KEY) >= 32
-
-
-def test_secret_empty_raises_error(mocker: MockerFixture):
-    """Test that auth enabled with empty secret raises AuthConfigError."""
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": ""}, clear=True)
-
-    with pytest.raises(Exception) as exc_info:
-        Settings()
-    assert "JWT_VERIFY_KEY" in str(exc_info.value)
-
-
-def test_secret_missing_raises_error(mocker: MockerFixture):
-    """Test that auth enabled without secret env var raises AuthConfigError."""
-    mocker.patch.dict(os.environ, {}, clear=True)
-
-    with pytest.raises(Exception) as exc_info:
-        Settings()
-    assert "JWT_VERIFY_KEY" in str(exc_info.value)
-
-
-@pytest.mark.parametrize("secret", [" ", "  ", "\t", "\n", " \t\n "])
-def test_secret_only_whitespace_raises_error(mocker: MockerFixture, secret: str):
-    """Test that auth enabled with whitespace-only secret raises error."""
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": secret}, clear=True)
-
-    with pytest.raises(ValueError):
-        Settings()
-
-
-def test_secret_weak_logs_warning(
-    mocker: MockerFixture, caplog: pytest.LogCaptureFixture
-):
-    """Test that weak JWT secret triggers warning log."""
-    weak_secret = "short"  # Less than 32 characters
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": weak_secret}, clear=True)
-
-    with caplog.at_level(logging.WARNING):
-        settings = Settings()
-        assert settings.JWT_VERIFY_KEY == weak_secret
-        assert "key appears weak" in caplog.text.lower()
-        assert "less than 32 characters" in caplog.text
-
-
-def test_secret_31_char_logs_warning(
-    mocker: MockerFixture, caplog: pytest.LogCaptureFixture
-):
-    """Test that 31-character secret triggers warning (boundary test)."""
-    secret_31 = "a" * 31  # Exactly 31 characters
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": secret_31}, clear=True)
-
-    with caplog.at_level(logging.WARNING):
-        settings = Settings()
-        assert len(settings.JWT_VERIFY_KEY) == 31
-        assert "key appears weak" in caplog.text.lower()
-
-
-def test_secret_32_char_no_warning(
-    mocker: MockerFixture, caplog: pytest.LogCaptureFixture
-):
-    """Test that 32-character secret does not trigger warning (boundary test)."""
-    secret_32 = "a" * 32  # Exactly 32 characters
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": secret_32}, clear=True)
-
-    with caplog.at_level(logging.WARNING):
-        settings = Settings()
-        assert len(settings.JWT_VERIFY_KEY) == 32
-        assert "JWT secret appears weak" not in caplog.text
-
-
-def test_secret_whitespace_stripped(mocker: MockerFixture):
-    """Test that JWT secret whitespace is stripped."""
-    secret = "a" * 32
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": f"  {secret}  "}, clear=True)
-
-    settings = Settings()
-    assert settings.JWT_VERIFY_KEY == secret
-
-
-def test_secret_with_special_characters(mocker: MockerFixture):
-    """Test JWT secret with special characters."""
-    special_secret = "!@#$%^&*()_+-=[]{}|;:,.<>?`~" + "a" * 10  # 40 chars total
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": special_secret}, clear=True)
-
-    settings = Settings()
-    assert settings.JWT_VERIFY_KEY == special_secret
-
-
-def test_secret_with_unicode(mocker: MockerFixture):
-    """Test JWT secret with unicode characters."""
-    unicode_secret = "秘密🔐キー" + "a" * 25  # Ensure >32 bytes
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": unicode_secret}, clear=True)
-
-    settings = Settings()
-    assert settings.JWT_VERIFY_KEY == unicode_secret
-
-
-def test_secret_very_long(mocker: MockerFixture):
-    """Test JWT secret with excessive length."""
-    long_secret = "a" * 1000  # 1000 character secret
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": long_secret}, clear=True)
-
-    settings = Settings()
-    assert settings.JWT_VERIFY_KEY == long_secret
-    assert len(settings.JWT_VERIFY_KEY) == 1000
-
-
-def test_secret_with_newline(mocker: MockerFixture):
-    """Test JWT secret containing newlines."""
-    multiline_secret = "secret\nwith\nnewlines" + "a" * 20
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": multiline_secret}, clear=True)
-
-    settings = Settings()
-    assert settings.JWT_VERIFY_KEY == multiline_secret
-
-
-def test_secret_base64_encoded(mocker: MockerFixture):
-    """Test JWT secret that looks like base64."""
-    base64_secret = "dGhpc19pc19hX3NlY3JldF9rZXlfd2l0aF9wcm9wZXJfbGVuZ3Ro"
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": base64_secret}, clear=True)
-
-    settings = Settings()
-    assert settings.JWT_VERIFY_KEY == base64_secret
-
-
-def test_secret_numeric_only(mocker: MockerFixture):
-    """Test JWT secret with only numbers."""
-    numeric_secret = "1234567890" * 4  # 40 character numeric secret
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": numeric_secret}, clear=True)
-
-    settings = Settings()
-    assert settings.JWT_VERIFY_KEY == numeric_secret
-
-
-def test_algorithm_default_hs256(mocker: MockerFixture):
-    """Test that JWT algorithm defaults to HS256."""
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": "a" * 32}, clear=True)
-
-    settings = Settings()
-    assert settings.JWT_ALGORITHM == "HS256"
-
-
-def test_algorithm_whitespace_stripped(mocker: MockerFixture):
-    """Test that JWT algorithm whitespace is stripped."""
-    secret = "a" * 32
-    mocker.patch.dict(
-        os.environ,
-        {"JWT_VERIFY_KEY": secret, "JWT_SIGN_ALGORITHM": "  HS256  "},
-        clear=True,
-    )
-
-    settings = Settings()
-    assert settings.JWT_ALGORITHM == "HS256"
-
-
-def test_no_crypto_warning(mocker: MockerFixture, caplog: pytest.LogCaptureFixture):
-    """Test warning when crypto package is not available."""
-    secret = "a" * 32
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": secret}, clear=True)
-
-    # Mock has_crypto to return False
-    mocker.patch("autogpt_libs.auth.config.has_crypto", False)
-
-    with caplog.at_level(logging.WARNING):
-        Settings()
-        assert "Asymmetric JWT verification is not available" in caplog.text
-        assert "cryptography" in caplog.text
-
-
-def test_algorithm_invalid_raises_error(mocker: MockerFixture):
-    """Test that invalid JWT algorithm raises AuthConfigError."""
-    secret = "a" * 32
-    mocker.patch.dict(
-        os.environ,
-        {"JWT_VERIFY_KEY": secret, "JWT_SIGN_ALGORITHM": "INVALID_ALG"},
-        clear=True,
-    )
-
-    with pytest.raises(AuthConfigError) as exc_info:
-        Settings()
-    assert "Invalid JWT_SIGN_ALGORITHM" in str(exc_info.value)
-    assert "INVALID_ALG" in str(exc_info.value)
-
-
-def test_algorithm_none_raises_error(mocker: MockerFixture):
-    """Test that 'none' algorithm raises AuthConfigError."""
-    secret = "a" * 32
-    mocker.patch.dict(
-        os.environ,
-        {"JWT_VERIFY_KEY": secret, "JWT_SIGN_ALGORITHM": "none"},
-        clear=True,
-    )
-
-    with pytest.raises(AuthConfigError) as exc_info:
-        Settings()
-    assert "Invalid JWT_SIGN_ALGORITHM" in str(exc_info.value)
-
-
-@pytest.mark.parametrize("algorithm", ["HS256", "HS384", "HS512"])
-def test_algorithm_symmetric_warning(
-    mocker: MockerFixture, caplog: pytest.LogCaptureFixture, algorithm: str
-):
-    """Test warning for symmetric algorithms (HS256, HS384, HS512)."""
-    secret = "a" * 32
-    mocker.patch.dict(
-        os.environ,
-        {"JWT_VERIFY_KEY": secret, "JWT_SIGN_ALGORITHM": algorithm},
-        clear=True,
-    )
-
-    with caplog.at_level(logging.WARNING):
-        settings = Settings()
-        assert algorithm in caplog.text
-        assert "symmetric shared-key signature algorithm" in caplog.text
-        assert settings.JWT_ALGORITHM == algorithm
-
-
-@pytest.mark.parametrize(
-    "algorithm",
-    ["ES256", "ES384", "ES512", "RS256", "RS384", "RS512", "PS256", "PS384", "PS512"],
-)
-def test_algorithm_asymmetric_no_warning(
-    mocker: MockerFixture, caplog: pytest.LogCaptureFixture, algorithm: str
-):
-    """Test that asymmetric algorithms do not trigger warning."""
-    secret = "a" * 32
-    mocker.patch.dict(
-        os.environ,
-        {"JWT_VERIFY_KEY": secret, "JWT_SIGN_ALGORITHM": algorithm},
-        clear=True,
-    )
-
-    with caplog.at_level(logging.WARNING):
-        settings = Settings()
-        # Should not contain the symmetric algorithm warning
-        assert "symmetric shared-key signature algorithm" not in caplog.text
-        assert settings.JWT_ALGORITHM == algorithm

autogpt_platform/autogpt_libs/autogpt_libs/auth/dependencies.py

@@ -1,45 +0,0 @@
-"""
-FastAPI dependency functions for JWT-based authentication and authorization.
-
-These are the high-level dependency functions used in route definitions.
-"""
-
-import fastapi
-
-from .jwt_utils import get_jwt_payload, verify_user
-from .models import User
-
-
-def requires_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> User:
-    """
-    FastAPI dependency that requires a valid authenticated user.
-
-    Raises:
-        HTTPException: 401 for authentication failures
-    """
-    return verify_user(jwt_payload, admin_only=False)
-
-
-def requires_admin_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> User:
-    """
-    FastAPI dependency that requires a valid admin user.
-
-    Raises:
-        HTTPException: 401 for authentication failures, 403 for insufficient permissions
-    """
-    return verify_user(jwt_payload, admin_only=True)
-
-
-def get_user_id(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> str:
-    """
-    FastAPI dependency that returns the ID of the authenticated user.
-
-    Raises:
-        HTTPException: 401 for authentication failures or missing user ID
-    """
-    user_id = jwt_payload.get("sub")
-    if not user_id:
-        raise fastapi.HTTPException(
-            status_code=401, detail="User ID not found in token"
-        )
-    return user_id

autogpt_platform/autogpt_libs/autogpt_libs/auth/dependencies_test.py

@@ -1,335 +0,0 @@
-"""
-Comprehensive integration tests for authentication dependencies.
-Tests the full authentication flow from HTTP requests to user validation.
-"""
-
-import os
-
-import pytest
-from fastapi import FastAPI, HTTPException, Security
-from fastapi.testclient import TestClient
-from pytest_mock import MockerFixture
-
-from autogpt_libs.auth.dependencies import (
-    get_user_id,
-    requires_admin_user,
-    requires_user,
-)
-from autogpt_libs.auth.models import User
-
-
-class TestAuthDependencies:
-    """Test suite for authentication dependency functions."""
-
-    @pytest.fixture
-    def app(self):
-        """Create a test FastAPI application."""
-        app = FastAPI()
-
-        @app.get("/user")
-        def get_user_endpoint(user: User = Security(requires_user)):
-            return {"user_id": user.user_id, "role": user.role}
-
-        @app.get("/admin")
-        def get_admin_endpoint(user: User = Security(requires_admin_user)):
-            return {"user_id": user.user_id, "role": user.role}
-
-        @app.get("/user-id")
-        def get_user_id_endpoint(user_id: str = Security(get_user_id)):
-            return {"user_id": user_id}
-
-        return app
-
-    @pytest.fixture
-    def client(self, app):
-        """Create a test client."""
-        return TestClient(app)
-
-    def test_requires_user_with_valid_jwt_payload(self, mocker: MockerFixture):
-        """Test requires_user with valid JWT payload."""
-        jwt_payload = {"sub": "user-123", "role": "user", "email": "user@example.com"}
-
-        # Mock get_jwt_payload to return our test payload
-        mocker.patch(
-            "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
-        )
-        user = requires_user(jwt_payload)
-        assert isinstance(user, User)
-        assert user.user_id == "user-123"
-        assert user.role == "user"
-
-    def test_requires_user_with_admin_jwt_payload(self, mocker: MockerFixture):
-        """Test requires_user accepts admin users."""
-        jwt_payload = {
-            "sub": "admin-456",
-            "role": "admin",
-            "email": "admin@example.com",
-        }
-
-        mocker.patch(
-            "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
-        )
-        user = requires_user(jwt_payload)
-        assert user.user_id == "admin-456"
-        assert user.role == "admin"
-
-    def test_requires_user_missing_sub(self):
-        """Test requires_user with missing user ID."""
-        jwt_payload = {"role": "user", "email": "user@example.com"}
-
-        with pytest.raises(HTTPException) as exc_info:
-            requires_user(jwt_payload)
-        assert exc_info.value.status_code == 401
-        assert "User ID not found" in exc_info.value.detail
-
-    def test_requires_user_empty_sub(self):
-        """Test requires_user with empty user ID."""
-        jwt_payload = {"sub": "", "role": "user"}
-
-        with pytest.raises(HTTPException) as exc_info:
-            requires_user(jwt_payload)
-        assert exc_info.value.status_code == 401
-
-    def test_requires_admin_user_with_admin(self, mocker: MockerFixture):
-        """Test requires_admin_user with admin role."""
-        jwt_payload = {
-            "sub": "admin-789",
-            "role": "admin",
-            "email": "admin@example.com",
-        }
-
-        mocker.patch(
-            "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
-        )
-        user = requires_admin_user(jwt_payload)
-        assert user.user_id == "admin-789"
-        assert user.role == "admin"
-
-    def test_requires_admin_user_with_regular_user(self):
-        """Test requires_admin_user rejects regular users."""
-        jwt_payload = {"sub": "user-123", "role": "user", "email": "user@example.com"}
-
-        with pytest.raises(HTTPException) as exc_info:
-            requires_admin_user(jwt_payload)
-        assert exc_info.value.status_code == 403
-        assert "Admin access required" in exc_info.value.detail
-
-    def test_requires_admin_user_missing_role(self):
-        """Test requires_admin_user with missing role."""
-        jwt_payload = {"sub": "user-123", "email": "user@example.com"}
-
-        with pytest.raises(KeyError):
-            requires_admin_user(jwt_payload)
-
-    def test_get_user_id_with_valid_payload(self, mocker: MockerFixture):
-        """Test get_user_id extracts user ID correctly."""
-        jwt_payload = {"sub": "user-id-xyz", "role": "user"}
-
-        mocker.patch(
-            "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
-        )
-        user_id = get_user_id(jwt_payload)
-        assert user_id == "user-id-xyz"
-
-    def test_get_user_id_missing_sub(self):
-        """Test get_user_id with missing user ID."""
-        jwt_payload = {"role": "user"}
-
-        with pytest.raises(HTTPException) as exc_info:
-            get_user_id(jwt_payload)
-        assert exc_info.value.status_code == 401
-        assert "User ID not found" in exc_info.value.detail
-
-    def test_get_user_id_none_sub(self):
-        """Test get_user_id with None user ID."""
-        jwt_payload = {"sub": None, "role": "user"}
-
-        with pytest.raises(HTTPException) as exc_info:
-            get_user_id(jwt_payload)
-        assert exc_info.value.status_code == 401
-
-
-class TestAuthDependenciesIntegration:
-    """Integration tests for auth dependencies with FastAPI."""
-
-    acceptable_jwt_secret = "test-secret-with-proper-length-123456"
-
-    @pytest.fixture
-    def create_token(self, mocker: MockerFixture):
-        """Helper to create JWT tokens."""
-        import jwt
-
-        mocker.patch.dict(
-            os.environ,
-            {"JWT_VERIFY_KEY": self.acceptable_jwt_secret},
-            clear=True,
-        )
-
-        def _create_token(payload, secret=self.acceptable_jwt_secret):
-            return jwt.encode(payload, secret, algorithm="HS256")
-
-        return _create_token
-
-    def test_endpoint_auth_enabled_no_token(self):
-        """Test endpoints require token when auth is enabled."""
-        app = FastAPI()
-
-        @app.get("/test")
-        def test_endpoint(user: User = Security(requires_user)):
-            return {"user_id": user.user_id}
-
-        client = TestClient(app)
-
-        # Should fail without auth header
-        response = client.get("/test")
-        assert response.status_code == 401
-
-    def test_endpoint_with_valid_token(self, create_token):
-        """Test endpoint with valid JWT token."""
-        app = FastAPI()
-
-        @app.get("/test")
-        def test_endpoint(user: User = Security(requires_user)):
-            return {"user_id": user.user_id, "role": user.role}
-
-        client = TestClient(app)
-
-        token = create_token(
-            {"sub": "test-user", "role": "user", "aud": "authenticated"},
-            secret=self.acceptable_jwt_secret,
-        )
-
-        response = client.get("/test", headers={"Authorization": f"Bearer {token}"})
-        assert response.status_code == 200
-        assert response.json()["user_id"] == "test-user"
-
-    def test_admin_endpoint_requires_admin_role(self, create_token):
-        """Test admin endpoint rejects non-admin users."""
-        app = FastAPI()
-
-        @app.get("/admin")
-        def admin_endpoint(user: User = Security(requires_admin_user)):
-            return {"user_id": user.user_id}
-
-        client = TestClient(app)
-
-        # Regular user token
-        user_token = create_token(
-            {"sub": "regular-user", "role": "user", "aud": "authenticated"},
-            secret=self.acceptable_jwt_secret,
-        )
-
-        response = client.get(
-            "/admin", headers={"Authorization": f"Bearer {user_token}"}
-        )
-        assert response.status_code == 403
-
-        # Admin token
-        admin_token = create_token(
-            {"sub": "admin-user", "role": "admin", "aud": "authenticated"},
-            secret=self.acceptable_jwt_secret,
-        )
-
-        response = client.get(
-            "/admin", headers={"Authorization": f"Bearer {admin_token}"}
-        )
-        assert response.status_code == 200
-        assert response.json()["user_id"] == "admin-user"
-
-
-class TestAuthDependenciesEdgeCases:
-    """Edge case tests for authentication dependencies."""
-
-    def test_dependency_with_complex_payload(self):
-        """Test dependencies handle complex JWT payloads."""
-        complex_payload = {
-            "sub": "user-123",
-            "role": "admin",
-            "email": "test@example.com",
-            "app_metadata": {"provider": "email", "providers": ["email"]},
-            "user_metadata": {
-                "full_name": "Test User",
-                "avatar_url": "https://example.com/avatar.jpg",
-            },
-            "aud": "authenticated",
-            "iat": 1234567890,
-            "exp": 9999999999,
-        }
-
-        user = requires_user(complex_payload)
-        assert user.user_id == "user-123"
-        assert user.email == "test@example.com"
-
-        admin = requires_admin_user(complex_payload)
-        assert admin.role == "admin"
-
-    def test_dependency_with_unicode_in_payload(self):
-        """Test dependencies handle unicode in JWT payloads."""
-        unicode_payload = {
-            "sub": "user-😀-123",
-            "role": "user",
-            "email": "测试@example.com",
-            "name": "日本語",
-        }
-
-        user = requires_user(unicode_payload)
-        assert "😀" in user.user_id
-        assert user.email == "测试@example.com"
-
-    def test_dependency_with_null_values(self):
-        """Test dependencies handle null values in payload."""
-        null_payload = {
-            "sub": "user-123",
-            "role": "user",
-            "email": None,
-            "phone": None,
-            "metadata": None,
-        }
-
-        user = requires_user(null_payload)
-        assert user.user_id == "user-123"
-        assert user.email is None
-
-    def test_concurrent_requests_isolation(self):
-        """Test that concurrent requests don't interfere with each other."""
-        payload1 = {"sub": "user-1", "role": "user"}
-        payload2 = {"sub": "user-2", "role": "admin"}
-
-        # Simulate concurrent processing
-        user1 = requires_user(payload1)
-        user2 = requires_admin_user(payload2)
-
-        assert user1.user_id == "user-1"
-        assert user2.user_id == "user-2"
-        assert user1.role == "user"
-        assert user2.role == "admin"
-
-    @pytest.mark.parametrize(
-        "payload,expected_error,admin_only",
-        [
-            (None, "Authorization header is missing", False),
-            ({}, "User ID not found", False),
-            ({"sub": ""}, "User ID not found", False),
-            ({"role": "user"}, "User ID not found", False),
-            ({"sub": "user", "role": "user"}, "Admin access required", True),
-        ],
-    )
-    def test_dependency_error_cases(
-        self, payload, expected_error: str, admin_only: bool
-    ):
-        """Test that errors propagate correctly through dependencies."""
-        # Import verify_user to test it directly since dependencies use FastAPI Security
-        from autogpt_libs.auth.jwt_utils import verify_user
-
-        with pytest.raises(HTTPException) as exc_info:
-            verify_user(payload, admin_only=admin_only)
-        assert expected_error in exc_info.value.detail
-
-    def test_dependency_valid_user(self):
-        """Test valid user case for dependency."""
-        # Import verify_user to test it directly since dependencies use FastAPI Security
-        from autogpt_libs.auth.jwt_utils import verify_user
-
-        # Valid case
-        user = verify_user({"sub": "user", "role": "user"}, admin_only=False)
-        assert user.user_id == "user"

autogpt_platform/autogpt_libs/autogpt_libs/auth/depends.py

@@ -0,0 +1,46 @@
+import fastapi
+
+from .config import settings
+from .middleware import auth_middleware
+from .models import DEFAULT_USER_ID, User
+
+
+def requires_user(payload: dict = fastapi.Depends(auth_middleware)) -> User:
+    return verify_user(payload, admin_only=False)
+
+
+def requires_admin_user(
+    payload: dict = fastapi.Depends(auth_middleware),
+) -> User:
+    return verify_user(payload, admin_only=True)
+
+
+def verify_user(payload: dict | None, admin_only: bool) -> User:
+    if not payload:
+        if settings.ENABLE_AUTH:
+            raise fastapi.HTTPException(
+                status_code=401, detail="Authorization header is missing"
+            )
+        # This handles the case when authentication is disabled
+        payload = {"sub": DEFAULT_USER_ID, "role": "admin"}
+
+    user_id = payload.get("sub")
+
+    if not user_id:
+        raise fastapi.HTTPException(
+            status_code=401, detail="User ID not found in token"
+        )
+
+    if admin_only and payload["role"] != "admin":
+        raise fastapi.HTTPException(status_code=403, detail="Admin access required")
+
+    return User.from_payload(payload)
+
+
+def get_user_id(payload: dict = fastapi.Depends(auth_middleware)) -> str:
+    user_id = payload.get("sub")
+    if not user_id:
+        raise fastapi.HTTPException(
+            status_code=401, detail="User ID not found in token"
+        )
+    return user_id

autogpt_platform/autogpt_libs/autogpt_libs/auth/depends_tests.py

@@ -0,0 +1,68 @@
+import pytest
+
+from .depends import requires_admin_user, requires_user, verify_user
+
+
+def test_verify_user_no_payload():
+    user = verify_user(None, admin_only=False)
+    assert user.user_id == "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
+    assert user.role == "admin"
+
+
+def test_verify_user_no_user_id():
+    with pytest.raises(Exception):
+        verify_user({"role": "admin"}, admin_only=False)
+
+
+def test_verify_user_not_admin():
+    with pytest.raises(Exception):
+        verify_user(
+            {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "user"},
+            admin_only=True,
+        )
+
+
+def test_verify_user_with_admin_role():
+    user = verify_user(
+        {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "admin"},
+        admin_only=True,
+    )
+    assert user.user_id == "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
+    assert user.role == "admin"
+
+
+def test_verify_user_with_user_role():
+    user = verify_user(
+        {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "user"},
+        admin_only=False,
+    )
+    assert user.user_id == "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
+    assert user.role == "user"
+
+
+def test_requires_user():
+    user = requires_user(
+        {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "user"}
+    )
+    assert user.user_id == "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
+    assert user.role == "user"
+
+
+def test_requires_user_no_user_id():
+    with pytest.raises(Exception):
+        requires_user({"role": "user"})
+
+
+def test_requires_admin_user():
+    user = requires_admin_user(
+        {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "admin"}
+    )
+    assert user.user_id == "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
+    assert user.role == "admin"
+
+
+def test_requires_admin_user_not_admin():
+    with pytest.raises(Exception):
+        requires_admin_user(
+            {"sub": "3e53486c-cf57-477e-ba2a-cb02dc828e1a", "role": "user"}
+        )

autogpt_platform/autogpt_libs/autogpt_libs/auth/helpers.py

@@ -1,68 +0,0 @@
-from fastapi import FastAPI
-from fastapi.openapi.utils import get_openapi
-
-from .jwt_utils import bearer_jwt_auth
-
-
-def add_auth_responses_to_openapi(app: FastAPI) -> None:
-    """
-    Set up custom OpenAPI schema generation that adds 401 responses
-    to all authenticated endpoints.
-
-    This is needed when using HTTPBearer with auto_error=False to get proper
-    401 responses instead of 403, but FastAPI only automatically adds security
-    responses when auto_error=True.
-    """
-
-    def custom_openapi():
-        if app.openapi_schema:
-            return app.openapi_schema
-
-        openapi_schema = get_openapi(
-            title=app.title,
-            version=app.version,
-            description=app.description,
-            routes=app.routes,
-        )
-
-        # Add 401 response to all endpoints that have security requirements
-        for path, methods in openapi_schema["paths"].items():
-            for method, details in methods.items():
-                security_schemas = [
-                    schema
-                    for auth_option in details.get("security", [])
-                    for schema in auth_option.keys()
-                ]
-                if bearer_jwt_auth.scheme_name not in security_schemas:
-                    continue
-
-                if "responses" not in details:
-                    details["responses"] = {}
-
-                details["responses"]["401"] = {
-                    "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-                }
-
-        # Ensure #/components/responses exists
-        if "components" not in openapi_schema:
-            openapi_schema["components"] = {}
-        if "responses" not in openapi_schema["components"]:
-            openapi_schema["components"]["responses"] = {}
-
-        # Define 401 response
-        openapi_schema["components"]["responses"]["HTTP401NotAuthenticatedError"] = {
-            "description": "Authentication required",
-            "content": {
-                "application/json": {
-                    "schema": {
-                        "type": "object",
-                        "properties": {"detail": {"type": "string"}},
-                    }
-                }
-            },
-        }
-
-        app.openapi_schema = openapi_schema
-        return app.openapi_schema
-
-    app.openapi = custom_openapi

autogpt_platform/autogpt_libs/autogpt_libs/auth/helpers_test.py

@@ -1,435 +0,0 @@
-"""
-Comprehensive tests for auth helpers module to achieve 100% coverage.
-Tests OpenAPI schema generation and authentication response handling.
-"""
-
-from unittest import mock
-
-from fastapi import FastAPI
-from fastapi.openapi.utils import get_openapi
-
-from autogpt_libs.auth.helpers import add_auth_responses_to_openapi
-from autogpt_libs.auth.jwt_utils import bearer_jwt_auth
-
-
-def test_add_auth_responses_to_openapi_basic():
-    """Test adding 401 responses to OpenAPI schema."""
-    app = FastAPI(title="Test App", version="1.0.0")
-
-    # Add some test endpoints with authentication
-    from fastapi import Depends
-
-    from autogpt_libs.auth.dependencies import requires_user
-
-    @app.get("/protected", dependencies=[Depends(requires_user)])
-    def protected_endpoint():
-        return {"message": "Protected"}
-
-    @app.get("/public")
-    def public_endpoint():
-        return {"message": "Public"}
-
-    # Apply the OpenAPI customization
-    add_auth_responses_to_openapi(app)
-
-    # Get the OpenAPI schema
-    schema = app.openapi()
-
-    # Verify basic schema properties
-    assert schema["info"]["title"] == "Test App"
-    assert schema["info"]["version"] == "1.0.0"
-
-    # Verify 401 response component is added
-    assert "components" in schema
-    assert "responses" in schema["components"]
-    assert "HTTP401NotAuthenticatedError" in schema["components"]["responses"]
-
-    # Verify 401 response structure
-    error_response = schema["components"]["responses"]["HTTP401NotAuthenticatedError"]
-    assert error_response["description"] == "Authentication required"
-    assert "application/json" in error_response["content"]
-    assert "schema" in error_response["content"]["application/json"]
-
-    # Verify schema properties
-    response_schema = error_response["content"]["application/json"]["schema"]
-    assert response_schema["type"] == "object"
-    assert "detail" in response_schema["properties"]
-    assert response_schema["properties"]["detail"]["type"] == "string"
-
-
-def test_add_auth_responses_to_openapi_with_security():
-    """Test that 401 responses are added only to secured endpoints."""
-    app = FastAPI()
-
-    # Mock endpoint with security
-    from fastapi import Security
-
-    from autogpt_libs.auth.dependencies import get_user_id
-
-    @app.get("/secured")
-    def secured_endpoint(user_id: str = Security(get_user_id)):
-        return {"user_id": user_id}
-
-    @app.post("/also-secured")
-    def another_secured(user_id: str = Security(get_user_id)):
-        return {"status": "ok"}
-
-    @app.get("/unsecured")
-    def unsecured_endpoint():
-        return {"public": True}
-
-    # Apply OpenAPI customization
-    add_auth_responses_to_openapi(app)
-
-    # Get schema
-    schema = app.openapi()
-
-    # Check that secured endpoints have 401 responses
-    if "/secured" in schema["paths"]:
-        if "get" in schema["paths"]["/secured"]:
-            secured_get = schema["paths"]["/secured"]["get"]
-            if "responses" in secured_get:
-                assert "401" in secured_get["responses"]
-                assert (
-                    secured_get["responses"]["401"]["$ref"]
-                    == "#/components/responses/HTTP401NotAuthenticatedError"
-                )
-
-    if "/also-secured" in schema["paths"]:
-        if "post" in schema["paths"]["/also-secured"]:
-            secured_post = schema["paths"]["/also-secured"]["post"]
-            if "responses" in secured_post:
-                assert "401" in secured_post["responses"]
-
-    # Check that unsecured endpoint does not have 401 response
-    if "/unsecured" in schema["paths"]:
-        if "get" in schema["paths"]["/unsecured"]:
-            unsecured_get = schema["paths"]["/unsecured"]["get"]
-            if "responses" in unsecured_get:
-                assert "401" not in unsecured_get.get("responses", {})
-
-
-def test_add_auth_responses_to_openapi_cached_schema():
-    """Test that OpenAPI schema is cached after first generation."""
-    app = FastAPI()
-
-    # Apply customization
-    add_auth_responses_to_openapi(app)
-
-    # Get schema twice
-    schema1 = app.openapi()
-    schema2 = app.openapi()
-
-    # Should return the same cached object
-    assert schema1 is schema2
-
-
-def test_add_auth_responses_to_openapi_existing_responses():
-    """Test handling endpoints that already have responses defined."""
-    app = FastAPI()
-
-    from fastapi import Security
-
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
-
-    @app.get(
-        "/with-responses",
-        responses={
-            200: {"description": "Success"},
-            404: {"description": "Not found"},
-        },
-    )
-    def endpoint_with_responses(jwt: dict = Security(get_jwt_payload)):
-        return {"data": "test"}
-
-    # Apply customization
-    add_auth_responses_to_openapi(app)
-
-    schema = app.openapi()
-
-    # Check that existing responses are preserved and 401 is added
-    if "/with-responses" in schema["paths"]:
-        if "get" in schema["paths"]["/with-responses"]:
-            responses = schema["paths"]["/with-responses"]["get"].get("responses", {})
-            # Original responses should be preserved
-            if "200" in responses:
-                assert responses["200"]["description"] == "Success"
-            if "404" in responses:
-                assert responses["404"]["description"] == "Not found"
-            # 401 should be added
-            if "401" in responses:
-                assert (
-                    responses["401"]["$ref"]
-                    == "#/components/responses/HTTP401NotAuthenticatedError"
-                )
-
-
-def test_add_auth_responses_to_openapi_no_security_endpoints():
-    """Test with app that has no secured endpoints."""
-    app = FastAPI()
-
-    @app.get("/public1")
-    def public1():
-        return {"message": "public1"}
-
-    @app.post("/public2")
-    def public2():
-        return {"message": "public2"}
-
-    # Apply customization
-    add_auth_responses_to_openapi(app)
-
-    schema = app.openapi()
-
-    # Component should still be added for consistency
-    assert "HTTP401NotAuthenticatedError" in schema["components"]["responses"]
-
-    # But no endpoints should have 401 responses
-    for path in schema["paths"].values():
-        for method in path.values():
-            if isinstance(method, dict) and "responses" in method:
-                assert "401" not in method["responses"]
-
-
-def test_add_auth_responses_to_openapi_multiple_security_schemes():
-    """Test endpoints with multiple security requirements."""
-    app = FastAPI()
-
-    from fastapi import Security
-
-    from autogpt_libs.auth.dependencies import requires_admin_user, requires_user
-    from autogpt_libs.auth.models import User
-
-    @app.get("/multi-auth")
-    def multi_auth(
-        user: User = Security(requires_user),
-        admin: User = Security(requires_admin_user),
-    ):
-        return {"status": "super secure"}
-
-    # Apply customization
-    add_auth_responses_to_openapi(app)
-
-    schema = app.openapi()
-
-    # Should have 401 response
-    if "/multi-auth" in schema["paths"]:
-        if "get" in schema["paths"]["/multi-auth"]:
-            responses = schema["paths"]["/multi-auth"]["get"].get("responses", {})
-            if "401" in responses:
-                assert (
-                    responses["401"]["$ref"]
-                    == "#/components/responses/HTTP401NotAuthenticatedError"
-                )
-
-
-def test_add_auth_responses_to_openapi_empty_components():
-    """Test when OpenAPI schema has no components section initially."""
-    app = FastAPI()
-
-    # Mock get_openapi to return schema without components
-    original_get_openapi = get_openapi
-
-    def mock_get_openapi(*args, **kwargs):
-        schema = original_get_openapi(*args, **kwargs)
-        # Remove components if it exists
-        if "components" in schema:
-            del schema["components"]
-        return schema
-
-    with mock.patch("autogpt_libs.auth.helpers.get_openapi", mock_get_openapi):
-        # Apply customization
-        add_auth_responses_to_openapi(app)
-
-        schema = app.openapi()
-
-        # Components should be created
-        assert "components" in schema
-        assert "responses" in schema["components"]
-        assert "HTTP401NotAuthenticatedError" in schema["components"]["responses"]
-
-
-def test_add_auth_responses_to_openapi_all_http_methods():
-    """Test that all HTTP methods are handled correctly."""
-    app = FastAPI()
-
-    from fastapi import Security
-
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
-
-    @app.get("/resource")
-    def get_resource(jwt: dict = Security(get_jwt_payload)):
-        return {"method": "GET"}
-
-    @app.post("/resource")
-    def post_resource(jwt: dict = Security(get_jwt_payload)):
-        return {"method": "POST"}
-
-    @app.put("/resource")
-    def put_resource(jwt: dict = Security(get_jwt_payload)):
-        return {"method": "PUT"}
-
-    @app.patch("/resource")
-    def patch_resource(jwt: dict = Security(get_jwt_payload)):
-        return {"method": "PATCH"}
-
-    @app.delete("/resource")
-    def delete_resource(jwt: dict = Security(get_jwt_payload)):
-        return {"method": "DELETE"}
-
-    # Apply customization
-    add_auth_responses_to_openapi(app)
-
-    schema = app.openapi()
-
-    # All methods should have 401 response
-    if "/resource" in schema["paths"]:
-        for method in ["get", "post", "put", "patch", "delete"]:
-            if method in schema["paths"]["/resource"]:
-                method_spec = schema["paths"]["/resource"][method]
-                if "responses" in method_spec:
-                    assert "401" in method_spec["responses"]
-
-
-def test_bearer_jwt_auth_scheme_config():
-    """Test that bearer_jwt_auth is configured correctly."""
-    assert bearer_jwt_auth.scheme_name == "HTTPBearerJWT"
-    assert bearer_jwt_auth.auto_error is False
-
-
-def test_add_auth_responses_with_no_routes():
-    """Test OpenAPI generation with app that has no routes."""
-    app = FastAPI(title="Empty App")
-
-    # Apply customization to empty app
-    add_auth_responses_to_openapi(app)
-
-    schema = app.openapi()
-
-    # Should still have basic structure
-    assert schema["info"]["title"] == "Empty App"
-    assert "components" in schema
-    assert "responses" in schema["components"]
-    assert "HTTP401NotAuthenticatedError" in schema["components"]["responses"]
-
-
-def test_custom_openapi_function_replacement():
-    """Test that the custom openapi function properly replaces the default."""
-    app = FastAPI()
-
-    # Store original function
-    original_openapi = app.openapi
-
-    # Apply customization
-    add_auth_responses_to_openapi(app)
-
-    # Function should be replaced
-    assert app.openapi != original_openapi
-    assert callable(app.openapi)
-
-
-def test_endpoint_without_responses_section():
-    """Test endpoint that has security but no responses section initially."""
-    app = FastAPI()
-
-    from fastapi import Security
-    from fastapi.openapi.utils import get_openapi as original_get_openapi
-
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
-
-    # Create endpoint
-    @app.get("/no-responses")
-    def endpoint_without_responses(jwt: dict = Security(get_jwt_payload)):
-        return {"data": "test"}
-
-    # Mock get_openapi to remove responses from the endpoint
-    def mock_get_openapi(*args, **kwargs):
-        schema = original_get_openapi(*args, **kwargs)
-        # Remove responses from our endpoint to trigger line 40
-        if "/no-responses" in schema.get("paths", {}):
-            if "get" in schema["paths"]["/no-responses"]:
-                # Delete responses to force the code to create it
-                if "responses" in schema["paths"]["/no-responses"]["get"]:
-                    del schema["paths"]["/no-responses"]["get"]["responses"]
-        return schema
-
-    with mock.patch("autogpt_libs.auth.helpers.get_openapi", mock_get_openapi):
-        # Apply customization
-        add_auth_responses_to_openapi(app)
-
-        # Get schema and verify 401 was added
-        schema = app.openapi()
-
-        # The endpoint should now have 401 response
-        if "/no-responses" in schema["paths"]:
-            if "get" in schema["paths"]["/no-responses"]:
-                responses = schema["paths"]["/no-responses"]["get"].get("responses", {})
-                assert "401" in responses
-                assert (
-                    responses["401"]["$ref"]
-                    == "#/components/responses/HTTP401NotAuthenticatedError"
-                )
-
-
-def test_components_with_existing_responses():
-    """Test when components already has a responses section."""
-    app = FastAPI()
-
-    # Mock get_openapi to return schema with existing components/responses
-    from fastapi.openapi.utils import get_openapi as original_get_openapi
-
-    def mock_get_openapi(*args, **kwargs):
-        schema = original_get_openapi(*args, **kwargs)
-        # Add existing components/responses
-        if "components" not in schema:
-            schema["components"] = {}
-        schema["components"]["responses"] = {
-            "ExistingResponse": {"description": "An existing response"}
-        }
-        return schema
-
-    with mock.patch("autogpt_libs.auth.helpers.get_openapi", mock_get_openapi):
-        # Apply customization
-        add_auth_responses_to_openapi(app)
-
-        schema = app.openapi()
-
-        # Both responses should exist
-        assert "ExistingResponse" in schema["components"]["responses"]
-        assert "HTTP401NotAuthenticatedError" in schema["components"]["responses"]
-
-        # Verify our 401 response structure
-        error_response = schema["components"]["responses"][
-            "HTTP401NotAuthenticatedError"
-        ]
-        assert error_response["description"] == "Authentication required"
-
-
-def test_openapi_schema_persistence():
-    """Test that modifications to OpenAPI schema persist correctly."""
-    app = FastAPI()
-
-    from fastapi import Security
-
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
-
-    @app.get("/test")
-    def test_endpoint(jwt: dict = Security(get_jwt_payload)):
-        return {"test": True}
-
-    # Apply customization
-    add_auth_responses_to_openapi(app)
-
-    # Get schema multiple times
-    schema1 = app.openapi()
-
-    # Modify the cached schema (shouldn't affect future calls)
-    schema1["info"]["title"] = "Modified Title"
-
-    # Clear cache and get again
-    app.openapi_schema = None
-    schema2 = app.openapi()
-
-    # Should regenerate with original title
-    assert schema2["info"]["title"] == app.title
-    assert schema2["info"]["title"] != "Modified Title"

autogpt_platform/autogpt_libs/autogpt_libs/auth/jwt_utils.py

@@ -1,48 +1,11 @@
-import logging
-from typing import Any
+from typing import Any, Dict
 
 import jwt
-from fastapi import HTTPException, Security
-from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 
-from .config import get_settings
-from .models import User
-
-logger = logging.getLogger(__name__)
-
-# Bearer token authentication scheme
-bearer_jwt_auth = HTTPBearer(
-    bearerFormat="jwt", scheme_name="HTTPBearerJWT", auto_error=False
-)
+from .config import settings
 
 
-def get_jwt_payload(
-    credentials: HTTPAuthorizationCredentials | None = Security(bearer_jwt_auth),
-) -> dict[str, Any]:
-    """
-    Extract and validate JWT payload from HTTP Authorization header.
-
-    This is the core authentication function that handles:
-    - Reading the `Authorization` header to obtain the JWT token
-    - Verifying the JWT token's signature
-    - Decoding the JWT token's payload
-
-    :param credentials: HTTP Authorization credentials from bearer token
-    :return: JWT payload dictionary
-    :raises HTTPException: 401 if authentication fails
-    """
-    if not credentials:
-        raise HTTPException(status_code=401, detail="Authorization header is missing")
-
-    try:
-        payload = parse_jwt_token(credentials.credentials)
-        logger.debug("Token decoded successfully")
-        return payload
-    except ValueError as e:
-        raise HTTPException(status_code=401, detail=str(e))
-
-
-def parse_jwt_token(token: str) -> dict[str, Any]:
+def parse_jwt_token(token: str) -> Dict[str, Any]:
     """
     Parse and validate a JWT token.
 
@@ -50,11 +13,10 @@ def parse_jwt_token(token: str) -> dict[str, Any]:
     :return: The decoded payload
     :raises ValueError: If the token is invalid or expired
     """
-    settings = get_settings()
     try:
         payload = jwt.decode(
             token,
-            settings.JWT_VERIFY_KEY,
+            settings.JWT_SECRET_KEY,
             algorithms=[settings.JWT_ALGORITHM],
             audience="authenticated",
         )
@@ -63,18 +25,3 @@ def parse_jwt_token(token: str) -> dict[str, Any]:
         raise ValueError("Token has expired")
     except jwt.InvalidTokenError as e:
         raise ValueError(f"Invalid token: {str(e)}")
-
-
-def verify_user(jwt_payload: dict | None, admin_only: bool) -> User:
-    if jwt_payload is None:
-        raise HTTPException(status_code=401, detail="Authorization header is missing")
-
-    user_id = jwt_payload.get("sub")
-
-    if not user_id:
-        raise HTTPException(status_code=401, detail="User ID not found in token")
-
-    if admin_only and jwt_payload["role"] != "admin":
-        raise HTTPException(status_code=403, detail="Admin access required")
-
-    return User.from_payload(jwt_payload)

autogpt_platform/autogpt_libs/autogpt_libs/auth/jwt_utils_test.py

@@ -1,308 +0,0 @@
-"""
-Comprehensive tests for JWT token parsing and validation.
-Ensures 100% line and branch coverage for JWT security functions.
-"""
-
-import os
-from datetime import datetime, timedelta, timezone
-
-import jwt
-import pytest
-from fastapi import HTTPException
-from fastapi.security import HTTPAuthorizationCredentials
-from pytest_mock import MockerFixture
-
-from autogpt_libs.auth import config, jwt_utils
-from autogpt_libs.auth.config import Settings
-from autogpt_libs.auth.models import User
-
-MOCK_JWT_SECRET = "test-secret-key-with-at-least-32-characters"
-TEST_USER_PAYLOAD = {
-    "sub": "test-user-id",
-    "role": "user",
-    "aud": "authenticated",
-    "email": "test@example.com",
-}
-TEST_ADMIN_PAYLOAD = {
-    "sub": "admin-user-id",
-    "role": "admin",
-    "aud": "authenticated",
-    "email": "admin@example.com",
-}
-
-
-@pytest.fixture(autouse=True)
-def mock_config(mocker: MockerFixture):
-    mocker.patch.dict(os.environ, {"JWT_VERIFY_KEY": MOCK_JWT_SECRET}, clear=True)
-    mocker.patch.object(config, "_settings", Settings())
-    yield
-
-
-def create_token(payload, secret=None, algorithm="HS256"):
-    """Helper to create JWT tokens."""
-    if secret is None:
-        secret = MOCK_JWT_SECRET
-    return jwt.encode(payload, secret, algorithm=algorithm)
-
-
-def test_parse_jwt_token_valid():
-    """Test parsing a valid JWT token."""
-    token = create_token(TEST_USER_PAYLOAD)
-    result = jwt_utils.parse_jwt_token(token)
-
-    assert result["sub"] == "test-user-id"
-    assert result["role"] == "user"
-    assert result["aud"] == "authenticated"
-
-
-def test_parse_jwt_token_expired():
-    """Test parsing an expired JWT token."""
-    expired_payload = {
-        **TEST_USER_PAYLOAD,
-        "exp": datetime.now(timezone.utc) - timedelta(hours=1),
-    }
-    token = create_token(expired_payload)
-
-    with pytest.raises(ValueError) as exc_info:
-        jwt_utils.parse_jwt_token(token)
-    assert "Token has expired" in str(exc_info.value)
-
-
-def test_parse_jwt_token_invalid_signature():
-    """Test parsing a token with invalid signature."""
-    # Create token with different secret
-    token = create_token(TEST_USER_PAYLOAD, secret="wrong-secret")
-
-    with pytest.raises(ValueError) as exc_info:
-        jwt_utils.parse_jwt_token(token)
-    assert "Invalid token" in str(exc_info.value)
-
-
-def test_parse_jwt_token_malformed():
-    """Test parsing a malformed token."""
-    malformed_tokens = [
-        "not.a.token",
-        "invalid",
-        "",
-        # Header only
-        "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9",
-        # No signature
-        "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ0ZXN0In0",
-    ]
-
-    for token in malformed_tokens:
-        with pytest.raises(ValueError) as exc_info:
-            jwt_utils.parse_jwt_token(token)
-        assert "Invalid token" in str(exc_info.value)
-
-
-def test_parse_jwt_token_wrong_audience():
-    """Test parsing a token with wrong audience."""
-    wrong_aud_payload = {**TEST_USER_PAYLOAD, "aud": "wrong-audience"}
-    token = create_token(wrong_aud_payload)
-
-    with pytest.raises(ValueError) as exc_info:
-        jwt_utils.parse_jwt_token(token)
-    assert "Invalid token" in str(exc_info.value)
-
-
-def test_parse_jwt_token_missing_audience():
-    """Test parsing a token without audience claim."""
-    no_aud_payload = {k: v for k, v in TEST_USER_PAYLOAD.items() if k != "aud"}
-    token = create_token(no_aud_payload)
-
-    with pytest.raises(ValueError) as exc_info:
-        jwt_utils.parse_jwt_token(token)
-    assert "Invalid token" in str(exc_info.value)
-
-
-def test_get_jwt_payload_with_valid_token():
-    """Test extracting JWT payload with valid bearer token."""
-    token = create_token(TEST_USER_PAYLOAD)
-    credentials = HTTPAuthorizationCredentials(scheme="Bearer", credentials=token)
-
-    result = jwt_utils.get_jwt_payload(credentials)
-    assert result["sub"] == "test-user-id"
-    assert result["role"] == "user"
-
-
-def test_get_jwt_payload_no_credentials():
-    """Test JWT payload when no credentials provided."""
-    with pytest.raises(HTTPException) as exc_info:
-        jwt_utils.get_jwt_payload(None)
-    assert exc_info.value.status_code == 401
-    assert "Authorization header is missing" in exc_info.value.detail
-
-
-def test_get_jwt_payload_invalid_token():
-    """Test JWT payload extraction with invalid token."""
-    credentials = HTTPAuthorizationCredentials(
-        scheme="Bearer", credentials="invalid.token.here"
-    )
-
-    with pytest.raises(HTTPException) as exc_info:
-        jwt_utils.get_jwt_payload(credentials)
-    assert exc_info.value.status_code == 401
-    assert "Invalid token" in exc_info.value.detail
-
-
-def test_verify_user_with_valid_user():
-    """Test verifying a valid user."""
-    user = jwt_utils.verify_user(TEST_USER_PAYLOAD, admin_only=False)
-    assert isinstance(user, User)
-    assert user.user_id == "test-user-id"
-    assert user.role == "user"
-    assert user.email == "test@example.com"
-
-
-def test_verify_user_with_admin():
-    """Test verifying an admin user."""
-    user = jwt_utils.verify_user(TEST_ADMIN_PAYLOAD, admin_only=True)
-    assert isinstance(user, User)
-    assert user.user_id == "admin-user-id"
-    assert user.role == "admin"
-
-
-def test_verify_user_admin_only_with_regular_user():
-    """Test verifying regular user when admin is required."""
-    with pytest.raises(HTTPException) as exc_info:
-        jwt_utils.verify_user(TEST_USER_PAYLOAD, admin_only=True)
-    assert exc_info.value.status_code == 403
-    assert "Admin access required" in exc_info.value.detail
-
-
-def test_verify_user_no_payload():
-    """Test verifying user with no payload."""
-    with pytest.raises(HTTPException) as exc_info:
-        jwt_utils.verify_user(None, admin_only=False)
-    assert exc_info.value.status_code == 401
-    assert "Authorization header is missing" in exc_info.value.detail
-
-
-def test_verify_user_missing_sub():
-    """Test verifying user with payload missing 'sub' field."""
-    invalid_payload = {"role": "user", "email": "test@example.com"}
-    with pytest.raises(HTTPException) as exc_info:
-        jwt_utils.verify_user(invalid_payload, admin_only=False)
-    assert exc_info.value.status_code == 401
-    assert "User ID not found in token" in exc_info.value.detail
-
-
-def test_verify_user_empty_sub():
-    """Test verifying user with empty 'sub' field."""
-    invalid_payload = {"sub": "", "role": "user"}
-    with pytest.raises(HTTPException) as exc_info:
-        jwt_utils.verify_user(invalid_payload, admin_only=False)
-    assert exc_info.value.status_code == 401
-    assert "User ID not found in token" in exc_info.value.detail
-
-
-def test_verify_user_none_sub():
-    """Test verifying user with None 'sub' field."""
-    invalid_payload = {"sub": None, "role": "user"}
-    with pytest.raises(HTTPException) as exc_info:
-        jwt_utils.verify_user(invalid_payload, admin_only=False)
-    assert exc_info.value.status_code == 401
-    assert "User ID not found in token" in exc_info.value.detail
-
-
-def test_verify_user_missing_role_admin_check():
-    """Test verifying admin when role field is missing."""
-    no_role_payload = {"sub": "user-id"}
-    with pytest.raises(KeyError):
-        # This will raise KeyError when checking payload["role"]
-        jwt_utils.verify_user(no_role_payload, admin_only=True)
-
-
-# ======================== EDGE CASES ======================== #
-
-
-def test_jwt_with_additional_claims():
-    """Test JWT token with additional custom claims."""
-    extra_claims_payload = {
-        "sub": "user-id",
-        "role": "user",
-        "aud": "authenticated",
-        "custom_claim": "custom_value",
-        "permissions": ["read", "write"],
-        "metadata": {"key": "value"},
-    }
-    token = create_token(extra_claims_payload)
-
-    result = jwt_utils.parse_jwt_token(token)
-    assert result["sub"] == "user-id"
-    assert result["custom_claim"] == "custom_value"
-    assert result["permissions"] == ["read", "write"]
-
-
-def test_jwt_with_numeric_sub():
-    """Test JWT token with numeric user ID."""
-    payload = {
-        "sub": 12345,  # Numeric ID
-        "role": "user",
-        "aud": "authenticated",
-    }
-    # Should convert to string internally
-    user = jwt_utils.verify_user(payload, admin_only=False)
-    assert user.user_id == 12345
-
-
-def test_jwt_with_very_long_sub():
-    """Test JWT token with very long user ID."""
-    long_id = "a" * 1000
-    payload = {
-        "sub": long_id,
-        "role": "user",
-        "aud": "authenticated",
-    }
-    user = jwt_utils.verify_user(payload, admin_only=False)
-    assert user.user_id == long_id
-
-
-def test_jwt_with_special_characters_in_claims():
-    """Test JWT token with special characters in claims."""
-    payload = {
-        "sub": "user@example.com/special-chars!@#$%",
-        "role": "admin",
-        "aud": "authenticated",
-        "email": "test+special@example.com",
-    }
-    user = jwt_utils.verify_user(payload, admin_only=True)
-    assert "special-chars!@#$%" in user.user_id
-
-
-def test_jwt_with_future_iat():
-    """Test JWT token with issued-at time in future."""
-    future_payload = {
-        "sub": "user-id",
-        "role": "user",
-        "aud": "authenticated",
-        "iat": datetime.now(timezone.utc) + timedelta(hours=1),
-    }
-    token = create_token(future_payload)
-
-    # PyJWT validates iat claim and should reject future tokens
-    with pytest.raises(ValueError, match="not yet valid"):
-        jwt_utils.parse_jwt_token(token)
-
-
-def test_jwt_with_different_algorithms():
-    """Test that only HS256 algorithm is accepted."""
-    payload = {
-        "sub": "user-id",
-        "role": "user",
-        "aud": "authenticated",
-    }
-
-    # Try different algorithms
-    algorithms = ["HS384", "HS512", "none"]
-    for algo in algorithms:
-        if algo == "none":
-            # Special case for 'none' algorithm (security vulnerability if accepted)
-            token = create_token(payload, "", algorithm="none")
-        else:
-            token = create_token(payload, algorithm=algo)
-
-        with pytest.raises(ValueError) as exc_info:
-            jwt_utils.parse_jwt_token(token)
-        assert "Invalid token" in str(exc_info.value)

autogpt_platform/autogpt_libs/autogpt_libs/auth/middleware.py

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

autogpt_platform/autogpt_libs/poetry.lock

@@ -54,7 +54,7 @@ version = "1.2.0"
 description = "Backport of asyncio.Runner, a context manager that controls event loop life cycle."
 optional = false
 python-versions = "<3.11,>=3.8"
-groups = ["dev"]
+groups = ["main"]
 markers = "python_version < \"3.11\""
 files = [
     {file = "backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5"},
@@ -85,87 +85,6 @@ files = [
     {file = "certifi-2025.7.14.tar.gz", hash = "sha256:8ea99dbdfaaf2ba2f9bac77b9249ef62ec5218e7c2b2e903378ed5fccf765995"},
 ]
 
-[[package]]
-name = "cffi"
-version = "1.17.1"
-description = "Foreign Function Interface for Python calling C code."
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-markers = "platform_python_implementation != \"PyPy\""
-files = [
-    {file = "cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14"},
-    {file = "cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67"},
-    {file = "cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382"},
-    {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702"},
-    {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3"},
-    {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6"},
-    {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17"},
-    {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8"},
-    {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e"},
-    {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be"},
-    {file = "cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c"},
-    {file = "cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15"},
-    {file = "cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401"},
-    {file = "cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf"},
-    {file = "cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4"},
-    {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41"},
-    {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1"},
-    {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6"},
-    {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d"},
-    {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6"},
-    {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f"},
-    {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b"},
-    {file = "cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655"},
-    {file = "cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0"},
-    {file = "cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4"},
-    {file = "cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c"},
-    {file = "cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36"},
-    {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5"},
-    {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff"},
-    {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99"},
-    {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93"},
-    {file = "cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3"},
-    {file = "cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8"},
-    {file = "cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65"},
-    {file = "cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903"},
-    {file = "cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e"},
-    {file = "cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2"},
-    {file = "cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3"},
-    {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683"},
-    {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5"},
-    {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4"},
-    {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd"},
-    {file = "cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed"},
-    {file = "cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9"},
-    {file = "cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d"},
-    {file = "cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a"},
-    {file = "cffi-1.17.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:636062ea65bd0195bc012fea9321aca499c0504409f413dc88af450b57ffd03b"},
-    {file = "cffi-1.17.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7eac2ef9b63c79431bc4b25f1cd649d7f061a28808cbc6c47b534bd789ef964"},
-    {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e221cf152cff04059d011ee126477f0d9588303eb57e88923578ace7baad17f9"},
-    {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:31000ec67d4221a71bd3f67df918b1f88f676f1c3b535a7eb473255fdc0b83fc"},
-    {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f17be4345073b0a7b8ea599688f692ac3ef23ce28e5df79c04de519dbc4912c"},
-    {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2b1fac190ae3ebfe37b979cc1ce69c81f4e4fe5746bb401dca63a9062cdaf1"},
-    {file = "cffi-1.17.1-cp38-cp38-win32.whl", hash = "sha256:7596d6620d3fa590f677e9ee430df2958d2d6d6de2feeae5b20e82c00b76fbf8"},
-    {file = "cffi-1.17.1-cp38-cp38-win_amd64.whl", hash = "sha256:78122be759c3f8a014ce010908ae03364d00a1f81ab5c7f4a7a5120607ea56e1"},
-    {file = "cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16"},
-    {file = "cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36"},
-    {file = "cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8"},
-    {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576"},
-    {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87"},
-    {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0"},
-    {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3"},
-    {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595"},
-    {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a"},
-    {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e"},
-    {file = "cffi-1.17.1-cp39-cp39-win32.whl", hash = "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7"},
-    {file = "cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662"},
-    {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"},
-]
-
-[package.dependencies]
-pycparser = "*"
-
 [[package]]
 name = "charset-normalizer"
 version = "3.4.2"
@@ -289,176 +208,12 @@ version = "0.4.6"
 description = "Cross-platform colored terminal text."
 optional = false
 python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
-groups = ["main", "dev"]
+groups = ["main"]
 files = [
     {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
     {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
 ]
 
-[[package]]
-name = "coverage"
-version = "7.10.5"
-description = "Code coverage measurement for Python"
-optional = false
-python-versions = ">=3.9"
-groups = ["dev"]
-files = [
-    {file = "coverage-7.10.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c6a5c3414bfc7451b879141ce772c546985163cf553f08e0f135f0699a911801"},
-    {file = "coverage-7.10.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:bc8e4d99ce82f1710cc3c125adc30fd1487d3cf6c2cd4994d78d68a47b16989a"},
-    {file = "coverage-7.10.5-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:02252dc1216e512a9311f596b3169fad54abcb13827a8d76d5630c798a50a754"},
-    {file = "coverage-7.10.5-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:73269df37883e02d460bee0cc16be90509faea1e3bd105d77360b512d5bb9c33"},
-    {file = "coverage-7.10.5-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f8a81b0614642f91c9effd53eec284f965577591f51f547a1cbeb32035b4c2f"},
-    {file = "coverage-7.10.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:6a29f8e0adb7f8c2b95fa2d4566a1d6e6722e0a637634c6563cb1ab844427dd9"},
-    {file = "coverage-7.10.5-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:fcf6ab569436b4a647d4e91accba12509ad9f2554bc93d3aee23cc596e7f99c3"},
-    {file = "coverage-7.10.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:90dc3d6fb222b194a5de60af8d190bedeeddcbc7add317e4a3cd333ee6b7c879"},
-    {file = "coverage-7.10.5-cp310-cp310-win32.whl", hash = "sha256:414a568cd545f9dc75f0686a0049393de8098414b58ea071e03395505b73d7a8"},
-    {file = "coverage-7.10.5-cp310-cp310-win_amd64.whl", hash = "sha256:e551f9d03347196271935fd3c0c165f0e8c049220280c1120de0084d65e9c7ff"},
-    {file = "coverage-7.10.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c177e6ffe2ebc7c410785307758ee21258aa8e8092b44d09a2da767834f075f2"},
-    {file = "coverage-7.10.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:14d6071c51ad0f703d6440827eaa46386169b5fdced42631d5a5ac419616046f"},
-    {file = "coverage-7.10.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:61f78c7c3bc272a410c5ae3fde7792b4ffb4acc03d35a7df73ca8978826bb7ab"},
-    {file = "coverage-7.10.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f39071caa126f69d63f99b324fb08c7b1da2ec28cbb1fe7b5b1799926492f65c"},
-    {file = "coverage-7.10.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:343a023193f04d46edc46b2616cdbee68c94dd10208ecd3adc56fcc54ef2baa1"},
-    {file = "coverage-7.10.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:585ffe93ae5894d1ebdee69fc0b0d4b7c75d8007983692fb300ac98eed146f78"},
-    {file = "coverage-7.10.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:b0ef4e66f006ed181df29b59921bd8fc7ed7cd6a9289295cd8b2824b49b570df"},
-    {file = "coverage-7.10.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:eb7b0bbf7cc1d0453b843eca7b5fa017874735bef9bfdfa4121373d2cc885ed6"},
-    {file = "coverage-7.10.5-cp311-cp311-win32.whl", hash = "sha256:1d043a8a06987cc0c98516e57c4d3fc2c1591364831e9deb59c9e1b4937e8caf"},
-    {file = "coverage-7.10.5-cp311-cp311-win_amd64.whl", hash = "sha256:fefafcca09c3ac56372ef64a40f5fe17c5592fab906e0fdffd09543f3012ba50"},
-    {file = "coverage-7.10.5-cp311-cp311-win_arm64.whl", hash = "sha256:7e78b767da8b5fc5b2faa69bb001edafcd6f3995b42a331c53ef9572c55ceb82"},
-    {file = "coverage-7.10.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c2d05c7e73c60a4cecc7d9b60dbfd603b4ebc0adafaef371445b47d0f805c8a9"},
-    {file = "coverage-7.10.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:32ddaa3b2c509778ed5373b177eb2bf5662405493baeff52278a0b4f9415188b"},
-    {file = "coverage-7.10.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:dd382410039fe062097aa0292ab6335a3f1e7af7bba2ef8d27dcda484918f20c"},
-    {file = "coverage-7.10.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7fa22800f3908df31cea6fb230f20ac49e343515d968cc3a42b30d5c3ebf9b5a"},
-    {file = "coverage-7.10.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f366a57ac81f5e12797136552f5b7502fa053c861a009b91b80ed51f2ce651c6"},
-    {file = "coverage-7.10.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5f1dc8f1980a272ad4a6c84cba7981792344dad33bf5869361576b7aef42733a"},
-    {file = "coverage-7.10.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:2285c04ee8676f7938b02b4936d9b9b672064daab3187c20f73a55f3d70e6b4a"},
-    {file = "coverage-7.10.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c2492e4dd9daab63f5f56286f8a04c51323d237631eb98505d87e4c4ff19ec34"},
-    {file = "coverage-7.10.5-cp312-cp312-win32.whl", hash = "sha256:38a9109c4ee8135d5df5505384fc2f20287a47ccbe0b3f04c53c9a1989c2bbaf"},
-    {file = "coverage-7.10.5-cp312-cp312-win_amd64.whl", hash = "sha256:6b87f1ad60b30bc3c43c66afa7db6b22a3109902e28c5094957626a0143a001f"},
-    {file = "coverage-7.10.5-cp312-cp312-win_arm64.whl", hash = "sha256:672a6c1da5aea6c629819a0e1461e89d244f78d7b60c424ecf4f1f2556c041d8"},
-    {file = "coverage-7.10.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ef3b83594d933020f54cf65ea1f4405d1f4e41a009c46df629dd964fcb6e907c"},
-    {file = "coverage-7.10.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2b96bfdf7c0ea9faebce088a3ecb2382819da4fbc05c7b80040dbc428df6af44"},
-    {file = "coverage-7.10.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:63df1fdaffa42d914d5c4d293e838937638bf75c794cf20bee12978fc8c4e3bc"},
-    {file = "coverage-7.10.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8002dc6a049aac0e81ecec97abfb08c01ef0c1fbf962d0c98da3950ace89b869"},
-    {file = "coverage-7.10.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:63d4bb2966d6f5f705a6b0c6784c8969c468dbc4bcf9d9ded8bff1c7e092451f"},
-    {file = "coverage-7.10.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1f672efc0731a6846b157389b6e6d5d5e9e59d1d1a23a5c66a99fd58339914d5"},
-    {file = "coverage-7.10.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:3f39cef43d08049e8afc1fde4a5da8510fc6be843f8dea350ee46e2a26b2f54c"},
-    {file = "coverage-7.10.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2968647e3ed5a6c019a419264386b013979ff1fb67dd11f5c9886c43d6a31fc2"},
-    {file = "coverage-7.10.5-cp313-cp313-win32.whl", hash = "sha256:0d511dda38595b2b6934c2b730a1fd57a3635c6aa2a04cb74714cdfdd53846f4"},
-    {file = "coverage-7.10.5-cp313-cp313-win_amd64.whl", hash = "sha256:9a86281794a393513cf117177fd39c796b3f8e3759bb2764259a2abba5cce54b"},
-    {file = "coverage-7.10.5-cp313-cp313-win_arm64.whl", hash = "sha256:cebd8e906eb98bb09c10d1feed16096700b1198d482267f8bf0474e63a7b8d84"},
-    {file = "coverage-7.10.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0520dff502da5e09d0d20781df74d8189ab334a1e40d5bafe2efaa4158e2d9e7"},
-    {file = "coverage-7.10.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d9cd64aca68f503ed3f1f18c7c9174cbb797baba02ca8ab5112f9d1c0328cd4b"},
-    {file = "coverage-7.10.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0913dd1613a33b13c4f84aa6e3f4198c1a21ee28ccb4f674985c1f22109f0aae"},
-    {file = "coverage-7.10.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1b7181c0feeb06ed8a02da02792f42f829a7b29990fef52eff257fef0885d760"},
-    {file = "coverage-7.10.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36d42b7396b605f774d4372dd9c49bed71cbabce4ae1ccd074d155709dd8f235"},
-    {file = "coverage-7.10.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b4fdc777e05c4940b297bf47bf7eedd56a39a61dc23ba798e4b830d585486ca5"},
-    {file = "coverage-7.10.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:42144e8e346de44a6f1dbd0a56575dd8ab8dfa7e9007da02ea5b1c30ab33a7db"},
-    {file = "coverage-7.10.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:66c644cbd7aed8fe266d5917e2c9f65458a51cfe5eeff9c05f15b335f697066e"},
-    {file = "coverage-7.10.5-cp313-cp313t-win32.whl", hash = "sha256:2d1b73023854068c44b0c554578a4e1ef1b050ed07cf8b431549e624a29a66ee"},
-    {file = "coverage-7.10.5-cp313-cp313t-win_amd64.whl", hash = "sha256:54a1532c8a642d8cc0bd5a9a51f5a9dcc440294fd06e9dda55e743c5ec1a8f14"},
-    {file = "coverage-7.10.5-cp313-cp313t-win_arm64.whl", hash = "sha256:74d5b63fe3f5f5d372253a4ef92492c11a4305f3550631beaa432fc9df16fcff"},
-    {file = "coverage-7.10.5-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:68c5e0bc5f44f68053369fa0d94459c84548a77660a5f2561c5e5f1e3bed7031"},
-    {file = "coverage-7.10.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cf33134ffae93865e32e1e37df043bef15a5e857d8caebc0099d225c579b0fa3"},
-    {file = "coverage-7.10.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:ad8fa9d5193bafcf668231294241302b5e683a0518bf1e33a9a0dfb142ec3031"},
-    {file = "coverage-7.10.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:146fa1531973d38ab4b689bc764592fe6c2f913e7e80a39e7eeafd11f0ef6db2"},
-    {file = "coverage-7.10.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6013a37b8a4854c478d3219ee8bc2392dea51602dd0803a12d6f6182a0061762"},
-    {file = "coverage-7.10.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:eb90fe20db9c3d930fa2ad7a308207ab5b86bf6a76f54ab6a40be4012d88fcae"},
-    {file = "coverage-7.10.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:384b34482272e960c438703cafe63316dfbea124ac62006a455c8410bf2a2262"},
-    {file = "coverage-7.10.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:467dc74bd0a1a7de2bedf8deaf6811f43602cb532bd34d81ffd6038d6d8abe99"},
-    {file = "coverage-7.10.5-cp314-cp314-win32.whl", hash = "sha256:556d23d4e6393ca898b2e63a5bca91e9ac2d5fb13299ec286cd69a09a7187fde"},
-    {file = "coverage-7.10.5-cp314-cp314-win_amd64.whl", hash = "sha256:f4446a9547681533c8fa3e3c6cf62121eeee616e6a92bd9201c6edd91beffe13"},
-    {file = "coverage-7.10.5-cp314-cp314-win_arm64.whl", hash = "sha256:5e78bd9cf65da4c303bf663de0d73bf69f81e878bf72a94e9af67137c69b9fe9"},
-    {file = "coverage-7.10.5-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:5661bf987d91ec756a47c7e5df4fbcb949f39e32f9334ccd3f43233bbb65e508"},
-    {file = "coverage-7.10.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a46473129244db42a720439a26984f8c6f834762fc4573616c1f37f13994b357"},
-    {file = "coverage-7.10.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1f64b8d3415d60f24b058b58d859e9512624bdfa57a2d1f8aff93c1ec45c429b"},
-    {file = "coverage-7.10.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:44d43de99a9d90b20e0163f9770542357f58860a26e24dc1d924643bd6aa7cb4"},
-    {file = "coverage-7.10.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a931a87e5ddb6b6404e65443b742cb1c14959622777f2a4efd81fba84f5d91ba"},
-    {file = "coverage-7.10.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f9559b906a100029274448f4c8b8b0a127daa4dade5661dfd821b8c188058842"},
-    {file = "coverage-7.10.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:b08801e25e3b4526ef9ced1aa29344131a8f5213c60c03c18fe4c6170ffa2874"},
-    {file = "coverage-7.10.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ed9749bb8eda35f8b636fb7632f1c62f735a236a5d4edadd8bbcc5ea0542e732"},
-    {file = "coverage-7.10.5-cp314-cp314t-win32.whl", hash = "sha256:609b60d123fc2cc63ccee6d17e4676699075db72d14ac3c107cc4976d516f2df"},
-    {file = "coverage-7.10.5-cp314-cp314t-win_amd64.whl", hash = "sha256:0666cf3d2c1626b5a3463fd5b05f5e21f99e6aec40a3192eee4d07a15970b07f"},
-    {file = "coverage-7.10.5-cp314-cp314t-win_arm64.whl", hash = "sha256:bc85eb2d35e760120540afddd3044a5bf69118a91a296a8b3940dfc4fdcfe1e2"},
-    {file = "coverage-7.10.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:62835c1b00c4a4ace24c1a88561a5a59b612fbb83a525d1c70ff5720c97c0610"},
-    {file = "coverage-7.10.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5255b3bbcc1d32a4069d6403820ac8e6dbcc1d68cb28a60a1ebf17e47028e898"},
-    {file = "coverage-7.10.5-cp39-cp39-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3876385722e335d6e991c430302c24251ef9c2a9701b2b390f5473199b1b8ebf"},
-    {file = "coverage-7.10.5-cp39-cp39-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8048ce4b149c93447a55d279078c8ae98b08a6951a3c4d2d7e87f4efc7bfe100"},
-    {file = "coverage-7.10.5-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4028e7558e268dd8bcf4d9484aad393cafa654c24b4885f6f9474bf53183a82a"},
-    {file = "coverage-7.10.5-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:03f47dc870eec0367fcdd603ca6a01517d2504e83dc18dbfafae37faec66129a"},
-    {file = "coverage-7.10.5-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:2d488d7d42b6ded7ea0704884f89dcabd2619505457de8fc9a6011c62106f6e5"},
-    {file = "coverage-7.10.5-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b3dcf2ead47fa8be14224ee817dfc1df98043af568fe120a22f81c0eb3c34ad2"},
-    {file = "coverage-7.10.5-cp39-cp39-win32.whl", hash = "sha256:02650a11324b80057b8c9c29487020073d5e98a498f1857f37e3f9b6ea1b2426"},
-    {file = "coverage-7.10.5-cp39-cp39-win_amd64.whl", hash = "sha256:b45264dd450a10f9e03237b41a9a24e85cbb1e278e5a32adb1a303f58f0017f3"},
-    {file = "coverage-7.10.5-py3-none-any.whl", hash = "sha256:0be24d35e4db1d23d0db5c0f6a74a962e2ec83c426b5cac09f4234aadef38e4a"},
-    {file = "coverage-7.10.5.tar.gz", hash = "sha256:f2e57716a78bc3ae80b2207be0709a3b2b63b9f2dcf9740ee6ac03588a2015b6"},
-]
-
-[package.dependencies]
-tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.11.0a6\" and extra == \"toml\""}
-
-[package.extras]
-toml = ["tomli ; python_full_version <= \"3.11.0a6\""]
-
-[[package]]
-name = "cryptography"
-version = "45.0.6"
-description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers."
-optional = false
-python-versions = "!=3.9.0,!=3.9.1,>=3.7"
-groups = ["main"]
-files = [
-    {file = "cryptography-45.0.6-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:048e7ad9e08cf4c0ab07ff7f36cc3115924e22e2266e034450a890d9e312dd74"},
-    {file = "cryptography-45.0.6-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:44647c5d796f5fc042bbc6d61307d04bf29bccb74d188f18051b635f20a9c75f"},
-    {file = "cryptography-45.0.6-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e40b80ecf35ec265c452eea0ba94c9587ca763e739b8e559c128d23bff7ebbbf"},
-    {file = "cryptography-45.0.6-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:00e8724bdad672d75e6f069b27970883179bd472cd24a63f6e620ca7e41cc0c5"},
-    {file = "cryptography-45.0.6-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a3085d1b319d35296176af31c90338eeb2ddac8104661df79f80e1d9787b8b2"},
-    {file = "cryptography-45.0.6-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1b7fa6a1c1188c7ee32e47590d16a5a0646270921f8020efc9a511648e1b2e08"},
-    {file = "cryptography-45.0.6-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:275ba5cc0d9e320cd70f8e7b96d9e59903c815ca579ab96c1e37278d231fc402"},
-    {file = "cryptography-45.0.6-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:f4028f29a9f38a2025abedb2e409973709c660d44319c61762202206ed577c42"},
-    {file = "cryptography-45.0.6-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ee411a1b977f40bd075392c80c10b58025ee5c6b47a822a33c1198598a7a5f05"},
-    {file = "cryptography-45.0.6-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e2a21a8eda2d86bb604934b6b37691585bd095c1f788530c1fcefc53a82b3453"},
-    {file = "cryptography-45.0.6-cp311-abi3-win32.whl", hash = "sha256:d063341378d7ee9c91f9d23b431a3502fc8bfacd54ef0a27baa72a0843b29159"},
-    {file = "cryptography-45.0.6-cp311-abi3-win_amd64.whl", hash = "sha256:833dc32dfc1e39b7376a87b9a6a4288a10aae234631268486558920029b086ec"},
-    {file = "cryptography-45.0.6-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:3436128a60a5e5490603ab2adbabc8763613f638513ffa7d311c900a8349a2a0"},
-    {file = "cryptography-45.0.6-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0d9ef57b6768d9fa58e92f4947cea96ade1233c0e236db22ba44748ffedca394"},
-    {file = "cryptography-45.0.6-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea3c42f2016a5bbf71825537c2ad753f2870191134933196bee408aac397b3d9"},
-    {file = "cryptography-45.0.6-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:20ae4906a13716139d6d762ceb3e0e7e110f7955f3bc3876e3a07f5daadec5f3"},
-    {file = "cryptography-45.0.6-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dac5ec199038b8e131365e2324c03d20e97fe214af051d20c49db129844e8b3"},
-    {file = "cryptography-45.0.6-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:18f878a34b90d688982e43f4b700408b478102dd58b3e39de21b5ebf6509c301"},
-    {file = "cryptography-45.0.6-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5bd6020c80c5b2b2242d6c48487d7b85700f5e0038e67b29d706f98440d66eb5"},
-    {file = "cryptography-45.0.6-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:eccddbd986e43014263eda489abbddfbc287af5cddfd690477993dbb31e31016"},
-    {file = "cryptography-45.0.6-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:550ae02148206beb722cfe4ef0933f9352bab26b087af00e48fdfb9ade35c5b3"},
-    {file = "cryptography-45.0.6-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5b64e668fc3528e77efa51ca70fadcd6610e8ab231e3e06ae2bab3b31c2b8ed9"},
-    {file = "cryptography-45.0.6-cp37-abi3-win32.whl", hash = "sha256:780c40fb751c7d2b0c6786ceee6b6f871e86e8718a8ff4bc35073ac353c7cd02"},
-    {file = "cryptography-45.0.6-cp37-abi3-win_amd64.whl", hash = "sha256:20d15aed3ee522faac1a39fbfdfee25d17b1284bafd808e1640a74846d7c4d1b"},
-    {file = "cryptography-45.0.6-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:705bb7c7ecc3d79a50f236adda12ca331c8e7ecfbea51edd931ce5a7a7c4f012"},
-    {file = "cryptography-45.0.6-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:826b46dae41a1155a0c0e66fafba43d0ede1dc16570b95e40c4d83bfcf0a451d"},
-    {file = "cryptography-45.0.6-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:cc4d66f5dc4dc37b89cfef1bd5044387f7a1f6f0abb490815628501909332d5d"},
-    {file = "cryptography-45.0.6-pp310-pypy310_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:f68f833a9d445cc49f01097d95c83a850795921b3f7cc6488731e69bde3288da"},
-    {file = "cryptography-45.0.6-pp310-pypy310_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:3b5bf5267e98661b9b888a9250d05b063220dfa917a8203744454573c7eb79db"},
-    {file = "cryptography-45.0.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:2384f2ab18d9be88a6e4f8972923405e2dbb8d3e16c6b43f15ca491d7831bd18"},
-    {file = "cryptography-45.0.6-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fc022c1fa5acff6def2fc6d7819bbbd31ccddfe67d075331a65d9cfb28a20983"},
-    {file = "cryptography-45.0.6-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:3de77e4df42ac8d4e4d6cdb342d989803ad37707cf8f3fbf7b088c9cbdd46427"},
-    {file = "cryptography-45.0.6-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:599c8d7df950aa68baa7e98f7b73f4f414c9f02d0e8104a30c0182a07732638b"},
-    {file = "cryptography-45.0.6-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:31a2b9a10530a1cb04ffd6aa1cd4d3be9ed49f7d77a4dafe198f3b382f41545c"},
-    {file = "cryptography-45.0.6-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:e5b3dda1b00fb41da3af4c5ef3f922a200e33ee5ba0f0bc9ecf0b0c173958385"},
-    {file = "cryptography-45.0.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:629127cfdcdc6806dfe234734d7cb8ac54edaf572148274fa377a7d3405b0043"},
-    {file = "cryptography-45.0.6.tar.gz", hash = "sha256:5c966c732cf6e4a276ce83b6e4c729edda2df6929083a952cc7da973c539c719"},
-]
-
-[package.dependencies]
-cffi = {version = ">=1.14", markers = "platform_python_implementation != \"PyPy\""}
-
-[package.extras]
-docs = ["sphinx (>=5.3.0)", "sphinx-inline-tabs ; python_full_version >= \"3.8.0\"", "sphinx-rtd-theme (>=3.0.0) ; python_full_version >= \"3.8.0\""]
-docstest = ["pyenchant (>=3)", "readme-renderer (>=30.0)", "sphinxcontrib-spelling (>=7.3.1)"]
-nox = ["nox (>=2024.4.15)", "nox[uv] (>=2024.3.2) ; python_full_version >= \"3.8.0\""]
-pep8test = ["check-sdist ; python_full_version >= \"3.8.0\"", "click (>=8.0.1)", "mypy (>=1.4)", "ruff (>=0.3.6)"]
-sdist = ["build (>=1.0.0)"]
-ssh = ["bcrypt (>=3.1.5)"]
-test = ["certifi (>=2024)", "cryptography-vectors (==45.0.6)", "pretend (>=0.7)", "pytest (>=7.4.0)", "pytest-benchmark (>=4.0)", "pytest-cov (>=2.10.1)", "pytest-xdist (>=3.5.0)"]
-test-randomorder = ["pytest-randomly"]
-
 [[package]]
 name = "deprecation"
 version = "2.1.0"
@@ -480,7 +235,7 @@ version = "1.3.0"
 description = "Backport of PEP 654 (exception groups)"
 optional = false
 python-versions = ">=3.7"
-groups = ["main", "dev"]
+groups = ["main"]
 markers = "python_version < \"3.11\""
 files = [
     {file = "exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10"},
@@ -955,7 +710,7 @@ version = "2.1.0"
 description = "brain-dead simple config-ini parsing"
 optional = false
 python-versions = ">=3.8"
-groups = ["dev"]
+groups = ["main"]
 files = [
     {file = "iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760"},
     {file = "iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7"},
@@ -1024,7 +779,7 @@ version = "25.0"
 description = "Core utilities for Python packages"
 optional = false
 python-versions = ">=3.8"
-groups = ["main", "dev"]
+groups = ["main"]
 files = [
     {file = "packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484"},
     {file = "packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f"},
@@ -1036,7 +791,7 @@ version = "1.6.0"
 description = "plugin and hook calling mechanisms for python"
 optional = false
 python-versions = ">=3.9"
-groups = ["dev"]
+groups = ["main"]
 files = [
     {file = "pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746"},
     {file = "pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3"},
@@ -1128,19 +883,6 @@ files = [
 [package.dependencies]
 pyasn1 = ">=0.6.1,<0.7.0"
 
-[[package]]
-name = "pycparser"
-version = "2.22"
-description = "C parser in Python"
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-markers = "platform_python_implementation != \"PyPy\""
-files = [
-    {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"},
-    {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"},
-]
-
 [[package]]
 name = "pydantic"
 version = "2.11.7"
@@ -1305,7 +1047,7 @@ version = "2.19.2"
 description = "Pygments is a syntax highlighting package written in Python."
 optional = false
 python-versions = ">=3.8"
-groups = ["dev"]
+groups = ["main"]
 files = [
     {file = "pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b"},
     {file = "pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887"},
@@ -1326,9 +1068,6 @@ files = [
     {file = "pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953"},
 ]
 
-[package.dependencies]
-cryptography = {version = ">=3.4.0", optional = true, markers = "extra == \"crypto\""}
-
 [package.extras]
 crypto = ["cryptography (>=3.4.0)"]
 dev = ["coverage[toml] (==5.0.4)", "cryptography (>=3.4.0)", "pre-commit", "pytest (>=6.0.0,<7.0.0)", "sphinx", "sphinx-rtd-theme", "zope.interface"]
@@ -1353,7 +1092,7 @@ version = "8.4.1"
 description = "pytest: simple powerful testing with Python"
 optional = false
 python-versions = ">=3.9"
-groups = ["dev"]
+groups = ["main"]
 files = [
     {file = "pytest-8.4.1-py3-none-any.whl", hash = "sha256:539c70ba6fcead8e78eebbf1115e8b589e7565830d7d006a8723f19ac8a0afb7"},
     {file = "pytest-8.4.1.tar.gz", hash = "sha256:7c67fd69174877359ed9371ec3af8a3d2b04741818c51e5e99cc1742251fa93c"},
@@ -1377,7 +1116,7 @@ version = "1.1.0"
 description = "Pytest support for asyncio"
 optional = false
 python-versions = ">=3.9"
-groups = ["dev"]
+groups = ["main"]
 files = [
     {file = "pytest_asyncio-1.1.0-py3-none-any.whl", hash = "sha256:5fe2d69607b0bd75c656d1211f969cadba035030156745ee09e7d71740e58ecf"},
     {file = "pytest_asyncio-1.1.0.tar.gz", hash = "sha256:796aa822981e01b68c12e4827b8697108f7205020f24b5793b3c41555dab68ea"},
@@ -1391,33 +1130,13 @@ pytest = ">=8.2,<9"
 docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1)"]
 testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"]
 
-[[package]]
-name = "pytest-cov"
-version = "6.2.1"
-description = "Pytest plugin for measuring coverage."
-optional = false
-python-versions = ">=3.9"
-groups = ["dev"]
-files = [
-    {file = "pytest_cov-6.2.1-py3-none-any.whl", hash = "sha256:f5bc4c23f42f1cdd23c70b1dab1bbaef4fc505ba950d53e0081d0730dd7e86d5"},
-    {file = "pytest_cov-6.2.1.tar.gz", hash = "sha256:25cc6cc0a5358204b8108ecedc51a9b57b34cc6b8c967cc2c01a4e00d8a67da2"},
-]
-
-[package.dependencies]
-coverage = {version = ">=7.5", extras = ["toml"]}
-pluggy = ">=1.2"
-pytest = ">=6.2.5"
-
-[package.extras]
-testing = ["fields", "hunter", "process-tests", "pytest-xdist", "virtualenv"]
-
 [[package]]
 name = "pytest-mock"
 version = "3.14.1"
 description = "Thin-wrapper around the mock package for easier use with pytest"
 optional = false
 python-versions = ">=3.8"
-groups = ["dev"]
+groups = ["main"]
 files = [
     {file = "pytest_mock-3.14.1-py3-none-any.whl", hash = "sha256:178aefcd11307d874b4cd3100344e7e2d888d9791a6a1d9bfe90fbc1b74fd1d0"},
     {file = "pytest_mock-3.14.1.tar.gz", hash = "sha256:159e9edac4c451ce77a5cdb9fc5d1100708d2dd4ba3c3df572f14097351af80e"},
@@ -1692,7 +1411,7 @@ version = "2.2.1"
 description = "A lil' TOML parser"
 optional = false
 python-versions = ">=3.8"
-groups = ["dev"]
+groups = ["main"]
 markers = "python_version < \"3.11\""
 files = [
     {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"},
@@ -1735,12 +1454,11 @@ version = "4.14.1"
 description = "Backported and Experimental Type Hints for Python 3.9+"
 optional = false
 python-versions = ">=3.9"
-groups = ["main", "dev"]
+groups = ["main"]
 files = [
     {file = "typing_extensions-4.14.1-py3-none-any.whl", hash = "sha256:d1e1e3b58374dc93031d6eda2420a48ea44a36c2b4766a4fdeb3710755731d76"},
     {file = "typing_extensions-4.14.1.tar.gz", hash = "sha256:38b39f4aeeab64884ce9f74c94263ef78f3c22467c8724005483154c26648d36"},
 ]
-markers = {dev = "python_version < \"3.11\""}
 
 [[package]]
 name = "typing-inspection"
@@ -1897,4 +1615,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.10,<4.0"
-content-hash = "ef7818fba061cea2841c6d7ca4852acde83e4f73b32fca1315e58660002bb0d0"
+content-hash = "4cc687aabe5865665fb8c4ccc0ea7e0af80b41e401ca37919f57efa6e0b5be00"

autogpt_platform/autogpt_libs/pyproject.toml

@@ -15,17 +15,15 @@ google-cloud-logging = "^3.12.1"
 launchdarkly-server-sdk = "^9.12.0"
 pydantic = "^2.11.7"
 pydantic-settings = "^2.10.1"
-pyjwt = { version = "^2.10.1", extras = ["crypto"] }
+pyjwt = "^2.10.1"
+pytest-asyncio = "^1.1.0"
+pytest-mock = "^3.14.1"
 redis = "^6.2.0"
 supabase = "^2.16.0"
 uvicorn = "^0.35.0"
 
 [tool.poetry.group.dev.dependencies]
 ruff = "^0.12.9"
-pytest = "^8.4.1"
-pytest-asyncio = "^1.1.0"
-pytest-mock = "^3.14.1"
-pytest-cov = "^6.2.1"
 
 [build-system]
 requires = ["poetry-core"]

autogpt_platform/backend/.env.default

@@ -16,6 +16,7 @@ DB_SCHEMA=platform
 DATABASE_URL="postgresql://${DB_USER}:${DB_PASS}@${DB_HOST}:${DB_PORT}/${DB_NAME}?schema=${DB_SCHEMA}&connect_timeout=${DB_CONNECT_TIMEOUT}"
 DIRECT_URL="postgresql://${DB_USER}:${DB_PASS}@${DB_HOST}:${DB_PORT}/${DB_NAME}?schema=${DB_SCHEMA}&connect_timeout=${DB_CONNECT_TIMEOUT}"
 PRISMA_SCHEMA="postgres/schema.prisma"
+ENABLE_AUTH=true
 
 ## ===== REQUIRED SERVICE CREDENTIALS ===== ##
 # Redis Configuration
@@ -30,7 +31,7 @@ RABBITMQ_DEFAULT_PASS=k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7
 # Supabase Authentication
 SUPABASE_URL=http://localhost:8000
 SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJzZXJ2aWNlX3JvbGUiLAogICAgImlzcyI6ICJzdXBhYmFzZS1kZW1vIiwKICAgICJpYXQiOiAxNjQxNzY5MjAwLAogICAgImV4cCI6IDE3OTk1MzU2MDAKfQ.DaYlNEoUrrEn2Ig7tqibS-PHK5vgusbcbo7X36XVt4Q
-JWT_VERIFY_KEY=your-super-secret-jwt-token-with-at-least-32-characters-long
+SUPABASE_JWT_SECRET=your-super-secret-jwt-token-with-at-least-32-characters-long
 
 ## ===== REQUIRED SECURITY KEYS ===== ##
 # Generate using: from cryptography.fernet import Fernet;Fernet.generate_key().decode()
@@ -174,4 +175,4 @@ SMARTLEAD_API_KEY=
 ZEROBOUNCE_API_KEY=
 
 # Other Services
-AUTOMOD_API_KEY=
+AUTOMOD_API_KEY=

autogpt_platform/backend/TESTING.md

@@ -132,58 +132,17 @@ def test_endpoint_success(snapshot: Snapshot):
 
 ### Testing with Authentication
 
-For the main API routes that use JWT authentication, auth is provided by the `autogpt_libs.auth` module. If the test actually uses the `user_id`, the recommended approach for testing is to mock the `get_jwt_payload` function, which underpins all higher-level auth functions used in the API (`requires_user`, `requires_admin_user`, `get_user_id`).
-
-If the test doesn't need the `user_id` specifically, mocking is not necessary as during tests auth is disabled anyway (see `conftest.py`).
-
-#### Using Global Auth Fixtures
-
-Two global auth fixtures are provided by `backend/server/conftest.py`:
-
-- `mock_jwt_user` - Regular user with `test_user_id` ("test-user-id")
-- `mock_jwt_admin` - Admin user with `admin_user_id` ("admin-user-id")
-
-These provide the easiest way to set up authentication mocking in test modules:
-
 ```python
-import fastapi
-import fastapi.testclient
-import pytest
-from backend.server.v2.myroute import router
+def override_auth_middleware():
+    return {"sub": "test-user-id"}
 
-app = fastapi.FastAPI()
-app.include_router(router)
-client = fastapi.testclient.TestClient(app)
+def override_get_user_id():
+    return "test-user-id"
 
-@pytest.fixture(autouse=True)
-def setup_app_auth(mock_jwt_user):
-    """Setup auth overrides for all tests in this module"""
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
-
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user['get_jwt_payload']
-    yield
-    app.dependency_overrides.clear()
+app.dependency_overrides[auth_middleware] = override_auth_middleware
+app.dependency_overrides[get_user_id] = override_get_user_id
 ```
 
-For admin-only endpoints, use `mock_jwt_admin` instead:
-
-```python
-@pytest.fixture(autouse=True)
-def setup_app_auth(mock_jwt_admin):
-    """Setup auth overrides for admin tests"""
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
-
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_admin['get_jwt_payload']
-    yield
-    app.dependency_overrides.clear()
-```
-
-The IDs are also available separately as fixtures:
-
-- `test_user_id`
-- `admin_user_id`
-- `target_user_id` (for admin <-> user operations)
-
 ### Mocking External Services
 
 ```python
@@ -194,10 +153,10 @@ def test_external_api_call(mocker, snapshot):
         "backend.services.external_api.call",
         return_value=mock_response
     )
-
+    
     response = client.post("/api/process")
     assert response.status_code == 200
-
+    
     snapshot.snapshot_dir = "snapshots"
     snapshot.assert_match(
         json.dumps(response.json(), indent=2, sort_keys=True),
@@ -228,17 +187,6 @@ def test_external_api_call(mocker, snapshot):
 - Use `async def` with `@pytest.mark.asyncio` for testing async functions directly
 
 ### 5. Fixtures
-
-#### Global Fixtures (conftest.py)
-
-Authentication fixtures are available globally from `conftest.py`:
-
-- `mock_jwt_user` - Standard user authentication
-- `mock_jwt_admin` - Admin user authentication
-- `configured_snapshot` - Pre-configured snapshot fixture
-
-#### Custom Fixtures
-
 Create reusable fixtures for common test data:
 
 ```python
@@ -254,18 +202,9 @@ def test_create_user(sample_user, snapshot):
     # ... test implementation
 ```
 
-#### Test Isolation
-
-All tests must use fixtures that ensure proper isolation:
-
-- Authentication overrides are automatically cleaned up after each test
-- Database connections are properly managed with cleanup
-- Mock objects are reset between tests
-
 ## CI/CD Integration
 
 The GitHub Actions workflow automatically runs tests on:
-
 - Pull requests
 - Pushes to main branch
 
@@ -277,19 +216,16 @@ Snapshot tests work in CI by:
 ## Troubleshooting
 
 ### Snapshot Mismatches
-
 - Review the diff carefully
 - If changes are expected: `poetry run pytest --snapshot-update`
 - If changes are unexpected: Fix the code causing the difference
 
 ### Async Test Issues
-
 - Ensure async functions use `@pytest.mark.asyncio`
 - Use `AsyncMock` for mocking async functions
 - FastAPI TestClient handles async automatically
 
 ### Import Errors
-
 - Check that all dependencies are in `pyproject.toml`
 - Run `poetry install` to ensure dependencies are installed
 - Verify import paths are correct
@@ -298,4 +234,4 @@ Snapshot tests work in CI by:
 
 Snapshot testing provides a powerful way to ensure API responses remain consistent. Combined with traditional assertions, it creates a robust test suite that catches regressions while remaining maintainable.
 
-Remember: Good tests are as important as good code!
+Remember: Good tests are as important as good code!

autogpt_platform/backend/backend/blocks/exa/websets.py

@@ -93,11 +93,11 @@ class Webset(BaseModel):
     """
     Set of key-value pairs you want to associate with this object.
     """
-    created_at: Annotated[datetime | None, Field(alias="createdAt")] = None
+    created_at: Annotated[datetime, Field(alias="createdAt")] | None = None
     """
     The date and time the webset was created
     """
-    updated_at: Annotated[datetime | None, Field(alias="updatedAt")] = None
+    updated_at: Annotated[datetime, Field(alias="updatedAt")] | None = None
     """
     The date and time the webset was last updated
     """

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

@@ -39,6 +39,18 @@ def serialize_email_recipients(recipients: list[str]) -> str:
     return ", ".join(recipients)
 
 
+def deduplicate_email_addresses(addresses: list[str]) -> list[str]:
+    """Deduplicate email addresses while preserving order.
+
+    Args:
+        addresses: List of email addresses that may contain duplicates or None values
+
+    Returns:
+        List of unique email addresses with None values filtered out
+    """
+    return list(dict.fromkeys(filter(None, addresses)))
+
+
 def _make_mime_text(
     body: str,
     content_type: Optional[Literal["auto", "plain", "html"]] = None,
@@ -1263,11 +1275,8 @@ class GmailReplyBlock(GmailBase):
                 recipients += [
                     addr for _, addr in getaddresses([headers.get("cc", "")])
                 ]
-                dedup: list[str] = []
-                for r in recipients:
-                    if r and r not in dedup:
-                        dedup.append(r)
-                input_data.to = dedup
+                # Deduplicate recipients while preserving order
+                input_data.to = deduplicate_email_addresses(recipients)
             else:
                 sender = parseaddr(headers.get("reply-to", headers.get("from", "")))[1]
                 input_data.to = [sender] if sender else []
@@ -1317,6 +1326,224 @@ class GmailReplyBlock(GmailBase):
         )
 
 
+class GmailCreateDraftReplyBlock(GmailBase):
+    """
+    Creates draft replies to Gmail threads with intelligent content type detection.
+
+    Features:
+    - Automatic HTML detection: Draft replies containing HTML tags are formatted as text/html
+    - No hard-wrap for plain text: Plain text drafts preserve natural line flow
+    - Manual content type override: Use content_type parameter to force specific format
+    - Reply-all functionality: Option to draft reply to all original recipients
+    - Thread preservation: Maintains proper email threading with headers
+    - Full Unicode/emoji support with UTF-8 encoding
+    - Attachment support for multiple files
+    """
+
+    class Input(BlockSchema):
+        credentials: GoogleCredentialsInput = GoogleCredentialsField(
+            [
+                "https://www.googleapis.com/auth/gmail.modify",
+                "https://www.googleapis.com/auth/gmail.readonly",
+            ]
+        )
+        threadId: str = SchemaField(description="Thread ID to reply in")
+        parentMessageId: str = SchemaField(
+            description="ID of the message being replied to"
+        )
+        to: list[str] = SchemaField(description="To recipients", default_factory=list)
+        cc: list[str] = SchemaField(description="CC recipients", default_factory=list)
+        bcc: list[str] = SchemaField(description="BCC recipients", default_factory=list)
+        replyAll: bool = SchemaField(
+            description="Reply to all original recipients", default=False
+        )
+        subject: str = SchemaField(description="Email subject", default="")
+        body: str = SchemaField(description="Email body (plain text or HTML)")
+        content_type: Optional[Literal["auto", "plain", "html"]] = SchemaField(
+            description="Content type: 'auto' (default - detects HTML), 'plain', or 'html'",
+            default=None,
+            advanced=True,
+        )
+        attachments: list[MediaFileType] = SchemaField(
+            description="Files to attach", default_factory=list, advanced=True
+        )
+
+    class Output(BlockSchema):
+        draftId: str = SchemaField(description="Created draft ID")
+        messageId: str = SchemaField(description="Draft message ID")
+        threadId: str = SchemaField(description="Thread ID")
+        status: str = SchemaField(description="Draft creation status")
+        error: str = SchemaField(description="Error message if any")
+
+    def __init__(self):
+        super().__init__(
+            id="8f2e9d3c-4b1a-4c7e-9a2f-1d3e5f7a9b1c",
+            description="Create draft replies to Gmail threads with automatic HTML detection and proper text formatting. Drafts maintain proper email threading and can be edited before sending.",
+            categories={BlockCategory.COMMUNICATION},
+            input_schema=GmailCreateDraftReplyBlock.Input,
+            output_schema=GmailCreateDraftReplyBlock.Output,
+            disabled=not GOOGLE_OAUTH_IS_CONFIGURED,
+            test_input={
+                "threadId": "t1",
+                "parentMessageId": "m1",
+                "body": "Thanks for your message. I'll draft a response.",
+                "replyAll": False,
+                "credentials": TEST_CREDENTIALS_INPUT,
+            },
+            test_credentials=TEST_CREDENTIALS,
+            test_output=[
+                ("draftId", "draft1"),
+                ("messageId", "msg1"),
+                ("threadId", "t1"),
+                ("status", "draft_reply_created"),
+            ],
+            test_mock={
+                "_create_draft_reply": lambda *args, **kwargs: {
+                    "id": "draft1",
+                    "message": {"id": "msg1", "threadId": "t1"},
+                },
+            },
+        )
+
+    async def run(
+        self,
+        input_data: Input,
+        *,
+        credentials: GoogleCredentials,
+        graph_exec_id: str,
+        user_id: str,
+        **kwargs,
+    ) -> BlockOutput:
+        service = self._build_service(credentials, **kwargs)
+        result = await self._create_draft_reply(
+            service,
+            input_data,
+            graph_exec_id,
+            user_id,
+        )
+        yield "draftId", result["id"]
+        yield "messageId", result["message"]["id"]
+        yield "threadId", result["message"].get("threadId", input_data.threadId)
+        yield "status", "draft_reply_created"
+
+    async def _create_draft_reply(
+        self, service, input_data: Input, graph_exec_id: str, user_id: str
+    ) -> dict:
+        # Fetch parent message metadata
+        parent = await asyncio.to_thread(
+            lambda: service.users()
+            .messages()
+            .get(
+                userId="me",
+                id=input_data.parentMessageId,
+                format="metadata",
+                metadataHeaders=[
+                    "Subject",
+                    "References",
+                    "Message-ID",
+                    "From",
+                    "To",
+                    "Cc",
+                    "Reply-To",
+                ],
+            )
+            .execute()
+        )
+
+        headers = {
+            h["name"].lower(): h["value"]
+            for h in parent.get("payload", {}).get("headers", [])
+        }
+
+        # Auto-populate recipients if not provided
+        if not (input_data.to or input_data.cc or input_data.bcc):
+            if input_data.replyAll:
+                # Reply all - include all original recipients
+                recipients = [parseaddr(headers.get("from", ""))[1]]
+                recipients += [
+                    addr for _, addr in getaddresses([headers.get("to", "")])
+                ]
+                recipients += [
+                    addr for _, addr in getaddresses([headers.get("cc", "")])
+                ]
+                # Deduplicate recipients
+                dedup: list[str] = []
+                for r in recipients:
+                    if r and r not in dedup:
+                        dedup.append(r)
+                input_data.to = dedup
+            else:
+                # Reply to sender only
+                sender = parseaddr(headers.get("reply-to", headers.get("from", "")))[1]
+                input_data.to = [sender] if sender else []
+
+        # Generate subject with Re: prefix if needed
+        subject = input_data.subject or (f"Re: {headers.get('subject', '')}".strip())
+
+        # Build References header chain
+        references = headers.get("references", "").split()
+        if headers.get("message-id"):
+            references.append(headers["message-id"])
+
+        # Create MIME message with threading headers
+        msg = MIMEMultipart()
+        if input_data.to:
+            msg["To"] = ", ".join(input_data.to)
+        if input_data.cc:
+            msg["Cc"] = ", ".join(input_data.cc)
+        if input_data.bcc:
+            msg["Bcc"] = ", ".join(input_data.bcc)
+        msg["Subject"] = subject
+
+        # Set threading headers for proper conversation grouping
+        if headers.get("message-id"):
+            msg["In-Reply-To"] = headers["message-id"]
+        if references:
+            msg["References"] = " ".join(references)
+
+        # Add body with proper content type handling
+        msg.attach(_make_mime_text(input_data.body, input_data.content_type))
+
+        # Handle attachments if any
+        for attach in input_data.attachments:
+            local_path = await store_media_file(
+                user_id=user_id,
+                graph_exec_id=graph_exec_id,
+                file=attach,
+                return_content=False,
+            )
+            abs_path = get_exec_file_path(graph_exec_id, local_path)
+            part = MIMEBase("application", "octet-stream")
+            with open(abs_path, "rb") as f:
+                part.set_payload(f.read())
+            encoders.encode_base64(part)
+            part.add_header(
+                "Content-Disposition", f"attachment; filename={Path(abs_path).name}"
+            )
+            msg.attach(part)
+
+        # Encode message for Gmail API
+        raw = base64.urlsafe_b64encode(msg.as_bytes()).decode("utf-8")
+
+        # Create draft with threadId to ensure it appears as a reply
+        draft = await asyncio.to_thread(
+            lambda: service.users()
+            .drafts()
+            .create(
+                userId="me",
+                body={
+                    "message": {
+                        "threadId": input_data.threadId,
+                        "raw": raw,
+                    }
+                },
+            )
+            .execute()
+        )
+
+        return draft
+
+
 class GmailGetProfileBlock(GmailBase):
     class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(

autogpt_platform/backend/backend/blocks/ideogram.py

@@ -30,7 +30,6 @@ TEST_CREDENTIALS_INPUT = {
 
 
 class IdeogramModelName(str, Enum):
-    V3 = "V_3"
     V2 = "V_2"
     V1 = "V_1"
     V1_TURBO = "V_1_TURBO"
@@ -96,8 +95,8 @@ class IdeogramModelBlock(Block):
             title="Prompt",
         )
         ideogram_model_name: IdeogramModelName = SchemaField(
-            description="The name of the Image Generation Model, e.g., V_3",
-            default=IdeogramModelName.V3,
+            description="The name of the Image Generation Model, e.g., V_2",
+            default=IdeogramModelName.V2,
             title="Image Generation Model",
             advanced=False,
         )
@@ -237,111 +236,6 @@ class IdeogramModelBlock(Block):
         negative_prompt: Optional[str],
         color_palette_name: str,
         custom_colors: Optional[list[str]],
-    ):
-        # Use V3 endpoint for V3 model, legacy endpoint for others
-        if model_name == "V_3":
-            return await self._run_model_v3(
-                api_key,
-                prompt,
-                seed,
-                aspect_ratio,
-                magic_prompt_option,
-                style_type,
-                negative_prompt,
-                color_palette_name,
-                custom_colors,
-            )
-        else:
-            return await self._run_model_legacy(
-                api_key,
-                model_name,
-                prompt,
-                seed,
-                aspect_ratio,
-                magic_prompt_option,
-                style_type,
-                negative_prompt,
-                color_palette_name,
-                custom_colors,
-            )
-
-    async def _run_model_v3(
-        self,
-        api_key: SecretStr,
-        prompt: str,
-        seed: Optional[int],
-        aspect_ratio: str,
-        magic_prompt_option: str,
-        style_type: str,
-        negative_prompt: Optional[str],
-        color_palette_name: str,
-        custom_colors: Optional[list[str]],
-    ):
-        url = "https://api.ideogram.ai/v1/ideogram-v3/generate"
-        headers = {
-            "Api-Key": api_key.get_secret_value(),
-            "Content-Type": "application/json",
-        }
-
-        # Map legacy aspect ratio values to V3 format
-        aspect_ratio_map = {
-            "ASPECT_10_16": "10x16",
-            "ASPECT_16_10": "16x10",
-            "ASPECT_9_16": "9x16",
-            "ASPECT_16_9": "16x9",
-            "ASPECT_3_2": "3x2",
-            "ASPECT_2_3": "2x3",
-            "ASPECT_4_3": "4x3",
-            "ASPECT_3_4": "3x4",
-            "ASPECT_1_1": "1x1",
-            "ASPECT_1_3": "1x3",
-            "ASPECT_3_1": "3x1",
-            # Additional V3 supported ratios
-            "ASPECT_1_2": "1x2",
-            "ASPECT_2_1": "2x1",
-            "ASPECT_4_5": "4x5",
-            "ASPECT_5_4": "5x4",
-        }
-
-        v3_aspect_ratio = aspect_ratio_map.get(
-            aspect_ratio, "1x1"
-        )  # Default to 1x1 if not found
-
-        # Use JSON for V3 endpoint (simpler than multipart/form-data)
-        data: Dict[str, Any] = {
-            "prompt": prompt,
-            "aspect_ratio": v3_aspect_ratio,
-            "magic_prompt": magic_prompt_option,
-            "style_type": style_type,
-        }
-
-        if seed is not None:
-            data["seed"] = seed
-
-        if negative_prompt:
-            data["negative_prompt"] = negative_prompt
-
-        # Note: V3 endpoint may have different color palette support
-        # For now, we'll omit color palettes for V3 to avoid errors
-
-        try:
-            response = await Requests().post(url, headers=headers, json=data)
-            return response.json()["data"][0]["url"]
-        except RequestException as e:
-            raise Exception(f"Failed to fetch image with V3 endpoint: {str(e)}")
-
-    async def _run_model_legacy(
-        self,
-        api_key: SecretStr,
-        model_name: str,
-        prompt: str,
-        seed: Optional[int],
-        aspect_ratio: str,
-        magic_prompt_option: str,
-        style_type: str,
-        negative_prompt: Optional[str],
-        color_palette_name: str,
-        custom_colors: Optional[list[str]],
     ):
         url = "https://api.ideogram.ai/generate"
         headers = {
@@ -355,33 +249,28 @@ class IdeogramModelBlock(Block):
                 "model": model_name,
                 "aspect_ratio": aspect_ratio,
                 "magic_prompt_option": magic_prompt_option,
+                "style_type": style_type,
             }
         }
 
-        # Only add style_type for V2, V2_TURBO, and V3 models (V1 models don't support it)
-        if model_name in ["V_2", "V_2_TURBO", "V_3"]:
-            data["image_request"]["style_type"] = style_type
-
         if seed is not None:
             data["image_request"]["seed"] = seed
 
         if negative_prompt:
             data["image_request"]["negative_prompt"] = negative_prompt
 
-        # Only add color palette for V2 and V2_TURBO models (V1 models don't support it)
-        if model_name in ["V_2", "V_2_TURBO"]:
-            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]
-                }
+        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]
+            }
 
         try:
             response = await Requests().post(url, headers=headers, json=data)
             return response.json()["data"][0]["url"]
         except RequestException as e:
-            raise Exception(f"Failed to fetch image with legacy endpoint: {str(e)}")
+            raise Exception(f"Failed to fetch image: {str(e)}")
 
     async def upscale_image(self, api_key: SecretStr, image_url: str):
         url = "https://api.ideogram.ai/upscale"

autogpt_platform/backend/backend/blocks/stagehand/_config.py

@@ -1,8 +0,0 @@
-from backend.sdk import BlockCostType, ProviderBuilder
-
-stagehand = (
-    ProviderBuilder("stagehand")
-    .with_api_key("STAGEHAND_API_KEY", "Stagehand API Key")
-    .with_base_cost(1, BlockCostType.RUN)
-    .build()
-)

autogpt_platform/backend/backend/blocks/stagehand/blocks.py

@@ -1,393 +0,0 @@
-import logging
-import signal
-import threading
-from contextlib import contextmanager
-from enum import Enum
-
-# Monkey patch Stagehands to prevent signal handling in worker threads
-import stagehand.main
-from stagehand import Stagehand
-
-from backend.blocks.llm import (
-    MODEL_METADATA,
-    AICredentials,
-    AICredentialsField,
-    LlmModel,
-    ModelMetadata,
-)
-from backend.blocks.stagehand._config import stagehand as stagehand_provider
-from backend.sdk import (
-    APIKeyCredentials,
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchema,
-    CredentialsMetaInput,
-    SchemaField,
-)
-
-# Store the original method
-original_register_signal_handlers = stagehand.main.Stagehand._register_signal_handlers
-
-
-def safe_register_signal_handlers(self):
-    """Only register signal handlers in the main thread"""
-    if threading.current_thread() is threading.main_thread():
-        original_register_signal_handlers(self)
-    else:
-        # Skip signal handling in worker threads
-        pass
-
-
-# Replace the method
-stagehand.main.Stagehand._register_signal_handlers = safe_register_signal_handlers
-
-
-@contextmanager
-def disable_signal_handling():
-    """Context manager to temporarily disable signal handling"""
-    if threading.current_thread() is not threading.main_thread():
-        # In worker threads, temporarily replace signal.signal with a no-op
-        original_signal = signal.signal
-
-        def noop_signal(*args, **kwargs):
-            pass
-
-        signal.signal = noop_signal
-        try:
-            yield
-        finally:
-            signal.signal = original_signal
-    else:
-        # In main thread, don't modify anything
-        yield
-
-
-logger = logging.getLogger(__name__)
-
-
-class StagehandRecommendedLlmModel(str, Enum):
-    """
-    This is subset of LLModel from autogpt_platform/backend/backend/blocks/llm.py
-
-    It contains only the models recommended by Stagehand
-    """
-
-    # OpenAI
-    GPT41 = "gpt-4.1-2025-04-14"
-    GPT41_MINI = "gpt-4.1-mini-2025-04-14"
-
-    # Anthropic
-    CLAUDE_3_7_SONNET = "claude-3-7-sonnet-20250219"
-
-    @property
-    def provider_name(self) -> str:
-        """
-        Returns the provider name for the model in the required format for Stagehand:
-        provider/model_name
-        """
-        model_metadata = MODEL_METADATA[LlmModel(self.value)]
-        model_name = self.value
-
-        if len(model_name.split("/")) == 1 and not self.value.startswith(
-            model_metadata.provider
-        ):
-            assert (
-                model_metadata.provider != "open_router"
-            ), "Logic failed and open_router provider attempted to be prepended to model name! in stagehand/_config.py"
-            model_name = f"{model_metadata.provider}/{model_name}"
-
-        logger.error(f"Model name: {model_name}")
-        return model_name
-
-    @property
-    def provider(self) -> str:
-        return MODEL_METADATA[LlmModel(self.value)].provider
-
-    @property
-    def metadata(self) -> ModelMetadata:
-        return MODEL_METADATA[LlmModel(self.value)]
-
-    @property
-    def context_window(self) -> int:
-        return MODEL_METADATA[LlmModel(self.value)].context_window
-
-    @property
-    def max_output_tokens(self) -> int | None:
-        return MODEL_METADATA[LlmModel(self.value)].max_output_tokens
-
-
-class StagehandObserveBlock(Block):
-    class Input(BlockSchema):
-        # Browserbase credentials (Stagehand provider) or raw API key
-        stagehand_credentials: CredentialsMetaInput = (
-            stagehand_provider.credentials_field(
-                description="Stagehand/Browserbase API key"
-            )
-        )
-        browserbase_project_id: str = SchemaField(
-            description="Browserbase project ID (required if using Browserbase)",
-        )
-        # Model selection and credentials (provider-discriminated like llm.py)
-        model: StagehandRecommendedLlmModel = SchemaField(
-            title="LLM Model",
-            description="LLM to use for Stagehand (provider is inferred)",
-            default=StagehandRecommendedLlmModel.CLAUDE_3_7_SONNET,
-            advanced=False,
-        )
-        model_credentials: AICredentials = AICredentialsField()
-        url: str = SchemaField(
-            description="URL to navigate to.",
-        )
-        instruction: str = SchemaField(
-            description="Natural language description of elements or actions to discover.",
-        )
-        iframes: bool = SchemaField(
-            description="Whether to search within iframes. If True, Stagehand will search for actions within iframes.",
-            default=True,
-        )
-        domSettleTimeoutMs: int = SchemaField(
-            description="Timeout in milliseconds for DOM settlement.Wait longer for dynamic content",
-            default=45000,
-        )
-
-    class Output(BlockSchema):
-        selector: str = SchemaField(description="XPath selector to locate element.")
-        description: str = SchemaField(description="Human-readable description")
-        method: str | None = SchemaField(description="Suggested action method")
-        arguments: list[str] | None = SchemaField(
-            description="Additional action parameters"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="d3863944-0eaf-45c4-a0c9-63e0fe1ee8b9",
-            description="Find suggested actions for your workflows",
-            categories={BlockCategory.AI, BlockCategory.DEVELOPER_TOOLS},
-            input_schema=StagehandObserveBlock.Input,
-            output_schema=StagehandObserveBlock.Output,
-        )
-
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        stagehand_credentials: APIKeyCredentials,
-        model_credentials: APIKeyCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-
-        logger.info(f"OBSERVE: Stagehand credentials: {stagehand_credentials}")
-        logger.info(
-            f"OBSERVE: Model credentials: {model_credentials} for provider {model_credentials.provider} secret: {model_credentials.api_key.get_secret_value()}"
-        )
-
-        with disable_signal_handling():
-            stagehand = Stagehand(
-                api_key=stagehand_credentials.api_key.get_secret_value(),
-                project_id=input_data.browserbase_project_id,
-                model_name=input_data.model.provider_name,
-                model_api_key=model_credentials.api_key.get_secret_value(),
-            )
-
-            await stagehand.init()
-
-        page = stagehand.page
-
-        assert page is not None, "Stagehand page is not initialized"
-
-        await page.goto(input_data.url)
-
-        observe_results = await page.observe(
-            input_data.instruction,
-            iframes=input_data.iframes,
-            domSettleTimeoutMs=input_data.domSettleTimeoutMs,
-        )
-        for result in observe_results:
-            yield "selector", result.selector
-            yield "description", result.description
-            yield "method", result.method
-            yield "arguments", result.arguments
-
-
-class StagehandActBlock(Block):
-    class Input(BlockSchema):
-        # Browserbase credentials (Stagehand provider) or raw API key
-        stagehand_credentials: CredentialsMetaInput = (
-            stagehand_provider.credentials_field(
-                description="Stagehand/Browserbase API key"
-            )
-        )
-        browserbase_project_id: str = SchemaField(
-            description="Browserbase project ID (required if using Browserbase)",
-        )
-        # Model selection and credentials (provider-discriminated like llm.py)
-        model: StagehandRecommendedLlmModel = SchemaField(
-            title="LLM Model",
-            description="LLM to use for Stagehand (provider is inferred)",
-            default=StagehandRecommendedLlmModel.CLAUDE_3_7_SONNET,
-            advanced=False,
-        )
-        model_credentials: AICredentials = AICredentialsField()
-        url: str = SchemaField(
-            description="URL to navigate to.",
-        )
-        action: list[str] = SchemaField(
-            description="Action to perform. Suggested actions are: click, fill, type, press, scroll, select from dropdown. For multi-step actions, add an entry for each step.",
-        )
-        variables: dict[str, str] = SchemaField(
-            description="Variables to use in the action. Variables contains data you want the action to use.",
-            default_factory=dict,
-        )
-        iframes: bool = SchemaField(
-            description="Whether to search within iframes. If True, Stagehand will search for actions within iframes.",
-            default=True,
-        )
-        domSettleTimeoutMs: int = SchemaField(
-            description="Timeout in milliseconds for DOM settlement.Wait longer for dynamic content",
-            default=45000,
-        )
-        timeoutMs: int = SchemaField(
-            description="Timeout in milliseconds for DOM ready. Extended timeout for slow-loading forms",
-            default=60000,
-        )
-
-    class Output(BlockSchema):
-        success: bool = SchemaField(
-            description="Whether the action was completed successfully"
-        )
-        message: str = SchemaField(description="Details about the action’s execution.")
-        action: str = SchemaField(description="Action performed")
-
-    def __init__(self):
-        super().__init__(
-            id="86eba68b-9549-4c0b-a0db-47d85a56cc27",
-            description="Interact with a web page by performing actions on a web page. Use it to build self-healing and deterministic automations that adapt to website chang.",
-            categories={BlockCategory.AI, BlockCategory.DEVELOPER_TOOLS},
-            input_schema=StagehandActBlock.Input,
-            output_schema=StagehandActBlock.Output,
-        )
-
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        stagehand_credentials: APIKeyCredentials,
-        model_credentials: APIKeyCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-
-        logger.info(f"ACT: Stagehand credentials: {stagehand_credentials}")
-        logger.info(
-            f"ACT: Model credentials: {model_credentials} for provider {model_credentials.provider} secret: {model_credentials.api_key.get_secret_value()}"
-        )
-
-        with disable_signal_handling():
-            stagehand = Stagehand(
-                api_key=stagehand_credentials.api_key.get_secret_value(),
-                project_id=input_data.browserbase_project_id,
-                model_name=input_data.model.provider_name,
-                model_api_key=model_credentials.api_key.get_secret_value(),
-            )
-
-            await stagehand.init()
-
-        page = stagehand.page
-
-        assert page is not None, "Stagehand page is not initialized"
-
-        await page.goto(input_data.url)
-        for action in input_data.action:
-            action_results = await page.act(
-                action,
-                variables=input_data.variables,
-                iframes=input_data.iframes,
-                domSettleTimeoutMs=input_data.domSettleTimeoutMs,
-                timeoutMs=input_data.timeoutMs,
-            )
-            yield "success", action_results.success
-            yield "message", action_results.message
-            yield "action", action_results.action
-
-
-class StagehandExtractBlock(Block):
-    class Input(BlockSchema):
-        # Browserbase credentials (Stagehand provider) or raw API key
-        stagehand_credentials: CredentialsMetaInput = (
-            stagehand_provider.credentials_field(
-                description="Stagehand/Browserbase API key"
-            )
-        )
-        browserbase_project_id: str = SchemaField(
-            description="Browserbase project ID (required if using Browserbase)",
-        )
-        # Model selection and credentials (provider-discriminated like llm.py)
-        model: StagehandRecommendedLlmModel = SchemaField(
-            title="LLM Model",
-            description="LLM to use for Stagehand (provider is inferred)",
-            default=StagehandRecommendedLlmModel.CLAUDE_3_7_SONNET,
-            advanced=False,
-        )
-        model_credentials: AICredentials = AICredentialsField()
-        url: str = SchemaField(
-            description="URL to navigate to.",
-        )
-        instruction: str = SchemaField(
-            description="Natural language description of elements or actions to discover.",
-        )
-        iframes: bool = SchemaField(
-            description="Whether to search within iframes. If True, Stagehand will search for actions within iframes.",
-            default=True,
-        )
-        domSettleTimeoutMs: int = SchemaField(
-            description="Timeout in milliseconds for DOM settlement.Wait longer for dynamic content",
-            default=45000,
-        )
-
-    class Output(BlockSchema):
-        extraction: str = SchemaField(description="Extracted data from the page.")
-
-    def __init__(self):
-        super().__init__(
-            id="fd3c0b18-2ba6-46ae-9339-fcb40537ad98",
-            description="Extract structured data from a webpage.",
-            categories={BlockCategory.AI, BlockCategory.DEVELOPER_TOOLS},
-            input_schema=StagehandExtractBlock.Input,
-            output_schema=StagehandExtractBlock.Output,
-        )
-
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        stagehand_credentials: APIKeyCredentials,
-        model_credentials: APIKeyCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-
-        logger.info(f"EXTRACT: Stagehand credentials: {stagehand_credentials}")
-        logger.info(
-            f"EXTRACT: Model credentials: {model_credentials} for provider {model_credentials.provider} secret: {model_credentials.api_key.get_secret_value()}"
-        )
-
-        with disable_signal_handling():
-            stagehand = Stagehand(
-                api_key=stagehand_credentials.api_key.get_secret_value(),
-                project_id=input_data.browserbase_project_id,
-                model_name=input_data.model.provider_name,
-                model_api_key=model_credentials.api_key.get_secret_value(),
-            )
-
-            await stagehand.init()
-
-        page = stagehand.page
-
-        assert page is not None, "Stagehand page is not initialized"
-
-        await page.goto(input_data.url)
-        extraction = await page.extract(
-            input_data.instruction,
-            iframes=input_data.iframes,
-            domSettleTimeoutMs=input_data.domSettleTimeoutMs,
-        )
-        yield "extraction", str(extraction.model_dump()["extraction"])

autogpt_platform/backend/backend/blocks/wordpress/_api.py

@@ -4,8 +4,6 @@ from logging import getLogger
 from typing import Any, Dict, List, Union
 from urllib.parse import urlencode
 
-from pydantic import field_serializer
-
 from backend.sdk import BaseModel, Credentials, Requests
 
 logger = getLogger(__name__)
@@ -384,9 +382,8 @@ class CreatePostRequest(BaseModel):
     # Advanced
     metadata: List[Dict[str, Any]] | None = None
 
-    @field_serializer("date")
-    def serialize_date(self, value: datetime | None) -> str | None:
-        return value.isoformat() if value else None
+    class Config:
+        json_encoders = {datetime: lambda v: v.isoformat()}
 
 
 class PostAuthor(BaseModel):

autogpt_platform/backend/backend/conftest.py

@@ -6,6 +6,8 @@ from dotenv import load_dotenv
 
 from backend.util.logging import configure_logging
 
+os.environ["ENABLE_AUTH"] = "false"
+
 load_dotenv()
 
 #  NOTE: You can run tests like with the --log-cli-level=INFO to see the logs

autogpt_platform/backend/backend/data/block_cost_config.py

@@ -307,18 +307,7 @@ BLOCK_COSTS: dict[Type[Block], list[BlockCost]] = {
                     "type": ideogram_credentials.type,
                 }
             },
-        ),
-        BlockCost(
-            cost_amount=18,
-            cost_filter={
-                "ideogram_model_name": "V_3",
-                "credentials": {
-                    "id": ideogram_credentials.id,
-                    "provider": ideogram_credentials.provider,
-                    "type": ideogram_credentials.type,
-                },
-            },
-        ),
+        )
     ],
     AIShortformVideoCreatorBlock: [
         BlockCost(

autogpt_platform/backend/backend/data/execution.py

@@ -315,10 +315,9 @@ class NodeExecutionResult(BaseModel):
     input_data: BlockInput
     output_data: CompletedBlockOutput
     add_time: datetime
-    queue_time: datetime | None = None
-    start_time: datetime | None = None
-    end_time: datetime | None = None
-    stats: NodeExecutionStats | None = None
+    queue_time: datetime | None
+    start_time: datetime | None
+    end_time: datetime | None
 
     @staticmethod
     def from_db(_node_exec: AgentNodeExecution, user_id: Optional[str] = None):
@@ -370,7 +369,6 @@ class NodeExecutionResult(BaseModel):
             queue_time=_node_exec.queuedTime,
             start_time=_node_exec.startedTime,
             end_time=_node_exec.endedTime,
-            stats=stats,
         )
 
     def to_node_execution_entry(
@@ -656,42 +654,6 @@ async def upsert_execution_input(
         )
 
 
-async def create_node_execution(
-    node_exec_id: str,
-    node_id: str,
-    graph_exec_id: str,
-    input_name: str,
-    input_data: Any,
-) -> None:
-    """Create a new node execution with the first input."""
-    json_input_data = SafeJson(input_data)
-    await AgentNodeExecution.prisma().create(
-        data=AgentNodeExecutionCreateInput(
-            id=node_exec_id,
-            agentNodeId=node_id,
-            agentGraphExecutionId=graph_exec_id,
-            executionStatus=ExecutionStatus.INCOMPLETE,
-            Input={"create": {"name": input_name, "data": json_input_data}},
-        )
-    )
-
-
-async def add_input_to_node_execution(
-    node_exec_id: str,
-    input_name: str,
-    input_data: Any,
-) -> None:
-    """Add an input to an existing node execution."""
-    json_input_data = SafeJson(input_data)
-    await AgentNodeExecutionInputOutput.prisma().create(
-        data=AgentNodeExecutionInputOutputCreateInput(
-            name=input_name,
-            data=json_input_data,
-            referencedByInputExecId=node_exec_id,
-        )
-    )
-
-
 async def upsert_execution_output(
     node_exec_id: str,
     output_name: str,

autogpt_platform/backend/backend/data/graph_test.py

@@ -2,6 +2,7 @@ import json
 from typing import Any
 from uuid import UUID
 
+import autogpt_libs.auth.models
 import fastapi.exceptions
 import pytest
 from pytest_snapshot.plugin import Snapshot
@@ -316,7 +317,12 @@ async def test_access_store_listing_graph(server: SpinTestServer):
             is_approved=True,
             comments="Test comments",
         ),
-        user_id=admin_user.id,
+        autogpt_libs.auth.models.User(
+            user_id=admin_user.id,
+            role="admin",
+            email=admin_user.email,
+            phone_number="1234567890",
+        ),
     )
 
     # Now we check the graph can be accessed by a user that does not own the graph

autogpt_platform/backend/backend/executor/activity_status_generator.py

@@ -115,7 +115,7 @@ async def generate_activity_status_for_execution(
 
         # Get all node executions for this graph execution
         node_executions = await db_client.get_node_executions(
-            graph_exec_id=graph_exec_id, include_exec_data=True
+            graph_exec_id, include_exec_data=True
         )
 
         # Get graph metadata and full graph structure for name, description, and links

autogpt_platform/backend/backend/executor/database.py

@@ -4,13 +4,12 @@ from typing import Callable, Concatenate, ParamSpec, TypeVar, cast
 from backend.data import db
 from backend.data.credit import UsageTransactionMetadata, get_user_credit_model
 from backend.data.execution import (
-    add_input_to_node_execution,
     create_graph_execution,
-    create_node_execution,
     get_block_error_stats,
     get_execution_kv_data,
     get_graph_execution_meta,
     get_graph_executions,
+    get_latest_node_execution,
     get_node_execution,
     get_node_executions,
     set_execution_kv_data,
@@ -18,6 +17,7 @@ from backend.data.execution import (
     update_graph_execution_stats,
     update_node_execution_status,
     update_node_execution_status_batch,
+    upsert_execution_input,
     upsert_execution_output,
 )
 from backend.data.generate_data import get_user_execution_summary_data
@@ -105,13 +105,13 @@ class DatabaseManager(AppService):
     create_graph_execution = _(create_graph_execution)
     get_node_execution = _(get_node_execution)
     get_node_executions = _(get_node_executions)
+    get_latest_node_execution = _(get_latest_node_execution)
     update_node_execution_status = _(update_node_execution_status)
     update_node_execution_status_batch = _(update_node_execution_status_batch)
     update_graph_execution_start_time = _(update_graph_execution_start_time)
     update_graph_execution_stats = _(update_graph_execution_stats)
+    upsert_execution_input = _(upsert_execution_input)
     upsert_execution_output = _(upsert_execution_output)
-    create_node_execution = _(create_node_execution)
-    add_input_to_node_execution = _(add_input_to_node_execution)
     get_execution_kv_data = _(get_execution_kv_data)
     set_execution_kv_data = _(set_execution_kv_data)
     get_block_error_stats = _(get_block_error_stats)
@@ -171,12 +171,10 @@ class DatabaseManagerClient(AppServiceClient):
     get_graph_executions = _(d.get_graph_executions)
     get_graph_execution_meta = _(d.get_graph_execution_meta)
     get_node_executions = _(d.get_node_executions)
-    create_node_execution = _(d.create_node_execution)
     update_node_execution_status = _(d.update_node_execution_status)
     update_graph_execution_start_time = _(d.update_graph_execution_start_time)
     update_graph_execution_stats = _(d.update_graph_execution_stats)
     upsert_execution_output = _(d.upsert_execution_output)
-    add_input_to_node_execution = _(d.add_input_to_node_execution)
 
     # Graphs
     get_graph_metadata = _(d.get_graph_metadata)
@@ -191,6 +189,14 @@ class DatabaseManagerClient(AppServiceClient):
     # User Emails
     get_user_email_by_id = _(d.get_user_email_by_id)
 
+    # Library
+    list_library_agents = _(d.list_library_agents)
+    add_store_agent_to_library = _(d.add_store_agent_to_library)
+
+    # Store
+    get_store_agents = _(d.get_store_agents)
+    get_store_agent_details = _(d.get_store_agent_details)
+
 
 class DatabaseManagerAsyncClient(AppServiceClient):
     d = DatabaseManager
@@ -201,12 +207,16 @@ class DatabaseManagerAsyncClient(AppServiceClient):
 
     create_graph_execution = d.create_graph_execution
     get_connected_output_nodes = d.get_connected_output_nodes
+    get_latest_node_execution = d.get_latest_node_execution
     get_graph = d.get_graph
     get_graph_metadata = d.get_graph_metadata
     get_graph_execution_meta = d.get_graph_execution_meta
     get_node = d.get_node
+    get_node_execution = d.get_node_execution
     get_node_executions = d.get_node_executions
     get_user_integrations = d.get_user_integrations
+    upsert_execution_input = d.upsert_execution_input
+    upsert_execution_output = d.upsert_execution_output
     update_graph_execution_stats = d.update_graph_execution_stats
     update_node_execution_status = d.update_node_execution_status
     update_node_execution_status_batch = d.update_node_execution_status_batch

autogpt_platform/backend/backend/executor/execution_cache.py

@@ -1,154 +0,0 @@
-import logging
-import threading
-from collections import OrderedDict
-from functools import wraps
-from typing import TYPE_CHECKING, Any, Optional
-
-from backend.data.execution import ExecutionStatus, NodeExecutionResult
-from backend.data.model import GraphExecutionStats, NodeExecutionStats
-
-if TYPE_CHECKING:
-    from backend.executor import DatabaseManagerClient
-
-logger = logging.getLogger(__name__)
-
-
-def with_lock(func):
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        with self._lock:
-            return func(self, *args, **kwargs)
-
-    return wrapper
-
-
-class ExecutionCache:
-    def __init__(self, graph_exec_id: str, db_client: "DatabaseManagerClient"):
-        self._lock = threading.RLock()
-        self._graph_exec_id = graph_exec_id
-        self._graph_stats: GraphExecutionStats = GraphExecutionStats()
-        self._node_executions: OrderedDict[str, NodeExecutionResult] = OrderedDict()
-
-        for execution in db_client.get_node_executions(self._graph_exec_id):
-            self._node_executions[execution.node_exec_id] = execution
-
-    @with_lock
-    def get_node_execution(self, node_exec_id: str) -> Optional[NodeExecutionResult]:
-        execution = self._node_executions.get(node_exec_id)
-        return execution.model_copy(deep=True) if execution else None
-
-    @with_lock
-    def get_latest_node_execution(self, node_id: str) -> Optional[NodeExecutionResult]:
-        for execution in reversed(self._node_executions.values()):
-            if (
-                execution.node_id == node_id
-                and execution.status != ExecutionStatus.INCOMPLETE
-            ):
-                return execution.model_copy(deep=True)
-        return None
-
-    @with_lock
-    def get_node_executions(
-        self,
-        *,
-        statuses: Optional[list] = None,
-        block_ids: Optional[list] = None,
-        node_id: Optional[str] = None,
-    ):
-        results = []
-        for execution in self._node_executions.values():
-            if statuses and execution.status not in statuses:
-                continue
-            if block_ids and execution.block_id not in block_ids:
-                continue
-            if node_id and execution.node_id != node_id:
-                continue
-            results.append(execution.model_copy(deep=True))
-        return results
-
-    @with_lock
-    def update_node_execution_status(
-        self,
-        exec_id: str,
-        status: ExecutionStatus,
-        execution_data: Optional[dict] = None,
-        stats: Optional[dict] = None,
-    ):
-        if exec_id not in self._node_executions:
-            raise RuntimeError(f"Execution {exec_id} not found in cache")
-
-        execution = self._node_executions[exec_id]
-        execution.status = status
-
-        if execution_data:
-            execution.input_data.update(execution_data)
-
-        if stats:
-            execution.stats = execution.stats or NodeExecutionStats()
-            current_stats = execution.stats.model_dump()
-            current_stats.update(stats)
-            execution.stats = NodeExecutionStats.model_validate(current_stats)
-
-    @with_lock
-    def upsert_execution_output(
-        self, node_exec_id: str, output_name: str, output_data: Any
-    ) -> NodeExecutionResult:
-        if node_exec_id not in self._node_executions:
-            raise RuntimeError(f"Execution {node_exec_id} not found in cache")
-
-        execution = self._node_executions[node_exec_id]
-        if output_name not in execution.output_data:
-            execution.output_data[output_name] = []
-        execution.output_data[output_name].append(output_data)
-
-        return execution
-
-    @with_lock
-    def update_graph_stats(
-        self, status: Optional[ExecutionStatus] = None, stats: Optional[dict] = None
-    ):
-        if status is not None:
-            pass
-        if stats is not None:
-            current_stats = self._graph_stats.model_dump()
-            current_stats.update(stats)
-            self._graph_stats = GraphExecutionStats.model_validate(current_stats)
-
-    @with_lock
-    def update_graph_start_time(self):
-        """Update graph start time (handled by database persistence)."""
-        pass
-
-    @with_lock
-    def find_incomplete_execution_for_input(
-        self, node_id: str, input_name: str
-    ) -> tuple[str, NodeExecutionResult] | None:
-        for exec_id, execution in self._node_executions.items():
-            if (
-                execution.node_id == node_id
-                and execution.status == ExecutionStatus.INCOMPLETE
-                and input_name not in execution.input_data
-            ):
-                return exec_id, execution
-        return None
-
-    @with_lock
-    def add_node_execution(
-        self, node_exec_id: str, execution: NodeExecutionResult
-    ) -> None:
-        self._node_executions[node_exec_id] = execution
-
-    @with_lock
-    def update_execution_input(
-        self, exec_id: str, input_name: str, input_data: Any
-    ) -> dict:
-        if exec_id not in self._node_executions:
-            raise RuntimeError(f"Execution {exec_id} not found in cache")
-        execution = self._node_executions[exec_id]
-        execution.input_data[input_name] = input_data
-        return execution.input_data.copy()
-
-    def finalize(self) -> None:
-        with self._lock:
-            self._node_executions.clear()
-            self._graph_stats = GraphExecutionStats()

autogpt_platform/backend/backend/executor/execution_creation_test.py

@@ -1,355 +0,0 @@
-"""Test execution creation with proper ID generation and persistence."""
-
-import asyncio
-import threading
-import uuid
-from datetime import datetime
-
-import pytest
-
-from backend.data.execution import ExecutionStatus
-from backend.executor.execution_data import ExecutionDataClient
-
-
-@pytest.fixture
-def event_loop():
-    loop = asyncio.new_event_loop()
-    yield loop
-    loop.close()
-
-
-@pytest.fixture
-async def execution_client_with_mock_db(event_loop):
-    """Create an ExecutionDataClient with proper database records."""
-    from datetime import datetime, timezone
-    from unittest.mock import AsyncMock, MagicMock, patch
-
-    from prisma.models import AgentGraph, AgentGraphExecution, User
-
-    from backend.data.execution import ExecutionStatus, GraphExecutionMeta
-
-    # Create test database records to satisfy foreign key constraints
-    try:
-        await User.prisma().create(
-            data={
-                "id": "test_user_123",
-                "email": "test@example.com",
-                "name": "Test User",
-            }
-        )
-
-        await AgentGraph.prisma().create(
-            data={
-                "id": "test_graph_456",
-                "version": 1,
-                "userId": "test_user_123",
-                "name": "Test Graph",
-                "description": "Test graph for execution tests",
-            }
-        )
-
-        from prisma.enums import AgentExecutionStatus
-
-        await AgentGraphExecution.prisma().create(
-            data={
-                "id": "test_graph_exec_id",
-                "userId": "test_user_123",
-                "agentGraphId": "test_graph_456",
-                "agentGraphVersion": 1,
-                "executionStatus": AgentExecutionStatus.RUNNING,
-            }
-        )
-    except Exception:
-        # Records might already exist, that's fine
-        pass
-
-    # Mock the graph execution metadata - align with assertions below
-    mock_graph_meta = GraphExecutionMeta(
-        id="test_graph_exec_id",
-        user_id="test_user_123",
-        graph_id="test_graph_456",
-        graph_version=1,
-        status=ExecutionStatus.RUNNING,
-        started_at=datetime.now(timezone.utc),
-        ended_at=datetime.now(timezone.utc),
-        stats=None,
-    )
-
-    # Create client with ThreadPoolExecutor and graph metadata (constructed inside patch)
-    from concurrent.futures import ThreadPoolExecutor
-
-    executor = ThreadPoolExecutor(max_workers=1)
-
-    # Storage for tracking created executions
-    created_executions = []
-
-    async def mock_create_node_execution(
-        node_exec_id, node_id, graph_exec_id, input_name, input_data
-    ):
-        """Mock execution creation that records what was created."""
-        created_executions.append(
-            {
-                "node_exec_id": node_exec_id,
-                "node_id": node_id,
-                "graph_exec_id": graph_exec_id,
-                "input_name": input_name,
-                "input_data": input_data,
-            }
-        )
-        return node_exec_id
-
-    def sync_mock_create_node_execution(
-        node_exec_id, node_id, graph_exec_id, input_name, input_data
-    ):
-        """Mock sync execution creation that records what was created."""
-        created_executions.append(
-            {
-                "node_exec_id": node_exec_id,
-                "node_id": node_id,
-                "graph_exec_id": graph_exec_id,
-                "input_name": input_name,
-                "input_data": input_data,
-            }
-        )
-        return node_exec_id
-
-    # Prepare mock async and sync DB clients
-    async_mock_client = AsyncMock()
-    async_mock_client.create_node_execution = mock_create_node_execution
-
-    sync_mock_client = MagicMock()
-    sync_mock_client.create_node_execution = sync_mock_create_node_execution
-    # Mock graph execution for return values
-    from backend.data.execution import GraphExecutionMeta
-
-    mock_graph_update = GraphExecutionMeta(
-        id="test_graph_exec_id",
-        user_id="test_user_123",
-        graph_id="test_graph_456",
-        graph_version=1,
-        status=ExecutionStatus.RUNNING,
-        started_at=datetime.now(timezone.utc),
-        ended_at=datetime.now(timezone.utc),
-        stats=None,
-    )
-
-    # No-ops for other sync methods used by the client during tests
-    sync_mock_client.add_input_to_node_execution.side_effect = lambda **kwargs: None
-    sync_mock_client.update_node_execution_status.side_effect = (
-        lambda *args, **kwargs: None
-    )
-    sync_mock_client.upsert_execution_output.side_effect = lambda **kwargs: None
-    sync_mock_client.update_graph_execution_stats.side_effect = (
-        lambda *args, **kwargs: mock_graph_update
-    )
-    sync_mock_client.update_graph_execution_start_time.side_effect = (
-        lambda *args, **kwargs: mock_graph_update
-    )
-
-    thread = threading.Thread(target=event_loop.run_forever, daemon=True)
-    thread.start()
-    with patch(
-        "backend.executor.execution_data.get_database_manager_async_client",
-        return_value=async_mock_client,
-    ), patch(
-        "backend.executor.execution_data.get_database_manager_client",
-        return_value=sync_mock_client,
-    ), patch(
-        "backend.executor.execution_data.get_execution_event_bus"
-    ), patch(
-        "backend.executor.execution_data.non_blocking_persist", lambda func: func
-    ):
-        # Now construct the client under the patch so it captures the mocked clients
-        client = ExecutionDataClient(executor, "test_graph_exec_id", mock_graph_meta)
-        # Store the mocks for the test to access if needed
-        setattr(client, "_test_async_client", async_mock_client)
-        setattr(client, "_test_sync_client", sync_mock_client)
-        setattr(client, "_created_executions", created_executions)
-        yield client
-
-    # Cleanup test database records
-    try:
-        await AgentGraphExecution.prisma().delete_many(
-            where={"id": "test_graph_exec_id"}
-        )
-        await AgentGraph.prisma().delete_many(where={"id": "test_graph_456"})
-        await User.prisma().delete_many(where={"id": "test_user_123"})
-    except Exception:
-        # Cleanup may fail if records don't exist
-        pass
-
-    # Cleanup
-    event_loop.call_soon_threadsafe(event_loop.stop)
-    thread.join(timeout=1)
-
-
-class TestExecutionCreation:
-    """Test execution creation with proper ID generation and persistence."""
-
-    async def test_execution_creation_with_valid_ids(
-        self, execution_client_with_mock_db
-    ):
-        """Test that execution creation generates and persists valid IDs."""
-        client = execution_client_with_mock_db
-
-        node_id = "test_node_789"
-        input_name = "test_input"
-        input_data = "test_value"
-        block_id = "test_block_abc"
-
-        # This should trigger execution creation since cache is empty
-        exec_id, input_dict = client.upsert_execution_input(
-            node_id=node_id,
-            input_name=input_name,
-            input_data=input_data,
-            block_id=block_id,
-        )
-
-        # Verify execution ID is valid UUID
-        try:
-            uuid.UUID(exec_id)
-        except ValueError:
-            pytest.fail(f"Generated execution ID '{exec_id}' is not a valid UUID")
-
-        # Verify execution was created in cache with complete data
-        assert exec_id in client._cache._node_executions
-        cached_execution = client._cache._node_executions[exec_id]
-
-        # Check all required fields have valid values
-        assert cached_execution.user_id == "test_user_123"
-        assert cached_execution.graph_id == "test_graph_456"
-        assert cached_execution.graph_version == 1
-        assert cached_execution.graph_exec_id == "test_graph_exec_id"
-        assert cached_execution.node_exec_id == exec_id
-        assert cached_execution.node_id == node_id
-        assert cached_execution.block_id == block_id
-        assert cached_execution.status == ExecutionStatus.INCOMPLETE
-        assert cached_execution.input_data == {input_name: input_data}
-        assert isinstance(cached_execution.add_time, datetime)
-
-        # Verify execution was persisted to database with our generated ID
-        created_executions = getattr(client, "_created_executions", [])
-        assert len(created_executions) == 1
-        created = created_executions[0]
-        assert created["node_exec_id"] == exec_id  # Our generated ID was used
-        assert created["node_id"] == node_id
-        assert created["graph_exec_id"] == "test_graph_exec_id"
-        assert created["input_name"] == input_name
-        assert created["input_data"] == input_data
-
-        # Verify input dict returned correctly
-        assert input_dict == {input_name: input_data}
-
-    async def test_execution_reuse_vs_creation(self, execution_client_with_mock_db):
-        """Test that execution reuse works and creation only happens when needed."""
-        client = execution_client_with_mock_db
-
-        node_id = "reuse_test_node"
-        block_id = "reuse_test_block"
-
-        # Create first execution
-        exec_id_1, input_dict_1 = client.upsert_execution_input(
-            node_id=node_id,
-            input_name="input_1",
-            input_data="value_1",
-            block_id=block_id,
-        )
-
-        # This should reuse the existing INCOMPLETE execution
-        exec_id_2, input_dict_2 = client.upsert_execution_input(
-            node_id=node_id,
-            input_name="input_2",
-            input_data="value_2",
-            block_id=block_id,
-        )
-
-        # Should reuse the same execution
-        assert exec_id_1 == exec_id_2
-        assert input_dict_2 == {"input_1": "value_1", "input_2": "value_2"}
-
-        # Only one execution should be created in database
-        created_executions = getattr(client, "_created_executions", [])
-        assert len(created_executions) == 1
-
-        # Verify cache has the merged inputs
-        cached_execution = client._cache._node_executions[exec_id_1]
-        assert cached_execution.input_data == {
-            "input_1": "value_1",
-            "input_2": "value_2",
-        }
-
-        # Now complete the execution and try to add another input
-        client.update_node_status_and_publish(
-            exec_id=exec_id_1, status=ExecutionStatus.COMPLETED
-        )
-
-        # Verify the execution status was actually updated in the cache
-        updated_execution = client._cache._node_executions[exec_id_1]
-        assert (
-            updated_execution.status == ExecutionStatus.COMPLETED
-        ), f"Expected COMPLETED but got {updated_execution.status}"
-
-        # This should create a NEW execution since the first is no longer INCOMPLETE
-        exec_id_3, input_dict_3 = client.upsert_execution_input(
-            node_id=node_id,
-            input_name="input_3",
-            input_data="value_3",
-            block_id=block_id,
-        )
-
-        # Should be a different execution
-        assert exec_id_3 != exec_id_1
-        assert input_dict_3 == {"input_3": "value_3"}
-
-        # Verify cache behavior: should have two different executions in cache now
-        cached_executions = client._cache._node_executions
-        assert len(cached_executions) == 2
-        assert exec_id_1 in cached_executions
-        assert exec_id_3 in cached_executions
-
-        # First execution should be COMPLETED
-        assert cached_executions[exec_id_1].status == ExecutionStatus.COMPLETED
-        # Third execution should be INCOMPLETE (newly created)
-        assert cached_executions[exec_id_3].status == ExecutionStatus.INCOMPLETE
-
-    async def test_multiple_nodes_get_different_execution_ids(
-        self, execution_client_with_mock_db
-    ):
-        """Test that different nodes get different execution IDs."""
-        client = execution_client_with_mock_db
-
-        # Create executions for different nodes
-        exec_id_a, _ = client.upsert_execution_input(
-            node_id="node_a",
-            input_name="test_input",
-            input_data="test_value",
-            block_id="block_a",
-        )
-
-        exec_id_b, _ = client.upsert_execution_input(
-            node_id="node_b",
-            input_name="test_input",
-            input_data="test_value",
-            block_id="block_b",
-        )
-
-        # Should be different executions with different IDs
-        assert exec_id_a != exec_id_b
-
-        # Both should be valid UUIDs
-        uuid.UUID(exec_id_a)
-        uuid.UUID(exec_id_b)
-
-        # Both should be in cache
-        cached_executions = client._cache._node_executions
-        assert len(cached_executions) == 2
-        assert exec_id_a in cached_executions
-        assert exec_id_b in cached_executions
-
-        # Both should have correct node IDs
-        assert cached_executions[exec_id_a].node_id == "node_a"
-        assert cached_executions[exec_id_b].node_id == "node_b"
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

autogpt_platform/backend/backend/executor/execution_data.py

@@ -1,338 +0,0 @@
-import logging
-import threading
-import uuid
-from concurrent.futures import Executor
-from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, Callable, ParamSpec, TypeVar, cast
-
-from backend.data import redis_client as redis
-from backend.data.credit import UsageTransactionMetadata
-from backend.data.execution import (
-    ExecutionStatus,
-    GraphExecutionMeta,
-    NodeExecutionResult,
-)
-from backend.data.graph import Node
-from backend.data.model import GraphExecutionStats
-from backend.executor.execution_cache import ExecutionCache
-from backend.util.clients import (
-    get_database_manager_async_client,
-    get_database_manager_client,
-    get_execution_event_bus,
-)
-from backend.util.settings import Settings
-
-if TYPE_CHECKING:
-    from backend.executor import DatabaseManagerAsyncClient, DatabaseManagerClient
-
-settings = Settings()
-logger = logging.getLogger(__name__)
-
-P = ParamSpec("P")
-T = TypeVar("T")
-
-
-def non_blocking_persist(func: Callable[P, T]) -> Callable[P, None]:
-    from functools import wraps
-
-    @wraps(func)
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> None:
-        # First argument is always self for methods - access through cast for typing
-        self = cast("ExecutionDataClient", args[0])
-        future = self._executor.submit(func, *args, **kwargs)
-        self._pending_tasks.add(future)
-
-    return wrapper
-
-
-class ExecutionDataClient:
-    def __init__(
-        self, executor: Executor, graph_exec_id: str, graph_metadata: GraphExecutionMeta
-    ):
-        self._executor = executor
-        self._graph_exec_id = graph_exec_id
-        self._cache = ExecutionCache(graph_exec_id, self.db_client_sync)
-        self._pending_tasks = set()
-        self._graph_metadata = graph_metadata
-        self.graph_lock = threading.RLock()
-
-    def finalize_execution(self, timeout: float = 30.0):
-        logger.info(f"Flushing db writes for execution {self._graph_exec_id}")
-        exceptions = []
-
-        # Wait for all pending database operations to complete
-        logger.debug(
-            f"Waiting for {len(self._pending_tasks)} pending database operations"
-        )
-        for future in list(self._pending_tasks):
-            try:
-                future.result(timeout=timeout)
-            except Exception as e:
-                logger.error(f"Background database operation failed: {e}")
-                exceptions.append(e)
-            finally:
-                self._pending_tasks.discard(future)
-
-        self._cache.finalize()
-
-        if exceptions:
-            logger.error(f"Background persistence failed with {len(exceptions)} errors")
-            raise RuntimeError(
-                f"Background persistence failed with {len(exceptions)} errors: {exceptions}"
-            )
-
-    @property
-    def db_client_async(self) -> "DatabaseManagerAsyncClient":
-        return get_database_manager_async_client()
-
-    @property
-    def db_client_sync(self) -> "DatabaseManagerClient":
-        return get_database_manager_client()
-
-    @property
-    def event_bus(self):
-        return get_execution_event_bus()
-
-    async def get_node(self, node_id: str) -> Node:
-        return await self.db_client_async.get_node(node_id)
-
-    def spend_credits(
-        self,
-        user_id: str,
-        cost: int,
-        metadata: UsageTransactionMetadata,
-    ) -> int:
-        return self.db_client_sync.spend_credits(
-            user_id=user_id, cost=cost, metadata=metadata
-        )
-
-    def get_graph_execution_meta(
-        self, user_id: str, execution_id: str
-    ) -> GraphExecutionMeta | None:
-        return self.db_client_sync.get_graph_execution_meta(
-            user_id=user_id, execution_id=execution_id
-        )
-
-    def get_graph_metadata(
-        self, graph_id: str, graph_version: int | None = None
-    ) -> Any:
-        return self.db_client_sync.get_graph_metadata(graph_id, graph_version)
-
-    def get_credits(self, user_id: str) -> int:
-        return self.db_client_sync.get_credits(user_id)
-
-    def get_user_email_by_id(self, user_id: str) -> str | None:
-        return self.db_client_sync.get_user_email_by_id(user_id)
-
-    def get_latest_node_execution(self, node_id: str) -> NodeExecutionResult | None:
-        return self._cache.get_latest_node_execution(node_id)
-
-    def get_node_execution(self, node_exec_id: str) -> NodeExecutionResult | None:
-        return self._cache.get_node_execution(node_exec_id)
-
-    def get_node_executions(
-        self,
-        *,
-        node_id: str | None = None,
-        statuses: list[ExecutionStatus] | None = None,
-        block_ids: list[str] | None = None,
-    ) -> list[NodeExecutionResult]:
-        return self._cache.get_node_executions(
-            statuses=statuses, block_ids=block_ids, node_id=node_id
-        )
-
-    def update_node_status_and_publish(
-        self,
-        exec_id: str,
-        status: ExecutionStatus,
-        execution_data: dict | None = None,
-        stats: dict[str, Any] | None = None,
-    ):
-        self._cache.update_node_execution_status(exec_id, status, execution_data, stats)
-        self._persist_node_status_to_db(exec_id, status, execution_data, stats)
-
-    def upsert_execution_input(
-        self, node_id: str, input_name: str, input_data: Any, block_id: str
-    ) -> tuple[str, dict]:
-        # Validate input parameters to prevent foreign key constraint errors
-        if not node_id or not isinstance(node_id, str):
-            raise ValueError(f"Invalid node_id: {node_id}")
-        if not self._graph_exec_id or not isinstance(self._graph_exec_id, str):
-            raise ValueError(f"Invalid graph_exec_id: {self._graph_exec_id}")
-        if not block_id or not isinstance(block_id, str):
-            raise ValueError(f"Invalid block_id: {block_id}")
-
-        # UPDATE: Try to find an existing incomplete execution for this node and input
-        if result := self._cache.find_incomplete_execution_for_input(
-            node_id, input_name
-        ):
-            exec_id, _ = result
-            updated_input_data = self._cache.update_execution_input(
-                exec_id, input_name, input_data
-            )
-            self._persist_add_input_to_db(exec_id, input_name, input_data)
-            return exec_id, updated_input_data
-
-        # CREATE: No suitable execution found, create new one
-        node_exec_id = str(uuid.uuid4())
-        logger.debug(
-            f"Creating new execution {node_exec_id} for node {node_id} "
-            f"in graph execution {self._graph_exec_id}"
-        )
-
-        new_execution = NodeExecutionResult(
-            user_id=self._graph_metadata.user_id,
-            graph_id=self._graph_metadata.graph_id,
-            graph_version=self._graph_metadata.graph_version,
-            graph_exec_id=self._graph_exec_id,
-            node_exec_id=node_exec_id,
-            node_id=node_id,
-            block_id=block_id,
-            status=ExecutionStatus.INCOMPLETE,
-            input_data={input_name: input_data},
-            output_data={},
-            add_time=datetime.now(timezone.utc),
-        )
-        self._cache.add_node_execution(node_exec_id, new_execution)
-        self._persist_new_node_execution_to_db(
-            node_exec_id, node_id, input_name, input_data
-        )
-
-        return node_exec_id, {input_name: input_data}
-
-    def upsert_execution_output(
-        self, node_exec_id: str, output_name: str, output_data: Any
-    ):
-        self._cache.upsert_execution_output(node_exec_id, output_name, output_data)
-        self._persist_execution_output_to_db(node_exec_id, output_name, output_data)
-
-    def update_graph_stats_and_publish(
-        self,
-        status: ExecutionStatus | None = None,
-        stats: GraphExecutionStats | None = None,
-    ) -> None:
-        stats_dict = stats.model_dump() if stats else None
-        self._cache.update_graph_stats(status=status, stats=stats_dict)
-        self._persist_graph_stats_to_db(status=status, stats=stats)
-
-    def update_graph_start_time_and_publish(self) -> None:
-        self._cache.update_graph_start_time()
-        self._persist_graph_start_time_to_db()
-
-    @non_blocking_persist
-    def _persist_node_status_to_db(
-        self,
-        exec_id: str,
-        status: ExecutionStatus,
-        execution_data: dict | None = None,
-        stats: dict[str, Any] | None = None,
-    ):
-        exec_update = self.db_client_sync.update_node_execution_status(
-            exec_id, status, execution_data, stats
-        )
-        self.event_bus.publish(exec_update)
-
-    @non_blocking_persist
-    def _persist_add_input_to_db(
-        self, node_exec_id: str, input_name: str, input_data: Any
-    ):
-        self.db_client_sync.add_input_to_node_execution(
-            node_exec_id=node_exec_id,
-            input_name=input_name,
-            input_data=input_data,
-        )
-
-    @non_blocking_persist
-    def _persist_execution_output_to_db(
-        self, node_exec_id: str, output_name: str, output_data: Any
-    ):
-        self.db_client_sync.upsert_execution_output(
-            node_exec_id=node_exec_id,
-            output_name=output_name,
-            output_data=output_data,
-        )
-        if exec_update := self.get_node_execution(node_exec_id):
-            self.event_bus.publish(exec_update)
-
-    @non_blocking_persist
-    def _persist_graph_stats_to_db(
-        self,
-        status: ExecutionStatus | None = None,
-        stats: GraphExecutionStats | None = None,
-    ):
-        graph_update = self.db_client_sync.update_graph_execution_stats(
-            self._graph_exec_id, status, stats
-        )
-        if not graph_update:
-            raise RuntimeError(
-                f"Failed to update graph execution stats for {self._graph_exec_id}"
-            )
-        self.event_bus.publish(graph_update)
-
-    @non_blocking_persist
-    def _persist_graph_start_time_to_db(self):
-        graph_update = self.db_client_sync.update_graph_execution_start_time(
-            self._graph_exec_id
-        )
-        if not graph_update:
-            raise RuntimeError(
-                f"Failed to update graph execution start time for {self._graph_exec_id}"
-            )
-        self.event_bus.publish(graph_update)
-
-    async def generate_activity_status(
-        self,
-        graph_id: str,
-        graph_version: int,
-        execution_stats: GraphExecutionStats,
-        user_id: str,
-        execution_status: ExecutionStatus,
-    ) -> str | None:
-        from backend.executor.activity_status_generator import (
-            generate_activity_status_for_execution,
-        )
-
-        return await generate_activity_status_for_execution(
-            graph_exec_id=self._graph_exec_id,
-            graph_id=graph_id,
-            graph_version=graph_version,
-            execution_stats=execution_stats,
-            db_client=self.db_client_async,
-            user_id=user_id,
-            execution_status=execution_status,
-        )
-
-    @non_blocking_persist
-    def _send_execution_update(self, execution: NodeExecutionResult):
-        """Send execution update to event bus."""
-        try:
-            self.event_bus.publish(execution)
-        except Exception as e:
-            logger.warning(f"Failed to send execution update: {e}")
-
-    @non_blocking_persist
-    def _persist_new_node_execution_to_db(
-        self, node_exec_id: str, node_id: str, input_name: str, input_data: Any
-    ):
-        try:
-            self.db_client_sync.create_node_execution(
-                node_exec_id=node_exec_id,
-                node_id=node_id,
-                graph_exec_id=self._graph_exec_id,
-                input_name=input_name,
-                input_data=input_data,
-            )
-        except Exception as e:
-            logger.error(
-                f"Failed to create node execution {node_exec_id} for node {node_id} "
-                f"in graph execution {self._graph_exec_id}: {e}"
-            )
-            raise
-
-    def increment_execution_count(self, user_id: str) -> int:
-        r = redis.get_redis()
-        k = f"uec:{user_id}"
-        counter = cast(int, r.incr(k))
-        if counter == 1:
-            r.expire(k, settings.config.execution_counter_expiration_time)
-        return counter

autogpt_platform/backend/backend/executor/execution_data_test.py

@@ -1,668 +0,0 @@
-"""Test suite for ExecutionDataClient."""
-
-import asyncio
-import threading
-
-import pytest
-
-from backend.data.execution import ExecutionStatus
-from backend.executor.execution_data import ExecutionDataClient
-
-
-@pytest.fixture
-def event_loop():
-    loop = asyncio.new_event_loop()
-    yield loop
-    loop.close()
-
-
-@pytest.fixture
-def execution_client(event_loop):
-    from datetime import datetime, timezone
-    from unittest.mock import AsyncMock, MagicMock, patch
-
-    from backend.data.execution import ExecutionStatus, GraphExecutionMeta
-
-    mock_graph_meta = GraphExecutionMeta(
-        id="test_graph_exec_id",
-        user_id="test_user_id",
-        graph_id="test_graph_id",
-        graph_version=1,
-        status=ExecutionStatus.RUNNING,
-        started_at=datetime.now(timezone.utc),
-        ended_at=datetime.now(timezone.utc),
-        stats=None,
-    )
-
-    from concurrent.futures import ThreadPoolExecutor
-
-    executor = ThreadPoolExecutor(max_workers=1)
-
-    # Mock all database operations to prevent connection attempts
-    async_mock_client = AsyncMock()
-    sync_mock_client = MagicMock()
-
-    # Mock all database methods to return None or empty results
-    sync_mock_client.get_node_executions.return_value = []
-    sync_mock_client.create_node_execution.return_value = None
-    sync_mock_client.add_input_to_node_execution.return_value = None
-    sync_mock_client.update_node_execution_status.return_value = None
-    sync_mock_client.upsert_execution_output.return_value = None
-    sync_mock_client.update_graph_execution_stats.return_value = mock_graph_meta
-    sync_mock_client.update_graph_execution_start_time.return_value = mock_graph_meta
-
-    # Mock event bus to prevent connection attempts
-    mock_event_bus = MagicMock()
-    mock_event_bus.publish.return_value = None
-
-    thread = threading.Thread(target=event_loop.run_forever, daemon=True)
-    thread.start()
-
-    with patch(
-        "backend.executor.execution_data.get_database_manager_async_client",
-        return_value=async_mock_client,
-    ), patch(
-        "backend.executor.execution_data.get_database_manager_client",
-        return_value=sync_mock_client,
-    ), patch(
-        "backend.executor.execution_data.get_execution_event_bus",
-        return_value=mock_event_bus,
-    ), patch(
-        "backend.executor.execution_data.non_blocking_persist", lambda func: func
-    ):
-
-        client = ExecutionDataClient(executor, "test_graph_exec_id", mock_graph_meta)
-        yield client
-
-    event_loop.call_soon_threadsafe(event_loop.stop)
-    thread.join(timeout=1)
-
-
-class TestExecutionDataClient:
-
-    async def test_update_node_status_writes_to_cache_immediately(
-        self, execution_client
-    ):
-        """Test that node status updates are immediately visible in cache."""
-        # First create an execution to update
-        node_exec_id, _ = execution_client.upsert_execution_input(
-            node_id="test-node",
-            input_name="test_input",
-            input_data="test_value",
-            block_id="test-block",
-        )
-
-        status = ExecutionStatus.RUNNING
-        execution_data = {"step": "processing"}
-        stats = {"duration": 5.2}
-
-        # Update status of existing execution
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id,
-            status=status,
-            execution_data=execution_data,
-            stats=stats,
-        )
-
-        # Verify immediate visibility in cache
-        cached_exec = execution_client.get_node_execution(node_exec_id)
-        assert cached_exec is not None
-        assert cached_exec.status == status
-        # execution_data should be merged with existing input_data, not replace it
-        expected_input_data = {"test_input": "test_value", "step": "processing"}
-        assert cached_exec.input_data == expected_input_data
-
-    def test_update_node_status_execution_not_found_raises_error(
-        self, execution_client
-    ):
-        """Test that updating non-existent execution raises error instead of creating it."""
-        non_existent_id = "does-not-exist"
-
-        with pytest.raises(
-            RuntimeError, match="Execution does-not-exist not found in cache"
-        ):
-            execution_client.update_node_status_and_publish(
-                exec_id=non_existent_id, status=ExecutionStatus.COMPLETED
-            )
-
-    async def test_upsert_execution_output_writes_to_cache_immediately(
-        self, execution_client
-    ):
-        """Test that output updates are immediately visible in cache."""
-        # First create an execution
-        node_exec_id, _ = execution_client.upsert_execution_input(
-            node_id="test-node",
-            input_name="test_input",
-            input_data="test_value",
-            block_id="test-block",
-        )
-
-        output_name = "result"
-        output_data = {"answer": 42, "confidence": 0.95}
-
-        # Update to RUNNING status first
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id,
-            status=ExecutionStatus.RUNNING,
-            execution_data={"input": "test"},
-        )
-
-        execution_client.upsert_execution_output(
-            node_exec_id=node_exec_id, output_name=output_name, output_data=output_data
-        )
-        # Check output through the node execution
-        cached_exec = execution_client.get_node_execution(node_exec_id)
-        assert cached_exec is not None
-        assert output_name in cached_exec.output_data
-        assert cached_exec.output_data[output_name] == [output_data]
-
-    async def test_get_node_execution_reads_from_cache(self, execution_client):
-        """Test that get_node_execution returns cached data immediately."""
-        # First create an execution to work with
-        node_exec_id, _ = execution_client.upsert_execution_input(
-            node_id="test-node",
-            input_name="test_input",
-            input_data="test_value",
-            block_id="test-block",
-        )
-
-        # Then update its status
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id,
-            status=ExecutionStatus.COMPLETED,
-            execution_data={"result": "success"},
-        )
-
-        result = execution_client.get_node_execution(node_exec_id)
-
-        assert result is not None
-        assert result.status == ExecutionStatus.COMPLETED
-        # execution_data gets merged with existing input_data
-        expected_input_data = {"test_input": "test_value", "result": "success"}
-        assert result.input_data == expected_input_data
-
-    async def test_get_latest_node_execution_reads_from_cache(self, execution_client):
-        """Test that get_latest_node_execution returns cached data."""
-        node_id = "node-1"
-
-        # First create an execution for this node
-        node_exec_id, _ = execution_client.upsert_execution_input(
-            node_id=node_id,
-            input_name="test_input",
-            input_data="test_value",
-            block_id="test-block",
-        )
-
-        # Then update its status to make it non-INCOMPLETE (so it's returned by get_latest)
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id,
-            status=ExecutionStatus.RUNNING,
-            execution_data={"from": "cache"},
-        )
-
-        result = execution_client.get_latest_node_execution(node_id)
-
-        assert result is not None
-        assert result.status == ExecutionStatus.RUNNING
-        # execution_data gets merged with existing input_data
-        expected_input_data = {"test_input": "test_value", "from": "cache"}
-        assert result.input_data == expected_input_data
-
-    async def test_get_node_executions_sync_filters_correctly(self, execution_client):
-        # Create executions with different statuses
-        executions = [
-            (ExecutionStatus.RUNNING, "block-a"),
-            (ExecutionStatus.COMPLETED, "block-a"),
-            (ExecutionStatus.FAILED, "block-b"),
-            (ExecutionStatus.RUNNING, "block-b"),
-        ]
-
-        exec_ids = []
-        for i, (status, block_id) in enumerate(executions):
-            # First create the execution
-            exec_id, _ = execution_client.upsert_execution_input(
-                node_id=f"node-{i}",
-                input_name="test_input",
-                input_data="test_value",
-                block_id=block_id,
-            )
-            exec_ids.append(exec_id)
-
-            # Then update its status and metadata
-            execution_client.update_node_status_and_publish(
-                exec_id=exec_id, status=status, execution_data={"block": block_id}
-            )
-            # Update cached execution with graph_exec_id and block_id for filtering
-            # Note: In real implementation, these would be set during creation
-            # For test purposes, we'll skip this manual update since the filtering
-            # logic should work with the data as created
-
-        # Test status filtering
-        running_execs = execution_client.get_node_executions(
-            statuses=[ExecutionStatus.RUNNING]
-        )
-        assert len(running_execs) == 2
-        assert all(e.status == ExecutionStatus.RUNNING for e in running_execs)
-
-        # Test block_id filtering
-        block_a_execs = execution_client.get_node_executions(block_ids=["block-a"])
-        assert len(block_a_execs) == 2
-        assert all(e.block_id == "block-a" for e in block_a_execs)
-
-        # Test combined filtering
-        running_block_b = execution_client.get_node_executions(
-            statuses=[ExecutionStatus.RUNNING], block_ids=["block-b"]
-        )
-        assert len(running_block_b) == 1
-        assert running_block_b[0].status == ExecutionStatus.RUNNING
-        assert running_block_b[0].block_id == "block-b"
-
-    async def test_write_then_read_consistency(self, execution_client):
-        """Test critical race condition scenario: immediate read after write."""
-        # First create an execution to work with
-        node_exec_id, _ = execution_client.upsert_execution_input(
-            node_id="consistency-test-node",
-            input_name="test_input",
-            input_data="test_value",
-            block_id="test-block",
-        )
-
-        # Write status
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id,
-            status=ExecutionStatus.RUNNING,
-            execution_data={"step": 1},
-        )
-
-        # Write output
-        execution_client.upsert_execution_output(
-            node_exec_id=node_exec_id,
-            output_name="intermediate",
-            output_data={"progress": 50},
-        )
-
-        # Update status again
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id,
-            status=ExecutionStatus.COMPLETED,
-            execution_data={"step": 2},
-        )
-
-        # All changes should be immediately visible
-        cached_exec = execution_client.get_node_execution(node_exec_id)
-        assert cached_exec is not None
-        assert cached_exec.status == ExecutionStatus.COMPLETED
-        # execution_data gets merged with existing input_data - step 2 overwrites step 1
-        expected_input_data = {"test_input": "test_value", "step": 2}
-        assert cached_exec.input_data == expected_input_data
-
-        # Output should be visible in execution record
-        assert cached_exec.output_data["intermediate"] == [{"progress": 50}]
-
-    async def test_concurrent_operations_are_thread_safe(self, execution_client):
-        """Test that concurrent operations don't corrupt cache."""
-        num_threads = 3  # Reduced for simpler test
-        operations_per_thread = 5  # Reduced for simpler test
-
-        # Create all executions upfront
-        created_exec_ids = []
-        for thread_id in range(num_threads):
-            for i in range(operations_per_thread):
-                exec_id, _ = execution_client.upsert_execution_input(
-                    node_id=f"node-{thread_id}-{i}",
-                    input_name="test_input",
-                    input_data="test_value",
-                    block_id=f"block-{thread_id}-{i}",
-                )
-                created_exec_ids.append((exec_id, thread_id, i))
-
-        def worker(thread_data):
-            """Perform multiple operations from a thread."""
-            thread_id, ops = thread_data
-            for i, (exec_id, _, _) in enumerate(ops):
-                # Status updates
-                execution_client.update_node_status_and_publish(
-                    exec_id=exec_id,
-                    status=ExecutionStatus.RUNNING,
-                    execution_data={"thread": thread_id, "op": i},
-                )
-
-                # Output updates (use just one exec_id per thread for outputs)
-                if i == 0:  # Only add outputs to first execution of each thread
-                    execution_client.upsert_execution_output(
-                        node_exec_id=exec_id,
-                        output_name=f"output_{i}",
-                        output_data={"thread": thread_id, "value": i},
-                    )
-
-        # Organize executions by thread
-        thread_data = []
-        for tid in range(num_threads):
-            thread_ops = [
-                exec_data for exec_data in created_exec_ids if exec_data[1] == tid
-            ]
-            thread_data.append((tid, thread_ops))
-
-        # Start multiple threads
-        threads = []
-        for data in thread_data:
-            thread = threading.Thread(target=worker, args=(data,))
-            threads.append(thread)
-            thread.start()
-
-        # Wait for completion
-        for thread in threads:
-            thread.join()
-
-        # Verify data integrity
-        expected_executions = num_threads * operations_per_thread
-        all_executions = execution_client.get_node_executions()
-        assert len(all_executions) == expected_executions
-
-        # Verify outputs - only first execution of each thread should have outputs
-        output_count = 0
-        for execution in all_executions:
-            if execution.output_data:
-                output_count += 1
-        assert output_count == num_threads  # One output per thread
-
-    async def test_sync_and_async_versions_consistent(self, execution_client):
-        """Test that sync and async versions of output operations behave the same."""
-        # First create the execution
-        node_exec_id, _ = execution_client.upsert_execution_input(
-            node_id="sync-async-test-node",
-            input_name="test_input",
-            input_data="test_value",
-            block_id="test-block",
-        )
-
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id,
-            status=ExecutionStatus.RUNNING,
-            execution_data={"input": "test"},
-        )
-
-        execution_client.upsert_execution_output(
-            node_exec_id=node_exec_id,
-            output_name="sync_result",
-            output_data={"method": "sync"},
-        )
-
-        execution_client.upsert_execution_output(
-            node_exec_id=node_exec_id,
-            output_name="async_result",
-            output_data={"method": "async"},
-        )
-
-        cached_exec = execution_client.get_node_execution(node_exec_id)
-        assert cached_exec is not None
-        assert "sync_result" in cached_exec.output_data
-        assert "async_result" in cached_exec.output_data
-        assert cached_exec.output_data["sync_result"] == [{"method": "sync"}]
-        assert cached_exec.output_data["async_result"] == [{"method": "async"}]
-
-    async def test_finalize_execution_completes_and_clears_cache(
-        self, execution_client
-    ):
-        """Test that finalize_execution waits for background tasks and clears cache."""
-        # First create the execution
-        node_exec_id, _ = execution_client.upsert_execution_input(
-            node_id="pending-test-node",
-            input_name="test_input",
-            input_data="test_value",
-            block_id="test-block",
-        )
-
-        # Trigger some background operations
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id, status=ExecutionStatus.RUNNING
-        )
-
-        execution_client.upsert_execution_output(
-            node_exec_id=node_exec_id, output_name="test", output_data={"value": 1}
-        )
-
-        # Wait for background tasks - may fail in test environment due to DB issues
-        try:
-            execution_client.finalize_execution(timeout=5.0)
-        except RuntimeError as e:
-            # In test environment, background DB operations may fail, but cache should still be cleared
-            assert "Background persistence failed" in str(e)
-
-        # Cache should be cleared regardless of background task failures
-        all_executions = execution_client.get_node_executions()
-        assert len(all_executions) == 0  # Cache should be cleared
-
-    async def test_manager_usage_pattern(self, execution_client):
-        # Create executions first
-        node_exec_id_1, _ = execution_client.upsert_execution_input(
-            node_id="node-1",
-            input_name="input1",
-            input_data="data1",
-            block_id="block-1",
-        )
-
-        node_exec_id_2, _ = execution_client.upsert_execution_input(
-            node_id="node-2",
-            input_name="input_from_node1",
-            input_data="value1",
-            block_id="block-2",
-        )
-
-        # Simulate manager.py workflow
-
-        # 1. Start execution
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id_1,
-            status=ExecutionStatus.RUNNING,
-            execution_data={"input": "data1"},
-        )
-
-        # 2. Node produces output
-        execution_client.upsert_execution_output(
-            node_exec_id=node_exec_id_1,
-            output_name="result",
-            output_data={"output": "value1"},
-        )
-
-        # 3. Complete first node
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id_1, status=ExecutionStatus.COMPLETED
-        )
-
-        # 4. Start second node (would read output from first)
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id_2,
-            status=ExecutionStatus.RUNNING,
-            execution_data={"input_from_node1": "value1"},
-        )
-
-        # 5. Manager queries for executions
-
-        all_executions = execution_client.get_node_executions()
-        running_executions = execution_client.get_node_executions(
-            statuses=[ExecutionStatus.RUNNING]
-        )
-        completed_executions = execution_client.get_node_executions(
-            statuses=[ExecutionStatus.COMPLETED]
-        )
-
-        # Verify manager can see all data immediately
-        assert len(all_executions) == 2
-        assert len(running_executions) == 1
-        assert len(completed_executions) == 1
-
-        # Verify output is accessible
-        exec_1 = execution_client.get_node_execution(node_exec_id_1)
-        assert exec_1 is not None
-        assert exec_1.output_data["result"] == [{"output": "value1"}]
-
-    def test_stats_handling_in_update_node_status(self, execution_client):
-        """Test that stats parameter is properly handled in update_node_status_and_publish."""
-        # Create a fake execution directly in cache to avoid database issues
-        from datetime import datetime, timezone
-
-        from backend.data.execution import NodeExecutionResult
-
-        node_exec_id = "test-stats-exec-id"
-        fake_execution = NodeExecutionResult(
-            user_id="test-user",
-            graph_id="test-graph",
-            graph_version=1,
-            graph_exec_id="test-graph-exec",
-            node_exec_id=node_exec_id,
-            node_id="stats-test-node",
-            block_id="test-block",
-            status=ExecutionStatus.INCOMPLETE,
-            input_data={"test_input": "test_value"},
-            output_data={},
-            add_time=datetime.now(timezone.utc),
-            queue_time=None,
-            start_time=None,
-            end_time=None,
-            stats=None,
-        )
-
-        # Add directly to cache
-        execution_client._cache.add_node_execution(node_exec_id, fake_execution)
-
-        stats = {"token_count": 150, "processing_time": 2.5}
-
-        # Update status with stats
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id,
-            status=ExecutionStatus.RUNNING,
-            execution_data={"input": "test"},
-            stats=stats,
-        )
-
-        # Verify execution was updated and stats are stored
-        execution = execution_client.get_node_execution(node_exec_id)
-        assert execution is not None
-        assert execution.status == ExecutionStatus.RUNNING
-
-        # Stats should be stored in proper stats field
-        assert execution.stats is not None
-        stats_dict = execution.stats.model_dump()
-        # Only check the fields we set, ignore defaults
-        assert stats_dict["token_count"] == 150
-        assert stats_dict["processing_time"] == 2.5
-
-        # Update with additional stats
-        additional_stats = {"error_count": 0}
-        execution_client.update_node_status_and_publish(
-            exec_id=node_exec_id,
-            status=ExecutionStatus.COMPLETED,
-            stats=additional_stats,
-        )
-
-        # Stats should be merged
-        execution = execution_client.get_node_execution(node_exec_id)
-        assert execution is not None
-        assert execution.status == ExecutionStatus.COMPLETED
-        stats_dict = execution.stats.model_dump()
-        # Check the merged stats
-        assert stats_dict["token_count"] == 150
-        assert stats_dict["processing_time"] == 2.5
-        assert stats_dict["error_count"] == 0
-
-    async def test_upsert_execution_input_scenarios(self, execution_client):
-        """Test different scenarios of upsert_execution_input - create vs update."""
-        node_id = "test-node"
-        graph_exec_id = (
-            "test_graph_exec_id"  # Must match the ExecutionDataClient's scope
-        )
-
-        # Scenario 1: Create new execution when none exists
-        exec_id_1, input_data_1 = execution_client.upsert_execution_input(
-            node_id=node_id,
-            input_name="first_input",
-            input_data="value1",
-            block_id="test-block",
-        )
-
-        # Should create new execution
-        execution = execution_client.get_node_execution(exec_id_1)
-        assert execution is not None
-        assert execution.status == ExecutionStatus.INCOMPLETE
-        assert execution.node_id == node_id
-        assert execution.graph_exec_id == graph_exec_id
-        assert input_data_1 == {"first_input": "value1"}
-
-        # Scenario 2: Add input to existing INCOMPLETE execution
-        exec_id_2, input_data_2 = execution_client.upsert_execution_input(
-            node_id=node_id,
-            input_name="second_input",
-            input_data="value2",
-            block_id="test-block",
-        )
-
-        # Should use same execution
-        assert exec_id_2 == exec_id_1
-        assert input_data_2 == {"first_input": "value1", "second_input": "value2"}
-
-        # Verify execution has both inputs
-        execution = execution_client.get_node_execution(exec_id_1)
-        assert execution is not None
-        assert execution.input_data == {
-            "first_input": "value1",
-            "second_input": "value2",
-        }
-
-        # Scenario 3: Create new execution when existing is not INCOMPLETE
-        execution_client.update_node_status_and_publish(
-            exec_id=exec_id_1, status=ExecutionStatus.RUNNING
-        )
-
-        exec_id_3, input_data_3 = execution_client.upsert_execution_input(
-            node_id=node_id,
-            input_name="third_input",
-            input_data="value3",
-            block_id="test-block",
-        )
-
-        # Should create new execution
-        assert exec_id_3 != exec_id_1
-        execution_3 = execution_client.get_node_execution(exec_id_3)
-        assert execution_3 is not None
-        assert input_data_3 == {"third_input": "value3"}
-
-        # Verify we now have 2 executions
-        all_executions = execution_client.get_node_executions()
-        assert len(all_executions) == 2
-
-    def test_graph_stats_operations(self, execution_client):
-        """Test graph-level stats and start time operations."""
-
-        # Test update_graph_stats_and_publish
-        from backend.data.model import GraphExecutionStats
-
-        stats = GraphExecutionStats(
-            walltime=10.5, cputime=8.2, node_count=5, node_error_count=1
-        )
-
-        execution_client.update_graph_stats_and_publish(
-            status=ExecutionStatus.RUNNING, stats=stats
-        )
-
-        # Verify stats are stored in cache
-        cached_stats = execution_client._cache._graph_stats
-        assert cached_stats.walltime == 10.5
-
-        execution_client.update_graph_start_time_and_publish()
-        cached_stats = execution_client._cache._graph_stats
-        assert cached_stats.walltime == 10.5
-
-    def test_public_methods_accessible(self, execution_client):
-        """Test that public methods are accessible."""
-        assert hasattr(execution_client._cache, "update_node_execution_status")
-        assert hasattr(execution_client._cache, "upsert_execution_output")
-        assert hasattr(execution_client._cache, "add_node_execution")
-        assert hasattr(execution_client._cache, "find_incomplete_execution_for_input")
-        assert hasattr(execution_client._cache, "update_execution_input")
-        assert hasattr(execution_client, "upsert_execution_input")
-        assert hasattr(execution_client, "update_node_status_and_publish")
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

autogpt_platform/backend/backend/executor/manager.py

@@ -5,15 +5,38 @@ import threading
 import time
 from collections import defaultdict
 from concurrent.futures import Future, ThreadPoolExecutor
-from typing import Any, Optional, TypeVar, cast
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, cast
 
 from pika.adapters.blocking_connection import BlockingChannel
 from pika.spec import Basic, BasicProperties
-from prometheus_client import Gauge, start_http_server
 from pydantic import JsonValue
+from redis.asyncio.lock import Lock as RedisLock
+
+from backend.blocks.io import AgentOutputBlock
+from backend.data.model import GraphExecutionStats, NodeExecutionStats
+from backend.data.notifications import (
+    AgentRunData,
+    LowBalanceData,
+    NotificationEventModel,
+    NotificationType,
+    ZeroBalanceData,
+)
+from backend.data.rabbitmq import SyncRabbitMQ
+from backend.executor.activity_status_generator import (
+    generate_activity_status_for_execution,
+)
+from backend.executor.utils import LogMetadata
+from backend.notifications.notifications import queue_notification
+from backend.util.exceptions import InsufficientBalanceError, ModerationError
+
+if TYPE_CHECKING:
+    from backend.executor import DatabaseManagerClient, DatabaseManagerAsyncClient
+
+from prometheus_client import Gauge, start_http_server
 
 from backend.blocks.agent import AgentExecutorBlock
-from backend.blocks.io import AgentOutputBlock
+from backend.data import redis_client as redis
 from backend.data.block import (
     BlockData,
     BlockInput,
@@ -25,28 +48,19 @@ from backend.data.credit import UsageTransactionMetadata
 from backend.data.execution import (
     ExecutionQueue,
     ExecutionStatus,
+    GraphExecution,
     GraphExecutionEntry,
     NodeExecutionEntry,
+    NodeExecutionResult,
     UserContext,
 )
 from backend.data.graph import Link, Node
-from backend.data.model import GraphExecutionStats, NodeExecutionStats
-from backend.data.notifications import (
-    AgentRunData,
-    LowBalanceData,
-    NotificationEventModel,
-    NotificationType,
-    ZeroBalanceData,
-)
-from backend.data.rabbitmq import SyncRabbitMQ
-from backend.executor.execution_data import ExecutionDataClient
 from backend.executor.utils import (
     GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS,
     GRAPH_EXECUTION_CANCEL_QUEUE_NAME,
     GRAPH_EXECUTION_QUEUE_NAME,
     CancelExecutionEvent,
     ExecutionOutputEntry,
-    LogMetadata,
     NodeExecutionProgress,
     block_usage_cost,
     create_execution_queue_config,
@@ -55,17 +69,21 @@ from backend.executor.utils import (
     validate_exec,
 )
 from backend.integrations.creds_manager import IntegrationCredentialsManager
-from backend.notifications.notifications import queue_notification
 from backend.server.v2.AutoMod.manager import automod_manager
 from backend.util import json
-from backend.util.clients import get_notification_manager_client
+from backend.util.clients import (
+    get_async_execution_event_bus,
+    get_database_manager_async_client,
+    get_database_manager_client,
+    get_execution_event_bus,
+    get_notification_manager_client,
+)
 from backend.util.decorator import (
     async_error_logged,
     async_time_measured,
     error_logged,
     time_measured,
 )
-from backend.util.exceptions import InsufficientBalanceError, ModerationError
 from backend.util.file import clean_exec_files
 from backend.util.logging import TruncatedLogger, configure_logging
 from backend.util.metrics import DiscordChannel
@@ -120,6 +138,7 @@ async def execute_node(
     persist the execution result, and return the subsequent node to be executed.
 
     Args:
+        db_client: The client to send execution updates to the server.
         creds_manager: The manager to acquire and release credentials.
         data: The execution data for executing the current node.
         execution_stats: The execution statistics to be updated.
@@ -216,7 +235,7 @@ async def execute_node(
 
 
 async def _enqueue_next_nodes(
-    execution_data_client: ExecutionDataClient,
+    db_client: "DatabaseManagerAsyncClient",
     node: Node,
     output: BlockData,
     user_id: str,
@@ -229,7 +248,8 @@ async def _enqueue_next_nodes(
     async def add_enqueued_execution(
         node_exec_id: str, node_id: str, block_id: str, data: BlockInput
     ) -> NodeExecutionEntry:
-        execution_data_client.update_node_status_and_publish(
+        await async_update_node_execution_status(
+            db_client=db_client,
             exec_id=node_exec_id,
             status=ExecutionStatus.QUEUED,
             execution_data=data,
@@ -262,22 +282,21 @@ async def _enqueue_next_nodes(
         next_data = parse_execution_output(output, next_output_name)
         if next_data is None and output_name != next_output_name:
             return enqueued_executions
-        next_node = await execution_data_client.get_node(next_node_id)
+        next_node = await db_client.get_node(next_node_id)
 
         # Multiple node can register the same next node, we need this to be atomic
         # To avoid same execution to be enqueued multiple times,
         # Or the same input to be consumed multiple times.
-        with execution_data_client.graph_lock:
+        async with synchronized(f"upsert_input-{next_node_id}-{graph_exec_id}"):
             # Add output data to the earliest incomplete execution, or create a new one.
-            next_node_exec_id, next_node_input = (
-                execution_data_client.upsert_execution_input(
-                    node_id=next_node_id,
-                    input_name=next_input_name,
-                    input_data=next_data,
-                    block_id=next_node.block_id,
-                )
+            next_node_exec_id, next_node_input = await db_client.upsert_execution_input(
+                node_id=next_node_id,
+                graph_exec_id=graph_exec_id,
+                input_name=next_input_name,
+                input_data=next_data,
             )
-            execution_data_client.update_node_status_and_publish(
+            await async_update_node_execution_status(
+                db_client=db_client,
                 exec_id=next_node_exec_id,
                 status=ExecutionStatus.INCOMPLETE,
             )
@@ -289,8 +308,8 @@ async def _enqueue_next_nodes(
                 if link.is_static and link.sink_name not in next_node_input
             }
             if static_link_names and (
-                latest_execution := execution_data_client.get_latest_node_execution(
-                    next_node_id
+                latest_execution := await db_client.get_latest_node_execution(
+                    next_node_id, graph_exec_id
                 )
             ):
                 for name in static_link_names:
@@ -329,8 +348,9 @@ async def _enqueue_next_nodes(
 
             # If link is static, there could be some incomplete executions waiting for it.
             # Load and complete the input missing input data, and try to re-enqueue them.
-            for iexec in execution_data_client.get_node_executions(
+            for iexec in await db_client.get_node_executions(
                 node_id=next_node_id,
+                graph_exec_id=graph_exec_id,
                 statuses=[ExecutionStatus.INCOMPLETE],
             ):
                 idata = iexec.input_data
@@ -394,9 +414,6 @@ class ExecutionProcessor:
         9. Node executor enqueues the next executed nodes to the node execution queue.
     """
 
-    # Current execution data client (scoped to current graph execution)
-    execution_data: ExecutionDataClient
-
     @async_error_logged(swallow=True)
     async def on_node_execution(
         self,
@@ -414,7 +431,8 @@ class ExecutionProcessor:
             node_id=node_exec.node_id,
             block_name="-",
         )
-        node = await self.execution_data.get_node(node_exec.node_id)
+        db_client = get_db_async_client()
+        node = await db_client.get_node(node_exec.node_id)
         execution_stats = NodeExecutionStats()
 
         timing_info, status = await self._on_node_execution(
@@ -422,6 +440,7 @@ class ExecutionProcessor:
             node_exec=node_exec,
             node_exec_progress=node_exec_progress,
             stats=execution_stats,
+            db_client=db_client,
             log_metadata=log_metadata,
             nodes_input_masks=nodes_input_masks,
         )
@@ -445,12 +464,15 @@ class ExecutionProcessor:
         if node_error and not isinstance(node_error, str):
             node_stats["error"] = str(node_error) or node_stats.__class__.__name__
 
-        self.execution_data.update_node_status_and_publish(
+        await async_update_node_execution_status(
+            db_client=db_client,
             exec_id=node_exec.node_exec_id,
             status=status,
             stats=node_stats,
         )
-        self.execution_data.update_graph_stats_and_publish(
+        await async_update_graph_execution_state(
+            db_client=db_client,
+            graph_exec_id=node_exec.graph_exec_id,
             stats=graph_stats,
         )
 
@@ -463,17 +485,22 @@ class ExecutionProcessor:
         node_exec: NodeExecutionEntry,
         node_exec_progress: NodeExecutionProgress,
         stats: NodeExecutionStats,
+        db_client: "DatabaseManagerAsyncClient",
         log_metadata: LogMetadata,
         nodes_input_masks: Optional[dict[str, dict[str, JsonValue]]] = None,
     ) -> ExecutionStatus:
         status = ExecutionStatus.RUNNING
 
         async def persist_output(output_name: str, output_data: Any) -> None:
-            self.execution_data.upsert_execution_output(
+            await db_client.upsert_execution_output(
                 node_exec_id=node_exec.node_exec_id,
                 output_name=output_name,
                 output_data=output_data,
             )
+            if exec_update := await db_client.get_node_execution(
+                node_exec.node_exec_id
+            ):
+                await send_async_execution_update(exec_update)
 
             node_exec_progress.add_output(
                 ExecutionOutputEntry(
@@ -485,7 +512,8 @@ class ExecutionProcessor:
 
         try:
             log_metadata.info(f"Start node execution {node_exec.node_exec_id}")
-            self.execution_data.update_node_status_and_publish(
+            await async_update_node_execution_status(
+                db_client=db_client,
                 exec_id=node_exec.node_exec_id,
                 status=ExecutionStatus.RUNNING,
             )
@@ -546,8 +574,6 @@ class ExecutionProcessor:
         self.node_evaluation_thread = threading.Thread(
             target=self.node_evaluation_loop.run_forever, daemon=True
         )
-        # single thread executor
-        self.execution_data_executor = ThreadPoolExecutor(max_workers=1)
         self.node_execution_thread.start()
         self.node_evaluation_thread.start()
         logger.info(f"[GraphExecutor] {self.tid} started")
@@ -567,13 +593,9 @@ class ExecutionProcessor:
             node_eid="*",
             block_name="-",
         )
+        db_client = get_db_client()
 
-        # Get graph execution metadata first via sync client
-        from backend.util.clients import get_database_manager_client
-
-        db_client_sync = get_database_manager_client()
-
-        exec_meta = db_client_sync.get_graph_execution_meta(
+        exec_meta = db_client.get_graph_execution_meta(
             user_id=graph_exec.user_id,
             execution_id=graph_exec.graph_exec_id,
         )
@@ -583,15 +605,12 @@ class ExecutionProcessor:
             )
             return
 
-        # Create scoped ExecutionDataClient for this graph execution with metadata
-        self.execution_data = ExecutionDataClient(
-            self.execution_data_executor, graph_exec.graph_exec_id, exec_meta
-        )
-
         if exec_meta.status == ExecutionStatus.QUEUED:
             log_metadata.info(f"⚙️ Starting graph execution #{graph_exec.graph_exec_id}")
             exec_meta.status = ExecutionStatus.RUNNING
-            self.execution_data.update_graph_start_time_and_publish()
+            send_execution_update(
+                db_client.update_graph_execution_start_time(graph_exec.graph_exec_id)
+            )
         elif exec_meta.status == ExecutionStatus.RUNNING:
             log_metadata.info(
                 f"⚙️ Graph execution #{graph_exec.graph_exec_id} is already running, continuing where it left off."
@@ -601,7 +620,9 @@ class ExecutionProcessor:
             log_metadata.info(
                 f"⚙️ Graph execution #{graph_exec.graph_exec_id} was disturbed, continuing where it left off."
             )
-            self.execution_data.update_graph_stats_and_publish(
+            update_graph_execution_state(
+                db_client=db_client,
+                graph_exec_id=graph_exec.graph_exec_id,
                 status=ExecutionStatus.RUNNING,
             )
         else:
@@ -632,10 +653,12 @@ class ExecutionProcessor:
 
             # Activity status handling
             activity_status = asyncio.run_coroutine_threadsafe(
-                self.execution_data.generate_activity_status(
+                generate_activity_status_for_execution(
+                    graph_exec_id=graph_exec.graph_exec_id,
                     graph_id=graph_exec.graph_id,
                     graph_version=graph_exec.graph_version,
                     execution_stats=exec_stats,
+                    db_client=get_db_async_client(),
                     user_id=graph_exec.user_id,
                     execution_status=status,
                 ),
@@ -650,14 +673,15 @@ class ExecutionProcessor:
                 )
 
             # Communication handling
-            self._handle_agent_run_notif(graph_exec, exec_stats)
+            self._handle_agent_run_notif(db_client, graph_exec, exec_stats)
 
         finally:
-            self.execution_data.update_graph_stats_and_publish(
+            update_graph_execution_state(
+                db_client=db_client,
+                graph_exec_id=graph_exec.graph_exec_id,
                 status=exec_meta.status,
                 stats=exec_stats,
             )
-            self.execution_data.finalize_execution()
 
     def _charge_usage(
         self,
@@ -666,6 +690,7 @@ class ExecutionProcessor:
     ) -> tuple[int, int]:
         total_cost = 0
         remaining_balance = 0
+        db_client = get_db_client()
         block = get_block(node_exec.block_id)
         if not block:
             logger.error(f"Block {node_exec.block_id} not found.")
@@ -675,7 +700,7 @@ class ExecutionProcessor:
             block=block, input_data=node_exec.inputs
         )
         if cost > 0:
-            remaining_balance = self.execution_data.spend_credits(
+            remaining_balance = db_client.spend_credits(
                 user_id=node_exec.user_id,
                 cost=cost,
                 metadata=UsageTransactionMetadata(
@@ -693,7 +718,7 @@ class ExecutionProcessor:
 
         cost, usage_count = execution_usage_cost(execution_count)
         if cost > 0:
-            remaining_balance = self.execution_data.spend_credits(
+            remaining_balance = db_client.spend_credits(
                 user_id=node_exec.user_id,
                 cost=cost,
                 metadata=UsageTransactionMetadata(
@@ -726,6 +751,7 @@ class ExecutionProcessor:
         """
         execution_status: ExecutionStatus = ExecutionStatus.RUNNING
         error: Exception | None = None
+        db_client = get_db_client()
         execution_stats_lock = threading.Lock()
 
         # State holders ----------------------------------------------------
@@ -736,7 +762,7 @@ class ExecutionProcessor:
         execution_queue = ExecutionQueue[NodeExecutionEntry]()
 
         try:
-            if self.execution_data.get_credits(graph_exec.user_id) <= 0:
+            if db_client.get_credits(graph_exec.user_id) <= 0:
                 raise InsufficientBalanceError(
                     user_id=graph_exec.user_id,
                     message="You have no credits left to run an agent.",
@@ -748,7 +774,7 @@ class ExecutionProcessor:
             try:
                 if moderation_error := asyncio.run_coroutine_threadsafe(
                     automod_manager.moderate_graph_execution_inputs(
-                        db_client=self.execution_data.db_client_async,
+                        db_client=get_db_async_client(),
                         graph_exec=graph_exec,
                     ),
                     self.node_evaluation_loop,
@@ -763,34 +789,16 @@ class ExecutionProcessor:
             # ------------------------------------------------------------
             # Pre‑populate queue ---------------------------------------
             # ------------------------------------------------------------
-
-            queued_executions = self.execution_data.get_node_executions(
+            for node_exec in db_client.get_node_executions(
+                graph_exec.graph_exec_id,
                 statuses=[
                     ExecutionStatus.RUNNING,
                     ExecutionStatus.QUEUED,
                     ExecutionStatus.TERMINATED,
                 ],
-            )
-            log_metadata.info(
-                f"Pre-populating queue with {len(queued_executions)} executions from cache"
-            )
-
-            for i, node_exec in enumerate(queued_executions):
-                log_metadata.info(
-                    f"  [{i}] {node_exec.node_exec_id}: status={node_exec.status}, node={node_exec.node_id}"
-                )
-                try:
-                    node_entry = node_exec.to_node_execution_entry(
-                        graph_exec.user_context
-                    )
-                    execution_queue.add(node_entry)
-                    log_metadata.info("    Added to execution queue successfully")
-                except Exception as e:
-                    log_metadata.error(f"    Failed to add to execution queue: {e}")
-
-            log_metadata.info(
-                f"Execution queue populated with {len(queued_executions)} executions"
-            )
+            ):
+                node_entry = node_exec.to_node_execution_entry(graph_exec.user_context)
+                execution_queue.add(node_entry)
 
             # ------------------------------------------------------------
             # Main dispatch / polling loop -----------------------------
@@ -810,14 +818,13 @@ class ExecutionProcessor:
                 try:
                     cost, remaining_balance = self._charge_usage(
                         node_exec=queued_node_exec,
-                        execution_count=self.execution_data.increment_execution_count(
-                            graph_exec.user_id
-                        ),
+                        execution_count=increment_execution_count(graph_exec.user_id),
                     )
                     with execution_stats_lock:
                         execution_stats.cost += cost
                     # Check if we crossed the low balance threshold
                     self._handle_low_balance(
+                        db_client=db_client,
                         user_id=graph_exec.user_id,
                         current_balance=remaining_balance,
                         transaction_cost=cost,
@@ -825,17 +832,19 @@ class ExecutionProcessor:
                 except InsufficientBalanceError as balance_error:
                     error = balance_error  # Set error to trigger FAILED status
                     node_exec_id = queued_node_exec.node_exec_id
-                    self.execution_data.upsert_execution_output(
+                    db_client.upsert_execution_output(
                         node_exec_id=node_exec_id,
                         output_name="error",
                         output_data=str(error),
                     )
-                    self.execution_data.update_node_status_and_publish(
+                    update_node_execution_status(
+                        db_client=db_client,
                         exec_id=node_exec_id,
                         status=ExecutionStatus.FAILED,
                     )
 
                     self._handle_insufficient_funds_notif(
+                        db_client,
                         graph_exec.user_id,
                         graph_exec.graph_id,
                         error,
@@ -922,13 +931,12 @@ class ExecutionProcessor:
                         time.sleep(0.1)
 
             # loop done --------------------------------------------------
-            # Background task finalization moved to finally block
 
             # Output moderation
             try:
                 if moderation_error := asyncio.run_coroutine_threadsafe(
                     automod_manager.moderate_graph_execution_outputs(
-                        db_client=self.execution_data.db_client_async,
+                        db_client=get_db_async_client(),
                         graph_exec_id=graph_exec.graph_exec_id,
                         user_id=graph_exec.user_id,
                         graph_id=graph_exec.graph_id,
@@ -982,6 +990,7 @@ class ExecutionProcessor:
                 error=error,
                 graph_exec_id=graph_exec.graph_exec_id,
                 log_metadata=log_metadata,
+                db_client=db_client,
             )
 
     @error_logged(swallow=True)
@@ -994,6 +1003,7 @@ class ExecutionProcessor:
         error: Exception | None,
         graph_exec_id: str,
         log_metadata: LogMetadata,
+        db_client: "DatabaseManagerClient",
     ) -> None:
         """
         Clean up running node executions and evaluations when graph execution ends.
@@ -1027,7 +1037,8 @@ class ExecutionProcessor:
                 )
 
         while queued_execution := execution_queue.get_or_none():
-            self.execution_data.update_node_status_and_publish(
+            update_node_execution_status(
+                db_client=db_client,
                 exec_id=queued_execution.node_exec_id,
                 status=execution_status,
                 stats={"error": str(error)} if error else None,
@@ -1055,10 +1066,12 @@ class ExecutionProcessor:
             nodes_input_masks: Optional map of node input overrides
             execution_queue: Queue to add next executions to
         """
+        db_client = get_db_async_client()
+
         log_metadata.debug(f"Enqueue nodes for {node_id}: {output}")
 
         for next_execution in await _enqueue_next_nodes(
-            execution_data_client=self.execution_data,
+            db_client=db_client,
             node=output.node,
             output=output.data,
             user_id=graph_exec.user_id,
@@ -1072,13 +1085,15 @@ class ExecutionProcessor:
 
     def _handle_agent_run_notif(
         self,
+        db_client: "DatabaseManagerClient",
         graph_exec: GraphExecutionEntry,
         exec_stats: GraphExecutionStats,
     ):
-        metadata = self.execution_data.get_graph_metadata(
+        metadata = db_client.get_graph_metadata(
             graph_exec.graph_id, graph_exec.graph_version
         )
-        outputs = self.execution_data.get_node_executions(
+        outputs = db_client.get_node_executions(
+            graph_exec.graph_exec_id,
             block_ids=[AgentOutputBlock().id],
         )
 
@@ -1107,12 +1122,13 @@ class ExecutionProcessor:
 
     def _handle_insufficient_funds_notif(
         self,
+        db_client: "DatabaseManagerClient",
         user_id: str,
         graph_id: str,
         e: InsufficientBalanceError,
     ):
         shortfall = abs(e.amount) - e.balance
-        metadata = self.execution_data.get_graph_metadata(graph_id)
+        metadata = db_client.get_graph_metadata(graph_id)
         base_url = (
             settings.config.frontend_base_url or settings.config.platform_base_url
         )
@@ -1131,7 +1147,7 @@ class ExecutionProcessor:
         )
 
         try:
-            user_email = self.execution_data.get_user_email_by_id(user_id)
+            user_email = db_client.get_user_email_by_id(user_id)
 
             alert_message = (
                 f"❌ **Insufficient Funds Alert**\n"
@@ -1153,6 +1169,7 @@ class ExecutionProcessor:
 
     def _handle_low_balance(
         self,
+        db_client: "DatabaseManagerClient",
         user_id: str,
         current_balance: int,
         transaction_cost: int,
@@ -1181,7 +1198,7 @@ class ExecutionProcessor:
             )
 
             try:
-                user_email = self.execution_data.get_user_email_by_id(user_id)
+                user_email = db_client.get_user_email_by_id(user_id)
                 alert_message = (
                     f"⚠️ **Low Balance Alert**\n"
                     f"User: {user_email or user_id}\n"
@@ -1377,14 +1394,14 @@ class ExecutionManager(AppProcess):
         delivery_tag = method.delivery_tag
 
         @func_retry
-        def _ack_message(reject: bool, requeue: bool):
+        def _ack_message(reject: bool = False):
             """Acknowledge or reject the message based on execution status."""
 
             # Connection can be lost, so always get a fresh channel
             channel = self.run_client.get_channel()
             if reject:
                 channel.connection.add_callback_threadsafe(
-                    lambda: channel.basic_nack(delivery_tag, requeue=requeue)
+                    lambda: channel.basic_nack(delivery_tag, requeue=True)
                 )
             else:
                 channel.connection.add_callback_threadsafe(
@@ -1396,13 +1413,13 @@ class ExecutionManager(AppProcess):
             logger.info(
                 f"[{self.service_name}] Rejecting new execution during shutdown"
             )
-            _ack_message(reject=True, requeue=True)
+            _ack_message(reject=True)
             return
 
         # Check if we can accept more runs
         self._cleanup_completed_runs()
         if len(self.active_graph_runs) >= self.pool_size:
-            _ack_message(reject=True, requeue=True)
+            _ack_message(reject=True)
             return
 
         try:
@@ -1411,7 +1428,7 @@ class ExecutionManager(AppProcess):
             logger.error(
                 f"[{self.service_name}] Could not parse run message: {e}, body={body}"
             )
-            _ack_message(reject=True, requeue=False)
+            _ack_message(reject=True)
             return
 
         graph_exec_id = graph_exec_entry.graph_exec_id
@@ -1423,7 +1440,7 @@ class ExecutionManager(AppProcess):
             logger.error(
                 f"[{self.service_name}] Graph {graph_exec_id} already running; rejecting duplicate run."
             )
-            _ack_message(reject=True, requeue=False)
+            _ack_message(reject=True)
             return
 
         cancel_event = threading.Event()
@@ -1439,9 +1456,9 @@ class ExecutionManager(AppProcess):
                     logger.error(
                         f"[{self.service_name}] Execution for {graph_exec_id} failed: {type(exec_error)} {exec_error}"
                     )
-                    _ack_message(reject=True, requeue=True)
+                    _ack_message(reject=True)
                 else:
-                    _ack_message(reject=False, requeue=False)
+                    _ack_message(reject=False)
             except BaseException as e:
                 logger.exception(
                     f"[{self.service_name}] Error in run completion callback: {e}"
@@ -1559,3 +1576,117 @@ class ExecutionManager(AppProcess):
         )
 
         logger.info(f"{prefix} ✅ Finished GraphExec cleanup")
+
+
+# ------- UTILITIES ------- #
+
+
+def get_db_client() -> "DatabaseManagerClient":
+    return get_database_manager_client()
+
+
+def get_db_async_client() -> "DatabaseManagerAsyncClient":
+    return get_database_manager_async_client()
+
+
+@func_retry
+async def send_async_execution_update(
+    entry: GraphExecution | NodeExecutionResult | None,
+) -> None:
+    if entry is None:
+        return
+    await get_async_execution_event_bus().publish(entry)
+
+
+@func_retry
+def send_execution_update(entry: GraphExecution | NodeExecutionResult | None):
+    if entry is None:
+        return
+    return get_execution_event_bus().publish(entry)
+
+
+async def async_update_node_execution_status(
+    db_client: "DatabaseManagerAsyncClient",
+    exec_id: str,
+    status: ExecutionStatus,
+    execution_data: BlockInput | None = None,
+    stats: dict[str, Any] | None = None,
+) -> NodeExecutionResult:
+    """Sets status and fetches+broadcasts the latest state of the node execution"""
+    exec_update = await db_client.update_node_execution_status(
+        exec_id, status, execution_data, stats
+    )
+    await send_async_execution_update(exec_update)
+    return exec_update
+
+
+def update_node_execution_status(
+    db_client: "DatabaseManagerClient",
+    exec_id: str,
+    status: ExecutionStatus,
+    execution_data: BlockInput | None = None,
+    stats: dict[str, Any] | None = None,
+) -> NodeExecutionResult:
+    """Sets status and fetches+broadcasts the latest state of the node execution"""
+    exec_update = db_client.update_node_execution_status(
+        exec_id, status, execution_data, stats
+    )
+    send_execution_update(exec_update)
+    return exec_update
+
+
+async def async_update_graph_execution_state(
+    db_client: "DatabaseManagerAsyncClient",
+    graph_exec_id: str,
+    status: ExecutionStatus | None = None,
+    stats: GraphExecutionStats | None = None,
+) -> GraphExecution | None:
+    """Sets status and fetches+broadcasts the latest state of the graph execution"""
+    graph_update = await db_client.update_graph_execution_stats(
+        graph_exec_id, status, stats
+    )
+    if graph_update:
+        await send_async_execution_update(graph_update)
+    else:
+        logger.error(f"Failed to update graph execution stats for {graph_exec_id}")
+    return graph_update
+
+
+def update_graph_execution_state(
+    db_client: "DatabaseManagerClient",
+    graph_exec_id: str,
+    status: ExecutionStatus | None = None,
+    stats: GraphExecutionStats | None = None,
+) -> GraphExecution | None:
+    """Sets status and fetches+broadcasts the latest state of the graph execution"""
+    graph_update = db_client.update_graph_execution_stats(graph_exec_id, status, stats)
+    if graph_update:
+        send_execution_update(graph_update)
+    else:
+        logger.error(f"Failed to update graph execution stats for {graph_exec_id}")
+    return graph_update
+
+
+@asynccontextmanager
+async def synchronized(key: str, timeout: int = 60):
+    r = await redis.get_redis_async()
+    lock: RedisLock = r.lock(f"lock:{key}", timeout=timeout)
+    try:
+        await lock.acquire()
+        yield
+    finally:
+        if await lock.locked() and await lock.owned():
+            await lock.release()
+
+
+def increment_execution_count(user_id: str) -> int:
+    """
+    Increment the execution count for a given user,
+    this will be used to charge the user for the execution cost.
+    """
+    r = redis.get_redis()
+    k = f"uec:{user_id}"  # User Execution Count global key
+    counter = cast(int, r.incr(k))
+    if counter == 1:
+        r.expire(k, settings.config.execution_counter_expiration_time)
+    return counter

autogpt_platform/backend/backend/executor/manager_low_balance_test.py

@@ -32,17 +32,13 @@ async def test_handle_low_balance_threshold_crossing(server: SpinTestServer):
         mock_settings.config.low_balance_threshold = 500  # $5 threshold
         mock_settings.config.frontend_base_url = "https://test.com"
 
-        # Initialize the execution processor and mock its execution_data
-        execution_processor.on_graph_executor_start()
-
-        # Mock the execution_data attribute since it's created in on_graph_execution
-        mock_execution_data = MagicMock()
-        execution_processor.execution_data = mock_execution_data
-
-        mock_execution_data.get_user_email_by_id.return_value = "test@example.com"
+        # Create mock database client
+        mock_db_client = MagicMock()
+        mock_db_client.get_user_email_by_id.return_value = "test@example.com"
 
         # Test the low balance handler
         execution_processor._handle_low_balance(
+            db_client=mock_db_client,
             user_id=user_id,
             current_balance=current_balance,
             transaction_cost=transaction_cost,
@@ -66,19 +62,6 @@ async def test_handle_low_balance_threshold_crossing(server: SpinTestServer):
         assert "$4.00" in discord_message
         assert "$6.00" in discord_message
 
-    # Cleanup execution processor threads
-    try:
-        execution_processor.node_execution_loop.call_soon_threadsafe(
-            execution_processor.node_execution_loop.stop
-        )
-        execution_processor.node_evaluation_loop.call_soon_threadsafe(
-            execution_processor.node_evaluation_loop.stop
-        )
-        execution_processor.node_execution_thread.join(timeout=1)
-        execution_processor.node_evaluation_thread.join(timeout=1)
-    except Exception:
-        pass  # Ignore cleanup errors
-
 
 @pytest.mark.asyncio(loop_scope="session")
 async def test_handle_low_balance_no_notification_when_not_crossing(
@@ -107,17 +90,12 @@ async def test_handle_low_balance_no_notification_when_not_crossing(
         mock_get_client.return_value = mock_client
         mock_settings.config.low_balance_threshold = 500  # $5 threshold
 
-        # Initialize the execution processor and mock its execution_data
-        execution_processor.on_graph_executor_start()
-
-        # Mock the execution_data attribute since it's created in on_graph_execution
-        mock_execution_data = MagicMock()
-        execution_processor.execution_data = mock_execution_data
-
-        mock_execution_data.get_user_email_by_id.return_value = "test@example.com"
+        # Create mock database client
+        mock_db_client = MagicMock()
 
         # Test the low balance handler
         execution_processor._handle_low_balance(
+            db_client=mock_db_client,
             user_id=user_id,
             current_balance=current_balance,
             transaction_cost=transaction_cost,
@@ -127,19 +105,6 @@ async def test_handle_low_balance_no_notification_when_not_crossing(
         mock_queue_notif.assert_not_called()
         mock_client.discord_system_alert.assert_not_called()
 
-    # Cleanup execution processor threads
-    try:
-        execution_processor.node_execution_loop.call_soon_threadsafe(
-            execution_processor.node_execution_loop.stop
-        )
-        execution_processor.node_evaluation_loop.call_soon_threadsafe(
-            execution_processor.node_evaluation_loop.stop
-        )
-        execution_processor.node_execution_thread.join(timeout=1)
-        execution_processor.node_evaluation_thread.join(timeout=1)
-    except Exception:
-        pass  # Ignore cleanup errors
-
 
 @pytest.mark.asyncio(loop_scope="session")
 async def test_handle_low_balance_no_duplicate_when_already_below(
@@ -168,17 +133,12 @@ async def test_handle_low_balance_no_duplicate_when_already_below(
         mock_get_client.return_value = mock_client
         mock_settings.config.low_balance_threshold = 500  # $5 threshold
 
-        # Initialize the execution processor and mock its execution_data
-        execution_processor.on_graph_executor_start()
-
-        # Mock the execution_data attribute since it's created in on_graph_execution
-        mock_execution_data = MagicMock()
-        execution_processor.execution_data = mock_execution_data
-
-        mock_execution_data.get_user_email_by_id.return_value = "test@example.com"
+        # Create mock database client
+        mock_db_client = MagicMock()
 
         # Test the low balance handler
         execution_processor._handle_low_balance(
+            db_client=mock_db_client,
             user_id=user_id,
             current_balance=current_balance,
             transaction_cost=transaction_cost,
@@ -187,16 +147,3 @@ async def test_handle_low_balance_no_duplicate_when_already_below(
         # Verify no notification was sent (user was already below threshold)
         mock_queue_notif.assert_not_called()
         mock_client.discord_system_alert.assert_not_called()
-
-    # Cleanup execution processor threads
-    try:
-        execution_processor.node_execution_loop.call_soon_threadsafe(
-            execution_processor.node_execution_loop.stop
-        )
-        execution_processor.node_evaluation_loop.call_soon_threadsafe(
-            execution_processor.node_evaluation_loop.stop
-        )
-        execution_processor.node_execution_thread.join(timeout=1)
-        execution_processor.node_evaluation_thread.join(timeout=1)
-    except Exception:
-        pass  # Ignore cleanup errors

autogpt_platform/backend/backend/executor/manager_test.py

@@ -1,5 +1,6 @@
 import logging
 
+import autogpt_libs.auth.models
 import fastapi.responses
 import pytest
 
@@ -520,7 +521,12 @@ async def test_store_listing_graph(server: SpinTestServer):
             is_approved=True,
             comments="Test comments",
         ),
-        user_id=admin_user.id,
+        autogpt_libs.auth.models.User(
+            user_id=admin_user.id,
+            role="admin",
+            email=admin_user.email,
+            phone_number="1234567890",
+        ),
     )
     alt_test_user = admin_user
 

autogpt_platform/backend/backend/server/conftest.py

@@ -11,45 +11,7 @@ def configured_snapshot(snapshot: Snapshot) -> Snapshot:
     return snapshot
 
 
-@pytest.fixture
-def test_user_id() -> str:
-    """Test user ID fixture."""
-    return "test-user-id"
-
-
-@pytest.fixture
-def admin_user_id() -> str:
-    """Admin user ID fixture."""
-    return "admin-user-id"
-
-
-@pytest.fixture
-def target_user_id() -> str:
-    """Target user ID fixture."""
-    return "target-user-id"
-
-
-@pytest.fixture
-def mock_jwt_user(test_user_id):
-    """Provide mock JWT payload for regular user testing."""
-    import fastapi
-
-    def override_get_jwt_payload(request: fastapi.Request) -> dict[str, str]:
-        return {"sub": test_user_id, "role": "user", "email": "test@example.com"}
-
-    return {"get_jwt_payload": override_get_jwt_payload, "user_id": test_user_id}
-
-
-@pytest.fixture
-def mock_jwt_admin(admin_user_id):
-    """Provide mock JWT payload for admin user testing."""
-    import fastapi
-
-    def override_get_jwt_payload(request: fastapi.Request) -> dict[str, str]:
-        return {
-            "sub": admin_user_id,
-            "role": "admin",
-            "email": "test-admin@example.com",
-        }
-
-    return {"get_jwt_payload": override_get_jwt_payload, "user_id": admin_user_id}
+# Test ID constants
+TEST_USER_ID = "test-user-id"
+ADMIN_USER_ID = "admin-user-id"
+TARGET_USER_ID = "target-user-id"

autogpt_platform/backend/backend/server/integrations/models.py

@@ -58,13 +58,17 @@ class ProviderConstants(BaseModel):
         default_factory=lambda: {
             name.upper().replace("-", "_"): name for name in get_all_provider_names()
         },
-        examples=[
-            {
-                "OPENAI": "openai",
-                "ANTHROPIC": "anthropic",
-                "EXA": "exa",
-                "GEM": "gem",
-                "EXAMPLE_SERVICE": "example-service",
-            }
-        ],
     )
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "PROVIDER_NAMES": {
+                    "OPENAI": "openai",
+                    "ANTHROPIC": "anthropic",
+                    "EXA": "exa",
+                    "GEM": "gem",
+                    "EXAMPLE_SERVICE": "example-service",
+                }
+            }
+        }

autogpt_platform/backend/backend/server/integrations/router.py

@@ -3,15 +3,14 @@ import logging
 from datetime import datetime, timedelta, timezone
 from typing import TYPE_CHECKING, Annotated, Awaitable, List, Literal
 
-from autogpt_libs.auth import get_user_id
 from fastapi import (
     APIRouter,
     Body,
+    Depends,
     HTTPException,
     Path,
     Query,
     Request,
-    Security,
     status,
 )
 from pydantic import BaseModel, Field, SecretStr
@@ -51,6 +50,8 @@ from backend.util.settings import Settings
 if TYPE_CHECKING:
     from backend.integrations.oauth import BaseOAuthHandler
 
+from ..utils import get_user_id
+
 logger = logging.getLogger(__name__)
 settings = Settings()
 router = APIRouter()
@@ -68,7 +69,7 @@ async def login(
     provider: Annotated[
         ProviderName, Path(title="The provider to initiate an OAuth flow for")
     ],
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     request: Request,
     scopes: Annotated[
         str, Query(title="Comma-separated list of authorization scopes")
@@ -108,7 +109,7 @@ async def callback(
     ],
     code: Annotated[str, Body(title="Authorization code acquired by user login")],
     state_token: Annotated[str, Body(title="Anti-CSRF nonce")],
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     request: Request,
 ) -> CredentialsMetaResponse:
     logger.debug(f"Received OAuth callback for provider: {provider}")
@@ -181,7 +182,7 @@ async def callback(
 
 @router.get("/credentials")
 async def list_credentials(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> list[CredentialsMetaResponse]:
     credentials = await creds_manager.store.get_all_creds(user_id)
     return [
@@ -203,7 +204,7 @@ async def list_credentials_by_provider(
     provider: Annotated[
         ProviderName, Path(title="The provider to list credentials for")
     ],
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> list[CredentialsMetaResponse]:
     credentials = await creds_manager.store.get_creds_by_provider(user_id, provider)
     return [
@@ -226,7 +227,7 @@ async def get_credential(
         ProviderName, Path(title="The provider to retrieve credentials for")
     ],
     cred_id: Annotated[str, Path(title="The ID of the credentials to retrieve")],
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> Credentials:
     credential = await creds_manager.get(user_id, cred_id)
     if not credential:
@@ -243,7 +244,7 @@ async def get_credential(
 
 @router.post("/{provider}/credentials", status_code=201)
 async def create_credentials(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     provider: Annotated[
         ProviderName, Path(title="The provider to create credentials for")
     ],
@@ -287,7 +288,7 @@ async def delete_credentials(
         ProviderName, Path(title="The provider to delete credentials for")
     ],
     cred_id: Annotated[str, Path(title="The ID of the credentials to delete")],
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     force: Annotated[
         bool, Query(title="Whether to proceed if any linked webhooks are still in use")
     ] = False,
@@ -428,7 +429,7 @@ async def webhook_ingress_generic(
 @router.post("/webhooks/{webhook_id}/ping")
 async def webhook_ping(
     webhook_id: Annotated[str, Path(title="Our ID for the webhook")],
-    user_id: Annotated[str, Security(get_user_id)],  # require auth
+    user_id: Annotated[str, Depends(get_user_id)],  # require auth
 ):
     webhook = await get_webhook(webhook_id)
     webhook_manager = get_webhook_manager(webhook.provider)
@@ -567,7 +568,7 @@ def _get_provider_oauth_handler(
 
 @router.get("/ayrshare/sso_url")
 async def get_ayrshare_sso_url(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> AyrshareSSOResponse:
     """
     Generate an SSO URL for Ayrshare social media integration.

autogpt_platform/backend/backend/server/rest_api.py

@@ -3,13 +3,12 @@ import logging
 from enum import Enum
 from typing import Any, Optional
 
+import autogpt_libs.auth.models
 import fastapi
 import fastapi.responses
 import pydantic
 import starlette.middleware.cors
 import uvicorn
-from autogpt_libs.auth import add_auth_responses_to_openapi
-from autogpt_libs.auth import verify_settings as verify_auth_settings
 from fastapi.exceptions import RequestValidationError
 from fastapi.routing import APIRoute
 
@@ -62,8 +61,6 @@ def launch_darkly_context():
 
 @contextlib.asynccontextmanager
 async def lifespan_context(app: fastapi.FastAPI):
-    verify_auth_settings()
-
     await backend.data.db.connect()
 
     # Ensure SDK auto-registration is patched before initializing blocks
@@ -134,9 +131,6 @@ app = fastapi.FastAPI(
 
 app.add_middleware(SecurityHeadersMiddleware)
 
-# Add 401 responses to authenticated endpoints in OpenAPI spec
-add_auth_responses_to_openapi(app)
-
 
 def handle_internal_http_error(status_code: int = 500, log_error: bool = True):
     def handler(request: fastapi.Request, exc: Exception):
@@ -376,10 +370,10 @@ class AgentServer(backend.util.service.AppProcess):
     @staticmethod
     async def test_review_store_listing(
         request: backend.server.v2.store.model.ReviewSubmissionRequest,
-        user_id: str,
+        user: autogpt_libs.auth.models.User,
     ):
         return await backend.server.v2.admin.store_admin_routes.review_submission(
-            request.store_listing_version_id, request, user_id
+            request.store_listing_version_id, request, user
         )
 
     @staticmethod

autogpt_platform/backend/backend/server/routers/analytics.py

@@ -5,9 +5,9 @@ from typing import Annotated
 
 import fastapi
 import pydantic
-from autogpt_libs.auth import get_user_id
 
 import backend.data.analytics
+from backend.server.utils import get_user_id
 
 router = fastapi.APIRouter()
 logger = logging.getLogger(__name__)
@@ -21,7 +21,7 @@ class LogRawMetricRequest(pydantic.BaseModel):
 
 @router.post(path="/log_raw_metric")
 async def log_raw_metric(
-    user_id: Annotated[str, fastapi.Security(get_user_id)],
+    user_id: Annotated[str, fastapi.Depends(get_user_id)],
     request: LogRawMetricRequest,
 ):
     try:
@@ -47,7 +47,7 @@ async def log_raw_metric(
 
 @router.post("/log_raw_analytics")
 async def log_raw_analytics(
-    user_id: Annotated[str, fastapi.Security(get_user_id)],
+    user_id: Annotated[str, fastapi.Depends(get_user_id)],
     type: Annotated[str, fastapi.Body(..., embed=True)],
     data: Annotated[
         dict,

autogpt_platform/backend/backend/server/routers/analytics_improved_test.py

@@ -5,17 +5,18 @@ from unittest.mock import AsyncMock, Mock
 
 import fastapi
 import fastapi.testclient
-import pytest
 import pytest_mock
 from pytest_snapshot.plugin import Snapshot
 
 import backend.server.routers.analytics as analytics_routes
+from backend.server.conftest import TEST_USER_ID
 from backend.server.test_helpers import (
     assert_error_response_structure,
     assert_mock_called_with_partial,
     assert_response_status,
     safe_parse_json,
 )
+from backend.server.utils import get_user_id
 
 app = fastapi.FastAPI()
 app.include_router(analytics_routes.router)
@@ -23,20 +24,17 @@ app.include_router(analytics_routes.router)
 client = fastapi.testclient.TestClient(app)
 
 
-@pytest.fixture(autouse=True)
-def setup_app_auth(mock_jwt_user):
-    """Setup auth overrides for all tests in this module"""
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
+def override_get_user_id() -> str:
+    """Override get_user_id for testing"""
+    return TEST_USER_ID
 
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
+
+app.dependency_overrides[get_user_id] = override_get_user_id
 
 
 def test_log_raw_metric_success_improved(
     mocker: pytest_mock.MockFixture,
     configured_snapshot: Snapshot,
-    test_user_id: str,
 ) -> None:
     """Test successful raw metric logging with improved assertions."""
     # Mock the analytics function
@@ -65,7 +63,7 @@ def test_log_raw_metric_success_improved(
     # Verify the function was called with correct parameters
     assert_mock_called_with_partial(
         mock_log_metric,
-        user_id=test_user_id,
+        user_id=TEST_USER_ID,
         metric_name="page_load_time",
         metric_value=2.5,
         data_string="/dashboard",

autogpt_platform/backend/backend/server/routers/analytics_parametrized_test.py

@@ -10,6 +10,8 @@ import pytest_mock
 from pytest_snapshot.plugin import Snapshot
 
 import backend.server.routers.analytics as analytics_routes
+from backend.server.conftest import TEST_USER_ID
+from backend.server.utils import get_user_id
 
 app = fastapi.FastAPI()
 app.include_router(analytics_routes.router)
@@ -17,14 +19,12 @@ app.include_router(analytics_routes.router)
 client = fastapi.testclient.TestClient(app)
 
 
-@pytest.fixture(autouse=True)
-def setup_app_auth(mock_jwt_user):
-    """Setup auth overrides for all tests in this module"""
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
+def override_get_user_id() -> str:
+    """Override get_user_id for testing"""
+    return TEST_USER_ID
 
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
+
+app.dependency_overrides[get_user_id] = override_get_user_id
 
 
 @pytest.mark.parametrize(

autogpt_platform/backend/backend/server/routers/analytics_test.py

@@ -3,11 +3,12 @@ from unittest.mock import AsyncMock, Mock
 
 import fastapi
 import fastapi.testclient
-import pytest
 import pytest_mock
 from pytest_snapshot.plugin import Snapshot
 
 import backend.server.routers.analytics as analytics_routes
+from backend.server.conftest import TEST_USER_ID
+from backend.server.utils import get_user_id
 
 app = fastapi.FastAPI()
 app.include_router(analytics_routes.router)
@@ -15,20 +16,17 @@ app.include_router(analytics_routes.router)
 client = fastapi.testclient.TestClient(app)
 
 
-@pytest.fixture(autouse=True)
-def setup_app_auth(mock_jwt_user):
-    """Setup auth overrides for all tests in this module"""
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
+def override_get_user_id() -> str:
+    """Override get_user_id for testing"""
+    return TEST_USER_ID
 
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
+
+app.dependency_overrides[get_user_id] = override_get_user_id
 
 
 def test_log_raw_metric_success(
     mocker: pytest_mock.MockFixture,
     configured_snapshot: Snapshot,
-    test_user_id: str,
 ) -> None:
     """Test successful raw metric logging"""
 
@@ -55,7 +53,7 @@ def test_log_raw_metric_success(
 
     # Verify the function was called with correct parameters
     mock_log_metric.assert_called_once_with(
-        user_id=test_user_id,
+        user_id=TEST_USER_ID,
         metric_name="page_load_time",
         metric_value=2.5,
         data_string="/dashboard",
@@ -123,7 +121,6 @@ def test_log_raw_metric_various_values(
 def test_log_raw_analytics_success(
     mocker: pytest_mock.MockFixture,
     configured_snapshot: Snapshot,
-    test_user_id: str,
 ) -> None:
     """Test successful raw analytics logging"""
 
@@ -158,7 +155,7 @@ def test_log_raw_analytics_success(
 
     # Verify the function was called with correct parameters
     mock_log_analytics.assert_called_once_with(
-        test_user_id,
+        TEST_USER_ID,
         "user_action",
         request_data["data"],
         "button_click_submit_form",

autogpt_platform/backend/backend/server/routers/postmark/postmark.py

@@ -1,7 +1,8 @@
 import logging
 from typing import Annotated
 
-from fastapi import APIRouter, Body, HTTPException, Query, Security
+from autogpt_libs.auth.middleware import APIKeyValidator
+from fastapi import APIRouter, Body, Depends, HTTPException, Query
 from fastapi.responses import JSONResponse
 
 from backend.data.user import (
@@ -19,19 +20,19 @@ from backend.server.routers.postmark.models import (
     PostmarkSubscriptionChangeWebhook,
     PostmarkWebhook,
 )
-from backend.server.utils.api_key_auth import APIKeyAuthenticator
 from backend.util.settings import Settings
 
-logger = logging.getLogger(__name__)
 settings = Settings()
-
-router = APIRouter()
-
-postmark_api_key_auth = APIKeyAuthenticator(
+postmark_validator = APIKeyValidator(
     "X-Postmark-Webhook-Token",
     settings.secrets.postmark_webhook_token,
 )
 
+router = APIRouter()
+
+
+logger = logging.getLogger(__name__)
+
 
 @router.post("/unsubscribe", summary="One Click Email Unsubscribe")
 async def unsubscribe_via_one_click(token: Annotated[str, Query()]):
@@ -49,7 +50,7 @@ async def unsubscribe_via_one_click(token: Annotated[str, Query()]):
 
 @router.post(
     "/",
-    dependencies=[Security(postmark_api_key_auth)],
+    dependencies=[Depends(postmark_validator.get_dependency())],
     summary="Handle Postmark Email Webhooks",
 )
 async def postmark_webhook_handler(

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

@@ -7,18 +7,17 @@ from typing import Annotated, Any, Sequence
 
 import pydantic
 import stripe
-from autogpt_libs.auth import get_user_id, requires_user
-from autogpt_libs.auth.jwt_utils import get_jwt_payload
+from autogpt_libs.auth.middleware import auth_middleware
 from fastapi import (
     APIRouter,
     Body,
+    Depends,
     File,
     HTTPException,
     Path,
     Query,
     Request,
     Response,
-    Security,
     UploadFile,
 )
 from starlette.status import HTTP_204_NO_CONTENT, HTTP_404_NOT_FOUND
@@ -86,6 +85,7 @@ from backend.server.model import (
     UpdateTimezoneRequest,
     UploadFileResponse,
 )
+from backend.server.utils import get_user_id
 from backend.util.clients import get_scheduler_client
 from backend.util.cloud_storage import get_cloud_storage_handler
 from backend.util.exceptions import GraphValidationError, NotFoundError
@@ -124,7 +124,7 @@ v1_router.include_router(
     backend.server.routers.analytics.router,
     prefix="/analytics",
     tags=["analytics"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 
 
@@ -137,9 +137,9 @@ v1_router.include_router(
     "/auth/user",
     summary="Get or create user",
     tags=["auth"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
-async def get_or_create_user_route(user_data: dict = Security(get_jwt_payload)):
+async def get_or_create_user_route(user_data: dict = Depends(auth_middleware)):
     user = await get_or_create_user(user_data)
     return user.model_dump()
 
@@ -148,10 +148,10 @@ async def get_or_create_user_route(user_data: dict = Security(get_jwt_payload)):
     "/auth/user/email",
     summary="Update user email",
     tags=["auth"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def update_user_email_route(
-    user_id: Annotated[str, Security(get_user_id)], email: str = Body(...)
+    user_id: Annotated[str, Depends(get_user_id)], email: str = Body(...)
 ) -> dict[str, str]:
     await update_user_email(user_id, email)
 
@@ -162,10 +162,10 @@ async def update_user_email_route(
     "/auth/user/timezone",
     summary="Get user timezone",
     tags=["auth"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def get_user_timezone_route(
-    user_data: dict = Security(get_jwt_payload),
+    user_data: dict = Depends(auth_middleware),
 ) -> TimezoneResponse:
     """Get user timezone setting."""
     user = await get_or_create_user(user_data)
@@ -176,11 +176,11 @@ async def get_user_timezone_route(
     "/auth/user/timezone",
     summary="Update user timezone",
     tags=["auth"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
     response_model=TimezoneResponse,
 )
 async def update_user_timezone_route(
-    user_id: Annotated[str, Security(get_user_id)], request: UpdateTimezoneRequest
+    user_id: Annotated[str, Depends(get_user_id)], request: UpdateTimezoneRequest
 ) -> TimezoneResponse:
     """Update user timezone. The timezone should be a valid IANA timezone identifier."""
     user = await update_user_timezone(user_id, str(request.timezone))
@@ -191,10 +191,10 @@ async def update_user_timezone_route(
     "/auth/user/preferences",
     summary="Get notification preferences",
     tags=["auth"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def get_preferences(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> NotificationPreference:
     preferences = await get_user_notification_preference(user_id)
     return preferences
@@ -204,10 +204,10 @@ async def get_preferences(
     "/auth/user/preferences",
     summary="Update notification preferences",
     tags=["auth"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def update_preferences(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     preferences: NotificationPreferenceDTO = Body(...),
 ) -> NotificationPreference:
     output = await update_user_notification_preference(user_id, preferences)
@@ -223,9 +223,9 @@ async def update_preferences(
     "/onboarding",
     summary="Get onboarding status",
     tags=["onboarding"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
-async def get_onboarding(user_id: Annotated[str, Security(get_user_id)]):
+async def get_onboarding(user_id: Annotated[str, Depends(get_user_id)]):
     return await get_user_onboarding(user_id)
 
 
@@ -233,10 +233,10 @@ async def get_onboarding(user_id: Annotated[str, Security(get_user_id)]):
     "/onboarding",
     summary="Update onboarding progress",
     tags=["onboarding"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def update_onboarding(
-    user_id: Annotated[str, Security(get_user_id)], data: UserOnboardingUpdate
+    user_id: Annotated[str, Depends(get_user_id)], data: UserOnboardingUpdate
 ):
     return await update_user_onboarding(user_id, data)
 
@@ -245,10 +245,10 @@ async def update_onboarding(
     "/onboarding/agents",
     summary="Get recommended agents",
     tags=["onboarding"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def get_onboarding_agents(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ):
     return await get_recommended_agents(user_id)
 
@@ -257,7 +257,7 @@ async def get_onboarding_agents(
     "/onboarding/enabled",
     summary="Check onboarding enabled",
     tags=["onboarding", "public"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def is_onboarding_enabled():
     return await onboarding_enabled()
@@ -272,7 +272,7 @@ async def is_onboarding_enabled():
     path="/blocks",
     summary="List available blocks",
     tags=["blocks"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 def get_graph_blocks() -> Sequence[dict[Any, Any]]:
     blocks = [block() for block in get_blocks().values()]
@@ -286,7 +286,7 @@ def get_graph_blocks() -> Sequence[dict[Any, Any]]:
     path="/blocks/{block_id}/execute",
     summary="Execute graph block",
     tags=["blocks"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def execute_graph_block(block_id: str, data: BlockInput) -> CompletedBlockOutput:
     obj = get_block(block_id)
@@ -303,10 +303,10 @@ async def execute_graph_block(block_id: str, data: BlockInput) -> CompletedBlock
     path="/files/upload",
     summary="Upload file to cloud storage",
     tags=["files"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def upload_file(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     file: UploadFile = File(...),
     provider: str = "gcs",
     expiration_hours: int = 24,
@@ -394,10 +394,10 @@ async def upload_file(
     path="/credits",
     tags=["credits"],
     summary="Get user credits",
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def get_user_credits(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> dict[str, int]:
     return {"credits": await _user_credit_model.get_credits(user_id)}
 
@@ -406,10 +406,10 @@ async def get_user_credits(
     path="/credits",
     summary="Request credit top up",
     tags=["credits"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def request_top_up(
-    request: RequestTopUp, user_id: Annotated[str, Security(get_user_id)]
+    request: RequestTopUp, user_id: Annotated[str, Depends(get_user_id)]
 ):
     checkout_url = await _user_credit_model.top_up_intent(
         user_id, request.credit_amount
@@ -421,10 +421,10 @@ async def request_top_up(
     path="/credits/{transaction_key}/refund",
     summary="Refund credit transaction",
     tags=["credits"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def refund_top_up(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     transaction_key: str,
     metadata: dict[str, str],
 ) -> int:
@@ -435,9 +435,9 @@ async def refund_top_up(
     path="/credits",
     summary="Fulfill checkout session",
     tags=["credits"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
-async def fulfill_checkout(user_id: Annotated[str, Security(get_user_id)]):
+async def fulfill_checkout(user_id: Annotated[str, Depends(get_user_id)]):
     await _user_credit_model.fulfill_checkout(user_id=user_id)
     return Response(status_code=200)
 
@@ -446,10 +446,10 @@ async def fulfill_checkout(user_id: Annotated[str, Security(get_user_id)]):
     path="/credits/auto-top-up",
     summary="Configure auto top up",
     tags=["credits"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def configure_user_auto_top_up(
-    request: AutoTopUpConfig, user_id: Annotated[str, Security(get_user_id)]
+    request: AutoTopUpConfig, user_id: Annotated[str, Depends(get_user_id)]
 ) -> str:
     if request.threshold < 0:
         raise ValueError("Threshold must be greater than 0")
@@ -475,10 +475,10 @@ async def configure_user_auto_top_up(
     path="/credits/auto-top-up",
     summary="Get auto top up",
     tags=["credits"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def get_user_auto_top_up(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> AutoTopUpConfig:
     return await get_auto_top_up(user_id)
 
@@ -528,10 +528,10 @@ async def stripe_webhook(request: Request):
     path="/credits/manage",
     tags=["credits"],
     summary="Manage payment methods",
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def manage_payment_method(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> dict[str, str]:
     return {"url": await _user_credit_model.create_billing_portal_session(user_id)}
 
@@ -540,10 +540,10 @@ async def manage_payment_method(
     path="/credits/transactions",
     tags=["credits"],
     summary="Get credit history",
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def get_credit_history(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     transaction_time: datetime | None = None,
     transaction_type: str | None = None,
     transaction_count_limit: int = 100,
@@ -563,10 +563,10 @@ async def get_credit_history(
     path="/credits/refunds",
     tags=["credits"],
     summary="Get refund requests",
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def get_refund_requests(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> list[RefundRequest]:
     return await _user_credit_model.get_refund_requests(user_id)
 
@@ -584,10 +584,10 @@ class DeleteGraphResponse(TypedDict):
     path="/graphs",
     summary="List user graphs",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def list_graphs(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> Sequence[graph_db.GraphMeta]:
     return await graph_db.list_graphs(filter_by="active", user_id=user_id)
 
@@ -596,17 +596,17 @@ async def list_graphs(
     path="/graphs/{graph_id}",
     summary="Get specific graph",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 @v1_router.get(
     path="/graphs/{graph_id}/versions/{version}",
     summary="Get graph version",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def get_graph(
     graph_id: str,
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     version: int | None = None,
     for_export: bool = False,
 ) -> graph_db.GraphModel:
@@ -626,10 +626,10 @@ async def get_graph(
     path="/graphs/{graph_id}/versions",
     summary="Get all graph versions",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def get_graph_all_versions(
-    graph_id: str, user_id: Annotated[str, Security(get_user_id)]
+    graph_id: str, user_id: Annotated[str, Depends(get_user_id)]
 ) -> Sequence[graph_db.GraphModel]:
     graphs = await graph_db.get_graph_all_versions(graph_id, user_id=user_id)
     if not graphs:
@@ -641,11 +641,11 @@ async def get_graph_all_versions(
     path="/graphs",
     summary="Create new graph",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def create_new_graph(
     create_graph: CreateGraph,
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> graph_db.GraphModel:
     graph = graph_db.make_graph_model(create_graph.graph, user_id)
     graph.reassign_ids(user_id=user_id, reassign_graph_id=True)
@@ -662,10 +662,10 @@ async def create_new_graph(
     path="/graphs/{graph_id}",
     summary="Delete graph permanently",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def delete_graph(
-    graph_id: str, user_id: Annotated[str, Security(get_user_id)]
+    graph_id: str, user_id: Annotated[str, Depends(get_user_id)]
 ) -> DeleteGraphResponse:
     if active_version := await graph_db.get_graph(graph_id, user_id=user_id):
         await on_graph_deactivate(active_version, user_id=user_id)
@@ -677,12 +677,12 @@ async def delete_graph(
     path="/graphs/{graph_id}",
     summary="Update graph version",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def update_graph(
     graph_id: str,
     graph: graph_db.Graph,
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> graph_db.GraphModel:
     # Sanity check
     if graph.id and graph.id != graph_id:
@@ -733,12 +733,12 @@ async def update_graph(
     path="/graphs/{graph_id}/versions/active",
     summary="Set active graph version",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def set_graph_active_version(
     graph_id: str,
     request_body: SetGraphActiveVersion,
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ):
     new_active_version = request_body.active_graph_version
     new_active_graph = await graph_db.get_graph(
@@ -772,11 +772,11 @@ async def set_graph_active_version(
     path="/graphs/{graph_id}/execute/{graph_version}",
     summary="Execute graph agent",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def execute_graph(
     graph_id: str,
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     inputs: Annotated[dict[str, Any], Body(..., embed=True, default_factory=dict)],
     credentials_inputs: Annotated[
         dict[str, CredentialsMetaInput], Body(..., embed=True, default_factory=dict)
@@ -818,10 +818,10 @@ async def execute_graph(
     path="/graphs/{graph_id}/executions/{graph_exec_id}/stop",
     summary="Stop graph execution",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def stop_graph_run(
-    graph_id: str, graph_exec_id: str, user_id: Annotated[str, Security(get_user_id)]
+    graph_id: str, graph_exec_id: str, user_id: Annotated[str, Depends(get_user_id)]
 ) -> execution_db.GraphExecutionMeta | None:
     res = await _stop_graph_run(
         user_id=user_id,
@@ -860,10 +860,10 @@ async def _stop_graph_run(
     path="/executions",
     summary="List all executions",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def list_graphs_executions(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> list[execution_db.GraphExecutionMeta]:
     return await execution_db.get_graph_executions(user_id=user_id)
 
@@ -872,11 +872,11 @@ async def list_graphs_executions(
     path="/graphs/{graph_id}/executions",
     summary="List graph executions",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def list_graph_executions(
     graph_id: str,
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     page: int = Query(1, ge=1, description="Page number (1-indexed)"),
     page_size: int = Query(
         25, ge=1, le=100, description="Number of executions per page"
@@ -894,12 +894,12 @@ async def list_graph_executions(
     path="/graphs/{graph_id}/executions/{graph_exec_id}",
     summary="Get execution details",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def get_graph_execution(
     graph_id: str,
     graph_exec_id: str,
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> execution_db.GraphExecution | execution_db.GraphExecutionWithNodes:
     graph = await graph_db.get_graph(graph_id=graph_id, user_id=user_id)
     if not graph:
@@ -924,12 +924,12 @@ async def get_graph_execution(
     path="/executions/{graph_exec_id}",
     summary="Delete graph execution",
     tags=["graphs"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
     status_code=HTTP_204_NO_CONTENT,
 )
 async def delete_graph_execution(
     graph_exec_id: str,
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> None:
     await execution_db.delete_graph_execution(
         graph_exec_id=graph_exec_id, user_id=user_id
@@ -953,10 +953,10 @@ class ScheduleCreationRequest(pydantic.BaseModel):
     path="/graphs/{graph_id}/schedules",
     summary="Create execution schedule",
     tags=["schedules"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def create_graph_execution_schedule(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     graph_id: str = Path(..., description="ID of the graph to schedule"),
     schedule_params: ScheduleCreationRequest = Body(),
 ) -> scheduler.GraphExecutionJobInfo:
@@ -1006,10 +1006,10 @@ async def create_graph_execution_schedule(
     path="/graphs/{graph_id}/schedules",
     summary="List execution schedules for a graph",
     tags=["schedules"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def list_graph_execution_schedules(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     graph_id: str = Path(),
 ) -> list[scheduler.GraphExecutionJobInfo]:
     schedules = await get_scheduler_client().get_execution_schedules(
@@ -1035,10 +1035,10 @@ async def list_graph_execution_schedules(
     path="/schedules",
     summary="List execution schedules for a user",
     tags=["schedules"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def list_all_graphs_execution_schedules(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> list[scheduler.GraphExecutionJobInfo]:
     schedules = await get_scheduler_client().get_execution_schedules(user_id=user_id)
 
@@ -1060,10 +1060,10 @@ async def list_all_graphs_execution_schedules(
     path="/schedules/{schedule_id}",
     summary="Delete execution schedule",
     tags=["schedules"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def delete_graph_execution_schedule(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
     schedule_id: str = Path(..., description="ID of the schedule to delete"),
 ) -> dict[str, Any]:
     try:
@@ -1086,10 +1086,10 @@ async def delete_graph_execution_schedule(
     summary="Create new API key",
     response_model=CreateAPIKeyResponse,
     tags=["api-keys"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def create_api_key(
-    request: CreateAPIKeyRequest, user_id: Annotated[str, Security(get_user_id)]
+    request: CreateAPIKeyRequest, user_id: Annotated[str, Depends(get_user_id)]
 ) -> CreateAPIKeyResponse:
     """Create a new API key"""
     try:
@@ -1117,10 +1117,10 @@ async def create_api_key(
     summary="List user API keys",
     response_model=list[APIKeyWithoutHash] | dict[str, str],
     tags=["api-keys"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def get_api_keys(
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> list[APIKeyWithoutHash]:
     """List all API keys for the user"""
     try:
@@ -1138,10 +1138,10 @@ async def get_api_keys(
     summary="Get specific API key",
     response_model=APIKeyWithoutHash,
     tags=["api-keys"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def get_api_key(
-    key_id: str, user_id: Annotated[str, Security(get_user_id)]
+    key_id: str, user_id: Annotated[str, Depends(get_user_id)]
 ) -> APIKeyWithoutHash:
     """Get a specific API key"""
     try:
@@ -1162,10 +1162,10 @@ async def get_api_key(
     summary="Revoke API key",
     response_model=APIKeyWithoutHash,
     tags=["api-keys"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def delete_api_key(
-    key_id: str, user_id: Annotated[str, Security(get_user_id)]
+    key_id: str, user_id: Annotated[str, Depends(get_user_id)]
 ) -> Optional[APIKeyWithoutHash]:
     """Revoke an API key"""
     try:
@@ -1190,10 +1190,10 @@ async def delete_api_key(
     summary="Suspend API key",
     response_model=APIKeyWithoutHash,
     tags=["api-keys"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def suspend_key(
-    key_id: str, user_id: Annotated[str, Security(get_user_id)]
+    key_id: str, user_id: Annotated[str, Depends(get_user_id)]
 ) -> Optional[APIKeyWithoutHash]:
     """Suspend an API key"""
     try:
@@ -1215,12 +1215,12 @@ async def suspend_key(
     summary="Update key permissions",
     response_model=APIKeyWithoutHash,
     tags=["api-keys"],
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
 )
 async def update_permissions(
     key_id: str,
     request: UpdatePermissionsRequest,
-    user_id: Annotated[str, Security(get_user_id)],
+    user_id: Annotated[str, Depends(get_user_id)],
 ) -> Optional[APIKeyWithoutHash]:
     """Update API key permissions"""
     try:

autogpt_platform/backend/backend/server/routers/v1_test.py

@@ -2,6 +2,7 @@ import json
 from io import BytesIO
 from unittest.mock import AsyncMock, Mock, patch
 
+import autogpt_libs.auth.depends
 import fastapi
 import fastapi.testclient
 import pytest
@@ -13,7 +14,9 @@ from pytest_snapshot.plugin import Snapshot
 import backend.server.routers.v1 as v1_routes
 from backend.data.credit import AutoTopUpConfig
 from backend.data.graph import GraphModel
+from backend.server.conftest import TEST_USER_ID
 from backend.server.routers.v1 import upload_file
+from backend.server.utils import get_user_id
 
 app = fastapi.FastAPI()
 app.include_router(v1_routes.v1_router)
@@ -21,26 +24,31 @@ app.include_router(v1_routes.v1_router)
 client = fastapi.testclient.TestClient(app)
 
 
-@pytest.fixture(autouse=True)
-def setup_app_auth(mock_jwt_user):
-    """Setup auth overrides for all tests in this module"""
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
+def override_auth_middleware(request: fastapi.Request) -> dict[str, str]:
+    """Override auth middleware for testing"""
+    return {"sub": TEST_USER_ID, "role": "user", "email": "test@example.com"}
 
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
+
+def override_get_user_id() -> str:
+    """Override get_user_id for testing"""
+    return TEST_USER_ID
+
+
+app.dependency_overrides[autogpt_libs.auth.middleware.auth_middleware] = (
+    override_auth_middleware
+)
+app.dependency_overrides[get_user_id] = override_get_user_id
 
 
 # Auth endpoints tests
 def test_get_or_create_user_route(
     mocker: pytest_mock.MockFixture,
     configured_snapshot: Snapshot,
-    test_user_id: str,
 ) -> None:
     """Test get or create user endpoint"""
     mock_user = Mock()
     mock_user.model_dump.return_value = {
-        "id": test_user_id,
+        "id": TEST_USER_ID,
         "email": "test@example.com",
         "name": "Test User",
     }
@@ -255,7 +263,6 @@ def test_get_auto_top_up(
 def test_get_graphs(
     mocker: pytest_mock.MockFixture,
     snapshot: Snapshot,
-    test_user_id: str,
 ) -> None:
     """Test get graphs endpoint"""
     mock_graph = GraphModel(
@@ -264,7 +271,7 @@ def test_get_graphs(
         is_active=True,
         name="Test Graph",
         description="A test graph",
-        user_id=test_user_id,
+        user_id="test-user-id",
     )
 
     mocker.patch(
@@ -289,7 +296,6 @@ def test_get_graphs(
 def test_get_graph(
     mocker: pytest_mock.MockFixture,
     snapshot: Snapshot,
-    test_user_id: str,
 ) -> None:
     """Test get single graph endpoint"""
     mock_graph = GraphModel(
@@ -298,7 +304,7 @@ def test_get_graph(
         is_active=True,
         name="Test Graph",
         description="A test graph",
-        user_id=test_user_id,
+        user_id="test-user-id",
     )
 
     mocker.patch(
@@ -337,7 +343,6 @@ def test_get_graph_not_found(
 def test_delete_graph(
     mocker: pytest_mock.MockFixture,
     snapshot: Snapshot,
-    test_user_id: str,
 ) -> None:
     """Test delete graph endpoint"""
     # Mock active graph for deactivation
@@ -347,7 +352,7 @@ def test_delete_graph(
         is_active=True,
         name="Test Graph",
         description="A test graph",
-        user_id=test_user_id,
+        user_id="test-user-id",
     )
 
     mocker.patch(
@@ -394,7 +399,7 @@ def test_missing_required_field() -> None:
 
 
 @pytest.mark.asyncio
-async def test_upload_file_success(test_user_id: str):
+async def test_upload_file_success():
     """Test successful file upload."""
     # Create mock upload file
     file_content = b"test file content"
@@ -420,7 +425,7 @@ async def test_upload_file_success(test_user_id: str):
 
         result = await upload_file(
             file=upload_file_mock,
-            user_id=test_user_id,
+            user_id="test-user-123",
             provider="gcs",
             expiration_hours=24,
         )
@@ -441,12 +446,12 @@ async def test_upload_file_success(test_user_id: str):
             filename="test.txt",
             provider="gcs",
             expiration_hours=24,
-            user_id=test_user_id,
+            user_id="test-user-123",
         )
 
 
 @pytest.mark.asyncio
-async def test_upload_file_no_filename(test_user_id: str):
+async def test_upload_file_no_filename():
     """Test file upload without filename."""
     file_content = b"test content"
     file_obj = BytesIO(file_content)
@@ -471,7 +476,7 @@ async def test_upload_file_no_filename(test_user_id: str):
 
         upload_file_mock.read = AsyncMock(return_value=file_content)
 
-        result = await upload_file(file=upload_file_mock, user_id=test_user_id)
+        result = await upload_file(file=upload_file_mock, user_id="test-user-123")
 
         assert result.file_name == "uploaded_file"
         assert result.content_type == "application/octet-stream"
@@ -481,7 +486,7 @@ async def test_upload_file_no_filename(test_user_id: str):
 
 
 @pytest.mark.asyncio
-async def test_upload_file_invalid_expiration(test_user_id: str):
+async def test_upload_file_invalid_expiration():
     """Test file upload with invalid expiration hours."""
     file_obj = BytesIO(b"content")
     upload_file_mock = UploadFile(
@@ -493,7 +498,7 @@ async def test_upload_file_invalid_expiration(test_user_id: str):
     # Test expiration too short
     with pytest.raises(HTTPException) as exc_info:
         await upload_file(
-            file=upload_file_mock, user_id=test_user_id, expiration_hours=0
+            file=upload_file_mock, user_id="test-user-123", expiration_hours=0
         )
     assert exc_info.value.status_code == 400
     assert "between 1 and 48" in exc_info.value.detail
@@ -501,14 +506,14 @@ async def test_upload_file_invalid_expiration(test_user_id: str):
     # Test expiration too long
     with pytest.raises(HTTPException) as exc_info:
         await upload_file(
-            file=upload_file_mock, user_id=test_user_id, expiration_hours=49
+            file=upload_file_mock, user_id="test-user-123", expiration_hours=49
         )
     assert exc_info.value.status_code == 400
     assert "between 1 and 48" in exc_info.value.detail
 
 
 @pytest.mark.asyncio
-async def test_upload_file_virus_scan_failure(test_user_id: str):
+async def test_upload_file_virus_scan_failure():
     """Test file upload when virus scan fails."""
     file_content = b"malicious content"
     file_obj = BytesIO(file_content)
@@ -525,11 +530,11 @@ async def test_upload_file_virus_scan_failure(test_user_id: str):
         upload_file_mock.read = AsyncMock(return_value=file_content)
 
         with pytest.raises(RuntimeError, match="Virus detected!"):
-            await upload_file(file=upload_file_mock, user_id=test_user_id)
+            await upload_file(file=upload_file_mock, user_id="test-user-123")
 
 
 @pytest.mark.asyncio
-async def test_upload_file_cloud_storage_failure(test_user_id: str):
+async def test_upload_file_cloud_storage_failure():
     """Test file upload when cloud storage fails."""
     file_content = b"test content"
     file_obj = BytesIO(file_content)
@@ -551,11 +556,11 @@ async def test_upload_file_cloud_storage_failure(test_user_id: str):
         upload_file_mock.read = AsyncMock(return_value=file_content)
 
         with pytest.raises(RuntimeError, match="Storage error!"):
-            await upload_file(file=upload_file_mock, user_id=test_user_id)
+            await upload_file(file=upload_file_mock, user_id="test-user-123")
 
 
 @pytest.mark.asyncio
-async def test_upload_file_size_limit_exceeded(test_user_id: str):
+async def test_upload_file_size_limit_exceeded():
     """Test file upload when file size exceeds the limit."""
     # Create a file that exceeds the default 256MB limit
     large_file_content = b"x" * (257 * 1024 * 1024)  # 257MB
@@ -569,14 +574,14 @@ async def test_upload_file_size_limit_exceeded(test_user_id: str):
     upload_file_mock.read = AsyncMock(return_value=large_file_content)
 
     with pytest.raises(HTTPException) as exc_info:
-        await upload_file(file=upload_file_mock, user_id=test_user_id)
+        await upload_file(file=upload_file_mock, user_id="test-user-123")
 
     assert exc_info.value.status_code == 400
     assert "exceeds the maximum allowed size of 256MB" in exc_info.value.detail
 
 
 @pytest.mark.asyncio
-async def test_upload_file_gcs_not_configured_fallback(test_user_id: str):
+async def test_upload_file_gcs_not_configured_fallback():
     """Test file upload fallback to base64 when GCS is not configured."""
     file_content = b"test file content"
     file_obj = BytesIO(file_content)
@@ -597,7 +602,7 @@ async def test_upload_file_gcs_not_configured_fallback(test_user_id: str):
 
         upload_file_mock.read = AsyncMock(return_value=file_content)
 
-        result = await upload_file(file=upload_file_mock, user_id=test_user_id)
+        result = await upload_file(file=upload_file_mock, user_id="test-user-123")
 
         # Verify fallback behavior
         assert result.file_name == "test.txt"

autogpt_platform/backend/backend/server/test_fixtures.py

@@ -0,0 +1,144 @@
+"""Common test fixtures with proper setup and teardown."""
+
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+from unittest.mock import Mock, patch
+
+import pytest
+from prisma import Prisma
+
+
+@pytest.fixture
+async def test_db_connection() -> AsyncGenerator[Prisma, None]:
+    """Provide a test database connection with proper cleanup.
+
+    This fixture ensures the database connection is properly
+    closed after the test, even if the test fails.
+    """
+    db = Prisma()
+    try:
+        await db.connect()
+        yield db
+    finally:
+        await db.disconnect()
+
+
+@pytest.fixture
+def mock_transaction():
+    """Mock database transaction with proper async context manager."""
+
+    @asynccontextmanager
+    async def mock_context(*args, **kwargs):
+        yield None
+
+    with patch("backend.data.db.locked_transaction", side_effect=mock_context) as mock:
+        yield mock
+
+
+@pytest.fixture
+def isolated_app_state():
+    """Fixture that ensures app state is isolated between tests."""
+    # Example: Save original state
+    # from backend.server.app import app
+    # original_overrides = app.dependency_overrides.copy()
+
+    # try:
+    #     yield app
+    # finally:
+    #     # Restore original state
+    #     app.dependency_overrides = original_overrides
+
+    # For now, just yield None as this is an example
+    yield None
+
+
+@pytest.fixture
+def cleanup_files():
+    """Fixture to track and cleanup files created during tests."""
+    created_files = []
+
+    def track_file(filepath: str):
+        created_files.append(filepath)
+
+    yield track_file
+
+    # Cleanup
+    import os
+
+    for filepath in created_files:
+        try:
+            if os.path.exists(filepath):
+                os.remove(filepath)
+        except Exception as e:
+            print(f"Warning: Failed to cleanup {filepath}: {e}")
+
+
+@pytest.fixture
+async def async_mock_with_cleanup():
+    """Create async mocks that are properly cleaned up."""
+    mocks = []
+
+    def create_mock(**kwargs):
+        mock = Mock(**kwargs)
+        mocks.append(mock)
+        return mock
+
+    yield create_mock
+
+    # Reset all mocks
+    for mock in mocks:
+        mock.reset_mock()
+
+
+class TestDatabaseIsolation:
+    """Example of proper test isolation with database operations."""
+
+    @pytest.fixture(autouse=True)
+    async def setup_and_teardown(self, test_db_connection):
+        """Setup and teardown for each test method."""
+        # Setup: Clear test data
+        await test_db_connection.user.delete_many(
+            where={"email": {"contains": "@test.example"}}
+        )
+
+        yield
+
+        # Teardown: Clear test data again
+        await test_db_connection.user.delete_many(
+            where={"email": {"contains": "@test.example"}}
+        )
+
+    @pytest.fixture(scope="session")
+    async def test_create_user(self, test_db_connection):
+        """Test that demonstrates proper isolation."""
+        # This test has access to a clean database
+        user = await test_db_connection.user.create(
+            data={
+                "id": "test-user-id",
+                "email": "test@test.example",
+                "name": "Test User",
+            }
+        )
+        assert user.email == "test@test.example"
+        # User will be cleaned up automatically
+
+
+@pytest.fixture(scope="function")  # Explicitly use function scope
+def reset_singleton_state():
+    """Reset singleton state between tests."""
+    # Example: Reset a singleton instance
+    # from backend.data.some_singleton import SingletonClass
+
+    # # Save original state
+    # original_instance = getattr(SingletonClass, "_instance", None)
+
+    # try:
+    #     # Clear singleton
+    #     SingletonClass._instance = None
+    #     yield
+    # finally:
+    #     # Restore original state
+    #     SingletonClass._instance = original_instance
+
+    # For now, just yield None as this is an example
+    yield None

autogpt_platform/backend/backend/server/test_utils.py

@@ -0,0 +1,74 @@
+"""Common test utilities and constants for server tests."""
+
+from typing import Any, Dict
+from unittest.mock import Mock
+
+import pytest
+
+# Test ID constants
+TEST_USER_ID = "test-user-id"
+ADMIN_USER_ID = "admin-user-id"
+TARGET_USER_ID = "target-user-id"
+
+# Common test data constants
+FIXED_TIMESTAMP = "2024-01-01T00:00:00Z"
+TRANSACTION_UUID = "transaction-123-uuid"
+METRIC_UUID = "metric-123-uuid"
+ANALYTICS_UUID = "analytics-123-uuid"
+
+
+def create_mock_with_id(mock_id: str) -> Mock:
+    """Create a mock object with an id attribute.
+
+    Args:
+        mock_id: The ID value to set on the mock
+
+    Returns:
+        Mock object with id attribute set
+    """
+    return Mock(id=mock_id)
+
+
+def assert_status_and_parse_json(
+    response: Any, expected_status: int = 200
+) -> Dict[str, Any]:
+    """Assert response status and return parsed JSON.
+
+    Args:
+        response: The HTTP response object
+        expected_status: Expected status code (default: 200)
+
+    Returns:
+        Parsed JSON response data
+
+    Raises:
+        AssertionError: If status code doesn't match expected
+    """
+    assert (
+        response.status_code == expected_status
+    ), f"Expected status {expected_status}, got {response.status_code}: {response.text}"
+    return response.json()
+
+
+@pytest.mark.parametrize(
+    "metric_value,metric_name,data_string",
+    [
+        (100, "api_calls_count", "external_api"),
+        (0, "error_count", "no_errors"),
+        (-5.2, "temperature_delta", "cooling"),
+        (1.23456789, "precision_test", "float_precision"),
+        (999999999, "large_number", "max_value"),
+    ],
+)
+def parametrized_metric_values_decorator(func):
+    """Decorator for parametrized metric value tests."""
+    return pytest.mark.parametrize(
+        "metric_value,metric_name,data_string",
+        [
+            (100, "api_calls_count", "external_api"),
+            (0, "error_count", "no_errors"),
+            (-5.2, "temperature_delta", "cooling"),
+            (1.23456789, "precision_test", "float_precision"),
+            (999999999, "large_number", "max_value"),
+        ],
+    )(func)

autogpt_platform/backend/backend/server/utils.py

@@ -0,0 +1,11 @@
+from autogpt_libs.auth.depends import requires_user
+from autogpt_libs.auth.models import User
+from fastapi import Depends
+
+from backend.util.settings import Settings
+
+settings = Settings()
+
+
+def get_user_id(user: User = Depends(requires_user)) -> str:
+    return user.user_id

autogpt_platform/backend/backend/server/utils/api_key_auth.py

@@ -1,109 +0,0 @@
-"""
-API Key authentication utilities for FastAPI applications.
-"""
-
-import inspect
-import secrets
-from typing import Any, Callable, Optional
-
-from fastapi import HTTPException, Request
-from fastapi.security import APIKeyHeader
-from starlette.status import HTTP_401_UNAUTHORIZED
-
-from backend.util.exceptions import MissingConfigError
-
-
-class APIKeyAuthenticator(APIKeyHeader):
-    """
-    Configurable API key authenticator for FastAPI applications,
-    with support for custom validation functions.
-
-    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
-        api_key_auth = APIKeyAuthenticator(
-            header_name="X-API-Key",
-            expected_token="your-secret-token"
-        )
-
-        @app.get("/protected", dependencies=[Security(api_key_auth)])
-        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
-
-        api_key_auth = APIKeyAuthenticator(
-            header_name="X-API-Key",
-            validator=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
-        validator (Optional[Callable]): Custom validation function that takes an API key
-            string and returns a boolean or object. Can be async.
-        status_if_missing (int): HTTP status code to use for validation errors
-        message_if_invalid (str): Error message to return when validation fails
-    """
-
-    def __init__(
-        self,
-        header_name: str,
-        expected_token: Optional[str] = None,
-        validator: Optional[Callable[[str], bool]] = None,
-        status_if_missing: int = HTTP_401_UNAUTHORIZED,
-        message_if_invalid: str = "Invalid API key",
-    ):
-        super().__init__(
-            name=header_name,
-            scheme_name=f"{__class__.__name__}-{header_name}",
-            auto_error=False,
-        )
-        self.expected_token = expected_token
-        self.custom_validator = validator
-        self.status_if_missing = status_if_missing
-        self.message_if_invalid = message_if_invalid
-
-    async def __call__(self, request: Request) -> Any:
-        api_key = await super()(request)
-        if api_key is None:
-            raise HTTPException(
-                status_code=self.status_if_missing, detail="No API key in request"
-            )
-
-        # Use custom validation if provided, otherwise use default equality check
-        validator = self.custom_validator 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.status_if_missing, detail=self.message_if_invalid
-            )
-
-        # 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
-
-    async def default_validator(self, api_key: str) -> bool:
-        if not self.expected_token:
-            raise MissingConfigError(
-                f"{self.__class__.__name__}.expected_token is not set; "
-                "either specify it or provide a custom validator"
-            )
-        return secrets.compare_digest(api_key, self.expected_token)

autogpt_platform/backend/backend/server/v2/AutoMod/manager.py

@@ -147,10 +147,8 @@ class AutoModManager:
             return None
 
         # Get completed executions and collect outputs
-        completed_executions = await db_client.get_node_executions(  # type: ignore
-            graph_exec_id=graph_exec_id,
-            statuses=[ExecutionStatus.COMPLETED],
-            include_exec_data=True,
+        completed_executions = await db_client.get_node_executions(
+            graph_exec_id, statuses=[ExecutionStatus.COMPLETED], include_exec_data=True
         )
 
         if not completed_executions:
@@ -220,7 +218,7 @@ class AutoModManager:
     ):
         """Update node execution statuses for frontend display when moderation fails"""
         # Import here to avoid circular imports
-        from backend.util.clients import get_async_execution_event_bus
+        from backend.executor.manager import send_async_execution_update
 
         if moderation_type == "input":
             # For input moderation, mark queued/running/incomplete nodes as failed
@@ -234,10 +232,8 @@ class AutoModManager:
             target_statuses = [ExecutionStatus.COMPLETED]
 
         # Get the executions that need to be updated
-        executions_to_update = await db_client.get_node_executions(  # type: ignore
-            graph_exec_id=graph_exec_id,
-            statuses=target_statuses,
-            include_exec_data=True,
+        executions_to_update = await db_client.get_node_executions(
+            graph_exec_id, statuses=target_statuses, include_exec_data=True
         )
 
         if not executions_to_update:
@@ -280,12 +276,10 @@ class AutoModManager:
         updated_execs = await asyncio.gather(*exec_updates)
 
         # Send all websocket updates in parallel
-        event_bus = get_async_execution_event_bus()
         await asyncio.gather(
             *[
-                event_bus.publish(updated_exec)
+                send_async_execution_update(updated_exec)
                 for updated_exec in updated_execs
-                if updated_exec is not None
             ]
         )
 

autogpt_platform/backend/backend/server/v2/admin/credit_admin_routes.py

@@ -1,8 +1,9 @@
 import logging
 import typing
 
-from autogpt_libs.auth import get_user_id, requires_admin_user
-from fastapi import APIRouter, Body, Security
+from autogpt_libs.auth import requires_admin_user
+from autogpt_libs.auth.depends import get_user_id
+from fastapi import APIRouter, Body, Depends
 from prisma.enums import CreditTransactionType
 
 from backend.data.credit import admin_get_user_history, get_user_credit_model
@@ -17,7 +18,7 @@ _user_credit_model = get_user_credit_model()
 router = APIRouter(
     prefix="/admin",
     tags=["credits", "admin"],
-    dependencies=[Security(requires_admin_user)],
+    dependencies=[Depends(requires_admin_user)],
 )
 
 
@@ -28,16 +29,18 @@ async def add_user_credits(
     user_id: typing.Annotated[str, Body()],
     amount: typing.Annotated[int, Body()],
     comments: typing.Annotated[str, Body()],
-    admin_user_id: str = Security(get_user_id),
+    admin_user: typing.Annotated[
+        str,
+        Depends(get_user_id),
+    ],
 ):
-    logger.info(
-        f"Admin user {admin_user_id} is adding {amount} credits to user {user_id}"
-    )
+    """ """
+    logger.info(f"Admin user {admin_user} is adding {amount} credits to user {user_id}")
     new_balance, transaction_key = await _user_credit_model._add_transaction(
         user_id,
         amount,
         transaction_type=CreditTransactionType.GRANT,
-        metadata=SafeJson({"admin_id": admin_user_id, "reason": comments}),
+        metadata=SafeJson({"admin_id": admin_user, "reason": comments}),
     )
     return {
         "new_balance": new_balance,
@@ -51,14 +54,17 @@ async def add_user_credits(
     summary="Get All Users History",
 )
 async def admin_get_all_user_history(
-    admin_user_id: str = Security(get_user_id),
+    admin_user: typing.Annotated[
+        str,
+        Depends(get_user_id),
+    ],
     search: typing.Optional[str] = None,
     page: int = 1,
     page_size: int = 20,
     transaction_filter: typing.Optional[CreditTransactionType] = None,
 ):
     """ """
-    logger.info(f"Admin user {admin_user_id} is getting grant history")
+    logger.info(f"Admin user {admin_user} is getting grant history")
 
     try:
         resp = await admin_get_user_history(
@@ -67,7 +73,7 @@ async def admin_get_all_user_history(
             search=search,
             transaction_filter=transaction_filter,
         )
-        logger.info(f"Admin user {admin_user_id} got {len(resp.history)} grant history")
+        logger.info(f"Admin user {admin_user} got {len(resp.history)} grant history")
         return resp
     except Exception as e:
         logger.exception(f"Error getting grant history: {e}")

autogpt_platform/backend/backend/server/v2/admin/credit_admin_routes_test.py

@@ -1,18 +1,19 @@
 import json
 from unittest.mock import AsyncMock
 
+import autogpt_libs.auth
+import autogpt_libs.auth.depends
 import fastapi
 import fastapi.testclient
 import prisma.enums
-import pytest
 import pytest_mock
-from autogpt_libs.auth.jwt_utils import get_jwt_payload
 from prisma import Json
 from pytest_snapshot.plugin import Snapshot
 
 import backend.server.v2.admin.credit_admin_routes as credit_admin_routes
 import backend.server.v2.admin.model as admin_model
 from backend.data.model import UserTransaction
+from backend.server.conftest import ADMIN_USER_ID, TARGET_USER_ID
 from backend.util.models import Pagination
 
 app = fastapi.FastAPI()
@@ -21,19 +22,25 @@ app.include_router(credit_admin_routes.router)
 client = fastapi.testclient.TestClient(app)
 
 
-@pytest.fixture(autouse=True)
-def setup_app_admin_auth(mock_jwt_admin):
-    """Setup admin auth overrides for all tests in this module"""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_admin["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
+def override_requires_admin_user() -> dict[str, str]:
+    """Override admin user check for testing"""
+    return {"sub": ADMIN_USER_ID, "role": "admin"}
+
+
+def override_get_user_id() -> str:
+    """Override get_user_id for testing"""
+    return ADMIN_USER_ID
+
+
+app.dependency_overrides[autogpt_libs.auth.requires_admin_user] = (
+    override_requires_admin_user
+)
+app.dependency_overrides[autogpt_libs.auth.depends.get_user_id] = override_get_user_id
 
 
 def test_add_user_credits_success(
     mocker: pytest_mock.MockFixture,
     configured_snapshot: Snapshot,
-    admin_user_id: str,
-    target_user_id: str,
 ) -> None:
     """Test successful credit addition by admin"""
     # Mock the credit model
@@ -45,7 +52,7 @@ def test_add_user_credits_success(
     )
 
     request_data = {
-        "user_id": target_user_id,
+        "user_id": TARGET_USER_ID,
         "amount": 500,
         "comments": "Test credit grant for debugging",
     }
@@ -60,12 +67,12 @@ def test_add_user_credits_success(
     # Verify the function was called with correct parameters
     mock_credit_model._add_transaction.assert_called_once()
     call_args = mock_credit_model._add_transaction.call_args
-    assert call_args[0] == (target_user_id, 500)
+    assert call_args[0] == (TARGET_USER_ID, 500)
     assert call_args[1]["transaction_type"] == prisma.enums.CreditTransactionType.GRANT
     # Check that metadata is a Json object with the expected content
     assert isinstance(call_args[1]["metadata"], Json)
     assert call_args[1]["metadata"] == Json(
-        {"admin_id": admin_user_id, "reason": "Test credit grant for debugging"}
+        {"admin_id": ADMIN_USER_ID, "reason": "Test credit grant for debugging"}
     )
 
     # Snapshot test the response
@@ -283,10 +290,18 @@ def test_add_credits_invalid_request() -> None:
     assert response.status_code == 422
 
 
-def test_admin_endpoints_require_admin_role(mock_jwt_user) -> None:
+def test_admin_endpoints_require_admin_role(mocker: pytest_mock.MockFixture) -> None:
     """Test that admin endpoints require admin role"""
-    # Simulate regular non-admin user
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
+    # Clear the admin override to test authorization
+    app.dependency_overrides.clear()
+
+    # Mock requires_admin_user to raise an exception
+    mocker.patch(
+        "autogpt_libs.auth.requires_admin_user",
+        side_effect=fastapi.HTTPException(
+            status_code=403, detail="Admin access required"
+        ),
+    )
 
     # Test add_credits endpoint
     response = client.post(
@@ -297,8 +312,20 @@ def test_admin_endpoints_require_admin_role(mock_jwt_user) -> None:
             "comments": "test",
         },
     )
-    assert response.status_code == 403
+    assert (
+        response.status_code == 401
+    )  # Auth middleware returns 401 when auth is disabled
 
     # Test users_history endpoint
     response = client.get("/admin/users_history")
-    assert response.status_code == 403
+    assert (
+        response.status_code == 401
+    )  # Auth middleware returns 401 when auth is disabled
+
+    # Restore the override
+    app.dependency_overrides[autogpt_libs.auth.requires_admin_user] = (
+        override_requires_admin_user
+    )
+    app.dependency_overrides[autogpt_libs.auth.depends.get_user_id] = (
+        override_get_user_id
+    )

autogpt_platform/backend/backend/server/v2/admin/store_admin_routes.py

@@ -2,28 +2,26 @@ import logging
 import tempfile
 import typing
 
-import autogpt_libs.auth
+import autogpt_libs.auth.depends
 import fastapi
 import fastapi.responses
 import prisma.enums
 
 import backend.server.v2.store.db
+import backend.server.v2.store.exceptions
 import backend.server.v2.store.model
 import backend.util.json
 
 logger = logging.getLogger(__name__)
 
-router = fastapi.APIRouter(
-    prefix="/admin",
-    tags=["store", "admin"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_admin_user)],
-)
+router = fastapi.APIRouter(prefix="/admin", tags=["store", "admin"])
 
 
 @router.get(
     "/listings",
     summary="Get Admin Listings History",
     response_model=backend.server.v2.store.model.StoreListingsWithVersionsResponse,
+    dependencies=[fastapi.Depends(autogpt_libs.auth.depends.requires_admin_user)],
 )
 async def get_admin_listings_with_versions(
     status: typing.Optional[prisma.enums.SubmissionStatus] = None,
@@ -68,11 +66,15 @@ async def get_admin_listings_with_versions(
     "/submissions/{store_listing_version_id}/review",
     summary="Review Store Submission",
     response_model=backend.server.v2.store.model.StoreSubmission,
+    dependencies=[fastapi.Depends(autogpt_libs.auth.depends.requires_admin_user)],
 )
 async def review_submission(
     store_listing_version_id: str,
     request: backend.server.v2.store.model.ReviewSubmissionRequest,
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+    user: typing.Annotated[
+        autogpt_libs.auth.models.User,
+        fastapi.Depends(autogpt_libs.auth.depends.requires_admin_user),
+    ],
 ):
     """
     Review a store listing submission.
@@ -80,7 +82,7 @@ async def review_submission(
     Args:
         store_listing_version_id: ID of the submission to review
         request: Review details including approval status and comments
-        user_id: Authenticated admin user performing the review
+        user: Authenticated admin user performing the review
 
     Returns:
         StoreSubmission with updated review information
@@ -91,7 +93,7 @@ async def review_submission(
             is_approved=request.is_approved,
             external_comments=request.comments,
             internal_comments=request.internal_comments or "",
-            reviewer_id=user_id,
+            reviewer_id=user.user_id,
         )
         return submission
     except Exception as e:
@@ -106,9 +108,13 @@ async def review_submission(
     "/submissions/download/{store_listing_version_id}",
     summary="Admin Download Agent File",
     tags=["store", "admin"],
+    dependencies=[fastapi.Depends(autogpt_libs.auth.depends.requires_admin_user)],
 )
 async def admin_download_agent_file(
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+    user: typing.Annotated[
+        autogpt_libs.auth.models.User,
+        fastapi.Depends(autogpt_libs.auth.depends.requires_admin_user),
+    ],
     store_listing_version_id: str = fastapi.Path(
         ..., description="The ID of the agent to download"
     ),
@@ -126,7 +132,7 @@ async def admin_download_agent_file(
         HTTPException: If the agent is not found or an unexpected error occurs.
     """
     graph_data = await backend.server.v2.store.db.get_agent_as_admin(
-        user_id=user_id,
+        user_id=user.user_id,
         store_listing_version_id=store_listing_version_id,
     )
     file_name = f"agent_{graph_data.id}_v{graph_data.version or 'latest'}.json"

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

@@ -2,7 +2,7 @@ import logging
 from typing import Annotated, Sequence
 
 import fastapi
-from autogpt_libs.auth.dependencies import get_user_id, requires_user
+from autogpt_libs.auth.depends import auth_middleware, get_user_id
 
 import backend.server.v2.builder.db as builder_db
 import backend.server.v2.builder.model as builder_model
@@ -15,9 +15,7 @@ from backend.util.models import Pagination
 
 logger = logging.getLogger(__name__)
 
-router = fastapi.APIRouter(
-    dependencies=[fastapi.Security(requires_user)],
-)
+router = fastapi.APIRouter()
 
 
 # Taken from backend/server/v2/store/db.py
@@ -43,9 +41,12 @@ def sanitize_query(query: str | None) -> str | None:
 @router.get(
     "/suggestions",
     summary="Get Builder suggestions",
+    dependencies=[fastapi.Depends(auth_middleware)],
     response_model=builder_model.SuggestionsResponse,
 )
-async def get_suggestions() -> builder_model.SuggestionsResponse:
+async def get_suggestions(
+    user_id: Annotated[str, fastapi.Depends(get_user_id)],
+) -> builder_model.SuggestionsResponse:
     """
     Get all suggestions for the Blocks Menu.
     """
@@ -75,6 +76,7 @@ async def get_suggestions() -> builder_model.SuggestionsResponse:
 @router.get(
     "/categories",
     summary="Get Builder block categories",
+    dependencies=[fastapi.Depends(auth_middleware)],
     response_model=Sequence[builder_model.BlockCategoryResponse],
 )
 async def get_block_categories(
@@ -89,6 +91,7 @@ async def get_block_categories(
 @router.get(
     "/blocks",
     summary="Get Builder blocks",
+    dependencies=[fastapi.Depends(auth_middleware)],
     response_model=builder_model.BlockResponse,
 )
 async def get_blocks(
@@ -113,6 +116,7 @@ async def get_blocks(
 @router.get(
     "/providers",
     summary="Get Builder integration providers",
+    dependencies=[fastapi.Depends(auth_middleware)],
     response_model=builder_model.ProviderResponse,
 )
 async def get_providers(
@@ -132,11 +136,12 @@ async def get_providers(
     "/search",
     summary="Builder search",
     tags=["store", "private"],
+    dependencies=[fastapi.Depends(auth_middleware)],
     response_model=builder_model.SearchResponse,
 )
 async def search(
     options: builder_model.SearchRequest,
-    user_id: Annotated[str, fastapi.Security(get_user_id)],
+    user_id: Annotated[str, fastapi.Depends(get_user_id)],
 ) -> builder_model.SearchResponse:
     """
     Search for blocks (including integrations), marketplace agents, and user library agents.
@@ -222,10 +227,11 @@ async def search(
 @router.get(
     "/counts",
     summary="Get Builder item counts",
+    dependencies=[fastapi.Depends(auth_middleware)],
     response_model=builder_model.CountResponse,
 )
 async def get_counts(
-    user_id: Annotated[str, fastapi.Security(get_user_id)],
+    user_id: Annotated[str, fastapi.Depends(get_user_id)],
 ) -> builder_model.CountResponse:
     """
     Get item counts for the menu categories in the Blocks Menu.

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

@@ -1,5 +1,6 @@
 import datetime
 
+import prisma.fields
 import prisma.models
 import pytest
 
@@ -7,7 +8,7 @@ import backend.server.v2.library.model as library_model
 
 
 @pytest.mark.asyncio
-async def test_agent_preset_from_db(test_user_id: str):
+async def test_agent_preset_from_db():
     # Create mock DB agent
     db_agent = prisma.models.AgentPreset(
         id="test-agent-123",
@@ -18,7 +19,7 @@ async def test_agent_preset_from_db(test_user_id: str):
         name="Test Agent",
         description="Test agent description",
         isActive=True,
-        userId=test_user_id,
+        userId="test-user-123",
         isDeleted=False,
         InputPresets=[
             prisma.models.AgentNodeExecutionInputOutput.model_validate(

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

@@ -2,7 +2,7 @@ import logging
 from typing import Optional
 
 import autogpt_libs.auth as autogpt_auth_lib
-from fastapi import APIRouter, Body, HTTPException, Query, Security, status
+from fastapi import APIRouter, Body, Depends, HTTPException, Query, status
 from fastapi.responses import Response
 
 import backend.server.v2.library.db as library_db
@@ -15,7 +15,7 @@ logger = logging.getLogger(__name__)
 router = APIRouter(
     prefix="/agents",
     tags=["library", "private"],
-    dependencies=[Security(autogpt_auth_lib.requires_user)],
+    dependencies=[Depends(autogpt_auth_lib.auth_middleware)],
 )
 
 
@@ -27,7 +27,7 @@ router = APIRouter(
     },
 )
 async def list_library_agents(
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
     search_term: Optional[str] = Query(
         None, description="Search term to filter agents"
     ),
@@ -82,7 +82,7 @@ async def list_library_agents(
 @router.get("/{library_agent_id}", summary="Get Library Agent")
 async def get_library_agent(
     library_agent_id: str,
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    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)
 
@@ -91,7 +91,7 @@ async def get_library_agent(
 async def get_library_agent_by_graph_id(
     graph_id: str,
     version: Optional[int] = Query(default=None),
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
 ) -> library_model.LibraryAgent:
     library_agent = await library_db.get_library_agent_by_graph_id(
         user_id, graph_id, version
@@ -111,7 +111,7 @@ async def get_library_agent_by_graph_id(
 )
 async def get_library_agent_by_store_listing_version_id(
     store_listing_version_id: str,
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
 ) -> library_model.LibraryAgent | None:
     """
     Get Library Agent from Store Listing Version ID.
@@ -145,7 +145,7 @@ async def get_library_agent_by_store_listing_version_id(
 )
 async def add_marketplace_agent_to_library(
     store_listing_version_id: str = Body(embed=True),
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    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.
@@ -201,7 +201,7 @@ async def add_marketplace_agent_to_library(
 async def update_library_agent(
     library_agent_id: str,
     payload: library_model.LibraryAgentUpdateRequest,
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
 ) -> library_model.LibraryAgent:
     """
     Update the library agent with the given fields.
@@ -252,7 +252,7 @@ async def update_library_agent(
 )
 async def delete_library_agent(
     library_agent_id: str,
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
 ) -> Response:
     """
     Soft-delete the specified library agent.
@@ -283,7 +283,7 @@ async def delete_library_agent(
 @router.post("/{library_agent_id}/fork", summary="Fork Library Agent")
 async def fork_library_agent(
     library_agent_id: str,
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
 ) -> library_model.LibraryAgent:
     return await library_db.fork_library_agent(
         library_agent_id=library_agent_id,

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

@@ -2,7 +2,7 @@ import logging
 from typing import Any, Optional
 
 import autogpt_libs.auth as autogpt_auth_lib
-from fastapi import APIRouter, Body, HTTPException, Query, Security, status
+from fastapi import APIRouter, Body, Depends, HTTPException, Query, status
 
 import backend.server.v2.library.db as db
 import backend.server.v2.library.model as models
@@ -17,10 +17,7 @@ from backend.util.exceptions import NotFoundError
 logger = logging.getLogger(__name__)
 
 credentials_manager = IntegrationCredentialsManager()
-router = APIRouter(
-    tags=["presets"],
-    dependencies=[Security(autogpt_auth_lib.requires_user)],
-)
+router = APIRouter(tags=["presets"])
 
 
 @router.get(
@@ -29,7 +26,7 @@ router = APIRouter(
     description="Retrieve a paginated list of presets for the current user.",
 )
 async def list_presets(
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
     page: int = Query(default=1, ge=1),
     page_size: int = Query(default=10, ge=1),
     graph_id: Optional[str] = Query(
@@ -69,7 +66,7 @@ async def list_presets(
 )
 async def get_preset(
     preset_id: str,
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
 ) -> models.LibraryAgentPreset:
     """
     Retrieve details for a specific preset by its ID.
@@ -112,7 +109,7 @@ async def create_preset(
         models.LibraryAgentPresetCreatable
         | models.LibraryAgentPresetCreatableFromGraphExecution
     ),
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    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.
@@ -144,7 +141,7 @@ async def create_preset(
 @router.post("/presets/setup-trigger")
 async def setup_trigger(
     params: models.TriggeredPresetSetupRequest = Body(),
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
 ) -> models.LibraryAgentPreset:
     """
     Sets up a webhook-triggered `LibraryAgentPreset` for a `LibraryAgent`.
@@ -209,7 +206,7 @@ async def setup_trigger(
 async def update_preset(
     preset_id: str,
     preset: models.LibraryAgentPresetUpdatable,
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
 ) -> models.LibraryAgentPreset:
     """
     Update an existing library agent preset.
@@ -313,7 +310,7 @@ async def update_preset(
 )
 async def delete_preset(
     preset_id: str,
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
 ) -> None:
     """
     Delete a preset by its ID. Returns 204 No Content on success.
@@ -367,7 +364,7 @@ async def delete_preset(
 )
 async def execute_preset(
     preset_id: str,
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
+    user_id: str = Depends(autogpt_auth_lib.depends.get_user_id),
     inputs: dict[str, Any] = Body(..., embed=True, default_factory=dict),
 ) -> dict[str, Any]:  # FIXME: add proper return type
     """

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

@@ -1,6 +1,7 @@
 import datetime
 import json
 
+import autogpt_libs.auth as autogpt_auth_lib
 import fastapi.testclient
 import pytest
 import pytest_mock
@@ -18,21 +19,24 @@ client = fastapi.testclient.TestClient(app)
 FIXED_NOW = datetime.datetime(2023, 1, 1, 0, 0, 0)
 
 
-@pytest.fixture(autouse=True)
-def setup_app_auth(mock_jwt_user):
-    """Setup auth overrides for all tests in this module"""
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
+def override_auth_middleware():
+    """Override auth middleware for testing"""
+    return {"sub": "test-user-id"}
 
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
+
+def override_get_user_id():
+    """Override get_user_id for testing"""
+    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
 
 
 @pytest.mark.asyncio
 async def test_get_library_agents_success(
     mocker: pytest_mock.MockFixture,
     snapshot: Snapshot,
-    test_user_id: str,
 ) -> None:
     mocked_value = library_model.LibraryAgentResponse(
         agents=[
@@ -96,7 +100,7 @@ async def test_get_library_agents_success(
     snapshot.assert_match(json.dumps(response.json(), indent=2), "lib_agts_search")
 
     mock_db_call.assert_called_once_with(
-        user_id=test_user_id,
+        user_id="test-user-id",
         search_term="test",
         sort_by=library_model.LibraryAgentSort.UPDATED_AT,
         page=1,
@@ -104,14 +108,14 @@ async def test_get_library_agents_success(
     )
 
 
-def test_get_library_agents_error(mocker: pytest_mock.MockFixture, test_user_id: str):
+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.side_effect = Exception("Test error")
 
     response = client.get("/agents?search_term=test")
     assert response.status_code == 500
     mock_db_call.assert_called_once_with(
-        user_id=test_user_id,
+        user_id="test-user-id",
         search_term="test",
         sort_by=library_model.LibraryAgentSort.UPDATED_AT,
         page=1,
@@ -119,9 +123,7 @@ def test_get_library_agents_error(mocker: pytest_mock.MockFixture, test_user_id:
     )
 
 
-def test_add_agent_to_library_success(
-    mocker: pytest_mock.MockFixture, test_user_id: str
-):
+def test_add_agent_to_library_success(mocker: pytest_mock.MockFixture):
     mock_library_agent = library_model.LibraryAgent(
         id="test-library-agent-id",
         graph_id="test-agent-1",
@@ -158,11 +160,11 @@ def test_add_agent_to_library_success(
     assert data.graph_id == "test-agent-1"
 
     mock_db_call.assert_called_once_with(
-        store_listing_version_id="test-version-id", user_id=test_user_id
+        store_listing_version_id="test-version-id", user_id="test-user-id"
     )
 
 
-def test_add_agent_to_library_error(mocker: pytest_mock.MockFixture, test_user_id: str):
+def test_add_agent_to_library_error(mocker: pytest_mock.MockFixture):
     mock_db_call = mocker.patch(
         "backend.server.v2.library.db.add_store_agent_to_library"
     )
@@ -174,5 +176,5 @@ def test_add_agent_to_library_error(mocker: pytest_mock.MockFixture, test_user_i
     assert response.status_code == 500
     assert "detail" in response.json()  # Verify error response structure
     mock_db_call.assert_called_once_with(
-        store_listing_version_id="test-version-id", user_id=test_user_id
+        store_listing_version_id="test-version-id", user_id="test-user-id"
     )

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

@@ -1,7 +1,9 @@
 import logging
 
-from autogpt_libs.auth import get_user_id, requires_user
-from fastapi import APIRouter, HTTPException, Security
+from autogpt_libs.auth.middleware import auth_middleware
+from fastapi import APIRouter, Depends, HTTPException
+
+from backend.server.utils import get_user_id
 
 from .models import ApiResponse, ChatRequest
 from .service import OttoService
@@ -14,11 +16,11 @@ router = APIRouter()
 @router.post(
     "/ask",
     response_model=ApiResponse,
-    dependencies=[Security(requires_user)],
+    dependencies=[Depends(auth_middleware)],
     summary="Proxy Otto Chat Request",
 )
 async def proxy_otto_request(
-    request: ChatRequest, user_id: str = Security(get_user_id)
+    request: ChatRequest, user_id: str = Depends(get_user_id)
 ) -> ApiResponse:
     """
     Proxy requests to Otto API while adding necessary security headers and logging.

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

@@ -1,13 +1,15 @@
 import json
 
+import autogpt_libs.auth.depends
+import autogpt_libs.auth.middleware
 import fastapi
 import fastapi.testclient
-import pytest
 import pytest_mock
 from pytest_snapshot.plugin import Snapshot
 
 import backend.server.v2.otto.models as otto_models
 import backend.server.v2.otto.routes as otto_routes
+from backend.server.utils import get_user_id
 from backend.server.v2.otto.service import OttoService
 
 app = fastapi.FastAPI()
@@ -16,14 +18,20 @@ app.include_router(otto_routes.router)
 client = fastapi.testclient.TestClient(app)
 
 
-@pytest.fixture(autouse=True)
-def setup_app_auth(mock_jwt_user):
-    """Setup auth overrides for all tests in this module"""
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
+def override_auth_middleware():
+    """Override auth middleware for testing"""
+    return {"sub": "test-user-id"}
 
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
+
+def override_get_user_id():
+    """Override get_user_id for testing"""
+    return "test-user-id"
+
+
+app.dependency_overrides[autogpt_libs.auth.middleware.auth_middleware] = (
+    override_auth_middleware
+)
+app.dependency_overrides[get_user_id] = override_get_user_id
 
 
 def test_ask_otto_success(
@@ -233,14 +241,31 @@ def test_ask_otto_invalid_request() -> None:
     assert response.status_code == 422
 
 
-def test_ask_otto_unconfigured() -> None:
-    """Test Otto API request without configuration"""
+def test_ask_otto_unauthenticated(mocker: pytest_mock.MockFixture) -> None:
+    """Test Otto API request without authentication"""
+    # Remove the auth override to test unauthenticated access
+    app.dependency_overrides.clear()
+
+    # Mock auth_middleware to raise an exception
+    mocker.patch(
+        "autogpt_libs.auth.middleware.auth_middleware",
+        side_effect=fastapi.HTTPException(status_code=401, detail="Unauthorized"),
+    )
+
     request_data = {
         "query": "Test",
         "conversation_history": [],
         "message_id": "123",
     }
 
-    # When Otto API URL is not configured, we get 502
     response = client.post("/ask", json=request_data)
+    # When auth is disabled and Otto API URL is not configured, we get 502 (wrapped from 503)
     assert response.status_code == 502
+
+    # Restore the override
+    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
+    )

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

@@ -1171,7 +1171,10 @@ async def get_my_agents(
         ) from e
 
 
-async def get_agent(store_listing_version_id: str) -> GraphModel:
+async def get_agent(
+    user_id: str | None,
+    store_listing_version_id: str,
+) -> GraphModel:
     """Get agent using the version ID and store listing version ID."""
     store_listing_version = (
         await prisma.models.StoreListingVersion.prisma().find_unique(
@@ -1183,6 +1186,7 @@ async def get_agent(store_listing_version_id: str) -> GraphModel:
         raise ValueError(f"Store listing version {store_listing_version_id} not found")
 
     graph = await get_graph(
+        user_id=user_id,
         graph_id=store_listing_version.agentGraphId,
         version=store_listing_version.agentGraphVersion,
         for_export=True,

autogpt_platform/backend/backend/server/v2/store/image_gen.py

@@ -82,7 +82,7 @@ async def generate_agent_image_v2(graph: BaseGraph | AgentGraph) -> io.BytesIO:
                 type=ideogram_credentials.type,
             ),
             prompt=prompt,
-            ideogram_model_name=IdeogramModelName.V3,
+            ideogram_model_name=IdeogramModelName.V2,
             aspect_ratio=AspectRatio.ASPECT_16_9,
             magic_prompt_option=MagicPromptOption.OFF,
             style_type=StyleType.AUTO,

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

@@ -3,10 +3,13 @@ import tempfile
 import typing
 import urllib.parse
 
-import autogpt_libs.auth
+import autogpt_libs.auth.depends
+import autogpt_libs.auth.middleware
 import fastapi
 import fastapi.responses
+from autogpt_libs.auth.depends import auth_middleware, get_user_id
 
+import backend.data.block
 import backend.data.graph
 import backend.server.v2.store.db
 import backend.server.v2.store.exceptions
@@ -29,11 +32,12 @@ router = fastapi.APIRouter()
     "/profile",
     summary="Get user profile",
     tags=["store", "private"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
     response_model=backend.server.v2.store.model.ProfileDetails,
 )
 async def get_profile(
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+    user_id: typing.Annotated[
+        str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)
+    ],
 ):
     """
     Get the profile details for the authenticated user.
@@ -61,12 +65,14 @@ async def get_profile(
     "/profile",
     summary="Update user profile",
     tags=["store", "private"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
+    dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],
     response_model=backend.server.v2.store.model.CreatorDetails,
 )
 async def update_or_create_profile(
     profile: backend.server.v2.store.model.Profile,
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+    user_id: typing.Annotated[
+        str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)
+    ],
 ):
     """
     Update the store profile for the authenticated user.
@@ -209,9 +215,11 @@ async def get_agent(username: str, agent_name: str):
     "/graph/{store_listing_version_id}",
     summary="Get agent graph",
     tags=["store"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
 )
-async def get_graph_meta_by_store_listing_version_id(store_listing_version_id: str):
+async def get_graph_meta_by_store_listing_version_id(
+    store_listing_version_id: str,
+    _: typing.Annotated[str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)],
+):
     """
     Get Agent Graph from Store Listing Version ID.
     """
@@ -232,10 +240,12 @@ async def get_graph_meta_by_store_listing_version_id(store_listing_version_id: s
     "/agents/{store_listing_version_id}",
     summary="Get agent by version",
     tags=["store"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
     response_model=backend.server.v2.store.model.StoreAgentDetails,
 )
-async def get_store_agent(store_listing_version_id: str):
+async def get_store_agent(
+    store_listing_version_id: str,
+    _: typing.Annotated[str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)],
+):
     """
     Get Store Agent Details from Store Listing Version ID.
     """
@@ -256,14 +266,16 @@ async def get_store_agent(store_listing_version_id: str):
     "/agents/{username}/{agent_name}/review",
     summary="Create agent review",
     tags=["store"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
+    dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],
     response_model=backend.server.v2.store.model.StoreReview,
 )
 async def create_review(
     username: str,
     agent_name: str,
     review: backend.server.v2.store.model.StoreReviewCreate,
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+    user_id: typing.Annotated[
+        str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)
+    ],
 ):
     """
     Create a review for a store agent.
@@ -390,11 +402,13 @@ async def get_creator(
     "/myagents",
     summary="Get my agents",
     tags=["store", "private"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
+    dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],
     response_model=backend.server.v2.store.model.MyAgentsResponse,
 )
 async def get_my_agents(
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+    user_id: typing.Annotated[
+        str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)
+    ],
     page: typing.Annotated[int, fastapi.Query(ge=1)] = 1,
     page_size: typing.Annotated[int, fastapi.Query(ge=1)] = 20,
 ):
@@ -415,12 +429,14 @@ async def get_my_agents(
     "/submissions/{submission_id}",
     summary="Delete store submission",
     tags=["store", "private"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
+    dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],
     response_model=bool,
 )
 async def delete_submission(
+    user_id: typing.Annotated[
+        str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)
+    ],
     submission_id: str,
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
 ):
     """
     Delete a store listing submission.
@@ -450,11 +466,13 @@ async def delete_submission(
     "/submissions",
     summary="List my submissions",
     tags=["store", "private"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
+    dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],
     response_model=backend.server.v2.store.model.StoreSubmissionsResponse,
 )
 async def get_submissions(
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+    user_id: typing.Annotated[
+        str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)
+    ],
     page: int = 1,
     page_size: int = 20,
 ):
@@ -502,12 +520,14 @@ async def get_submissions(
     "/submissions",
     summary="Create store submission",
     tags=["store", "private"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
+    dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],
     response_model=backend.server.v2.store.model.StoreSubmission,
 )
 async def create_submission(
     submission_request: backend.server.v2.store.model.StoreSubmissionRequest,
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+    user_id: typing.Annotated[
+        str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)
+    ],
 ):
     """
     Create a new store listing submission.
@@ -548,13 +568,15 @@ async def create_submission(
     "/submissions/{store_listing_version_id}",
     summary="Edit store submission",
     tags=["store", "private"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
+    dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],
     response_model=backend.server.v2.store.model.StoreSubmission,
 )
 async def edit_submission(
     store_listing_version_id: str,
     submission_request: backend.server.v2.store.model.StoreSubmissionEditRequest,
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+    user_id: typing.Annotated[
+        str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)
+    ],
 ):
     """
     Edit an existing store listing submission.
@@ -587,11 +609,13 @@ async def edit_submission(
     "/submissions/media",
     summary="Upload submission media",
     tags=["store", "private"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
+    dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],
 )
 async def upload_submission_media(
     file: fastapi.UploadFile,
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+    user_id: typing.Annotated[
+        str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)
+    ],
 ):
     """
     Upload media (images/videos) for a store listing submission.
@@ -642,11 +666,13 @@ async def upload_submission_media(
     "/submissions/generate_image",
     summary="Generate submission image",
     tags=["store", "private"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
+    dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],
 )
 async def generate_image(
     agent_id: str,
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
+    user_id: typing.Annotated[
+        str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)
+    ],
 ) -> fastapi.responses.Response:
     """
     Generate an image for a store listing submission.
@@ -704,6 +730,7 @@ async def generate_image(
     tags=["store", "public"],
 )
 async def download_agent_file(
+    request: fastapi.Request,
     store_listing_version_id: str = fastapi.Path(
         ..., description="The ID of the agent to download"
     ),
@@ -720,7 +747,15 @@ async def download_agent_file(
     Raises:
         HTTPException: If the agent is not found or an unexpected error occurs.
     """
-    graph_data = await backend.server.v2.store.db.get_agent(store_listing_version_id)
+    try:
+        user_id = get_user_id(await auth_middleware(request))
+    except fastapi.HTTPException:
+        user_id = None
+
+    graph_data = await backend.server.v2.store.db.get_agent(
+        user_id=user_id,
+        store_listing_version_id=store_listing_version_id,
+    )
     file_name = f"agent_{graph_data.id}_v{graph_data.version or 'latest'}.json"
 
     # Sending graph as a stream (similar to marketplace v1)

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

@@ -1,10 +1,11 @@
 import datetime
 import json
 
+import autogpt_libs.auth.depends
+import autogpt_libs.auth.middleware
 import fastapi
 import fastapi.testclient
 import prisma.enums
-import pytest
 import pytest_mock
 from pytest_snapshot.plugin import Snapshot
 
@@ -21,14 +22,20 @@ app.include_router(backend.server.v2.store.routes.router)
 client = fastapi.testclient.TestClient(app)
 
 
-@pytest.fixture(autouse=True)
-def setup_app_auth(mock_jwt_user):
-    """Setup auth overrides for all tests in this module"""
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
+def override_auth_middleware() -> dict[str, str]:
+    """Override auth middleware for testing"""
+    return {"sub": "test-user-id"}
 
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
+
+def override_get_user_id() -> str:
+    """Override get_user_id for testing"""
+    return "test-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
 
 
 def test_get_agents_defaults(
@@ -529,7 +536,6 @@ def test_get_creator_details(
 def test_get_submissions_success(
     mocker: pytest_mock.MockFixture,
     snapshot: Snapshot,
-    test_user_id: str,
 ) -> None:
     mocked_value = backend.server.v2.store.model.StoreSubmissionsResponse(
         submissions=[
@@ -570,13 +576,12 @@ def test_get_submissions_success(
     assert data.pagination.current_page == 1
     snapshot.snapshot_dir = "snapshots"
     snapshot.assert_match(json.dumps(response.json(), indent=2), "sub_success")
-    mock_db_call.assert_called_once_with(user_id=test_user_id, page=1, page_size=20)
+    mock_db_call.assert_called_once_with(user_id="test-user-id", page=1, page_size=20)
 
 
 def test_get_submissions_pagination(
     mocker: pytest_mock.MockFixture,
     snapshot: Snapshot,
-    test_user_id: str,
 ) -> None:
     mocked_value = backend.server.v2.store.model.StoreSubmissionsResponse(
         submissions=[],
@@ -600,7 +605,7 @@ def test_get_submissions_pagination(
     assert data.pagination.page_size == 5
     snapshot.snapshot_dir = "snapshots"
     snapshot.assert_match(json.dumps(response.json(), indent=2), "sub_pagination")
-    mock_db_call.assert_called_once_with(user_id=test_user_id, page=2, page_size=5)
+    mock_db_call.assert_called_once_with(user_id="test-user-id", page=2, page_size=5)
 
 
 def test_get_submissions_malformed_request(mocker: pytest_mock.MockFixture):

autogpt_platform/backend/backend/server/ws_api.py

@@ -5,7 +5,7 @@ from typing import Protocol
 
 import pydantic
 import uvicorn
-from autogpt_libs.auth.jwt_utils import parse_jwt_token
+from autogpt_libs.auth import parse_jwt_token
 from fastapi import Depends, FastAPI, WebSocket, WebSocketDisconnect
 from starlette.middleware.cors import CORSMiddleware
 

autogpt_platform/backend/backend/util/test.py

@@ -4,8 +4,6 @@ import time
 import uuid
 from typing import Sequence, cast
 
-from autogpt_libs.auth import get_user_id
-
 from backend.data import db
 from backend.data.block import Block, BlockSchema, initialize_blocks
 from backend.data.execution import (
@@ -19,6 +17,7 @@ from backend.data.user import create_default_user
 from backend.executor import DatabaseManager, ExecutionManager, Scheduler
 from backend.notifications.notifications import NotificationManager
 from backend.server.rest_api import AgentServer
+from backend.server.utils import get_user_id
 
 log = logging.getLogger(__name__)
 

autogpt_platform/backend/poetry.lock

@@ -409,7 +409,9 @@ google-cloud-logging = "^3.12.1"
 launchdarkly-server-sdk = "^9.12.0"
 pydantic = "^2.11.7"
 pydantic-settings = "^2.10.1"
-pyjwt = {version = "^2.10.1", extras = ["crypto"]}
+pyjwt = "^2.10.1"
+pytest-asyncio = "^1.1.0"
+pytest-mock = "^3.14.1"
 redis = "^6.2.0"
 supabase = "^2.16.0"
 uvicorn = "^0.35.0"
@@ -526,26 +528,6 @@ webencodings = "*"
 [package.extras]
 css = ["tinycss2 (>=1.1.0,<1.5)"]
 
-[[package]]
-name = "browserbase"
-version = "1.4.0"
-description = "The official Python library for the Browserbase API"
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-files = [
-    {file = "browserbase-1.4.0-py3-none-any.whl", hash = "sha256:ea9f1fb4a88921975b8b9606835c441a59d8ce82ce00313a6d48bbe8e30f79fb"},
-    {file = "browserbase-1.4.0.tar.gz", hash = "sha256:e2ed36f513c8630b94b826042c4bb9f497c333f3bd28e5b76cb708c65b4318a0"},
-]
-
-[package.dependencies]
-anyio = ">=3.5.0,<5"
-distro = ">=1.7.0,<2"
-httpx = ">=0.23.0,<1"
-pydantic = ">=1.9.0,<3"
-sniffio = "*"
-typing-extensions = ">=4.10,<5"
-
 [[package]]
 name = "build"
 version = "1.2.2.post1"
@@ -866,7 +848,7 @@ files = [
     {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
     {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
 ]
-markers = {dev = "platform_system == \"Windows\" or sys_platform == \"win32\""}
+markers = {dev = "sys_platform == \"win32\" or platform_system == \"Windows\""}
 
 [[package]]
 name = "crashtest"
@@ -1229,14 +1211,14 @@ tests = ["coverage", "coveralls", "dill", "mock", "nose"]
 
 [[package]]
 name = "faker"
-version = "37.6.0"
+version = "37.4.2"
 description = "Faker is a Python package that generates fake data for you."
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
 files = [
-    {file = "faker-37.6.0-py3-none-any.whl", hash = "sha256:3c5209b23d7049d596a51db5d76403a0ccfea6fc294ffa2ecfef6a8843b1e6a7"},
-    {file = "faker-37.6.0.tar.gz", hash = "sha256:0f8cc34f30095184adf87c3c24c45b38b33ad81c35ef6eb0a3118f301143012c"},
+    {file = "faker-37.4.2-py3-none-any.whl", hash = "sha256:b70ed1af57bfe988cbcd0afd95f4768c51eaf4e1ce8a30962e127ac5c139c93f"},
+    {file = "faker-37.4.2.tar.gz", hash = "sha256:8e281bbaea30e5658895b8bea21cc50d27aaf3a43db3f2694409ca5701c56b0a"},
 ]
 
 [package.dependencies]
@@ -1477,46 +1459,6 @@ files = [
     {file = "frozenlist-1.7.0.tar.gz", hash = "sha256:2e310d81923c2437ea8670467121cc3e9b0f76d3043cc1d2331d56c7fb7a3a8f"},
 ]
 
-[[package]]
-name = "fsspec"
-version = "2025.7.0"
-description = "File-system specification"
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "fsspec-2025.7.0-py3-none-any.whl", hash = "sha256:8b012e39f63c7d5f10474de957f3ab793b47b45ae7d39f2fb735f8bbe25c0e21"},
-    {file = "fsspec-2025.7.0.tar.gz", hash = "sha256:786120687ffa54b8283d942929540d8bc5ccfa820deb555a2b5d0ed2b737bf58"},
-]
-
-[package.extras]
-abfs = ["adlfs"]
-adl = ["adlfs"]
-arrow = ["pyarrow (>=1)"]
-dask = ["dask", "distributed"]
-dev = ["pre-commit", "ruff (>=0.5)"]
-doc = ["numpydoc", "sphinx", "sphinx-design", "sphinx-rtd-theme", "yarl"]
-dropbox = ["dropbox", "dropboxdrivefs", "requests"]
-full = ["adlfs", "aiohttp (!=4.0.0a0,!=4.0.0a1)", "dask", "distributed", "dropbox", "dropboxdrivefs", "fusepy", "gcsfs", "libarchive-c", "ocifs", "panel", "paramiko", "pyarrow (>=1)", "pygit2", "requests", "s3fs", "smbprotocol", "tqdm"]
-fuse = ["fusepy"]
-gcs = ["gcsfs"]
-git = ["pygit2"]
-github = ["requests"]
-gs = ["gcsfs"]
-gui = ["panel"]
-hdfs = ["pyarrow (>=1)"]
-http = ["aiohttp (!=4.0.0a0,!=4.0.0a1)"]
-libarchive = ["libarchive-c"]
-oci = ["ocifs"]
-s3 = ["s3fs"]
-sftp = ["paramiko"]
-smb = ["smbprotocol"]
-ssh = ["paramiko"]
-test = ["aiohttp (!=4.0.0a0,!=4.0.0a1)", "numpy", "pytest", "pytest-asyncio (!=0.22.0)", "pytest-benchmark", "pytest-cov", "pytest-mock", "pytest-recording", "pytest-rerunfailures", "requests"]
-test-downstream = ["aiobotocore (>=2.5.4,<3.0.0)", "dask[dataframe,test]", "moto[server] (>4,<5)", "pytest-timeout", "xarray"]
-test-full = ["adlfs", "aiohttp (!=4.0.0a0,!=4.0.0a1)", "cloudpickle", "dask", "distributed", "dropbox", "dropboxdrivefs", "fastparquet", "fusepy", "gcsfs", "jinja2", "kerchunk", "libarchive-c", "lz4", "notebook", "numpy", "ocifs", "pandas", "panel", "paramiko", "pyarrow", "pyarrow (>=1)", "pyftpdlib", "pygit2", "pytest", "pytest-asyncio (!=0.22.0)", "pytest-benchmark", "pytest-cov", "pytest-mock", "pytest-recording", "pytest-rerunfailures", "python-snappy", "requests", "smbprotocol", "tqdm", "urllib3", "zarr", "zstandard ; python_version < \"3.14\""]
-tqdm = ["tqdm"]
-
 [[package]]
 name = "gcloud-aio-auth"
 version = "5.4.2"
@@ -1918,6 +1860,7 @@ description = "Lightweight in-process concurrent programming"
 optional = false
 python-versions = ">=3.9"
 groups = ["main"]
+markers = "platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\""
 files = [
     {file = "greenlet-3.2.3-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:1afd685acd5597349ee6d7a88a8bec83ce13c106ac78c196ee9dde7c04fe87be"},
     {file = "greenlet-3.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:761917cac215c61e9dc7324b2606107b3b292a8349bdebb31503ab4de3f559ac"},
@@ -2128,28 +2071,6 @@ files = [
 hpack = ">=4.1,<5"
 hyperframe = ">=6.1,<7"
 
-[[package]]
-name = "hf-xet"
-version = "1.1.8"
-description = "Fast transfer of large files with the Hugging Face Hub."
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-markers = "platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"arm64\" or platform_machine == \"aarch64\""
-files = [
-    {file = "hf_xet-1.1.8-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:3d5f82e533fc51c7daad0f9b655d9c7811b5308e5890236828bd1dd3ed8fea74"},
-    {file = "hf_xet-1.1.8-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:8e2dba5896bca3ab61d0bef4f01a1647004de59640701b37e37eaa57087bbd9d"},
-    {file = "hf_xet-1.1.8-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bfe5700bc729be3d33d4e9a9b5cc17a951bf8c7ada7ba0c9198a6ab2053b7453"},
-    {file = "hf_xet-1.1.8-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:09e86514c3c4284ed8a57d6b0f3d089f9836a0af0a1ceb3c9dd664f1f3eaefef"},
-    {file = "hf_xet-1.1.8-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4a9b99ab721d385b83f4fc8ee4e0366b0b59dce03b5888a86029cc0ca634efbf"},
-    {file = "hf_xet-1.1.8-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:25b9d43333bbef39aeae1616789ec329c21401a7fe30969d538791076227b591"},
-    {file = "hf_xet-1.1.8-cp37-abi3-win_amd64.whl", hash = "sha256:4171f31d87b13da4af1ed86c98cf763292e4720c088b4957cf9d564f92904ca9"},
-    {file = "hf_xet-1.1.8.tar.gz", hash = "sha256:62a0043e441753bbc446dcb5a3fe40a4d03f5fb9f13589ef1df9ab19252beb53"},
-]
-
-[package.extras]
-tests = ["pytest"]
-
 [[package]]
 name = "hpack"
 version = "4.1.0"
@@ -2292,45 +2213,6 @@ http2 = ["h2 (>=3,<5)"]
 socks = ["socksio (==1.*)"]
 zstd = ["zstandard (>=0.18.0)"]
 
-[[package]]
-name = "huggingface-hub"
-version = "0.34.4"
-description = "Client library to download and publish models, datasets and other repos on the huggingface.co hub"
-optional = false
-python-versions = ">=3.8.0"
-groups = ["main"]
-files = [
-    {file = "huggingface_hub-0.34.4-py3-none-any.whl", hash = "sha256:9b365d781739c93ff90c359844221beef048403f1bc1f1c123c191257c3c890a"},
-    {file = "huggingface_hub-0.34.4.tar.gz", hash = "sha256:a4228daa6fb001be3f4f4bdaf9a0db00e1739235702848df00885c9b5742c85c"},
-]
-
-[package.dependencies]
-filelock = "*"
-fsspec = ">=2023.5.0"
-hf-xet = {version = ">=1.1.3,<2.0.0", markers = "platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"arm64\" or platform_machine == \"aarch64\""}
-packaging = ">=20.9"
-pyyaml = ">=5.1"
-requests = "*"
-tqdm = ">=4.42.1"
-typing-extensions = ">=3.7.4.3"
-
-[package.extras]
-all = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "authlib (>=1.3.2)", "fastapi", "gradio (>=4.0.0)", "httpx", "itsdangerous", "jedi", "libcst (>=1.4.0)", "mypy (==1.15.0) ; python_version >= \"3.9\"", "mypy (>=1.14.1,<1.15.0) ; python_version == \"3.8\"", "numpy", "pytest (>=8.1.1,<8.2.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures", "pytest-vcr", "pytest-xdist", "ruff (>=0.9.0)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)", "urllib3 (<2.0)"]
-cli = ["InquirerPy (==0.3.4)"]
-dev = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "authlib (>=1.3.2)", "fastapi", "gradio (>=4.0.0)", "httpx", "itsdangerous", "jedi", "libcst (>=1.4.0)", "mypy (==1.15.0) ; python_version >= \"3.9\"", "mypy (>=1.14.1,<1.15.0) ; python_version == \"3.8\"", "numpy", "pytest (>=8.1.1,<8.2.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures", "pytest-vcr", "pytest-xdist", "ruff (>=0.9.0)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)", "urllib3 (<2.0)"]
-fastai = ["fastai (>=2.4)", "fastcore (>=1.3.27)", "toml"]
-hf-transfer = ["hf-transfer (>=0.1.4)"]
-hf-xet = ["hf-xet (>=1.1.2,<2.0.0)"]
-inference = ["aiohttp"]
-mcp = ["aiohttp", "mcp (>=1.8.0)", "typer"]
-oauth = ["authlib (>=1.3.2)", "fastapi", "httpx", "itsdangerous"]
-quality = ["libcst (>=1.4.0)", "mypy (==1.15.0) ; python_version >= \"3.9\"", "mypy (>=1.14.1,<1.15.0) ; python_version == \"3.8\"", "ruff (>=0.9.0)"]
-tensorflow = ["graphviz", "pydot", "tensorflow"]
-tensorflow-testing = ["keras (<3.0)", "tensorflow"]
-testing = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "authlib (>=1.3.2)", "fastapi", "gradio (>=4.0.0)", "httpx", "itsdangerous", "jedi", "numpy", "pytest (>=8.1.1,<8.2.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures", "pytest-vcr", "pytest-xdist", "soundfile", "urllib3 (<2.0)"]
-torch = ["safetensors[torch]", "torch"]
-typing = ["types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)"]
-
 [[package]]
 name = "hyperframe"
 version = "6.1.0"
@@ -2790,62 +2672,6 @@ dynamodb = ["boto3 (>=1.9.71)"]
 redis = ["redis (>=2.10.5)"]
 test-filesource = ["pyyaml (>=5.3.1)", "watchdog (>=3.0.0)"]
 
-[[package]]
-name = "litellm"
-version = "1.74.15.post2"
-description = "Library to easily interface with LLM API providers"
-optional = false
-python-versions = "!=2.7.*,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,!=3.7.*,>=3.8"
-groups = ["main"]
-files = [
-    {file = "litellm-1.74.15.post2.tar.gz", hash = "sha256:8eddb1c8a6a5a7048f8ba16e652aba23d6ca996dd87cb853c874ba375aa32479"},
-]
-
-[package.dependencies]
-aiohttp = ">=3.10"
-click = "*"
-httpx = ">=0.23.0"
-importlib-metadata = ">=6.8.0"
-jinja2 = ">=3.1.2,<4.0.0"
-jsonschema = ">=4.22.0,<5.0.0"
-openai = ">=1.68.2"
-pydantic = ">=2.5.0,<3.0.0"
-python-dotenv = ">=0.2.0"
-tiktoken = ">=0.7.0"
-tokenizers = "*"
-
-[package.extras]
-caching = ["diskcache (>=5.6.1,<6.0.0)"]
-extra-proxy = ["azure-identity (>=1.15.0,<2.0.0)", "azure-keyvault-secrets (>=4.8.0,<5.0.0)", "google-cloud-kms (>=2.21.3,<3.0.0)", "prisma (==0.11.0)", "redisvl (>=0.4.1,<0.5.0) ; python_version >= \"3.9\" and python_version < \"3.14\"", "resend (>=0.8.0,<0.9.0)"]
-mlflow = ["mlflow (>3.1.4) ; python_version >= \"3.10\""]
-proxy = ["PyJWT (>=2.8.0,<3.0.0)", "apscheduler (>=3.10.4,<4.0.0)", "azure-identity (>=1.15.0,<2.0.0)", "azure-storage-blob (>=12.25.1,<13.0.0)", "backoff", "boto3 (==1.34.34)", "cryptography (>=43.0.1,<44.0.0)", "fastapi (>=0.115.5,<0.116.0)", "fastapi-sso (>=0.16.0,<0.17.0)", "gunicorn (>=23.0.0,<24.0.0)", "litellm-enterprise (==0.1.16)", "litellm-proxy-extras (==0.2.16)", "mcp (>=1.10.0,<2.0.0) ; python_version >= \"3.10\"", "orjson (>=3.9.7,<4.0.0)", "polars (>=1.31.0,<2.0.0) ; python_version >= \"3.10\"", "pynacl (>=1.5.0,<2.0.0)", "python-multipart (>=0.0.18,<0.0.19)", "pyyaml (>=6.0.1,<7.0.0)", "rich (==13.7.1)", "rq", "uvicorn (>=0.29.0,<0.30.0)", "uvloop (>=0.21.0,<0.22.0) ; sys_platform != \"win32\"", "websockets (>=13.1.0,<14.0.0)"]
-semantic-router = ["semantic-router ; python_version >= \"3.9\""]
-utils = ["numpydoc"]
-
-[[package]]
-name = "markdown-it-py"
-version = "4.0.0"
-description = "Python port of markdown-it. Markdown parsing, done right!"
-optional = false
-python-versions = ">=3.10"
-groups = ["main"]
-files = [
-    {file = "markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147"},
-    {file = "markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3"},
-]
-
-[package.dependencies]
-mdurl = ">=0.1,<1.0"
-
-[package.extras]
-benchmarking = ["psutil", "pytest", "pytest-benchmark"]
-compare = ["commonmark (>=0.9,<1.0)", "markdown (>=3.4,<4.0)", "markdown-it-pyrs", "mistletoe (>=1.0,<2.0)", "mistune (>=3.0,<4.0)", "panflute (>=2.3,<3.0)"]
-linkify = ["linkify-it-py (>=1,<3)"]
-plugins = ["mdit-py-plugins (>=0.5.0)"]
-profiling = ["gprof2dot"]
-rtd = ["ipykernel", "jupyter_sphinx", "mdit-py-plugins (>=0.5.0)", "myst-parser", "pyyaml", "sphinx", "sphinx-book-theme (>=1.0,<2.0)", "sphinx-copybutton", "sphinx-design"]
-testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions", "requests"]
-
 [[package]]
 name = "markupsafe"
 version = "3.0.2"
@@ -2929,18 +2755,6 @@ files = [
     {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"},
 ]
 
-[[package]]
-name = "mdurl"
-version = "0.1.2"
-description = "Markdown URL utilities"
-optional = false
-python-versions = ">=3.7"
-groups = ["main"]
-files = [
-    {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"},
-    {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"},
-]
-
 [[package]]
 name = "mem0ai"
 version = "0.1.115"
@@ -3829,28 +3643,6 @@ docs = ["furo (>=2024.8.6)", "proselint (>=0.14)", "sphinx (>=8.1.3)", "sphinx-a
 test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=8.3.4)", "pytest-cov (>=6)", "pytest-mock (>=3.14)"]
 type = ["mypy (>=1.14.1)"]
 
-[[package]]
-name = "playwright"
-version = "1.54.0"
-description = "A high-level API to automate web browsers"
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "playwright-1.54.0-py3-none-macosx_10_13_x86_64.whl", hash = "sha256:bf3b845af744370f1bd2286c2a9536f474cc8a88dc995b72ea9a5be714c9a77d"},
-    {file = "playwright-1.54.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:780928b3ca2077aea90414b37e54edd0c4bbb57d1aafc42f7aa0b3fd2c2fac02"},
-    {file = "playwright-1.54.0-py3-none-macosx_11_0_universal2.whl", hash = "sha256:81d0b6f28843b27f288cfe438af0a12a4851de57998009a519ea84cee6fbbfb9"},
-    {file = "playwright-1.54.0-py3-none-manylinux1_x86_64.whl", hash = "sha256:09919f45cc74c64afb5432646d7fef0d19fff50990c862cb8d9b0577093f40cc"},
-    {file = "playwright-1.54.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:13ae206c55737e8e3eae51fb385d61c0312eeef31535643bb6232741b41b6fdc"},
-    {file = "playwright-1.54.0-py3-none-win32.whl", hash = "sha256:0b108622ffb6906e28566f3f31721cd57dda637d7e41c430287804ac01911f56"},
-    {file = "playwright-1.54.0-py3-none-win_amd64.whl", hash = "sha256:9e5aee9ae5ab1fdd44cd64153313a2045b136fcbcfb2541cc0a3d909132671a2"},
-    {file = "playwright-1.54.0-py3-none-win_arm64.whl", hash = "sha256:a975815971f7b8dca505c441a4c56de1aeb56a211290f8cc214eeef5524e8d75"},
-]
-
-[package.dependencies]
-greenlet = ">=3.1.1,<4.0.0"
-pyee = ">=13,<14"
-
 [[package]]
 name = "pluggy"
 version = "1.6.0"
@@ -3869,14 +3661,14 @@ testing = ["coverage", "pytest", "pytest-benchmark"]
 
 [[package]]
 name = "poethepoet"
-version = "0.37.0"
+version = "0.36.0"
 description = "A task runner that works well with poetry and uv."
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
 files = [
-    {file = "poethepoet-0.37.0-py3-none-any.whl", hash = "sha256:861790276315abcc8df1b4bd60e28c3d48a06db273edd3092f3c94e1a46e5e22"},
-    {file = "poethepoet-0.37.0.tar.gz", hash = "sha256:73edf458707c674a079baa46802e21455bda3a7f82a408e58c31b9f4fe8e933d"},
+    {file = "poethepoet-0.36.0-py3-none-any.whl", hash = "sha256:693e3c1eae9f6731d3613c3c0c40f747d3c5c68a375beda42e590a63c5623308"},
+    {file = "poethepoet-0.36.0.tar.gz", hash = "sha256:2217b49cb4e4c64af0b42ff8c4814b17f02e107d38bc461542517348ede25663"},
 ]
 
 [package.dependencies]
@@ -4060,14 +3852,14 @@ test = ["betamax (>=0.8,<0.9)", "pytest (>=2.7.3)", "urllib3 (==1.26.*)"]
 
 [[package]]
 name = "pre-commit"
-version = "4.3.0"
+version = "4.2.0"
 description = "A framework for managing and maintaining multi-language pre-commit hooks."
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
 files = [
-    {file = "pre_commit-4.3.0-py2.py3-none-any.whl", hash = "sha256:2b0747ad7e6e967169136edffee14c16e148a778a54e4f967921aa1ebf2308d8"},
-    {file = "pre_commit-4.3.0.tar.gz", hash = "sha256:499fe450cc9d42e9d58e606262795ecb64dd05438943c62b66f6a8673da30b16"},
+    {file = "pre_commit-4.2.0-py2.py3-none-any.whl", hash = "sha256:a009ca7205f1eb497d10b845e52c838a98b6cdd2102a6c8e4540e94ee75c58bd"},
+    {file = "pre_commit-4.2.0.tar.gz", hash = "sha256:601283b9757afd87d40c4c4a9b2b5de9637a8ea02eaff7adc2d0fb4e04841146"},
 ]
 
 [package.dependencies]
@@ -4685,24 +4477,6 @@ gcp-secret-manager = ["google-cloud-secret-manager (>=2.23.1)"]
 toml = ["tomli (>=2.0.1)"]
 yaml = ["pyyaml (>=6.0.1)"]
 
-[[package]]
-name = "pyee"
-version = "13.0.0"
-description = "A rough port of Node.js's EventEmitter to Python with a few tricks of its own"
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-files = [
-    {file = "pyee-13.0.0-py3-none-any.whl", hash = "sha256:48195a3cddb3b1515ce0695ed76036b5ccc2ef3a9f963ff9f77aec0139845498"},
-    {file = "pyee-13.0.0.tar.gz", hash = "sha256:b391e3c5a434d1f5118a25615001dbc8f669cf410ab67d04c4d4e07c55481c37"},
-]
-
-[package.dependencies]
-typing-extensions = "*"
-
-[package.extras]
-dev = ["black", "build", "flake8", "flake8-black", "isort", "jupyter-console", "mkdocs", "mkdocs-include-markdown-plugin", "mkdocstrings[python]", "mypy", "pytest", "pytest-asyncio ; python_version >= \"3.4\"", "pytest-trio ; python_version >= \"3.7\"", "sphinx", "toml", "tox", "trio", "trio ; python_version > \"3.6\"", "trio-typing ; python_version > \"3.6\"", "twine", "twisted", "validate-pyproject[all]"]
-
 [[package]]
 name = "pyflakes"
 version = "3.4.0"
@@ -4742,9 +4516,6 @@ files = [
     {file = "pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953"},
 ]
 
-[package.dependencies]
-cryptography = {version = ">=3.4.0", optional = true, markers = "extra == \"crypto\""}
-
 [package.extras]
 crypto = ["cryptography (>=3.4.0)"]
 dev = ["coverage[toml] (==5.0.4)", "cryptography (>=3.4.0)", "pre-commit", "pytest (>=6.0.0,<7.0.0)", "sphinx", "sphinx-rtd-theme", "zope.interface"]
@@ -4792,14 +4563,14 @@ files = [
 
 [[package]]
 name = "pyright"
-version = "1.1.404"
+version = "1.1.403"
 description = "Command line wrapper for pyright"
 optional = false
 python-versions = ">=3.7"
 groups = ["dev"]
 files = [
-    {file = "pyright-1.1.404-py3-none-any.whl", hash = "sha256:c7b7ff1fdb7219c643079e4c3e7d4125f0dafcc19d253b47e898d130ea426419"},
-    {file = "pyright-1.1.404.tar.gz", hash = "sha256:455e881a558ca6be9ecca0b30ce08aa78343ecc031d37a198ffa9a7a1abeb63e"},
+    {file = "pyright-1.1.403-py3-none-any.whl", hash = "sha256:c0eeca5aa76cbef3fcc271259bbd785753c7ad7bcac99a9162b4c4c7daed23b3"},
+    {file = "pyright-1.1.403.tar.gz", hash = "sha256:3ab69b9f41c67fb5bbb4d7a36243256f0d549ed3608678d381d5f51863921104"},
 ]
 
 [package.dependencies]
@@ -4861,7 +4632,7 @@ version = "3.14.1"
 description = "Thin-wrapper around the mock package for easier use with pytest"
 optional = false
 python-versions = ">=3.8"
-groups = ["dev"]
+groups = ["main", "dev"]
 files = [
     {file = "pytest_mock-3.14.1-py3-none-any.whl", hash = "sha256:178aefcd11307d874b4cd3100344e7e2d888d9791a6a1d9bfe90fbc1b74fd1d0"},
     {file = "pytest_mock-3.14.1.tar.gz", hash = "sha256:159e9edac4c451ce77a5cdb9fc5d1100708d2dd4ba3c3df572f14097351af80e"},
@@ -5379,14 +5150,14 @@ typing_extensions = ">=4.5.0"
 
 [[package]]
 name = "requests"
-version = "2.32.5"
+version = "2.32.4"
 description = "Python HTTP for Humans."
 optional = false
-python-versions = ">=3.9"
+python-versions = ">=3.8"
 groups = ["main", "dev"]
 files = [
-    {file = "requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6"},
-    {file = "requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf"},
+    {file = "requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c"},
+    {file = "requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422"},
 ]
 
 [package.dependencies]
@@ -5433,25 +5204,6 @@ files = [
 [package.dependencies]
 requests = ">=2.0.1,<3.0.0"
 
-[[package]]
-name = "rich"
-version = "14.1.0"
-description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal"
-optional = false
-python-versions = ">=3.8.0"
-groups = ["main"]
-files = [
-    {file = "rich-14.1.0-py3-none-any.whl", hash = "sha256:536f5f1785986d6dbdea3c75205c473f970777b4a0d6c6dd1b696aa05a3fa04f"},
-    {file = "rich-14.1.0.tar.gz", hash = "sha256:e497a48b844b0320d45007cdebfeaeed8db2a4f4bcf49f15e455cfc4af11eaa8"},
-]
-
-[package.dependencies]
-markdown-it-py = ">=2.2.0"
-pygments = ">=2.13.0,<3.0.0"
-
-[package.extras]
-jupyter = ["ipywidgets (>=7.5.1,<9)"]
-
 [[package]]
 name = "rpds-py"
 version = "0.26.0"
@@ -5623,31 +5375,30 @@ pyasn1 = ">=0.1.3"
 
 [[package]]
 name = "ruff"
-version = "0.12.11"
+version = "0.12.4"
 description = "An extremely fast Python linter and code formatter, written in Rust."
 optional = false
 python-versions = ">=3.7"
 groups = ["dev"]
 files = [
-    {file = "ruff-0.12.11-py3-none-linux_armv6l.whl", hash = "sha256:93fce71e1cac3a8bf9200e63a38ac5c078f3b6baebffb74ba5274fb2ab276065"},
-    {file = "ruff-0.12.11-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b8e33ac7b28c772440afa80cebb972ffd823621ded90404f29e5ab6d1e2d4b93"},
-    {file = "ruff-0.12.11-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d69fb9d4937aa19adb2e9f058bc4fbfe986c2040acb1a4a9747734834eaa0bfd"},
-    {file = "ruff-0.12.11-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:411954eca8464595077a93e580e2918d0a01a19317af0a72132283e28ae21bee"},
-    {file = "ruff-0.12.11-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6a2c0a2e1a450f387bf2c6237c727dd22191ae8c00e448e0672d624b2bbd7fb0"},
-    {file = "ruff-0.12.11-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ca4c3a7f937725fd2413c0e884b5248a19369ab9bdd850b5781348ba283f644"},
-    {file = "ruff-0.12.11-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:4d1df0098124006f6a66ecf3581a7f7e754c4df7644b2e6704cd7ca80ff95211"},
-    {file = "ruff-0.12.11-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5a8dd5f230efc99a24ace3b77e3555d3fbc0343aeed3fc84c8d89e75ab2ff793"},
-    {file = "ruff-0.12.11-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4dc75533039d0ed04cd33fb8ca9ac9620b99672fe7ff1533b6402206901c34ee"},
-    {file = "ruff-0.12.11-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4fc58f9266d62c6eccc75261a665f26b4ef64840887fc6cbc552ce5b29f96cc8"},
-    {file = "ruff-0.12.11-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5a0113bd6eafd545146440225fe60b4e9489f59eb5f5f107acd715ba5f0b3d2f"},
-    {file = "ruff-0.12.11-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:0d737b4059d66295c3ea5720e6efc152623bb83fde5444209b69cd33a53e2000"},
-    {file = "ruff-0.12.11-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:916fc5defee32dbc1fc1650b576a8fed68f5e8256e2180d4d9855aea43d6aab2"},
-    {file = "ruff-0.12.11-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c984f07d7adb42d3ded5be894fb4007f30f82c87559438b4879fe7aa08c62b39"},
-    {file = "ruff-0.12.11-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e07fbb89f2e9249f219d88331c833860489b49cdf4b032b8e4432e9b13e8a4b9"},
-    {file = "ruff-0.12.11-py3-none-win32.whl", hash = "sha256:c792e8f597c9c756e9bcd4d87cf407a00b60af77078c96f7b6366ea2ce9ba9d3"},
-    {file = "ruff-0.12.11-py3-none-win_amd64.whl", hash = "sha256:a3283325960307915b6deb3576b96919ee89432ebd9c48771ca12ee8afe4a0fd"},
-    {file = "ruff-0.12.11-py3-none-win_arm64.whl", hash = "sha256:bae4d6e6a2676f8fb0f98b74594a048bae1b944aab17e9f5d504062303c6dbea"},
-    {file = "ruff-0.12.11.tar.gz", hash = "sha256:c6b09ae8426a65bbee5425b9d0b82796dbb07cb1af045743c79bfb163001165d"},
+    {file = "ruff-0.12.4-py3-none-linux_armv6l.whl", hash = "sha256:cb0d261dac457ab939aeb247e804125a5d521b21adf27e721895b0d3f83a0d0a"},
+    {file = "ruff-0.12.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:55c0f4ca9769408d9b9bac530c30d3e66490bd2beb2d3dae3e4128a1f05c7442"},
+    {file = "ruff-0.12.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a8224cc3722c9ad9044da7f89c4c1ec452aef2cfe3904365025dd2f51daeae0e"},
+    {file = "ruff-0.12.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e9949d01d64fa3672449a51ddb5d7548b33e130240ad418884ee6efa7a229586"},
+    {file = "ruff-0.12.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:be0593c69df9ad1465e8a2d10e3defd111fdb62dcd5be23ae2c06da77e8fcffb"},
+    {file = "ruff-0.12.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a7dea966bcb55d4ecc4cc3270bccb6f87a337326c9dcd3c07d5b97000dbff41c"},
+    {file = "ruff-0.12.4-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:afcfa3ab5ab5dd0e1c39bf286d829e042a15e966b3726eea79528e2e24d8371a"},
+    {file = "ruff-0.12.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c057ce464b1413c926cdb203a0f858cd52f3e73dcb3270a3318d1630f6395bb3"},
+    {file = "ruff-0.12.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e64b90d1122dc2713330350626b10d60818930819623abbb56535c6466cce045"},
+    {file = "ruff-0.12.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2abc48f3d9667fdc74022380b5c745873499ff827393a636f7a59da1515e7c57"},
+    {file = "ruff-0.12.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:2b2449dc0c138d877d629bea151bee8c0ae3b8e9c43f5fcaafcd0c0d0726b184"},
+    {file = "ruff-0.12.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:56e45bb11f625db55f9b70477062e6a1a04d53628eda7784dce6e0f55fd549eb"},
+    {file = "ruff-0.12.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:478fccdb82ca148a98a9ff43658944f7ab5ec41c3c49d77cd99d44da019371a1"},
+    {file = "ruff-0.12.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:0fc426bec2e4e5f4c4f182b9d2ce6a75c85ba9bcdbe5c6f2a74fcb8df437df4b"},
+    {file = "ruff-0.12.4-py3-none-win32.whl", hash = "sha256:4de27977827893cdfb1211d42d84bc180fceb7b72471104671c59be37041cf93"},
+    {file = "ruff-0.12.4-py3-none-win_amd64.whl", hash = "sha256:fe0b9e9eb23736b453143d72d2ceca5db323963330d5b7859d60d101147d461a"},
+    {file = "ruff-0.12.4-py3-none-win_arm64.whl", hash = "sha256:0618ec4442a83ab545e5b71202a5c0ed7791e8471435b94e655b570a5031a98e"},
+    {file = "ruff-0.12.4.tar.gz", hash = "sha256:13efa16df6c6eeb7d0f091abae50f58e9522f3843edb40d56ad52a5a4a4b6873"},
 ]
 
 [[package]]
@@ -5906,34 +5657,6 @@ postgresql-psycopgbinary = ["psycopg[binary] (>=3.0.7)"]
 pymysql = ["pymysql"]
 sqlcipher = ["sqlcipher3_binary"]
 
-[[package]]
-name = "stagehand"
-version = "0.5.1"
-description = "Python SDK for Stagehand"
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "stagehand-0.5.1-py3-none-any.whl", hash = "sha256:97f88ef31c4b2ad448c2ef341a3cff074b83e40c60872d8f49f79c82f9249174"},
-    {file = "stagehand-0.5.1.tar.gz", hash = "sha256:312611f776a5f93f3a10a3cae87cd4881eb020c999a87394b21bff2b123fdfc3"},
-]
-
-[package.dependencies]
-anthropic = ">=0.51.0"
-browserbase = ">=1.4.0"
-httpx = ">=0.24.0"
-litellm = ">=1.72.0,<1.75.0"
-nest-asyncio = ">=1.6.0"
-openai = ">=1.83.0,<1.99.6"
-playwright = ">=1.42.1"
-pydantic = ">=1.10.0"
-python-dotenv = ">=1.0.0"
-requests = ">=2.31.0"
-rich = ">=13.7.0"
-
-[package.extras]
-dev = ["black (>=23.3.0)", "isort (>=5.12.0)", "mypy (>=1.3.0)", "psutil (>=5.9.0)", "pytest (>=7.3.1)", "pytest-asyncio (>=0.21.0)", "pytest-cov (>=4.1.0)", "pytest-mock (>=3.10.0)", "ruff"]
-
 [[package]]
 name = "starlette"
 version = "0.47.1"
@@ -6137,39 +5860,6 @@ files = [
 [package.dependencies]
 requests = ">=2.32.3,<3.0.0"
 
-[[package]]
-name = "tokenizers"
-version = "0.21.4"
-description = ""
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "tokenizers-0.21.4-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:2ccc10a7c3bcefe0f242867dc914fc1226ee44321eb618cfe3019b5df3400133"},
-    {file = "tokenizers-0.21.4-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:5e2f601a8e0cd5be5cc7506b20a79112370b9b3e9cb5f13f68ab11acd6ca7d60"},
-    {file = "tokenizers-0.21.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b376f5a1aee67b4d29032ee85511bbd1b99007ec735f7f35c8a2eb104eade5"},
-    {file = "tokenizers-0.21.4-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2107ad649e2cda4488d41dfd031469e9da3fcbfd6183e74e4958fa729ffbf9c6"},
-    {file = "tokenizers-0.21.4-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c73012da95afafdf235ba80047699df4384fdc481527448a078ffd00e45a7d9"},
-    {file = "tokenizers-0.21.4-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f23186c40395fc390d27f519679a58023f368a0aad234af145e0f39ad1212732"},
-    {file = "tokenizers-0.21.4-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cc88bb34e23a54cc42713d6d98af5f1bf79c07653d24fe984d2d695ba2c922a2"},
-    {file = "tokenizers-0.21.4-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51b7eabb104f46c1c50b486520555715457ae833d5aee9ff6ae853d1130506ff"},
-    {file = "tokenizers-0.21.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:714b05b2e1af1288bd1bc56ce496c4cebb64a20d158ee802887757791191e6e2"},
-    {file = "tokenizers-0.21.4-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:1340ff877ceedfa937544b7d79f5b7becf33a4cfb58f89b3b49927004ef66f78"},
-    {file = "tokenizers-0.21.4-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:3c1f4317576e465ac9ef0d165b247825a2a4078bcd01cba6b54b867bdf9fdd8b"},
-    {file = "tokenizers-0.21.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:c212aa4e45ec0bb5274b16b6f31dd3f1c41944025c2358faaa5782c754e84c24"},
-    {file = "tokenizers-0.21.4-cp39-abi3-win32.whl", hash = "sha256:6c42a930bc5f4c47f4ea775c91de47d27910881902b0f20e4990ebe045a415d0"},
-    {file = "tokenizers-0.21.4-cp39-abi3-win_amd64.whl", hash = "sha256:475d807a5c3eb72c59ad9b5fcdb254f6e17f53dfcbb9903233b0dfa9c943b597"},
-    {file = "tokenizers-0.21.4.tar.gz", hash = "sha256:fa23f85fbc9a02ec5c6978da172cdcbac23498c3ca9f3645c5c68740ac007880"},
-]
-
-[package.dependencies]
-huggingface-hub = ">=0.16.4,<1.0"
-
-[package.extras]
-dev = ["tokenizers[testing]"]
-docs = ["setuptools-rust", "sphinx", "sphinx-rtd-theme"]
-testing = ["black (==22.3)", "datasets", "numpy", "pytest", "requests", "ruff"]
-
 [[package]]
 name = "tomli"
 version = "2.2.1"
@@ -7132,4 +6822,4 @@ cffi = ["cffi (>=1.11)"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.10,<3.14"
-content-hash = "892daa57d7126d9a9d5308005b07328a39b8c4cd7fe198f9b5ab10f957787c48"
+content-hash = "e780199a6b02f5fef3f930a4f1d69443af1977b591172c3a18a299166345c37a"

autogpt_platform/backend/pyproject.toml

@@ -78,21 +78,20 @@ pandas = "^2.3.1"
 firecrawl-py = "^2.16.3"
 exa-py = "^1.14.20"
 croniter = "^6.0.0"
-stagehand = "^0.5.1"
 
 [tool.poetry.group.dev.dependencies]
 aiohappyeyeballs = "^2.6.1"
 black = "^24.10.0"
-faker = "^37.6.0"
+faker = "^37.4.2"
 httpx = "^0.28.1"
 isort = "^5.13.2"
-poethepoet = "^0.37.0"
-pre-commit = "^4.3.0"
-pyright = "^1.1.404"
+poethepoet = "^0.36.0"
+pre-commit = "^4.2.0"
+pyright = "^1.1.403"
 pytest-mock = "^3.14.0"
 pytest-watcher = "^0.4.2"
-requests = "^2.32.5"
-ruff = "^0.12.11"
+requests = "^2.32.4"
+ruff = "^0.12.3"
 # NOTE: please insert new dependencies in their alphabetical location
 
 [build-system]

autogpt_platform/frontend/orval.config.ts

@@ -45,8 +45,7 @@ export default defineConfig({
       },
     },
     hooks: {
-      afterAllFilesWrite:
-        "prettier --ignore-path= --write ./src/app/api/__generated__",
+      afterAllFilesWrite: "prettier --write",
     },
   },
   // autogpt_zod_schema: {

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/AgentRunsView.tsx

@@ -5,16 +5,17 @@ import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
 import { useAgentRunsView } from "./useAgentRunsView";
 import { AgentRunsLoading } from "./components/AgentRunsLoading";
 import { Button } from "@/components/atoms/Button/Button";
-import { RunAgentModal } from "@/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/RunAgentModal";
-import { PlusIcon } from "@phosphor-icons/react/dist/ssr";
+import { Plus } from "@phosphor-icons/react";
 
 export function AgentRunsView() {
   const { response, ready, error, agentId } = useAgentRunsView();
 
+  // Handle loading state
   if (!ready) {
     return <AgentRunsLoading />;
   }
 
+  // Handle errors - check for query error first, then response errors
   if (error || (response && response.status !== 200)) {
     return (
       <ErrorCard
@@ -52,15 +53,9 @@ export function AgentRunsView() {
     <div className="grid h-screen grid-cols-[25%_85%] gap-4 pt-8">
       {/* Left Sidebar - 30% */}
       <div className="bg-gray-50 p-4">
-        <RunAgentModal
-          triggerSlot={
-            <Button variant="primary" size="large" className="w-full">
-              <PlusIcon size={20} /> New Run
-            </Button>
-          }
-          agent={agent}
-          agentId={agent.id.toString()}
-        />
+        <Button variant="primary" size="large" className="w-full">
+          <Plus size={20} /> New Run
+        </Button>
       </div>
 
       {/* Main Content - 70% */}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/RunAgentModal.tsx

@@ -1,156 +0,0 @@
-"use client";
-
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import { useState } from "react";
-import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
-import { useAgentRunModal } from "./useAgentRunModal";
-import { ModalHeader } from "./components/ModalHeader/ModalHeader";
-import { AgentCostSection } from "./components/AgentCostSection/AgentCostSection";
-import { AgentSectionHeader } from "./components/AgentSectionHeader/AgentSectionHeader";
-import { DefaultRunView } from "./components/DefaultRunView/DefaultRunView";
-import { ScheduleView } from "./components/ScheduleView/ScheduleView";
-import { AgentDetails } from "./components/AgentDetails/AgentDetails";
-import { RunActions } from "./components/RunActions/RunActions";
-import { ScheduleActions } from "./components/ScheduleActions/ScheduleActions";
-
-interface Props {
-  triggerSlot: React.ReactNode;
-  agent: LibraryAgent;
-  agentId: string;
-  agentVersion?: number;
-}
-
-export function RunAgentModal({ triggerSlot, agent }: Props) {
-  const {
-    isOpen,
-    setIsOpen,
-    showScheduleView,
-    defaultRunType,
-    inputValues,
-    setInputValues,
-    scheduleName,
-    cronExpression,
-    allRequiredInputsAreSet,
-    // agentInputFields, // Available if needed for future use
-    hasInputFields,
-    isExecuting,
-    isCreatingSchedule,
-    isSettingUpTrigger,
-    handleRun,
-    handleSchedule,
-    handleShowSchedule,
-    handleGoBack,
-    handleSetScheduleName,
-    handleSetCronExpression,
-  } = useAgentRunModal(agent);
-
-  const [isScheduleFormValid, setIsScheduleFormValid] = useState(true);
-
-  function handleInputChange(key: string, value: string) {
-    setInputValues((prev) => ({
-      ...prev,
-      [key]: value,
-    }));
-  }
-
-  function handleSetOpen(open: boolean) {
-    setIsOpen(open);
-    // Always reset to Run view when opening/closing
-    if (open || !open) handleGoBack();
-  }
-
-  return (
-    <Dialog
-      controlled={{ isOpen, set: handleSetOpen }}
-      styling={{ maxWidth: "600px", maxHeight: "90vh" }}
-    >
-      <Dialog.Trigger>{triggerSlot}</Dialog.Trigger>
-      <Dialog.Content>
-        <div className="flex h-full flex-col">
-          {/* Header */}
-          <div className="flex-shrink-0">
-            <ModalHeader agent={agent} />
-            <AgentCostSection flowId={agent.graph_id} />
-          </div>
-
-          {/* Scrollable content */}
-          <div
-            className="flex-1 overflow-y-auto overflow-x-hidden pr-1"
-            style={{ scrollbarGutter: "stable" }}
-          >
-            {/* Setup Section */}
-            <div className="mt-10">
-              {showScheduleView ? (
-                <>
-                  <AgentSectionHeader title="Schedule Setup" />
-                  <div>
-                    <ScheduleView
-                      agent={agent}
-                      scheduleName={scheduleName}
-                      cronExpression={cronExpression}
-                      inputValues={inputValues}
-                      onScheduleNameChange={handleSetScheduleName}
-                      onCronExpressionChange={handleSetCronExpression}
-                      onInputChange={handleInputChange}
-                      onValidityChange={setIsScheduleFormValid}
-                    />
-                  </div>
-                </>
-              ) : hasInputFields ? (
-                <>
-                  <AgentSectionHeader
-                    title={
-                      defaultRunType === "automatic-trigger"
-                        ? "Trigger Setup"
-                        : "Agent Setup"
-                    }
-                  />
-                  <div>
-                    <DefaultRunView
-                      agent={agent}
-                      defaultRunType={defaultRunType}
-                      inputValues={inputValues}
-                      onInputChange={handleInputChange}
-                    />
-                  </div>
-                </>
-              ) : null}
-            </div>
-
-            {/* Agent Details Section */}
-            <div className="mt-8">
-              <AgentSectionHeader title="Agent Details" />
-              <AgentDetails agent={agent} />
-            </div>
-          </div>
-
-          {/* Fixed Actions - sticky inside dialog scroll */}
-          <Dialog.Footer className="sticky bottom-0 z-10 bg-white">
-            {!showScheduleView ? (
-              <RunActions
-                hasExternalTrigger={agent.has_external_trigger}
-                defaultRunType={defaultRunType}
-                onShowSchedule={handleShowSchedule}
-                onRun={handleRun}
-                isExecuting={isExecuting}
-                isSettingUpTrigger={isSettingUpTrigger}
-                allRequiredInputsAreSet={allRequiredInputsAreSet}
-              />
-            ) : (
-              <ScheduleActions
-                onGoBack={handleGoBack}
-                onSchedule={handleSchedule}
-                isCreatingSchedule={isCreatingSchedule}
-                allRequiredInputsAreSet={
-                  allRequiredInputsAreSet &&
-                  !!scheduleName.trim() &&
-                  isScheduleFormValid
-                }
-              />
-            )}
-          </Dialog.Footer>
-        </div>
-      </Dialog.Content>
-    </Dialog>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/AgentCostSection/AgentCostSection.tsx

@@ -1,31 +0,0 @@
-import { Button } from "@/components/atoms/Button/Button";
-
-interface Props {
-  flowId: string;
-}
-
-export function AgentCostSection({ flowId }: Props) {
-  return (
-    <div className="mt-6 flex items-center justify-between">
-      {/* TODO: enable once we have an API to show estimated cost for an agent run */}
-      {/* <div className="flex items-center gap-2">
-        <Text variant="body-medium">Cost</Text>
-        <Text variant="body">{cost}</Text>
-      </div> */}
-      <div className="flex items-center gap-2">
-        <Button
-          variant="outline"
-          size="small"
-          as="NextLink"
-          href={`/build?flowID=${flowId}`}
-        >
-          Open in builder
-        </Button>
-        {/* TODO: enable once we can easily link to the agent listing page from the library agent response */}
-        {/* <Button variant="outline" size="small">
-          View listing <ArrowSquareOutIcon size={16} />
-        </Button> */}
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/AgentDetails/AgentDetails.tsx

@@ -1,63 +0,0 @@
-import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
-import { Text } from "@/components/atoms/Text/Text";
-import { Badge } from "@/components/atoms/Badge/Badge";
-import { formatAgentStatus, getStatusColor } from "./helpers";
-import { formatDate } from "@/lib/utils/time";
-
-interface Props {
-  agent: LibraryAgent;
-}
-
-export function AgentDetails({ agent }: Props) {
-  return (
-    <div className="mt-4 flex flex-col gap-5">
-      <div>
-        <Text variant="body-medium" className="mb-1 !text-black">
-          Current Status
-        </Text>
-        <div className="flex items-center gap-2">
-          <div
-            className={`h-2 w-2 rounded-full ${getStatusColor(agent.status)}`}
-          />
-          <Text variant="body" className="!text-zinc-700">
-            {formatAgentStatus(agent.status)}
-          </Text>
-        </div>
-      </div>
-
-      <div>
-        <Text variant="body-medium" className="mb-1 !text-black">
-          Version
-        </Text>
-        <div className="flex items-center gap-2">
-          <Text variant="body" className="!text-zinc-700">
-            v{agent.graph_version}
-          </Text>
-          {agent.is_latest_version && (
-            <Badge variant="success" size="small">
-              Latest
-            </Badge>
-          )}
-        </div>
-      </div>
-      <div>
-        <Text variant="body-medium" className="mb-1 !text-black">
-          Last Updated
-        </Text>
-        <Text variant="body" className="!text-zinc-700">
-          {formatDate(agent.updated_at)}
-        </Text>
-      </div>
-      {agent.has_external_trigger && (
-        <div>
-          <Text variant="body-medium" className="mb-1">
-            Trigger Type
-          </Text>
-          <Text variant="body" className="!text-neutral-700">
-            External Webhook
-          </Text>
-        </div>
-      )}
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/AgentDetails/helpers.tsx

@@ -1,23 +0,0 @@
-import { LibraryAgentStatus } from "@/app/api/__generated__/models/libraryAgentStatus";
-
-export function formatAgentStatus(status: LibraryAgentStatus) {
-  const statusMap: Record<string, string> = {
-    COMPLETED: "Ready",
-    HEALTHY: "Running",
-    WAITING: "Run Queued",
-    ERROR: "Failed Run",
-  };
-
-  return statusMap[status];
-}
-
-export function getStatusColor(status: LibraryAgentStatus): string {
-  const colorMap: Record<LibraryAgentStatus, string> = {
-    COMPLETED: "bg-blue-300",
-    HEALTHY: "bg-green-300",
-    WAITING: "bg-amber-300",
-    ERROR: "bg-red-300",
-  };
-
-  return colorMap[status] || "bg-gray-300";
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/AgentInputFields/AgentInputFields.tsx

@@ -1,51 +0,0 @@
-import { Input } from "@/components/atoms/Input/Input";
-import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
-
-interface Props {
-  agent: LibraryAgent;
-  inputValues: Record<string, any>;
-  onInputChange: (key: string, value: string) => void;
-  variant?: "default" | "schedule";
-}
-
-export function AgentInputFields({
-  agent,
-  inputValues,
-  onInputChange,
-  variant = "default",
-}: Props) {
-  const hasInputFields =
-    agent.input_schema &&
-    typeof agent.input_schema === "object" &&
-    "properties" in agent.input_schema;
-
-  if (!hasInputFields) {
-    const emptyStateClass =
-      variant === "schedule"
-        ? "rounded-lg bg-neutral-50 p-4 text-sm text-neutral-500"
-        : "p-4 text-sm text-neutral-500";
-
-    return (
-      <div className={emptyStateClass}>
-        No input fields required for this agent
-      </div>
-    );
-  }
-
-  return (
-    <>
-      {Object.entries((agent.input_schema as any).properties || {}).map(
-        ([key, schema]: [string, any]) => (
-          <Input
-            key={key}
-            id={key}
-            label={schema.title || key}
-            value={inputValues[key] || ""}
-            onChange={(e) => onInputChange(key, e.target.value)}
-            placeholder={schema.description}
-          />
-        ),
-      )}
-    </>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/AgentSectionHeader/AgentSectionHeader.tsx

@@ -1,15 +0,0 @@
-import { Text } from "@/components/atoms/Text/Text";
-
-interface Props {
-  title: string;
-}
-
-export function AgentSectionHeader({ title }: Props) {
-  return (
-    <div className="border-t border-zinc-400 px-0 py-2">
-      <Text variant="label" className="!text-zinc-700">
-        {title}
-      </Text>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/DefaultRunView/DefaultRunView.tsx

@@ -1,30 +0,0 @@
-import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
-import { RunVariant } from "../../useAgentRunModal";
-import { WebhookTriggerBanner } from "../WebhookTriggerBanner/WebhookTriggerBanner";
-import { AgentInputFields } from "../AgentInputFields/AgentInputFields";
-
-interface Props {
-  agent: LibraryAgent;
-  defaultRunType: RunVariant;
-  inputValues: Record<string, any>;
-  onInputChange: (key: string, value: string) => void;
-}
-
-export function DefaultRunView({
-  agent,
-  defaultRunType,
-  inputValues,
-  onInputChange,
-}: Props) {
-  return (
-    <div className="mt-6">
-      {defaultRunType === "automatic-trigger" && <WebhookTriggerBanner />}
-
-      <AgentInputFields
-        agent={agent}
-        inputValues={inputValues}
-        onInputChange={onInputChange}
-      />
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/ModalHeader/ModalHeader.tsx

@@ -1,31 +0,0 @@
-import { Badge } from "@/components/atoms/Badge/Badge";
-import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
-import { Text } from "@/components/atoms/Text/Text";
-import { ShowMoreText } from "@/components/molecules/ShowMoreText/ShowMoreText";
-
-interface ModalHeaderProps {
-  agent: LibraryAgent;
-}
-
-export function ModalHeader({ agent }: ModalHeaderProps) {
-  return (
-    <div className="space-y-4">
-      <div className="flex items-center gap-3">
-        <Badge variant="info">New Run</Badge>
-      </div>
-      <div>
-        <Text variant="h3">{agent.name}</Text>
-        <Text variant="body-medium">
-          by {agent.creator_name === "Unknown" ? "–" : agent.creator_name}
-        </Text>
-        <ShowMoreText
-          previewLimit={80}
-          variant="small"
-          className="mt-4 !text-zinc-700"
-        >
-          {agent.description}
-        </ShowMoreText>
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/RunActions/RunActions.tsx

@@ -1,42 +0,0 @@
-import { Button } from "@/components/atoms/Button/Button";
-import { RunVariant } from "../../useAgentRunModal";
-
-interface Props {
-  hasExternalTrigger: boolean;
-  defaultRunType: RunVariant;
-  onShowSchedule: () => void;
-  onRun: () => void;
-  isExecuting?: boolean;
-  isSettingUpTrigger?: boolean;
-  allRequiredInputsAreSet?: boolean;
-}
-
-export function RunActions({
-  hasExternalTrigger,
-  defaultRunType,
-  onShowSchedule,
-  onRun,
-  isExecuting = false,
-  isSettingUpTrigger = false,
-  allRequiredInputsAreSet = true,
-}: Props) {
-  return (
-    <div className="flex justify-end gap-3">
-      {!hasExternalTrigger && (
-        <Button variant="secondary" onClick={onShowSchedule}>
-          Schedule Run
-        </Button>
-      )}
-      <Button
-        variant="primary"
-        onClick={onRun}
-        disabled={!allRequiredInputsAreSet || isExecuting || isSettingUpTrigger}
-        loading={isExecuting || isSettingUpTrigger}
-      >
-        {defaultRunType === "automatic-trigger"
-          ? "Set up Trigger"
-          : "Run Agent"}
-      </Button>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/ScheduleActions/ScheduleActions.tsx

@@ -1,31 +0,0 @@
-import { Button } from "@/components/atoms/Button/Button";
-
-interface Props {
-  onGoBack: () => void;
-  onSchedule: () => void;
-  isCreatingSchedule?: boolean;
-  allRequiredInputsAreSet?: boolean;
-}
-
-export function ScheduleActions({
-  onGoBack,
-  onSchedule,
-  isCreatingSchedule = false,
-  allRequiredInputsAreSet = true,
-}: Props) {
-  return (
-    <div className="flex justify-end gap-3">
-      <Button variant="ghost" onClick={onGoBack}>
-        Go Back
-      </Button>
-      <Button
-        variant="primary"
-        onClick={onSchedule}
-        disabled={!allRequiredInputsAreSet || isCreatingSchedule}
-        loading={isCreatingSchedule}
-      >
-        Create Schedule
-      </Button>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/ScheduleView/ScheduleView.tsx

@@ -1,150 +0,0 @@
-import { Input } from "@/components/atoms/Input/Input";
-import { MultiToggle } from "@/components/molecules/MultiToggle/MultiToggle";
-import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
-import { AgentInputFields } from "../AgentInputFields/AgentInputFields";
-import { Text } from "@/components/atoms/Text/Text";
-import { Select } from "@/components/atoms/Select/Select";
-import { useScheduleView } from "./useScheduleView";
-import { useCallback, useState } from "react";
-import { validateSchedule } from "./helpers";
-
-interface Props {
-  agent: LibraryAgent;
-  scheduleName: string;
-  cronExpression: string;
-  inputValues: Record<string, any>;
-  onScheduleNameChange: (name: string) => void;
-  onCronExpressionChange: (expression: string) => void;
-  onInputChange: (key: string, value: string) => void;
-  onValidityChange?: (valid: boolean) => void;
-}
-
-export function ScheduleView({
-  agent,
-  scheduleName,
-  cronExpression: _cronExpression,
-  inputValues,
-  onScheduleNameChange,
-  onCronExpressionChange,
-  onInputChange,
-  onValidityChange,
-}: Props) {
-  const {
-    repeat,
-    selectedDays,
-    time,
-    repeatOptions,
-    dayItems,
-    setSelectedDays,
-    handleRepeatChange,
-    handleTimeChange,
-    handleSelectAll,
-    handleWeekdays,
-    handleWeekends,
-  } = useScheduleView({ onCronExpressionChange });
-
-  function handleScheduleNameChange(e: React.ChangeEvent<HTMLInputElement>) {
-    onScheduleNameChange(e.target.value);
-  }
-
-  const [errors, setErrors] = useState<{
-    scheduleName?: string;
-    time?: string;
-  }>({});
-
-  const validateNow = useCallback(
-    (partial: { scheduleName?: string; time?: string }) => {
-      const fieldErrors = validateSchedule({
-        scheduleName,
-        time,
-        ...partial,
-      });
-      setErrors(fieldErrors);
-      if (onValidityChange)
-        onValidityChange(Object.keys(fieldErrors).length === 0);
-    },
-    [scheduleName, time, onValidityChange],
-  );
-
-  return (
-    <div className="mt-6">
-      <Input
-        id="schedule-name"
-        label="Schedule Name"
-        value={scheduleName}
-        onChange={(e) => {
-          handleScheduleNameChange(e);
-          validateNow({ scheduleName: e.target.value });
-        }}
-        placeholder="Enter a name for this schedule"
-        error={errors.scheduleName}
-      />
-
-      <Select
-        id="repeat"
-        label="Repeats"
-        value={repeat}
-        onValueChange={handleRepeatChange}
-        options={repeatOptions}
-      />
-
-      {repeat === "weekly" && (
-        <div className="mb-8 space-y-3">
-          <Text variant="body-medium" as="span" className="text-black">
-            Repeats on
-          </Text>
-          <div className="flex flex-wrap gap-2">
-            <button
-              type="button"
-              className="h-[2.25rem] rounded-full border border-zinc-700 px-4 py-2 text-sm font-medium leading-[16px] text-black hover:bg-zinc-100"
-              onClick={handleSelectAll}
-            >
-              Select all
-            </button>
-            <button
-              type="button"
-              className="h-[2.25rem] rounded-full border border-zinc-700 px-4 py-2 text-sm font-medium leading-[16px] text-black hover:bg-zinc-100"
-              onClick={handleWeekdays}
-            >
-              Weekdays
-            </button>
-            <button
-              type="button"
-              className="h-[2.25rem] rounded-full border border-zinc-700 px-4 py-2 text-sm font-medium leading-[16px] text-black hover:bg-zinc-100"
-              onClick={handleWeekends}
-            >
-              Weekends
-            </button>
-          </div>
-
-          <MultiToggle
-            items={dayItems}
-            selectedValues={selectedDays}
-            onChange={setSelectedDays}
-            aria-label="Select days of week"
-          />
-        </div>
-      )}
-
-      <Input
-        id="schedule-time"
-        label="At"
-        value={time}
-        onChange={(e) => {
-          const value = e.target.value.trim();
-          handleTimeChange({ ...e, target: { ...e.target, value } } as any);
-          validateNow({ time: value });
-        }}
-        placeholder="00:00"
-        error={errors.time}
-      />
-
-      <AgentInputFields
-        agent={agent}
-        inputValues={inputValues}
-        onInputChange={onInputChange}
-        variant="schedule"
-      />
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/ScheduleView/helpers.ts

@@ -1,28 +0,0 @@
-import { z } from "zod";
-
-export const timeRegex = /^([01]?\d|2[0-3]):([0-5]\d)$/;
-
-export const scheduleFormSchema = z.object({
-  scheduleName: z.string().trim().min(1, "Schedule name is required"),
-  time: z.string().trim().regex(timeRegex, "Use HH:MM (24h)"),
-});
-
-export type ScheduleFormValues = z.infer<typeof scheduleFormSchema>;
-
-export function validateSchedule(
-  values: Partial<ScheduleFormValues>,
-): Partial<Record<keyof ScheduleFormValues, string>> {
-  const result = scheduleFormSchema.safeParse({
-    scheduleName: values.scheduleName ?? "",
-    time: values.time ?? "",
-  });
-
-  if (result.success) return {};
-
-  const fieldErrors: Partial<Record<keyof ScheduleFormValues, string>> = {};
-  for (const issue of result.error.issues) {
-    const path = issue.path[0] as keyof ScheduleFormValues | undefined;
-    if (path && !fieldErrors[path]) fieldErrors[path] = issue.message;
-  }
-  return fieldErrors;
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/ScheduleView/useScheduleView.ts

@@ -1,97 +0,0 @@
-import { useEffect, useMemo, useState } from "react";
-
-interface UseScheduleViewOptions {
-  onCronExpressionChange: (expression: string) => void;
-}
-
-export function useScheduleView({
-  onCronExpressionChange,
-}: UseScheduleViewOptions) {
-  const repeatOptions = useMemo(
-    () => [
-      { value: "daily", label: "Daily" },
-      { value: "weekly", label: "Weekly" },
-    ],
-    [],
-  );
-
-  const dayItems = useMemo(
-    () => [
-      { value: "0", label: "Su" },
-      { value: "1", label: "Mo" },
-      { value: "2", label: "Tu" },
-      { value: "3", label: "We" },
-      { value: "4", label: "Th" },
-      { value: "5", label: "Fr" },
-      { value: "6", label: "Sa" },
-    ],
-    [],
-  );
-
-  const [repeat, setRepeat] = useState<string>("weekly");
-  const [selectedDays, setSelectedDays] = useState<string[]>([]);
-  const [time, setTime] = useState<string>("00:00");
-
-  function handleRepeatChange(value: string) {
-    setRepeat(value);
-  }
-
-  function handleTimeChange(e: React.ChangeEvent<HTMLInputElement>) {
-    setTime(e.target.value.trim());
-  }
-
-  function parseTimeToHM(value: string): { h: number; m: number } {
-    const match = /^([01]?\d|2[0-3]):([0-5]\d)$/.exec(value || "");
-    if (!match) return { h: 0, m: 0 };
-    return { h: Number(match[1]), m: Number(match[2]) };
-  }
-
-  // Helpful default: when switching to Weekly with no days picked, preselect Monday
-  useEffect(() => {
-    if (repeat === "weekly" && selectedDays.length === 0)
-      setSelectedDays(["1"]);
-  }, [repeat, selectedDays]);
-
-  // Build cron string any time repeat/days/time change
-  useEffect(() => {
-    const { h, m } = parseTimeToHM(time);
-    const minute = String(m);
-    const hour = String(h);
-    if (repeat === "daily") {
-      onCronExpressionChange(`${minute} ${hour} * * *`);
-      return;
-    }
-
-    const dow = selectedDays.length ? selectedDays.join(",") : "*";
-    onCronExpressionChange(`${minute} ${hour} * * ${dow}`);
-  }, [repeat, selectedDays, time, onCronExpressionChange]);
-
-  function handleSelectAll() {
-    setSelectedDays(["0", "1", "2", "3", "4", "5", "6"]);
-  }
-
-  function handleWeekdays() {
-    setSelectedDays(["1", "2", "3", "4", "5"]);
-  }
-
-  function handleWeekends() {
-    setSelectedDays(["0", "6"]);
-  }
-
-  return {
-    // state
-    repeat,
-    selectedDays,
-    time,
-    // derived/static
-    repeatOptions,
-    dayItems,
-    // handlers
-    setSelectedDays,
-    handleRepeatChange,
-    handleTimeChange,
-    handleSelectAll,
-    handleWeekdays,
-    handleWeekends,
-  };
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/components/WebhookTriggerBanner/WebhookTriggerBanner.tsx

@@ -1,30 +0,0 @@
-export function WebhookTriggerBanner() {
-  return (
-    <div className="rounded-lg border border-blue-200 bg-blue-50 p-4">
-      <div className="flex items-start">
-        <div className="flex-shrink-0">
-          <svg
-            className="h-5 w-5 text-blue-400"
-            viewBox="0 0 20 20"
-            fill="currentColor"
-          >
-            <path
-              fillRule="evenodd"
-              d="M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7-4a1 1 0 11-2 0 1 1 0 012 0zM9 9a1 1 0 000 2v3a1 1 0 001 1h1a1 1 0 100-2v-3a1 1 0 00-1-1H9z"
-              clipRule="evenodd"
-            />
-          </svg>
-        </div>
-        <div className="ml-3">
-          <h3 className="text-sm font-medium text-blue-800">Webhook Trigger</h3>
-          <div className="mt-2 text-sm text-blue-700">
-            <p>
-              This will create a webhook endpoint that automatically runs your
-              agent when triggered by external events.
-            </p>
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/helpers.ts

@@ -1,67 +0,0 @@
-import { CredentialsMetaInput } from "@/app/api/__generated__/models/credentialsMetaInput";
-import { isEmpty } from "@/lib/utils";
-
-export function validateInputs(
-  inputSchema: any,
-  values: Record<string, any>,
-): Record<string, string> {
-  const errors: Record<string, string> = {};
-
-  if (!inputSchema?.properties) return errors;
-
-  const requiredFields = inputSchema.required || [];
-
-  for (const fieldName of requiredFields) {
-    const fieldSchema = inputSchema.properties[fieldName];
-    if (!fieldSchema?.hidden && isEmpty(values[fieldName])) {
-      errors[fieldName] = `${fieldSchema?.title || fieldName} is required`;
-    }
-  }
-
-  return errors;
-}
-
-export function validateCredentials(
-  credentialsSchema: any,
-  values: Record<string, CredentialsMetaInput>,
-): Record<string, string> {
-  const errors: Record<string, string> = {};
-
-  if (!credentialsSchema?.properties) return errors;
-
-  const credentialFields = Object.keys(credentialsSchema.properties);
-
-  for (const fieldName of credentialFields) {
-    if (!values[fieldName]) {
-      errors[fieldName] = `${fieldName} credentials are required`;
-    }
-  }
-
-  return errors;
-}
-
-export function formatCronExpression(cron: string): string {
-  // Basic cron expression formatting/validation
-  const parts = cron.trim().split(/\s+/);
-  if (parts.length !== 5) {
-    throw new Error(
-      "Cron expression must have exactly 5 parts: minute hour day month weekday",
-    );
-  }
-  return parts.join(" ");
-}
-
-export function parseCronDescription(cron: string): string {
-  // Simple cron description parser
-  const parts = cron.split(" ");
-  if (parts.length !== 5) return cron;
-
-  // Handle some common patterns
-  if (cron === "0 * * * *") return "Every hour";
-  if (cron === "0 9 * * *") return "Daily at 9:00 AM";
-  if (cron === "0 9 * * 1") return "Every Monday at 9:00 AM";
-  if (cron === "0 9 * * 1-5") return "Weekdays at 9:00 AM";
-  if (cron === "0 9 1 * *") return "Monthly on the 1st at 9:00 AM";
-
-  return cron; // Fallback to showing the raw cron
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/AgentRunsView/components/RunAgentModal/useAgentRunModal.ts

@@ -1,296 +0,0 @@
-import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
-import { useState, useCallback, useMemo } from "react";
-import { useToast } from "@/components/molecules/Toast/use-toast";
-import { isEmpty } from "@/lib/utils";
-import { usePostV1ExecuteGraphAgent } from "@/app/api/__generated__/endpoints/graphs/graphs";
-import { usePostV1CreateExecutionSchedule as useCreateSchedule } from "@/app/api/__generated__/endpoints/schedules/schedules";
-import { usePostV2SetupTrigger } from "@/app/api/__generated__/endpoints/presets/presets";
-import { ExecuteGraphResponse } from "@/app/api/__generated__/models/executeGraphResponse";
-import { GraphExecutionJobInfo } from "@/app/api/__generated__/models/graphExecutionJobInfo";
-import { LibraryAgentPreset } from "@/app/api/__generated__/models/libraryAgentPreset";
-
-export type RunVariant =
-  | "manual"
-  | "schedule"
-  | "automatic-trigger"
-  | "manual-trigger";
-
-interface UseAgentRunModalCallbacks {
-  onRun?: (execution: ExecuteGraphResponse) => void;
-  onCreateSchedule?: (schedule: GraphExecutionJobInfo) => void;
-  onSetupTrigger?: (preset: LibraryAgentPreset) => void;
-}
-
-export function useAgentRunModal(
-  agent: LibraryAgent,
-  callbacks?: UseAgentRunModalCallbacks,
-) {
-  const { toast } = useToast();
-  const [isOpen, setIsOpen] = useState(false);
-  const [showScheduleView, setShowScheduleView] = useState(false);
-  const [inputValues, setInputValues] = useState<Record<string, any>>({});
-  const defaultScheduleName = useMemo(() => `Run ${agent.name}`, [agent.name]);
-  const [scheduleName, setScheduleName] = useState(defaultScheduleName);
-  const [cronExpression, setCronExpression] = useState("0 9 * * 1");
-
-  // Determine the default run type based on agent capabilities
-  const defaultRunType: RunVariant = agent.has_external_trigger
-    ? "automatic-trigger"
-    : "manual";
-
-  // API mutations
-  const executeGraphMutation = usePostV1ExecuteGraphAgent({
-    mutation: {
-      onSuccess: (response) => {
-        if (response.status === 200) {
-          toast({
-            title: "✅ Agent execution started",
-            description: "Your agent is now running.",
-          });
-          callbacks?.onRun?.(response.data);
-          setIsOpen(false);
-        }
-      },
-      onError: (error: any) => {
-        toast({
-          title: "❌ Failed to execute agent",
-          description: error.message || "An unexpected error occurred.",
-          variant: "destructive",
-        });
-      },
-    },
-  });
-
-  const createScheduleMutation = useCreateSchedule({
-    mutation: {
-      onSuccess: (response) => {
-        if (response.status === 200) {
-          toast({
-            title: "✅ Schedule created",
-            description: `Agent scheduled to run: ${scheduleName}`,
-          });
-          callbacks?.onCreateSchedule?.(response.data);
-          setIsOpen(false);
-        }
-      },
-      onError: (error: any) => {
-        toast({
-          title: "❌ Failed to create schedule",
-          description: error.message || "An unexpected error occurred.",
-          variant: "destructive",
-        });
-      },
-    },
-  });
-
-  const setupTriggerMutation = usePostV2SetupTrigger({
-    mutation: {
-      onSuccess: (response: any) => {
-        if (response.status === 200) {
-          toast({
-            title: "✅ Trigger setup complete",
-            description: "Your webhook trigger is now active.",
-          });
-          callbacks?.onSetupTrigger?.(response.data);
-          setIsOpen(false);
-        }
-      },
-      onError: (error: any) => {
-        toast({
-          title: "❌ Failed to setup trigger",
-          description: error.message || "An unexpected error occurred.",
-          variant: "destructive",
-        });
-      },
-    },
-  });
-
-  // Input schema validation
-  const agentInputSchema = useMemo(
-    () => agent.input_schema || { properties: {}, required: [] },
-    [agent.input_schema],
-  );
-
-  const agentInputFields = useMemo(() => {
-    if (
-      !agentInputSchema ||
-      typeof agentInputSchema !== "object" ||
-      !("properties" in agentInputSchema) ||
-      !agentInputSchema.properties
-    ) {
-      return {};
-    }
-    const properties = agentInputSchema.properties as Record<string, any>;
-    return Object.fromEntries(
-      Object.entries(properties).filter(
-        ([_, subSchema]: [string, any]) => !subSchema.hidden,
-      ),
-    );
-  }, [agentInputSchema]);
-
-  // Validation logic
-  const [allRequiredInputsAreSet, missingInputs] = useMemo(() => {
-    const nonEmptyInputs = new Set(
-      Object.keys(inputValues).filter((k) => !isEmpty(inputValues[k])),
-    );
-    const requiredInputs = new Set(
-      (agentInputSchema.required as string[]) || [],
-    );
-    const missing = [...requiredInputs].filter(
-      (input) => !nonEmptyInputs.has(input),
-    );
-    return [missing.length === 0, missing];
-  }, [agentInputSchema.required, inputValues]);
-
-  const notifyMissingInputs = useCallback(
-    (needScheduleName: boolean = false) => {
-      const allMissingFields = (
-        needScheduleName && !scheduleName ? ["schedule_name"] : []
-      ).concat(missingInputs);
-
-      toast({
-        title: "⚠️ Missing required inputs",
-        description: `Please provide: ${allMissingFields.map((k) => `"${k}"`).join(", ")}`,
-        variant: "destructive",
-      });
-    },
-    [missingInputs, scheduleName, toast],
-  );
-
-  // Action handlers
-  const handleRun = useCallback(() => {
-    if (!allRequiredInputsAreSet) {
-      notifyMissingInputs();
-      return;
-    }
-
-    if (defaultRunType === "automatic-trigger") {
-      // Setup trigger
-      if (!scheduleName.trim()) {
-        toast({
-          title: "⚠️ Trigger name required",
-          description: "Please provide a name for your trigger.",
-          variant: "destructive",
-        });
-        return;
-      }
-
-      setupTriggerMutation.mutate({
-        data: {
-          name: scheduleName,
-          description: `Trigger for ${agent.name}`,
-          graph_id: agent.graph_id,
-          graph_version: agent.graph_version,
-          trigger_config: inputValues,
-          agent_credentials: {}, // TODO: Add credentials handling if needed
-        },
-      });
-    } else {
-      // Manual execution
-      executeGraphMutation.mutate({
-        graphId: agent.graph_id,
-        graphVersion: agent.graph_version,
-        data: {
-          inputs: inputValues,
-          credentials_inputs: {}, // TODO: Add credentials handling if needed
-        },
-      });
-    }
-  }, [
-    allRequiredInputsAreSet,
-    defaultRunType,
-    scheduleName,
-    inputValues,
-    agent,
-    notifyMissingInputs,
-    setupTriggerMutation,
-    executeGraphMutation,
-    toast,
-  ]);
-
-  const handleSchedule = useCallback(() => {
-    if (!allRequiredInputsAreSet) {
-      notifyMissingInputs(true);
-      return;
-    }
-
-    if (!scheduleName.trim()) {
-      toast({
-        title: "⚠️ Schedule name required",
-        description: "Please provide a name for your schedule.",
-        variant: "destructive",
-      });
-      return;
-    }
-
-    createScheduleMutation.mutate({
-      graphId: agent.graph_id,
-      data: {
-        name: scheduleName,
-        cron: cronExpression,
-        inputs: inputValues,
-        graph_version: agent.graph_version,
-        credentials: {}, // TODO: Add credentials handling if needed
-      },
-    });
-  }, [
-    allRequiredInputsAreSet,
-    scheduleName,
-    cronExpression,
-    inputValues,
-    agent,
-    notifyMissingInputs,
-    createScheduleMutation,
-    toast,
-  ]);
-
-  function handleShowSchedule() {
-    // Initialize with sensible defaults when entering schedule view
-    setScheduleName((prev) => prev || defaultScheduleName);
-    setCronExpression((prev) => prev || "0 9 * * 1");
-    setShowScheduleView(true);
-  }
-
-  function handleGoBack() {
-    setShowScheduleView(false);
-    // Reset schedule fields on exit
-    setScheduleName(defaultScheduleName);
-    setCronExpression("0 9 * * 1");
-  }
-
-  function handleSetScheduleName(name: string) {
-    setScheduleName(name);
-  }
-
-  function handleSetCronExpression(expression: string) {
-    setCronExpression(expression);
-  }
-
-  const hasInputFields = useMemo(() => {
-    return Object.keys(agentInputFields).length > 0;
-  }, [agentInputFields]);
-
-  return {
-    isOpen,
-    setIsOpen,
-    showScheduleView,
-    defaultRunType,
-    inputValues,
-    setInputValues,
-    scheduleName,
-    cronExpression,
-    allRequiredInputsAreSet,
-    missingInputs,
-    agentInputFields,
-    hasInputFields,
-    isExecuting: executeGraphMutation.isPending,
-    isCreatingSchedule: createScheduleMutation.isPending,
-    isSettingUpTrigger: setupTriggerMutation.isPending,
-    handleRun,
-    handleSchedule,
-    handleShowSchedule,
-    handleGoBack,
-    handleSetScheduleName,
-    handleSetCronExpression,
-  };
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/agent-run-draft-view.tsx

@@ -509,7 +509,7 @@ export function AgentRunDraftView({
 
   return (
     <div className={cn("agpt-div flex gap-6", className)}>
-      <div className="flex min-w-0 flex-1 flex-col gap-4">
+      <div className="flex flex-1 flex-col gap-4">
         <Card className="agpt-box">
           <CardHeader>
             <CardTitle className="font-poppins text-lg">Input</CardTitle>

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/agent-schedule-details-view.tsx

@@ -42,11 +42,8 @@ export function AgentScheduleDetailsView({
   const toastOnFail = useToastOnFail();
 
   // Get user's timezone for displaying schedule times
-  const { data: userTimezone } = useGetV1GetUserTimezone({
-    query: {
-      select: (res) => (res.status === 200 ? res.data.timezone : undefined),
-    },
-  });
+  const { data: timezoneData } = useGetV1GetUserTimezone();
+  const userTimezone = timezoneData?.data?.timezone || "UTC";
 
   const infoStats: { label: string; value: React.ReactNode }[] = useMemo(() => {
     return [

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/use-agent-runs.ts

@@ -1,6 +1,5 @@
 import {
   getV1ListGraphExecutionsResponse,
-  getV1ListGraphExecutionsResponse200,
   useGetV1ListGraphExecutionsInfinite,
 } from "@/app/api/__generated__/endpoints/graphs/graphs";
 import { GraphExecutionsPaginated } from "@/app/api/__generated__/models/graphExecutionsPaginated";
@@ -93,14 +92,12 @@ export const useAgentRunsInfinite = (graphID?: GraphID) => {
 
   const upsertAgentRun = (newAgentRun: GraphExecutionMeta) => {
     queryClient.setQueryData(
-      queryKey,
+      [queryKey, { page: 1, page_size: 20 }],
       (currentQueryData: typeof queryResults) => {
         if (!currentQueryData?.pages) return currentQueryData;
 
         const exists = currentQueryData.pages.some((page) => {
-          if (page.status !== 200) return false;
-
-          const response = page.data;
+          const response = page.data as GraphExecutionsPaginated;
           return response.executions.some((run) => run.id === newAgentRun.id);
         });
         if (exists) {
@@ -108,8 +105,7 @@ export const useAgentRunsInfinite = (graphID?: GraphID) => {
           return {
             ...currentQueryData,
             pages: currentQueryData.pages.map((page) => {
-              if (page.status !== 200) return page;
-              const response = page.data;
+              const response = page.data as GraphExecutionsPaginated;
               const executions = response.executions;
 
               const index = executions.findIndex(
@@ -126,24 +122,24 @@ export const useAgentRunsInfinite = (graphID?: GraphID) => {
                   ...response,
                   executions: newExecutions,
                 },
-              } satisfies getV1ListGraphExecutionsResponse;
+              };
             }),
           };
         }
 
         // If the run does not exist, we add it to the first page
-        const page = currentQueryData
-          .pages[0] as getV1ListGraphExecutionsResponse200 & {
-          headers: Headers;
-        };
-        const updatedExecutions = [newAgentRun, ...page.data.executions];
+        const page = currentQueryData.pages[0];
+        const updatedExecutions = [
+          newAgentRun,
+          ...(page.data as GraphExecutionsPaginated).executions,
+        ];
         const updatedPage = {
           ...page,
           data: {
             ...page.data,
             executions: updatedExecutions,
           },
-        } satisfies getV1ListGraphExecutionsResponse;
+        };
         const updatedPages = [updatedPage, ...currentQueryData.pages.slice(1)];
         return {
           ...currentQueryData,

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

@@ -1,115 +0,0 @@
-import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
-import { StarRatingIcons } from "@/components/ui/icons";
-
-interface CreatorInfoCardProps {
-  username: string;
-  handle: string;
-  avatarSrc: string;
-  categories: string[];
-  averageRating: number;
-  totalRuns: number;
-}
-
-export const CreatorInfoCard = ({
-  username,
-  handle,
-  avatarSrc,
-  categories,
-  averageRating,
-  totalRuns,
-}: CreatorInfoCardProps) => {
-  return (
-    <div
-      className="inline-flex h-auto min-h-[500px] w-full max-w-[440px] flex-col items-start justify-between rounded-[26px] bg-violet-100 p-4 dark:bg-violet-900 sm:h-[632px] sm:w-[440px] sm:p-6"
-      role="article"
-      aria-label={`Creator profile for ${username}`}
-    >
-      <div className="flex w-full flex-col items-start justify-start gap-3.5 sm:h-[218px]">
-        <Avatar className="h-[100px] w-[100px] sm:h-[130px] sm:w-[130px]">
-          <AvatarImage
-            width={130}
-            height={130}
-            src={avatarSrc}
-            alt={`${username}'s avatar`}
-          />
-          <AvatarFallback
-            size={130}
-            className="h-[100px] w-[100px] sm:h-[130px] sm:w-[130px]"
-          >
-            {username.charAt(0)}
-          </AvatarFallback>
-        </Avatar>
-        <div className="flex w-full flex-col items-start justify-start gap-1.5">
-          <div
-            data-testid="creator-title"
-            className="w-full font-poppins text-[35px] font-medium leading-10 text-neutral-900 dark:text-neutral-100 sm:text-[35px] sm:leading-10"
-          >
-            {username}
-          </div>
-          <div className="w-full text-lg font-normal leading-6 text-neutral-800 dark:text-neutral-200 sm:text-xl sm:leading-7">
-            @{handle}
-          </div>
-        </div>
-      </div>
-
-      <div className="my-4 flex w-full flex-col items-start justify-start gap-6 sm:gap-[50px]">
-        <div className="flex w-full flex-col items-start justify-start gap-3">
-          <div className="h-px w-full bg-neutral-700 dark:bg-neutral-300" />
-          <div className="flex flex-col items-start justify-start gap-2.5">
-            <div className="w-full text-base font-medium leading-normal text-neutral-800 dark:text-neutral-200">
-              Top categories
-            </div>
-            <div
-              className="flex flex-wrap items-center gap-2.5"
-              role="list"
-              aria-label="Categories"
-            >
-              {categories.map((category, index) => (
-                <div
-                  key={index}
-                  className="flex items-center justify-center gap-2.5 rounded-[34px] border border-neutral-600 px-4 py-3 dark:border-neutral-400"
-                  role="listitem"
-                >
-                  <div className="text-base font-normal leading-normal text-neutral-800 dark:text-neutral-200">
-                    {category}
-                  </div>
-                </div>
-              ))}
-            </div>
-          </div>
-        </div>
-
-        <div className="flex w-full flex-col items-start justify-start gap-3">
-          <div className="h-px w-full bg-neutral-700 dark:bg-neutral-300" />
-          <div className="flex w-full flex-col items-start justify-between gap-4 sm:flex-row sm:gap-0">
-            <div className="flex w-full flex-col items-start justify-start gap-2.5 sm:w-[164px]">
-              <div className="w-full text-base font-medium leading-normal text-neutral-800 dark:text-neutral-200">
-                Average rating
-              </div>
-              <div className="inline-flex items-center gap-2">
-                <div className="text-[18px] font-semibold leading-[28px] text-neutral-800 dark:text-neutral-200">
-                  {averageRating.toFixed(1)}
-                </div>
-                <div
-                  className="flex items-center gap-px"
-                  role="img"
-                  aria-label={`Rating: ${averageRating} out of 5 stars`}
-                >
-                  {StarRatingIcons(averageRating)}
-                </div>
-              </div>
-            </div>
-            <div className="flex w-full flex-col items-start justify-start gap-2.5 sm:w-[164px]">
-              <div className="w-full text-base font-medium leading-normal text-neutral-800 dark:text-neutral-200">
-                Number of runs
-              </div>
-              <div className="text-[18px] font-semibold leading-[28px] text-neutral-800 dark:text-neutral-200">
-                {new Intl.NumberFormat().format(totalRuns)} runs
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-};

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

@@ -1,43 +0,0 @@
-import { getIconForSocial } from "@/components/ui/icons";
-import { Fragment } from "react";
-
-interface CreatorLinksProps {
-  links: string[];
-}
-
-export const CreatorLinks = ({ links }: CreatorLinksProps) => {
-  if (!links || links.length === 0) {
-    return null;
-  }
-
-  const renderLinkButton = (url: string) => (
-    <a
-      href={url}
-      target="_blank"
-      rel="noopener noreferrer"
-      className="flex min-w-[200px] flex-1 items-center justify-between rounded-[34px] border border-neutral-600 px-5 py-3 dark:border-neutral-400"
-    >
-      <div className="text-base font-medium leading-normal text-neutral-800 dark:text-neutral-200">
-        {new URL(url).hostname.replace("www.", "")}
-      </div>
-      <div className="relative h-6 w-6">
-        {getIconForSocial(url, {
-          className: "h-6 w-6 text-neutral-800 dark:text-neutral-200",
-        })}
-      </div>
-    </a>
-  );
-
-  return (
-    <div className="flex flex-col items-start justify-start gap-4">
-      <div className="text-base font-medium leading-normal text-neutral-800 dark:text-neutral-200">
-        Other links
-      </div>
-      <div className="flex w-full flex-wrap gap-3">
-        {links.map((link, index) => (
-          <Fragment key={index}>{renderLinkButton(link)}</Fragment>
-        ))}
-      </div>
-    </div>
-  );
-};

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

@@ -1,40 +0,0 @@
-import { Skeleton } from "@/components/ui/skeleton";
-
-export const CreatorPageLoading = () => {
-  return (
-    <div className="mx-auto w-screen max-w-[1360px]">
-      <main className="mt-5 px-4">
-        <Skeleton className="mb-4 h-6 w-40" />
-
-        <div className="mt-4 flex flex-col items-start gap-4 sm:mt-6 sm:gap-6 md:mt-8 md:flex-row md:gap-8">
-          <div className="w-full md:w-auto md:shrink-0">
-            <Skeleton className="h-80 w-80 rounded-xl" />
-            <div className="mt-4 space-y-2">
-              <Skeleton className="h-6 w-80" />
-              <Skeleton className="h-4 w-80" />
-            </div>
-          </div>
-
-          <div className="flex min-w-0 flex-1 flex-col gap-4">
-            <Skeleton className="h-6 w-24" />
-            <Skeleton className="h-8 w-full max-w-xl" />
-            <Skeleton className="h-4 w-1/2" />
-            <div className="flex gap-2">
-              <Skeleton className="h-8 w-8 rounded-full" />
-              <Skeleton className="h-8 w-8 rounded-full" />
-            </div>
-          </div>
-        </div>
-
-        <div className="mt-8">
-          <Skeleton className="mb-6 h-px w-full" />
-          <div className="grid grid-cols-1 gap-6 sm:grid-cols-2 md:grid-cols-3">
-            {Array.from({ length: 3 }).map((_, i) => (
-              <Skeleton key={i} className="h-32 w-full rounded-lg" />
-            ))}
-          </div>
-        </div>
-      </main>
-    </div>
-  );
-};

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

@@ -1,90 +0,0 @@
-"use client";
-
-import { Separator } from "@/components/ui/separator";
-import { AgentsSection } from "../AgentsSection/AgentsSection";
-import { MarketplaceCreatorPageParams } from "../../creator/[creator]/page";
-import { Breadcrumbs } from "@/components/molecules/Breadcrumbs/Breadcrumbs";
-import { CreatorInfoCard } from "../CreatorInfoCard/CreatorInfoCard";
-import { CreatorLinks } from "../CreatorLinks/CreatorLinks";
-import { useMainCreatorPage } from "./useMainCreatorPage";
-import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
-import { CreatorPageLoading } from "../CreatorPageLoading";
-
-interface MainCreatorPageProps {
-  params: MarketplaceCreatorPageParams;
-}
-
-export const MainCreatorPage = ({ params }: MainCreatorPageProps) => {
-  const { creatorAgents, creator, isLoading, hasError } = useMainCreatorPage({
-    params,
-  });
-
-  if (isLoading) return <CreatorPageLoading />;
-
-  if (hasError) {
-    return (
-      <div className="mx-auto w-screen max-w-[1360px]">
-        <div className="flex min-h-[60vh] items-center justify-center">
-          <ErrorCard
-            isSuccess={false}
-            responseError={{ message: "Failed to load creator data" }}
-            context="creator page"
-            onRetry={() => window.location.reload()}
-            className="w-full max-w-md"
-          />
-        </div>
-      </div>
-    );
-  }
-
-  if (creator)
-    return (
-      <div className="mx-auto w-screen max-w-[1360px]">
-        <main className="mt-5 px-4">
-          <Breadcrumbs
-            items={[
-              { name: "Store", link: "/marketplace" },
-              { name: creator.name, link: "#" },
-            ]}
-          />
-
-          <div className="mt-4 flex flex-col items-start gap-4 sm:mt-6 sm:gap-6 md:mt-8 md:flex-row md:gap-8">
-            <div className="w-full md:w-auto md:shrink-0">
-              <CreatorInfoCard
-                username={creator.name}
-                handle={creator.username}
-                avatarSrc={creator.avatar_url}
-                categories={creator.top_categories}
-                averageRating={creator.agent_rating}
-                totalRuns={creator.agent_runs}
-              />
-            </div>
-            <div className="flex min-w-0 flex-1 flex-col gap-4 sm:gap-6 md:gap-8">
-              <p className="text-underline-position-from-font text-decoration-skip-none text-left font-poppins text-base font-medium leading-6">
-                About
-              </p>
-              <div
-                className="text-[48px] font-normal leading-[59px] text-neutral-900 dark:text-zinc-50"
-                style={{ whiteSpace: "pre-line" }}
-                data-testid="creator-description"
-              >
-                {creator.description}
-              </div>
-
-              <CreatorLinks links={creator.links} />
-            </div>
-          </div>
-          <div className="mt-8 sm:mt-12 md:mt-16 lg:pb-[58px]">
-            <Separator className="mb-6 bg-gray-200" />
-            {creatorAgents && (
-              <AgentsSection
-                agents={creatorAgents.agents}
-                hideAvatars={true}
-                sectionTitle={`Agents by ${creator.name}`}
-              />
-            )}
-          </div>
-        </main>
-      </div>
-    );
-};

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainCreatorPage/useMainCreatorPage.ts

@@ -1,50 +0,0 @@
-import {
-  useGetV2GetCreatorDetails,
-  useGetV2ListStoreAgents,
-} from "@/app/api/__generated__/endpoints/store/store";
-import { StoreAgentsResponse } from "@/app/api/__generated__/models/storeAgentsResponse";
-import { MarketplaceCreatorPageParams } from "../../creator/[creator]/page";
-import { CreatorDetails } from "@/app/api/__generated__/models/creatorDetails";
-
-interface useMainCreatorPageProps {
-  params: MarketplaceCreatorPageParams;
-}
-
-export const useMainCreatorPage = ({ params }: useMainCreatorPageProps) => {
-  const {
-    data: creatorAgents,
-    isLoading: isCreatorAgentsLoading,
-    isError: isCreatorAgentsError,
-  } = useGetV2ListStoreAgents(
-    { creator: params.creator },
-    {
-      query: {
-        select: (x) => {
-          return x.data as StoreAgentsResponse;
-        },
-      },
-    },
-  );
-
-  const {
-    data: creator,
-    isLoading: isCreatorDetailsLoading,
-    isError: isCreatorDetailsError,
-  } = useGetV2GetCreatorDetails(params.creator, {
-    query: {
-      select: (x) => {
-        return x.data as CreatorDetails;
-      },
-    },
-  });
-
-  const isLoading = isCreatorAgentsLoading || isCreatorDetailsLoading;
-  const hasError = isCreatorAgentsError || isCreatorDetailsError;
-
-  return {
-    creatorAgents,
-    creator,
-    isLoading,
-    hasError,
-  };
-};

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

@@ -6,29 +6,52 @@ import { HeroSection } from "../HeroSection/HeroSection";
 import { AgentsSection } from "../AgentsSection/AgentsSection";
 import { useMainMarketplacePage } from "./useMainMarketplacePage";
 import { FeaturedCreators } from "../FeaturedCreators/FeaturedCreators";
-import { MainMarketplacePageLoading } from "../MainMarketplacePageLoading";
-import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
+import { Skeleton } from "@/components/ui/skeleton";
 
 export const MainMarkeplacePage = () => {
   const { featuredAgents, topAgents, featuredCreators, isLoading, hasError } =
     useMainMarketplacePage();
 
+  // FRONTEND-TODO : Add better Loading Skeletons
   if (isLoading) {
-    return <MainMarketplacePageLoading />;
+    return (
+      <div className="mx-auto w-screen max-w-[1360px]">
+        <main className="px-4">
+          <div className="flex flex-col gap-2 pt-16">
+            <div className="flex flex-col items-center justify-center gap-8">
+              <Skeleton className="h-16 w-[60%]" />
+              <Skeleton className="h-12 w-[40%]" />
+            </div>
+            <div className="flex flex-col items-center justify-center gap-8 pt-8">
+              <Skeleton className="h-8 w-[60%]" />
+            </div>
+            <div className="mx-auto flex w-[80%] flex-wrap items-center justify-center gap-8 pt-24">
+              <Skeleton className="h-[12rem] w-[12rem]" />
+              <Skeleton className="h-[12rem] w-[12rem]" />
+              <Skeleton className="h-[12rem] w-[12rem]" />
+              <Skeleton className="h-[12rem] w-[12rem]" />
+              <Skeleton className="h-[12rem] w-[12rem]" />
+              <Skeleton className="h-[12rem] w-[12rem]" />
+              <Skeleton className="h-[12rem] w-[12rem]" />
+              <Skeleton className="h-[12rem] w-[12rem]" />
+              <Skeleton className="h-[12rem] w-[12rem]" />
+              <Skeleton className="h-[12rem] w-[12rem]" />
+            </div>
+          </div>
+        </main>
+      </div>
+    );
   }
 
+  // FRONTEND-TODO : Add better Error UI
   if (hasError) {
     return (
       <div className="mx-auto w-screen max-w-[1360px]">
         <main className="px-4">
           <div className="flex min-h-[400px] items-center justify-center">
-            <ErrorCard
-              isSuccess={false}
-              responseError={{ message: "Failed to load marketplace data" }}
-              context="marketplace page"
-              onRetry={() => window.location.reload()}
-              className="w-full max-w-md"
-            />
+            <div className="text-lg text-red-500">
+              Error loading marketplace data. Please try again later.
+            </div>
           </div>
         </main>
       </div>

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

@@ -1,31 +0,0 @@
-import { Skeleton } from "@/components/ui/skeleton";
-
-export const MainMarketplacePageLoading = () => {
-  return (
-    <div className="mx-auto w-screen max-w-[1360px]">
-      <main className="px-4">
-        <div className="flex flex-col gap-2 pt-16">
-          <div className="flex flex-col items-center justify-center gap-8">
-            <Skeleton className="h-16 w-[60%]" />
-            <Skeleton className="h-12 w-[40%]" />
-          </div>
-          <div className="flex flex-col items-center justify-center gap-8 pt-8">
-            <Skeleton className="h-8 w-[60%]" />
-          </div>
-          <div className="mx-auto flex w-[80%] flex-wrap items-center justify-center gap-8 pt-24">
-            <Skeleton className="h-[12rem] w-[12rem]" />
-            <Skeleton className="h-[12rem] w-[12rem]" />
-            <Skeleton className="h-[12rem] w-[12rem]" />
-            <Skeleton className="h-[12rem] w-[12rem]" />
-            <Skeleton className="h-[12rem] w-[12rem]" />
-            <Skeleton className="h-[12rem] w-[12rem]" />
-            <Skeleton className="h-[12rem] w-[12rem]" />
-            <Skeleton className="h-[12rem] w-[12rem]" />
-            <Skeleton className="h-[12rem] w-[12rem]" />
-            <Skeleton className="h-[12rem] w-[12rem]" />
-          </div>
-        </div>
-      </main>
-    </div>
-  );
-};