added ability to disable cors at the backend

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

@@ -3,7 +3,6 @@ name: AutoGPT Platform - Deploy Prod Environment
 on:
   release:
     types: [published]
-  workflow_dispatch:
 
 permissions:
   contents: 'read'
@@ -18,8 +17,6 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
-        with:
-          ref: ${{ github.ref_name || 'master' }}
 
       - name: Set up Python
         uses: actions/setup-python@v5
@@ -39,7 +36,7 @@ jobs:
           DATABASE_URL: ${{ secrets.BACKEND_DATABASE_URL }}
           DIRECT_URL: ${{ secrets.BACKEND_DATABASE_URL }}
 
-
+          
   trigger:
     needs: migrate
     runs-on: ubuntu-latest
@@ -50,5 +47,4 @@ jobs:
           token: ${{ secrets.DEPLOY_TOKEN }}
           repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
           event-type: build_deploy_prod
-          client-payload: |
-            {"ref": "${{ github.ref_name || 'master' }}", "repository": "${{ github.repository }}"}
+          client-payload: '{"ref": "${{ github.ref }}", "sha": "${{ github.sha }}", "repository": "${{ github.repository }}"}'

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

@@ -5,13 +5,6 @@ on:
     branches: [ dev ]
     paths:
       - 'autogpt_platform/**'
-  workflow_dispatch:
-    inputs:
-      git_ref:
-        description: 'Git ref (branch/tag) of AutoGPT to deploy'
-        required: true
-        default: 'master'
-        type: string
 
 permissions:
   contents: 'read'
@@ -26,8 +19,6 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.inputs.git_ref || github.ref_name }}
 
       - name: Set up Python
         uses: actions/setup-python@v5
@@ -57,4 +48,4 @@ jobs:
           token: ${{ secrets.DEPLOY_TOKEN }}
           repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
           event-type: build_deploy_dev
-          client-payload: '{"ref": "${{ github.event.inputs.git_ref || github.ref }}", "repository": "${{ github.repository }}"}'
+          client-payload: '{"ref": "${{ github.ref }}", "sha": "${{ github.sha }}", "repository": "${{ github.repository }}"}'

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

@@ -37,7 +37,9 @@ jobs:
 
     services:
       redis:
-        image: redis:latest
+        image: bitnami/redis:6.2
+        env:
+          REDIS_PASSWORD: testpassword
         ports:
           - 6379:6379
       rabbitmq:
@@ -202,6 +204,7 @@ jobs:
           JWT_VERIFY_KEY: ${{ steps.supabase.outputs.JWT_SECRET }}
           REDIS_HOST: "localhost"
           REDIS_PORT: "6379"
+          REDIS_PASSWORD: "testpassword"
           ENCRYPTION_KEY: "dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw=" # DO NOT USE IN PRODUCTION!!
 
     env:

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/config.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from pydantic import Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
@@ -15,8 +13,8 @@ class RateLimitSettings(BaseSettings):
         default="6379", description="Redis port", validation_alias="REDIS_PORT"
     )
 
-    redis_password: Optional[str] = Field(
-        default=None,
+    redis_password: str = Field(
+        default="password",
         description="Redis password",
         validation_alias="REDIS_PASSWORD",
     )

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/limiter.py

@@ -11,7 +11,7 @@ class RateLimiter:
         self,
         redis_host: str = RATE_LIMIT_SETTINGS.redis_host,
         redis_port: str = RATE_LIMIT_SETTINGS.redis_port,
-        redis_password: str | None = RATE_LIMIT_SETTINGS.redis_password,
+        redis_password: str = RATE_LIMIT_SETTINGS.redis_password,
         requests_per_minute: int = RATE_LIMIT_SETTINGS.requests_per_minute,
     ):
         self.redis = Redis(

autogpt_platform/autogpt_libs/autogpt_libs/utils/cache.py

@@ -1,68 +1,90 @@
-import asyncio
 import inspect
 import logging
 import threading
 import time
 from functools import wraps
 from typing import (
-    Any,
+    Awaitable,
     Callable,
     ParamSpec,
     Protocol,
+    Tuple,
     TypeVar,
     cast,
+    overload,
     runtime_checkable,
 )
 
 P = ParamSpec("P")
 R = TypeVar("R")
-R_co = TypeVar("R_co", covariant=True)
 
 logger = logging.getLogger(__name__)
 
 
-def _make_hashable_key(
-    args: tuple[Any, ...], kwargs: dict[str, Any]
-) -> tuple[Any, ...]:
-    """
-    Convert args and kwargs into a hashable cache key.
+@overload
+def thread_cached(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
+    pass
 
-    Handles unhashable types like dict, list, set by converting them to
-    their sorted string representations.
-    """
 
-    def make_hashable(obj: Any) -> Any:
-        """Recursively convert an object to a hashable representation."""
-        if isinstance(obj, dict):
-            # Sort dict items to ensure consistent ordering
-            return (
-                "__dict__",
-                tuple(sorted((k, make_hashable(v)) for k, v in obj.items())),
-            )
-        elif isinstance(obj, (list, tuple)):
-            return ("__list__", tuple(make_hashable(item) for item in obj))
-        elif isinstance(obj, set):
-            return ("__set__", tuple(sorted(make_hashable(item) for item in obj)))
-        elif hasattr(obj, "__dict__"):
-            # Handle objects with __dict__ attribute
-            return ("__obj__", obj.__class__.__name__, make_hashable(obj.__dict__))
-        else:
-            # For basic hashable types (str, int, bool, None, etc.)
-            try:
-                hash(obj)
-                return obj
-            except TypeError:
-                # Fallback: convert to string representation
-                return ("__str__", str(obj))
+@overload
+def thread_cached(func: Callable[P, R]) -> Callable[P, R]:
+    pass
 
-    hashable_args = tuple(make_hashable(arg) for arg in args)
-    hashable_kwargs = tuple(sorted((k, make_hashable(v)) for k, v in kwargs.items()))
-    return (hashable_args, hashable_kwargs)
+
+def thread_cached(
+    func: Callable[P, R] | Callable[P, Awaitable[R]],
+) -> Callable[P, R] | Callable[P, Awaitable[R]]:
+    thread_local = threading.local()
+
+    def _clear():
+        if hasattr(thread_local, "cache"):
+            del thread_local.cache
+
+    if inspect.iscoroutinefunction(func):
+
+        async def async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            cache = getattr(thread_local, "cache", None)
+            if cache is None:
+                cache = thread_local.cache = {}
+            key = (args, tuple(sorted(kwargs.items())))
+            if key not in cache:
+                cache[key] = await cast(Callable[P, Awaitable[R]], func)(
+                    *args, **kwargs
+                )
+            return cache[key]
+
+        setattr(async_wrapper, "clear_cache", _clear)
+        return async_wrapper
+
+    else:
+
+        def sync_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            cache = getattr(thread_local, "cache", None)
+            if cache is None:
+                cache = thread_local.cache = {}
+            key = (args, tuple(sorted(kwargs.items())))
+            if key not in cache:
+                cache[key] = func(*args, **kwargs)
+            return cache[key]
+
+        setattr(sync_wrapper, "clear_cache", _clear)
+        return sync_wrapper
+
+
+def clear_thread_cache(func: Callable) -> None:
+    if clear := getattr(func, "clear_cache", None):
+        clear()
+
+
+FuncT = TypeVar("FuncT")
+
+
+R_co = TypeVar("R_co", covariant=True)
 
 
 @runtime_checkable
-class CachedFunction(Protocol[P, R_co]):
-    """Protocol for cached functions with cache management methods."""
+class AsyncCachedFunction(Protocol[P, R_co]):
+    """Protocol for async functions with cache management methods."""
 
     def cache_clear(self) -> None:
         """Clear all cached entries."""
@@ -72,169 +94,101 @@ class CachedFunction(Protocol[P, R_co]):
         """Get cache statistics."""
         return {}
 
-    def cache_delete(self, *args: P.args, **kwargs: P.kwargs) -> bool:
-        """Delete a specific cache entry by its arguments. Returns True if entry existed."""
-        return False
-
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R_co:
+    async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R_co:
         """Call the cached function."""
         return None  # type: ignore
 
 
-def cached(
-    *,
-    maxsize: int = 128,
-    ttl_seconds: int | None = None,
-) -> Callable[[Callable], CachedFunction]:
+def async_ttl_cache(
+    maxsize: int = 128, ttl_seconds: int | None = None
+) -> Callable[[Callable[P, Awaitable[R]]], AsyncCachedFunction[P, R]]:
     """
-    Thundering herd safe cache decorator for both sync and async functions.
+    TTL (Time To Live) cache decorator for async functions.
 
-    Uses double-checked locking to prevent multiple threads/coroutines from
-    executing the expensive operation simultaneously during cache misses.
+    Similar to functools.lru_cache but works with async functions and includes optional TTL.
 
     Args:
-        func: The function to cache (when used without parentheses)
         maxsize: Maximum number of cached entries
-        ttl_seconds: Time to live in seconds. If None, entries never expire
+        ttl_seconds: Time to live in seconds. If None, entries never expire (like lru_cache)
 
     Returns:
-        Decorated function or decorator
+        Decorator function
 
     Example:
-        @cache()  # Default: maxsize=128, no TTL
-        def expensive_sync_operation(param: str) -> dict:
+        # With TTL
+        @async_ttl_cache(maxsize=1000, ttl_seconds=300)
+        async def api_call(param: str) -> dict:
             return {"result": param}
 
-        @cache()  # Works with async too
-        async def expensive_async_operation(param: str) -> dict:
-            return {"result": param}
-
-        @cache(maxsize=1000, ttl_seconds=300)  # Custom maxsize and TTL
-        def another_operation(param: str) -> dict:
+        # Without TTL (permanent cache like lru_cache)
+        @async_ttl_cache(maxsize=1000)
+        async def expensive_computation(param: str) -> dict:
             return {"result": param}
     """
 
-    def decorator(target_func):
-        # Cache storage and locks
-        cache_storage = {}
+    def decorator(
+        async_func: Callable[P, Awaitable[R]],
+    ) -> AsyncCachedFunction[P, R]:
+        # Cache storage - use union type to handle both cases
+        cache_storage: dict[tuple, R | Tuple[R, float]] = {}
 
-        if inspect.iscoroutinefunction(target_func):
-            # Async function with asyncio.Lock
-            cache_lock = asyncio.Lock()
+        @wraps(async_func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            # Create cache key from arguments
+            key = (args, tuple(sorted(kwargs.items())))
+            current_time = time.time()
 
-            @wraps(target_func)
-            async def async_wrapper(*args: P.args, **kwargs: P.kwargs):
-                key = _make_hashable_key(args, kwargs)
-                current_time = time.time()
-
-                # Fast path: check cache without lock
-                if key in cache_storage:
-                    if ttl_seconds is None:
-                        logger.debug(f"Cache hit for {target_func.__name__}")
-                        return cache_storage[key]
-                    else:
-                        cached_data = cache_storage[key]
-                        if isinstance(cached_data, tuple):
-                            result, timestamp = cached_data
-                            if current_time - timestamp < ttl_seconds:
-                                logger.debug(f"Cache hit for {target_func.__name__}")
-                                return result
-
-                # Slow path: acquire lock for cache miss/expiry
-                async with cache_lock:
-                    # Double-check: another coroutine might have populated cache
-                    if key in cache_storage:
-                        if ttl_seconds is None:
-                            return cache_storage[key]
+            # Check if we have a valid cached entry
+            if key in cache_storage:
+                if ttl_seconds is None:
+                    # No TTL - return cached result directly
+                    logger.debug(
+                        f"Cache hit for {async_func.__name__} with key: {str(key)[:50]}"
+                    )
+                    return cast(R, cache_storage[key])
+                else:
+                    # With TTL - check expiration
+                    cached_data = cache_storage[key]
+                    if isinstance(cached_data, tuple):
+                        result, timestamp = cached_data
+                        if current_time - timestamp < ttl_seconds:
+                            logger.debug(
+                                f"Cache hit for {async_func.__name__} with key: {str(key)[:50]}"
+                            )
+                            return cast(R, result)
                         else:
-                            cached_data = cache_storage[key]
-                            if isinstance(cached_data, tuple):
-                                result, timestamp = cached_data
-                                if current_time - timestamp < ttl_seconds:
-                                    return result
+                            # Expired entry
+                            del cache_storage[key]
+                            logger.debug(
+                                f"Cache entry expired for {async_func.__name__}"
+                            )
 
-                    # Cache miss - execute function
-                    logger.debug(f"Cache miss for {target_func.__name__}")
-                    result = await target_func(*args, **kwargs)
+            # Cache miss or expired - fetch fresh data
+            logger.debug(
+                f"Cache miss for {async_func.__name__} with key: {str(key)[:50]}"
+            )
+            result = await async_func(*args, **kwargs)
 
-                    # Store result
-                    if ttl_seconds is None:
-                        cache_storage[key] = result
-                    else:
-                        cache_storage[key] = (result, current_time)
+            # Store in cache
+            if ttl_seconds is None:
+                cache_storage[key] = result
+            else:
+                cache_storage[key] = (result, current_time)
 
-                    # Cleanup if needed
-                    if len(cache_storage) > maxsize:
-                        cutoff = maxsize // 2
-                        oldest_keys = (
-                            list(cache_storage.keys())[:-cutoff] if cutoff > 0 else []
-                        )
-                        for old_key in oldest_keys:
-                            cache_storage.pop(old_key, None)
+            # Simple cleanup when cache gets too large
+            if len(cache_storage) > maxsize:
+                # Remove oldest entries (simple FIFO cleanup)
+                cutoff = maxsize // 2
+                oldest_keys = list(cache_storage.keys())[:-cutoff] if cutoff > 0 else []
+                for old_key in oldest_keys:
+                    cache_storage.pop(old_key, None)
+                logger.debug(
+                    f"Cache cleanup: removed {len(oldest_keys)} entries for {async_func.__name__}"
+                )
 
-                    return result
+            return result
 
-            wrapper = async_wrapper
-
-        else:
-            # Sync function with threading.Lock
-            cache_lock = threading.Lock()
-
-            @wraps(target_func)
-            def sync_wrapper(*args: P.args, **kwargs: P.kwargs):
-                key = _make_hashable_key(args, kwargs)
-                current_time = time.time()
-
-                # Fast path: check cache without lock
-                if key in cache_storage:
-                    if ttl_seconds is None:
-                        logger.debug(f"Cache hit for {target_func.__name__}")
-                        return cache_storage[key]
-                    else:
-                        cached_data = cache_storage[key]
-                        if isinstance(cached_data, tuple):
-                            result, timestamp = cached_data
-                            if current_time - timestamp < ttl_seconds:
-                                logger.debug(f"Cache hit for {target_func.__name__}")
-                                return result
-
-                # Slow path: acquire lock for cache miss/expiry
-                with cache_lock:
-                    # Double-check: another thread might have populated cache
-                    if key in cache_storage:
-                        if ttl_seconds is None:
-                            return cache_storage[key]
-                        else:
-                            cached_data = cache_storage[key]
-                            if isinstance(cached_data, tuple):
-                                result, timestamp = cached_data
-                                if current_time - timestamp < ttl_seconds:
-                                    return result
-
-                    # Cache miss - execute function
-                    logger.debug(f"Cache miss for {target_func.__name__}")
-                    result = target_func(*args, **kwargs)
-
-                    # Store result
-                    if ttl_seconds is None:
-                        cache_storage[key] = result
-                    else:
-                        cache_storage[key] = (result, current_time)
-
-                    # Cleanup if needed
-                    if len(cache_storage) > maxsize:
-                        cutoff = maxsize // 2
-                        oldest_keys = (
-                            list(cache_storage.keys())[:-cutoff] if cutoff > 0 else []
-                        )
-                        for old_key in oldest_keys:
-                            cache_storage.pop(old_key, None)
-
-                    return result
-
-            wrapper = sync_wrapper
-
-        # Add cache management methods
+        # Add cache management methods (similar to functools.lru_cache)
         def cache_clear() -> None:
             cache_storage.clear()
 
@@ -245,84 +199,68 @@ def cached(
                 "ttl_seconds": ttl_seconds,
             }
 
-        def cache_delete(*args, **kwargs) -> bool:
-            """Delete a specific cache entry. Returns True if entry existed."""
-            key = _make_hashable_key(args, kwargs)
-            if key in cache_storage:
-                del cache_storage[key]
-                return True
-            return False
-
+        # Attach methods to wrapper
         setattr(wrapper, "cache_clear", cache_clear)
         setattr(wrapper, "cache_info", cache_info)
-        setattr(wrapper, "cache_delete", cache_delete)
 
-        return cast(CachedFunction, wrapper)
+        return cast(AsyncCachedFunction[P, R], wrapper)
 
     return decorator
 
 
-def thread_cached(func):
-    """
-    Thread-local cache decorator for both sync and async functions.
+@overload
+def async_cache(
+    func: Callable[P, Awaitable[R]],
+) -> AsyncCachedFunction[P, R]:
+    pass
 
-    Each thread gets its own cache, which is useful for request-scoped caching
-    in web applications where you want to cache within a single request but
-    not across requests.
+
+@overload
+def async_cache(
+    func: None = None,
+    *,
+    maxsize: int = 128,
+) -> Callable[[Callable[P, Awaitable[R]]], AsyncCachedFunction[P, R]]:
+    pass
+
+
+def async_cache(
+    func: Callable[P, Awaitable[R]] | None = None,
+    *,
+    maxsize: int = 128,
+) -> (
+    AsyncCachedFunction[P, R]
+    | Callable[[Callable[P, Awaitable[R]]], AsyncCachedFunction[P, R]]
+):
+    """
+    Process-level cache decorator for async functions (no TTL).
+
+    Similar to functools.lru_cache but works with async functions.
+    This is a convenience wrapper around async_ttl_cache with ttl_seconds=None.
 
     Args:
-        func: The function to cache
+        func: The async function to cache (when used without parentheses)
+        maxsize: Maximum number of cached entries
 
     Returns:
-        Decorated function with thread-local caching
+        Decorated function or decorator
 
     Example:
-        @thread_cached
-        def expensive_operation(param: str) -> dict:
+        # Without parentheses (uses default maxsize=128)
+        @async_cache
+        async def get_data(param: str) -> dict:
             return {"result": param}
 
-        @thread_cached  # Works with async too
-        async def expensive_async_operation(param: str) -> dict:
+        # With parentheses and custom maxsize
+        @async_cache(maxsize=1000)
+        async def expensive_computation(param: str) -> dict:
+            # Expensive computation here
             return {"result": param}
     """
-    thread_local = threading.local()
-
-    def _clear():
-        if hasattr(thread_local, "cache"):
-            del thread_local.cache
-
-    if inspect.iscoroutinefunction(func):
-
-        @wraps(func)
-        async def async_wrapper(*args, **kwargs):
-            cache = getattr(thread_local, "cache", None)
-            if cache is None:
-                cache = thread_local.cache = {}
-            key = _make_hashable_key(args, kwargs)
-            if key not in cache:
-                cache[key] = await func(*args, **kwargs)
-            return cache[key]
-
-        setattr(async_wrapper, "clear_cache", _clear)
-        return async_wrapper
-
+    if func is None:
+        # Called with parentheses @async_cache() or @async_cache(maxsize=...)
+        return async_ttl_cache(maxsize=maxsize, ttl_seconds=None)
     else:
-
-        @wraps(func)
-        def sync_wrapper(*args, **kwargs):
-            cache = getattr(thread_local, "cache", None)
-            if cache is None:
-                cache = thread_local.cache = {}
-            key = _make_hashable_key(args, kwargs)
-            if key not in cache:
-                cache[key] = func(*args, **kwargs)
-            return cache[key]
-
-        setattr(sync_wrapper, "clear_cache", _clear)
-        return sync_wrapper
-
-
-def clear_thread_cache(func: Callable) -> None:
-    """Clear thread-local cache for a function."""
-    if clear := getattr(func, "clear_cache", None):
-        clear()
+        # Called without parentheses @async_cache
+        decorator = async_ttl_cache(maxsize=maxsize, ttl_seconds=None)
+        return decorator(func)

autogpt_platform/autogpt_libs/autogpt_libs/utils/cache_test.py

@@ -16,7 +16,12 @@ from unittest.mock import Mock
 
 import pytest
 
-from autogpt_libs.utils.cache import cached, clear_thread_cache, thread_cached
+from autogpt_libs.utils.cache import (
+    async_cache,
+    async_ttl_cache,
+    clear_thread_cache,
+    thread_cached,
+)
 
 
 class TestThreadCached:
@@ -325,202 +330,102 @@ class TestThreadCached:
         assert mock.call_count == 2
 
 
-class TestCache:
-    """Tests for the unified @cache decorator (works for both sync and async)."""
-
-    def test_basic_sync_caching(self):
-        """Test basic sync caching functionality."""
-        call_count = 0
-
-        @cached()
-        def expensive_sync_function(x: int, y: int = 0) -> int:
-            nonlocal call_count
-            call_count += 1
-            return x + y
-
-        # First call
-        result1 = expensive_sync_function(1, 2)
-        assert result1 == 3
-        assert call_count == 1
-
-        # Second call with same args - should use cache
-        result2 = expensive_sync_function(1, 2)
-        assert result2 == 3
-        assert call_count == 1
-
-        # Different args - should call function again
-        result3 = expensive_sync_function(2, 3)
-        assert result3 == 5
-        assert call_count == 2
+class TestAsyncTTLCache:
+    """Tests for the @async_ttl_cache decorator."""
 
     @pytest.mark.asyncio
-    async def test_basic_async_caching(self):
-        """Test basic async caching functionality."""
+    async def test_basic_caching(self):
+        """Test basic caching functionality."""
         call_count = 0
 
-        @cached()
-        async def expensive_async_function(x: int, y: int = 0) -> int:
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def cached_function(x: int, y: int = 0) -> int:
             nonlocal call_count
             call_count += 1
             await asyncio.sleep(0.01)  # Simulate async work
             return x + y
 
         # First call
-        result1 = await expensive_async_function(1, 2)
+        result1 = await cached_function(1, 2)
         assert result1 == 3
         assert call_count == 1
 
         # Second call with same args - should use cache
-        result2 = await expensive_async_function(1, 2)
+        result2 = await cached_function(1, 2)
         assert result2 == 3
-        assert call_count == 1
+        assert call_count == 1  # No additional call
 
         # Different args - should call function again
-        result3 = await expensive_async_function(2, 3)
+        result3 = await cached_function(2, 3)
         assert result3 == 5
         assert call_count == 2
 
-    def test_sync_thundering_herd_protection(self):
-        """Test that concurrent sync calls don't cause thundering herd."""
-        call_count = 0
-        results = []
-
-        @cached()
-        def slow_function(x: int) -> int:
-            nonlocal call_count
-            call_count += 1
-            time.sleep(0.1)  # Simulate expensive operation
-            return x * x
-
-        def worker():
-            result = slow_function(5)
-            results.append(result)
-
-        # Launch multiple concurrent threads
-        with ThreadPoolExecutor(max_workers=5) as executor:
-            futures = [executor.submit(worker) for _ in range(5)]
-            for future in futures:
-                future.result()
-
-        # All results should be the same
-        assert all(result == 25 for result in results)
-        # Only one thread should have executed the expensive operation
-        assert call_count == 1
-
     @pytest.mark.asyncio
-    async def test_async_thundering_herd_protection(self):
-        """Test that concurrent async calls don't cause thundering herd."""
+    async def test_ttl_expiration(self):
+        """Test that cache entries expire after TTL."""
         call_count = 0
 
-        @cached()
-        async def slow_async_function(x: int) -> int:
+        @async_ttl_cache(maxsize=10, ttl_seconds=1)  # Short TTL
+        async def short_lived_cache(x: int) -> int:
             nonlocal call_count
             call_count += 1
-            await asyncio.sleep(0.1)  # Simulate expensive operation
-            return x * x
-
-        # Launch concurrent coroutines
-        tasks = [slow_async_function(7) for _ in range(5)]
-        results = await asyncio.gather(*tasks)
-
-        # All results should be the same
-        assert all(result == 49 for result in results)
-        # Only one coroutine should have executed the expensive operation
-        assert call_count == 1
-
-    def test_ttl_functionality(self):
-        """Test TTL functionality with sync function."""
-        call_count = 0
-
-        @cached(maxsize=10, ttl_seconds=1)  # Short TTL
-        def ttl_function(x: int) -> int:
-            nonlocal call_count
-            call_count += 1
-            return x * 3
+            return x * 2
 
         # First call
-        result1 = ttl_function(3)
-        assert result1 == 9
+        result1 = await short_lived_cache(5)
+        assert result1 == 10
         assert call_count == 1
 
         # Second call immediately - should use cache
-        result2 = ttl_function(3)
-        assert result2 == 9
-        assert call_count == 1
-
-        # Wait for TTL to expire
-        time.sleep(1.1)
-
-        # Third call after expiration - should call function again
-        result3 = ttl_function(3)
-        assert result3 == 9
-        assert call_count == 2
-
-    @pytest.mark.asyncio
-    async def test_async_ttl_functionality(self):
-        """Test TTL functionality with async function."""
-        call_count = 0
-
-        @cached(maxsize=10, ttl_seconds=1)  # Short TTL
-        async def async_ttl_function(x: int) -> int:
-            nonlocal call_count
-            call_count += 1
-            await asyncio.sleep(0.01)
-            return x * 4
-
-        # First call
-        result1 = await async_ttl_function(3)
-        assert result1 == 12
-        assert call_count == 1
-
-        # Second call immediately - should use cache
-        result2 = await async_ttl_function(3)
-        assert result2 == 12
+        result2 = await short_lived_cache(5)
+        assert result2 == 10
         assert call_count == 1
 
         # Wait for TTL to expire
         await asyncio.sleep(1.1)
 
         # Third call after expiration - should call function again
-        result3 = await async_ttl_function(3)
-        assert result3 == 12
+        result3 = await short_lived_cache(5)
+        assert result3 == 10
         assert call_count == 2
 
-    def test_cache_info(self):
+    @pytest.mark.asyncio
+    async def test_cache_info(self):
         """Test cache info functionality."""
 
-        @cached(maxsize=10, ttl_seconds=60)
-        def info_test_function(x: int) -> int:
+        @async_ttl_cache(maxsize=5, ttl_seconds=300)
+        async def info_test_function(x: int) -> int:
             return x * 3
 
         # Check initial cache info
         info = info_test_function.cache_info()
         assert info["size"] == 0
-        assert info["maxsize"] == 10
-        assert info["ttl_seconds"] == 60
+        assert info["maxsize"] == 5
+        assert info["ttl_seconds"] == 300
 
         # Add an entry
-        info_test_function(1)
+        await info_test_function(1)
         info = info_test_function.cache_info()
         assert info["size"] == 1
 
-    def test_cache_clear(self):
+    @pytest.mark.asyncio
+    async def test_cache_clear(self):
         """Test cache clearing functionality."""
         call_count = 0
 
-        @cached()
-        def clearable_function(x: int) -> int:
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def clearable_function(x: int) -> int:
             nonlocal call_count
             call_count += 1
             return x * 4
 
         # First call
-        result1 = clearable_function(2)
+        result1 = await clearable_function(2)
         assert result1 == 8
         assert call_count == 1
 
         # Second call - should use cache
-        result2 = clearable_function(2)
+        result2 = await clearable_function(2)
         assert result2 == 8
         assert call_count == 1
 
@@ -528,149 +433,273 @@ class TestCache:
         clearable_function.cache_clear()
 
         # Third call after clear - should call function again
-        result3 = clearable_function(2)
+        result3 = await clearable_function(2)
         assert result3 == 8
         assert call_count == 2
 
     @pytest.mark.asyncio
-    async def test_async_cache_clear(self):
-        """Test cache clearing functionality with async function."""
+    async def test_maxsize_cleanup(self):
+        """Test that cache cleans up when maxsize is exceeded."""
         call_count = 0
 
-        @cached()
-        async def async_clearable_function(x: int) -> int:
+        @async_ttl_cache(maxsize=3, ttl_seconds=60)
+        async def size_limited_function(x: int) -> int:
             nonlocal call_count
             call_count += 1
-            await asyncio.sleep(0.01)
-            return x * 5
+            return x**2
 
-        # First call
-        result1 = await async_clearable_function(2)
+        # Fill cache to maxsize
+        await size_limited_function(1)  # call_count: 1
+        await size_limited_function(2)  # call_count: 2
+        await size_limited_function(3)  # call_count: 3
+
+        info = size_limited_function.cache_info()
+        assert info["size"] == 3
+
+        # Add one more entry - should trigger cleanup
+        await size_limited_function(4)  # call_count: 4
+
+        # Cache size should be reduced (cleanup removes oldest entries)
+        info = size_limited_function.cache_info()
+        assert info["size"] is not None and info["size"] <= 3  # Should be cleaned up
+
+    @pytest.mark.asyncio
+    async def test_argument_variations(self):
+        """Test caching with different argument patterns."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def arg_test_function(a: int, b: str = "default", *, c: int = 100) -> str:
+            nonlocal call_count
+            call_count += 1
+            return f"{a}-{b}-{c}"
+
+        # Different ways to call with same logical arguments
+        result1 = await arg_test_function(1, "test", c=200)
+        assert call_count == 1
+
+        # Same arguments, same order - should use cache
+        result2 = await arg_test_function(1, "test", c=200)
+        assert call_count == 1
+        assert result1 == result2
+
+        # Different arguments - should call function
+        result3 = await arg_test_function(2, "test", c=200)
+        assert call_count == 2
+        assert result1 != result3
+
+    @pytest.mark.asyncio
+    async def test_exception_handling(self):
+        """Test that exceptions are not cached."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def exception_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            if x < 0:
+                raise ValueError("Negative value not allowed")
+            return x * 2
+
+        # Successful call - should be cached
+        result1 = await exception_function(5)
         assert result1 == 10
         assert call_count == 1
 
-        # Second call - should use cache
-        result2 = await async_clearable_function(2)
+        # Same successful call - should use cache
+        result2 = await exception_function(5)
         assert result2 == 10
         assert call_count == 1
 
-        # Clear cache
-        async_clearable_function.cache_clear()
-
-        # Third call after clear - should call function again
-        result3 = await async_clearable_function(2)
-        assert result3 == 10
+        # Exception call - should not be cached
+        with pytest.raises(ValueError):
+            await exception_function(-1)
         assert call_count == 2
 
+        # Same exception call - should call again (not cached)
+        with pytest.raises(ValueError):
+            await exception_function(-1)
+        assert call_count == 3
+
     @pytest.mark.asyncio
-    async def test_async_function_returns_results_not_coroutines(self):
-        """Test that cached async functions return actual results, not coroutines."""
+    async def test_concurrent_calls(self):
+        """Test caching behavior with concurrent calls."""
         call_count = 0
 
-        @cached()
-        async def async_result_function(x: int) -> str:
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def concurrent_function(x: int) -> int:
             nonlocal call_count
             call_count += 1
-            await asyncio.sleep(0.01)
-            return f"result_{x}"
+            await asyncio.sleep(0.05)  # Simulate work
+            return x * x
+
+        # Launch concurrent calls with same arguments
+        tasks = [concurrent_function(3) for _ in range(5)]
+        results = await asyncio.gather(*tasks)
+
+        # All results should be the same
+        assert all(result == 9 for result in results)
+
+        # Note: Due to race conditions, call_count might be up to 5 for concurrent calls
+        # This tests that the cache doesn't break under concurrent access
+        assert 1 <= call_count <= 5
+
+
+class TestAsyncCache:
+    """Tests for the @async_cache decorator (no TTL)."""
+
+    @pytest.mark.asyncio
+    async def test_basic_caching_no_ttl(self):
+        """Test basic caching functionality without TTL."""
+        call_count = 0
+
+        @async_cache(maxsize=10)
+        async def cached_function(x: int, y: int = 0) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)  # Simulate async work
+            return x + y
 
         # First call
-        result1 = await async_result_function(1)
-        assert result1 == "result_1"
-        assert isinstance(result1, str)  # Should be string, not coroutine
+        result1 = await cached_function(1, 2)
+        assert result1 == 3
         assert call_count == 1
 
-        # Second call - should return cached result (string), not coroutine
-        result2 = await async_result_function(1)
-        assert result2 == "result_1"
-        assert isinstance(result2, str)  # Should be string, not coroutine
-        assert call_count == 1  # Function should not be called again
+        # Second call with same args - should use cache
+        result2 = await cached_function(1, 2)
+        assert result2 == 3
+        assert call_count == 1  # No additional call
 
-        # Verify results are identical
-        assert result1 is result2  # Should be same cached object
+        # Third call after some time - should still use cache (no TTL)
+        await asyncio.sleep(0.05)
+        result3 = await cached_function(1, 2)
+        assert result3 == 3
+        assert call_count == 1  # Still no additional call
 
-    def test_cache_delete(self):
-        """Test selective cache deletion functionality."""
-        call_count = 0
-
-        @cached()
-        def deletable_function(x: int) -> int:
-            nonlocal call_count
-            call_count += 1
-            return x * 6
-
-        # First call for x=1
-        result1 = deletable_function(1)
-        assert result1 == 6
-        assert call_count == 1
-
-        # First call for x=2
-        result2 = deletable_function(2)
-        assert result2 == 12
+        # Different args - should call function again
+        result4 = await cached_function(2, 3)
+        assert result4 == 5
         assert call_count == 2
 
-        # Second calls - should use cache
-        assert deletable_function(1) == 6
-        assert deletable_function(2) == 12
-        assert call_count == 2
-
-        # Delete specific entry for x=1
-        was_deleted = deletable_function.cache_delete(1)
-        assert was_deleted is True
-
-        # Call with x=1 should execute function again
-        result3 = deletable_function(1)
-        assert result3 == 6
-        assert call_count == 3
-
-        # Call with x=2 should still use cache
-        assert deletable_function(2) == 12
-        assert call_count == 3
-
-        # Try to delete non-existent entry
-        was_deleted = deletable_function.cache_delete(99)
-        assert was_deleted is False
-
     @pytest.mark.asyncio
-    async def test_async_cache_delete(self):
-        """Test selective cache deletion functionality with async function."""
+    async def test_no_ttl_vs_ttl_behavior(self):
+        """Test the difference between TTL and no-TTL caching."""
+        ttl_call_count = 0
+        no_ttl_call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=1)  # Short TTL
+        async def ttl_function(x: int) -> int:
+            nonlocal ttl_call_count
+            ttl_call_count += 1
+            return x * 2
+
+        @async_cache(maxsize=10)  # No TTL
+        async def no_ttl_function(x: int) -> int:
+            nonlocal no_ttl_call_count
+            no_ttl_call_count += 1
+            return x * 2
+
+        # First calls
+        await ttl_function(5)
+        await no_ttl_function(5)
+        assert ttl_call_count == 1
+        assert no_ttl_call_count == 1
+
+        # Wait for TTL to expire
+        await asyncio.sleep(1.1)
+
+        # Second calls after TTL expiry
+        await ttl_function(5)  # Should call function again (TTL expired)
+        await no_ttl_function(5)  # Should use cache (no TTL)
+        assert ttl_call_count == 2  # TTL function called again
+        assert no_ttl_call_count == 1  # No-TTL function still cached
+
+    @pytest.mark.asyncio
+    async def test_async_cache_info(self):
+        """Test cache info for no-TTL cache."""
+
+        @async_cache(maxsize=5)
+        async def info_test_function(x: int) -> int:
+            return x * 3
+
+        # Check initial cache info
+        info = info_test_function.cache_info()
+        assert info["size"] == 0
+        assert info["maxsize"] == 5
+        assert info["ttl_seconds"] is None  # No TTL
+
+        # Add an entry
+        await info_test_function(1)
+        info = info_test_function.cache_info()
+        assert info["size"] == 1
+
+
+class TestTTLOptional:
+    """Tests for optional TTL functionality."""
+
+    @pytest.mark.asyncio
+    async def test_ttl_none_behavior(self):
+        """Test that ttl_seconds=None works like no TTL."""
         call_count = 0
 
-        @cached()
-        async def async_deletable_function(x: int) -> int:
+        @async_ttl_cache(maxsize=10, ttl_seconds=None)
+        async def no_ttl_via_none(x: int) -> int:
             nonlocal call_count
             call_count += 1
-            await asyncio.sleep(0.01)
-            return x * 7
+            return x**2
 
-        # First call for x=1
-        result1 = await async_deletable_function(1)
-        assert result1 == 7
+        # First call
+        result1 = await no_ttl_via_none(3)
+        assert result1 == 9
         assert call_count == 1
 
-        # First call for x=2
-        result2 = await async_deletable_function(2)
-        assert result2 == 14
-        assert call_count == 2
+        # Wait (would expire if there was TTL)
+        await asyncio.sleep(0.1)
 
-        # Second calls - should use cache
-        assert await async_deletable_function(1) == 7
-        assert await async_deletable_function(2) == 14
-        assert call_count == 2
+        # Second call - should still use cache
+        result2 = await no_ttl_via_none(3)
+        assert result2 == 9
+        assert call_count == 1  # No additional call
 
-        # Delete specific entry for x=1
-        was_deleted = async_deletable_function.cache_delete(1)
-        assert was_deleted is True
+        # Check cache info
+        info = no_ttl_via_none.cache_info()
+        assert info["ttl_seconds"] is None
 
-        # Call with x=1 should execute function again
-        result3 = await async_deletable_function(1)
-        assert result3 == 7
-        assert call_count == 3
+    @pytest.mark.asyncio
+    async def test_cache_options_comparison(self):
+        """Test different cache options work as expected."""
+        ttl_calls = 0
+        no_ttl_calls = 0
 
-        # Call with x=2 should still use cache
-        assert await async_deletable_function(2) == 14
-        assert call_count == 3
+        @async_ttl_cache(maxsize=10, ttl_seconds=1)  # With TTL
+        async def ttl_function(x: int) -> int:
+            nonlocal ttl_calls
+            ttl_calls += 1
+            return x * 10
 
-        # Try to delete non-existent entry
-        was_deleted = async_deletable_function.cache_delete(99)
-        assert was_deleted is False
+        @async_cache(maxsize=10)  # Process-level cache (no TTL)
+        async def process_function(x: int) -> int:
+            nonlocal no_ttl_calls
+            no_ttl_calls += 1
+            return x * 10
+
+        # Both should cache initially
+        await ttl_function(3)
+        await process_function(3)
+        assert ttl_calls == 1
+        assert no_ttl_calls == 1
+
+        # Immediate second calls - both should use cache
+        await ttl_function(3)
+        await process_function(3)
+        assert ttl_calls == 1
+        assert no_ttl_calls == 1
+
+        # Wait for TTL to expire
+        await asyncio.sleep(1.1)
+
+        # After TTL expiry
+        await ttl_function(3)  # Should call function again
+        await process_function(3)  # Should still use cache
+        assert ttl_calls == 2  # TTL cache expired, called again
+        assert no_ttl_calls == 1  # Process cache never expires

autogpt_platform/backend/.env.default

@@ -21,7 +21,7 @@ PRISMA_SCHEMA="postgres/schema.prisma"
 # Redis Configuration
 REDIS_HOST=localhost
 REDIS_PORT=6379
-# REDIS_PASSWORD=
+REDIS_PASSWORD=password
 
 # RabbitMQ Credentials
 RABBITMQ_DEFAULT_USER=rabbitmq_user_default
@@ -66,11 +66,6 @@ NVIDIA_API_KEY=
 GITHUB_CLIENT_ID=
 GITHUB_CLIENT_SECRET=
 
-# Notion OAuth App server credentials - https://developers.notion.com/docs/authorization
-# Configure a public integration
-NOTION_CLIENT_ID=
-NOTION_CLIENT_SECRET=
-
 # Google OAuth App server credentials - https://console.cloud.google.com/apis/credentials, and enable gmail api and set scopes
 # https://console.cloud.google.com/apis/credentials/consent ?project=<your_project_id>
 # You'll need to add/enable the following scopes (minimum):

autogpt_platform/backend/.gitignore

@@ -9,12 +9,4 @@ secrets/*
 !secrets/.gitkeep
 
 *.ignore.*
-*.ign.*
-
-# Load test results and reports
-load-tests/*_RESULTS.md
-load-tests/*_REPORT.md
-load-tests/results/
-load-tests/*.json
-load-tests/*.log
-load-tests/node_modules/*
+*.ign.*

autogpt_platform/backend/Dockerfile

@@ -9,15 +9,8 @@ WORKDIR /app
 
 RUN echo 'Acquire::http::Pipeline-Depth 0;\nAcquire::http::No-Cache true;\nAcquire::BrokenProxy true;\n' > /etc/apt/apt.conf.d/99fixbadproxy
 
-# Install Node.js repository key and setup
+# Update package list and install Python and build dependencies
 RUN apt-get update --allow-releaseinfo-change --fix-missing \
-    && apt-get install -y curl ca-certificates gnupg \
-    && mkdir -p /etc/apt/keyrings \
-    && curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg \
-    && echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
-
-# Update package list and install Python, Node.js, and build dependencies
-RUN apt-get update \
     && apt-get install -y \
     python3.13 \
     python3.13-dev \
@@ -27,9 +20,7 @@ RUN apt-get update \
     libpq5 \
     libz-dev \
     libssl-dev \
-    postgresql-client \
-    nodejs \
-    && rm -rf /var/lib/apt/lists/*
+    postgresql-client
 
 ENV POETRY_HOME=/opt/poetry
 ENV POETRY_NO_INTERACTION=1
@@ -63,18 +54,13 @@ ENV PATH=/opt/poetry/bin:$PATH
 # Install Python without upgrading system-managed packages
 RUN apt-get update && apt-get install -y \
     python3.13 \
-    python3-pip \
-    && rm -rf /var/lib/apt/lists/*
+    python3-pip
 
 # Copy only necessary files from builder
 COPY --from=builder /app /app
 COPY --from=builder /usr/local/lib/python3* /usr/local/lib/python3*
 COPY --from=builder /usr/local/bin/poetry /usr/local/bin/poetry
-# Copy Node.js installation for Prisma
-COPY --from=builder /usr/bin/node /usr/bin/node
-COPY --from=builder /usr/lib/node_modules /usr/lib/node_modules
-COPY --from=builder /usr/bin/npm /usr/bin/npm
-COPY --from=builder /usr/bin/npx /usr/bin/npx
+# Copy Prisma binaries
 COPY --from=builder /root/.cache/prisma-python/binaries /root/.cache/prisma-python/binaries
 
 ENV PATH="/app/autogpt_platform/backend/.venv/bin:$PATH"

autogpt_platform/backend/backend/blocks/__init__.py

@@ -1,3 +1,4 @@
+import functools
 import importlib
 import logging
 import os
@@ -5,8 +6,6 @@ import re
 from pathlib import Path
 from typing import TYPE_CHECKING, TypeVar
 
-from autogpt_libs.utils.cache import cached
-
 logger = logging.getLogger(__name__)
 
 
@@ -16,7 +15,7 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 
 
-@cached()
+@functools.cache
 def load_all_blocks() -> dict[str, type["Block"]]:
     from backend.data.block import Block
     from backend.util.settings import Config

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

@@ -241,7 +241,6 @@ class AirtableCreateRecordsBlock(Block):
 
     class Output(BlockSchema):
         records: list[dict] = SchemaField(description="Array of created record objects")
-        details: dict = SchemaField(description="Details of the created records")
 
     def __init__(self):
         super().__init__(
@@ -280,9 +279,6 @@ class AirtableCreateRecordsBlock(Block):
             result_records = normalized_data["records"]
 
         yield "records", result_records
-        details = data.get("details", None)
-        if details:
-            yield "details", details
 
 
 class AirtableUpdateRecordsBlock(Block):

autogpt_platform/backend/backend/blocks/dataforseo/_api.py

@@ -113,7 +113,6 @@ class DataForSeoClient:
         include_serp_info: bool = False,
         include_clickstream_data: bool = False,
         limit: int = 100,
-        depth: Optional[int] = None,
     ) -> List[Dict[str, Any]]:
         """
         Get related keywords from DataForSEO Labs.
@@ -126,7 +125,6 @@ class DataForSeoClient:
             include_serp_info: Include SERP data
             include_clickstream_data: Include clickstream metrics
             limit: Maximum number of results (up to 3000)
-            depth: Keyword search depth (0-4), controls number of returned keywords
 
         Returns:
             API response with related keywords
@@ -150,8 +148,6 @@ class DataForSeoClient:
             task_data["include_clickstream_data"] = include_clickstream_data
         if limit is not None:
             task_data["limit"] = limit
-        if depth is not None:
-            task_data["depth"] = depth
 
         payload = [task_data]
 

autogpt_platform/backend/backend/blocks/dataforseo/related_keywords.py

@@ -78,12 +78,6 @@ class DataForSeoRelatedKeywordsBlock(Block):
             ge=1,
             le=3000,
         )
-        depth: int = SchemaField(
-            description="Keyword search depth (0-4). Controls the number of returned keywords: 0=1 keyword, 1=~8 keywords, 2=~72 keywords, 3=~584 keywords, 4=~4680 keywords",
-            default=1,
-            ge=0,
-            le=4,
-        )
 
     class Output(BlockSchema):
         related_keywords: List[RelatedKeyword] = SchemaField(
@@ -160,7 +154,6 @@ class DataForSeoRelatedKeywordsBlock(Block):
             include_serp_info=input_data.include_serp_info,
             include_clickstream_data=input_data.include_clickstream_data,
             limit=input_data.limit,
-            depth=input_data.depth,
         )
 
     async def run(

autogpt_platform/backend/backend/blocks/io.py

@@ -10,6 +10,7 @@ from backend.util.settings import Config
 from backend.util.text import TextFormatter
 from backend.util.type import LongTextType, MediaFileType, ShortTextType
 
+formatter = TextFormatter()
 config = Config()
 
 
@@ -131,11 +132,6 @@ class AgentOutputBlock(Block):
             default="",
             advanced=True,
         )
-        escape_html: bool = SchemaField(
-            default=False,
-            advanced=True,
-            description="Whether to escape special characters in the inserted values to be HTML-safe. Enable for HTML output, disable for plain text.",
-        )
         advanced: bool = SchemaField(
             description="Whether to treat the output as advanced.",
             default=False,
@@ -197,7 +193,6 @@ class AgentOutputBlock(Block):
         """
         if input_data.format:
             try:
-                formatter = TextFormatter(autoescape=input_data.escape_html)
                 yield "output", formatter.format_string(
                     input_data.format, {input_data.name: input_data.value}
                 )

autogpt_platform/backend/backend/blocks/llm.py

@@ -1,9 +1,5 @@
-# This file contains a lot of prompt block strings that would trigger "line too long"
-# flake8: noqa: E501
 import ast
 import logging
-import re
-import secrets
 from abc import ABC
 from enum import Enum, EnumMeta
 from json import JSONDecodeError
@@ -31,7 +27,7 @@ from backend.util.prompt import compress_prompt, estimate_token_count
 from backend.util.text import TextFormatter
 
 logger = TruncatedLogger(logging.getLogger(__name__), "[LLM-Block]")
-fmt = TextFormatter(autoescape=False)
+fmt = TextFormatter()
 
 LLMProviderName = Literal[
     ProviderName.AIML_API,
@@ -208,13 +204,13 @@ MODEL_METADATA = {
         "anthropic", 200000, 32000
     ),  # claude-opus-4-1-20250805
     LlmModel.CLAUDE_4_OPUS: ModelMetadata(
-        "anthropic", 200000, 32000
+        "anthropic", 200000, 8192
     ),  # claude-4-opus-20250514
     LlmModel.CLAUDE_4_SONNET: ModelMetadata(
-        "anthropic", 200000, 64000
+        "anthropic", 200000, 8192
     ),  # claude-4-sonnet-20250514
     LlmModel.CLAUDE_3_7_SONNET: ModelMetadata(
-        "anthropic", 200000, 64000
+        "anthropic", 200000, 8192
     ),  # claude-3-7-sonnet-20250219
     LlmModel.CLAUDE_3_5_SONNET: ModelMetadata(
         "anthropic", 200000, 8192
@@ -386,9 +382,7 @@ def extract_openai_tool_calls(response) -> list[ToolContentBlock] | None:
     return None
 
 
-def get_parallel_tool_calls_param(
-    llm_model: LlmModel, parallel_tool_calls: bool | None
-):
+def get_parallel_tool_calls_param(llm_model: LlmModel, parallel_tool_calls):
     """Get the appropriate parallel_tool_calls parameter for OpenAI-compatible APIs."""
     if llm_model.startswith("o") or parallel_tool_calls is None:
         return openai.NOT_GIVEN
@@ -399,8 +393,8 @@ async def llm_call(
     credentials: APIKeyCredentials,
     llm_model: LlmModel,
     prompt: list[dict],
+    json_format: bool,
     max_tokens: int | None,
-    force_json_output: bool = False,
     tools: list[dict] | None = None,
     ollama_host: str = "localhost:11434",
     parallel_tool_calls=None,
@@ -413,7 +407,7 @@ async def llm_call(
         credentials: The API key credentials to use.
         llm_model: The LLM model to use.
         prompt: The prompt to send to the LLM.
-        force_json_output: Whether the response should be in JSON format.
+        json_format: Whether the response should be in JSON format.
         max_tokens: The maximum number of tokens to generate in the chat completion.
         tools: The tools to use in the chat completion.
         ollama_host: The host for ollama to use.
@@ -452,7 +446,7 @@ async def llm_call(
             llm_model, parallel_tool_calls
         )
 
-        if force_json_output:
+        if json_format:
             response_format = {"type": "json_object"}
 
         response = await oai_client.chat.completions.create(
@@ -565,7 +559,7 @@ async def llm_call(
             raise ValueError("Groq does not support tools.")
 
         client = AsyncGroq(api_key=credentials.api_key.get_secret_value())
-        response_format = {"type": "json_object"} if force_json_output else None
+        response_format = {"type": "json_object"} if json_format else None
         response = await client.chat.completions.create(
             model=llm_model.value,
             messages=prompt,  # type: ignore
@@ -723,7 +717,7 @@ async def llm_call(
         )
 
         response_format = None
-        if force_json_output:
+        if json_format:
             response_format = {"type": "json_object"}
 
         parallel_tool_calls_param = get_parallel_tool_calls_param(
@@ -786,17 +780,6 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
             description="The language model to use for answering the prompt.",
             advanced=False,
         )
-        force_json_output: bool = SchemaField(
-            title="Restrict LLM to pure JSON output",
-            default=False,
-            description=(
-                "Whether to force the LLM to produce a JSON-only response. "
-                "This can increase the block's reliability, "
-                "but may also reduce the quality of the response "
-                "because it prohibits the LLM from reasoning "
-                "before providing its JSON response."
-            ),
-        )
         credentials: AICredentials = AICredentialsField()
         sys_prompt: str = SchemaField(
             title="System Prompt",
@@ -865,18 +848,17 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
                 "llm_call": lambda *args, **kwargs: LLMResponse(
                     raw_response="",
                     prompt=[""],
-                    response=(
-                        '<json_output id="test123456">{\n'
-                        '  "key1": "key1Value",\n'
-                        '  "key2": "key2Value"\n'
-                        "}</json_output>"
+                    response=json.dumps(
+                        {
+                            "key1": "key1Value",
+                            "key2": "key2Value",
+                        }
                     ),
                     tool_calls=None,
                     prompt_tokens=0,
                     completion_tokens=0,
                     reasoning=None,
-                ),
-                "get_collision_proof_output_tag_id": lambda *args: "test123456",
+                )
             },
         )
 
@@ -885,9 +867,9 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
         credentials: APIKeyCredentials,
         llm_model: LlmModel,
         prompt: list[dict],
+        json_format: bool,
+        compress_prompt_to_fit: bool,
         max_tokens: int | None,
-        force_json_output: bool = False,
-        compress_prompt_to_fit: bool = True,
         tools: list[dict] | None = None,
         ollama_host: str = "localhost:11434",
     ) -> LLMResponse:
@@ -900,8 +882,8 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
             credentials=credentials,
             llm_model=llm_model,
             prompt=prompt,
+            json_format=json_format,
             max_tokens=max_tokens,
-            force_json_output=force_json_output,
             tools=tools,
             ollama_host=ollama_host,
             compress_prompt_to_fit=compress_prompt_to_fit,
@@ -913,6 +895,10 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
         logger.debug(f"Calling LLM with input data: {input_data}")
         prompt = [json.to_dict(p) for p in input_data.conversation_history]
 
+        def trim_prompt(s: str) -> str:
+            lines = s.strip().split("\n")
+            return "\n".join([line.strip().lstrip("|") for line in lines])
+
         values = input_data.prompt_values
         if values:
             input_data.prompt = fmt.format_string(input_data.prompt, values)
@@ -921,15 +907,27 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
         if input_data.sys_prompt:
             prompt.append({"role": "system", "content": input_data.sys_prompt})
 
-        # Use a one-time unique tag to prevent collisions with user/LLM content
-        output_tag_id = self.get_collision_proof_output_tag_id()
-        output_tag_start = f'<json_output id="{output_tag_id}">'
         if input_data.expected_format:
-            sys_prompt = self.response_format_instructions(
-                input_data.expected_format,
-                list_mode=input_data.list_result,
-                pure_json_mode=input_data.force_json_output,
-                output_tag_start=output_tag_start,
+            expected_format = [
+                f'"{k}": "{v}"' for k, v in input_data.expected_format.items()
+            ]
+            if input_data.list_result:
+                format_prompt = (
+                    f'"results": [\n  {{\n  {", ".join(expected_format)}\n  }}\n]'
+                )
+            else:
+                format_prompt = "\n  ".join(expected_format)
+
+            sys_prompt = trim_prompt(
+                f"""
+                  |Reply strictly only in the following JSON format:
+                  |{{
+                  |  {format_prompt}
+                  |}}
+                  |
+                  |Ensure the response is valid JSON. Do not include any additional text outside of the JSON.
+                  |If you cannot provide all the keys, provide an empty string for the values you cannot answer.
+                """
             )
             prompt.append({"role": "system", "content": sys_prompt})
 
@@ -947,21 +945,18 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
             except JSONDecodeError as e:
                 return f"JSON decode error: {e}"
 
-        error_feedback_message = ""
+        logger.debug(f"LLM request: {prompt}")
+        retry_prompt = ""
         llm_model = input_data.model
 
         for retry_count in range(input_data.retry):
-            logger.debug(f"LLM request: {prompt}")
             try:
                 llm_response = await self.llm_call(
                     credentials=credentials,
                     llm_model=llm_model,
                     prompt=prompt,
                     compress_prompt_to_fit=input_data.compress_prompt_to_fit,
-                    force_json_output=(
-                        input_data.force_json_output
-                        and bool(input_data.expected_format)
-                    ),
+                    json_format=bool(input_data.expected_format),
                     ollama_host=input_data.ollama_host,
                     max_tokens=input_data.max_tokens,
                 )
@@ -975,55 +970,16 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
                 logger.debug(f"LLM attempt-{retry_count} response: {response_text}")
 
                 if input_data.expected_format:
-                    try:
-                        response_obj = self.get_json_from_response(
-                            response_text,
-                            pure_json_mode=input_data.force_json_output,
-                            output_tag_start=output_tag_start,
-                        )
-                    except (ValueError, JSONDecodeError) as parse_error:
-                        censored_response = re.sub(r"[A-Za-z0-9]", "*", response_text)
-                        response_snippet = (
-                            f"{censored_response[:50]}...{censored_response[-30:]}"
-                        )
-                        logger.warning(
-                            f"Error getting JSON from LLM response: {parse_error}\n\n"
-                            f"Response start+end: `{response_snippet}`"
-                        )
-                        prompt.append({"role": "assistant", "content": response_text})
 
-                        error_feedback_message = self.invalid_response_feedback(
-                            parse_error,
-                            was_parseable=False,
-                            list_mode=input_data.list_result,
-                            pure_json_mode=input_data.force_json_output,
-                            output_tag_start=output_tag_start,
-                        )
-                        prompt.append(
-                            {"role": "user", "content": error_feedback_message}
-                        )
-                        continue
+                    response_obj = json.loads(response_text)
 
-                    # Handle object response for `force_json_output`+`list_result`
                     if input_data.list_result and isinstance(response_obj, dict):
-                        if "results" in response_obj and isinstance(
-                            response_obj["results"], list
-                        ):
-                            response_obj = response_obj["results"]
-                        else:
-                            error_feedback_message = (
-                                "Expected an array of objects in the 'results' key, "
-                                f"but got: {response_obj}"
-                            )
-                            prompt.append(
-                                {"role": "assistant", "content": response_text}
-                            )
-                            prompt.append(
-                                {"role": "user", "content": error_feedback_message}
-                            )
-                            continue
+                        if "results" in response_obj:
+                            response_obj = response_obj.get("results", [])
+                        elif len(response_obj) == 1:
+                            response_obj = list(response_obj.values())
 
-                    validation_errors = "\n".join(
+                    response_error = "\n".join(
                         [
                             validation_error
                             for response_item in (
@@ -1035,7 +991,7 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
                         ]
                     )
 
-                    if not validation_errors:
+                    if not response_error:
                         self.merge_stats(
                             NodeExecutionStats(
                                 llm_call_count=retry_count + 1,
@@ -1045,16 +1001,6 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
                         yield "response", response_obj
                         yield "prompt", self.prompt
                         return
-
-                    prompt.append({"role": "assistant", "content": response_text})
-                    error_feedback_message = self.invalid_response_feedback(
-                        validation_errors,
-                        was_parseable=True,
-                        list_mode=input_data.list_result,
-                        pure_json_mode=input_data.force_json_output,
-                        output_tag_start=output_tag_start,
-                    )
-                    prompt.append({"role": "user", "content": error_feedback_message})
                 else:
                     self.merge_stats(
                         NodeExecutionStats(
@@ -1065,6 +1011,21 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
                     yield "response", {"response": response_text}
                     yield "prompt", self.prompt
                     return
+
+                retry_prompt = trim_prompt(
+                    f"""
+                  |This is your previous error response:
+                  |--
+                  |{response_text}
+                  |--
+                  |
+                  |And this is the error:
+                  |--
+                  |{response_error}
+                  |--
+                """
+                )
+                prompt.append({"role": "user", "content": retry_prompt})
             except Exception as e:
                 logger.exception(f"Error calling LLM: {e}")
                 if (
@@ -1077,133 +1038,9 @@ class AIStructuredResponseGeneratorBlock(AIBlockBase):
                     logger.debug(
                         f"Reducing max_tokens to {input_data.max_tokens} for next attempt"
                     )
-                    # Don't add retry prompt for token limit errors,
-                    # just retry with lower maximum output tokens
+                retry_prompt = f"Error calling LLM: {e}"
 
-                error_feedback_message = f"Error calling LLM: {e}"
-
-        raise RuntimeError(error_feedback_message)
-
-    def response_format_instructions(
-        self,
-        expected_object_format: dict[str, str],
-        *,
-        list_mode: bool,
-        pure_json_mode: bool,
-        output_tag_start: str,
-    ) -> str:
-        expected_output_format = json.dumps(expected_object_format, indent=2)
-        output_type = "object" if not list_mode else "array"
-        outer_output_type = "object" if pure_json_mode else output_type
-
-        if output_type == "array":
-            indented_obj_format = expected_output_format.replace("\n", "\n  ")
-            expected_output_format = f"[\n  {indented_obj_format},\n  ...\n]"
-            if pure_json_mode:
-                indented_list_format = expected_output_format.replace("\n", "\n  ")
-                expected_output_format = (
-                    "{\n"
-                    '  "reasoning": "... (optional)",\n'  # for better performance
-                    f'  "results": {indented_list_format}\n'
-                    "}"
-                )
-
-        # Preserve indentation in prompt
-        expected_output_format = expected_output_format.replace("\n", "\n|")
-
-        # Prepare prompt
-        if not pure_json_mode:
-            expected_output_format = (
-                f"{output_tag_start}\n{expected_output_format}\n</json_output>"
-            )
-
-        instructions = f"""
-        |In your response you MUST include a valid JSON {outer_output_type} strictly following this format:
-        |{expected_output_format}
-        |
-        |If you cannot provide all the keys, you MUST provide an empty string for the values you cannot answer.
-        """.strip()
-
-        if not pure_json_mode:
-            instructions += f"""
-            |
-            |You MUST enclose your final JSON answer in {output_tag_start}...</json_output> tags, even if the user specifies a different tag.
-            |There MUST be exactly ONE {output_tag_start}...</json_output> block in your response, which MUST ONLY contain the JSON {outer_output_type} and nothing else. Other text outside this block is allowed.
-            """.strip()
-
-        return trim_prompt(instructions)
-
-    def invalid_response_feedback(
-        self,
-        error,
-        *,
-        was_parseable: bool,
-        list_mode: bool,
-        pure_json_mode: bool,
-        output_tag_start: str,
-    ) -> str:
-        outer_output_type = "object" if not list_mode or pure_json_mode else "array"
-
-        if was_parseable:
-            complaint = f"Your previous response did not match the expected {outer_output_type} format."
-        else:
-            complaint = f"Your previous response did not contain a parseable JSON {outer_output_type}."
-
-        indented_parse_error = str(error).replace("\n", "\n|")
-
-        instruction = (
-            f"Please provide a {output_tag_start}...</json_output> block containing a"
-            if not pure_json_mode
-            else "Please provide a"
-        ) + f" valid JSON {outer_output_type} that matches the expected format."
-
-        return trim_prompt(
-            f"""
-            |{complaint}
-            |
-            |{indented_parse_error}
-            |
-            |{instruction}
-        """
-        )
-
-    def get_json_from_response(
-        self, response_text: str, *, pure_json_mode: bool, output_tag_start: str
-    ) -> dict[str, Any] | list[dict[str, Any]]:
-        if pure_json_mode:
-            # Handle pure JSON responses
-            try:
-                return json.loads(response_text)
-            except JSONDecodeError as first_parse_error:
-                # If that didn't work, try finding the { and } to deal with possible ```json fences etc.
-                json_start = response_text.find("{")
-                json_end = response_text.rfind("}")
-                try:
-                    return json.loads(response_text[json_start : json_end + 1])
-                except JSONDecodeError:
-                    # Raise the original error, as it's more likely to be relevant
-                    raise first_parse_error from None
-
-        if output_tag_start not in response_text:
-            raise ValueError(
-                "Response does not contain the expected "
-                f"{output_tag_start}...</json_output> block."
-            )
-        json_output = (
-            response_text.split(output_tag_start, 1)[1]
-            .rsplit("</json_output>", 1)[0]
-            .strip()
-        )
-        return json.loads(json_output)
-
-    def get_collision_proof_output_tag_id(self) -> str:
-        return secrets.token_hex(8)
-
-
-def trim_prompt(s: str) -> str:
-    """Removes indentation up to and including `|` from a multi-line prompt."""
-    lines = s.strip().split("\n")
-    return "\n".join([line.strip().lstrip("|") for line in lines])
+        raise RuntimeError(retry_prompt)
 
 
 class AITextGeneratorBlock(AIBlockBase):

autogpt_platform/backend/backend/blocks/notion/_api.py

@@ -1,536 +0,0 @@
-"""
-Notion API helper functions and client for making authenticated requests.
-"""
-
-from typing import Any, Dict, List, Optional
-
-from backend.data.model import OAuth2Credentials
-from backend.util.request import Requests
-
-NOTION_VERSION = "2022-06-28"
-
-
-class NotionAPIException(Exception):
-    """Exception raised for Notion API errors."""
-
-    def __init__(self, message: str, status_code: int):
-        super().__init__(message)
-        self.status_code = status_code
-
-
-class NotionClient:
-    """Client for interacting with the Notion API."""
-
-    def __init__(self, credentials: OAuth2Credentials):
-        self.credentials = credentials
-        self.headers = {
-            "Authorization": credentials.auth_header(),
-            "Notion-Version": NOTION_VERSION,
-            "Content-Type": "application/json",
-        }
-        self.requests = Requests()
-
-    async def get_page(self, page_id: str) -> dict:
-        """
-        Fetch a page by ID.
-
-        Args:
-            page_id: The ID of the page to fetch.
-
-        Returns:
-            The page object from Notion API.
-        """
-        url = f"https://api.notion.com/v1/pages/{page_id}"
-        response = await self.requests.get(url, headers=self.headers)
-
-        if not response.ok:
-            raise NotionAPIException(
-                f"Failed to fetch page: {response.status} - {response.text()}",
-                response.status,
-            )
-
-        return response.json()
-
-    async def get_blocks(self, block_id: str, recursive: bool = True) -> List[dict]:
-        """
-        Fetch all blocks from a page or block.
-
-        Args:
-            block_id: The ID of the page or block to fetch children from.
-            recursive: Whether to fetch nested blocks recursively.
-
-        Returns:
-            List of block objects.
-        """
-        blocks = []
-        cursor = None
-
-        while True:
-            url = f"https://api.notion.com/v1/blocks/{block_id}/children"
-            params = {"page_size": 100}
-            if cursor:
-                params["start_cursor"] = cursor
-
-            response = await self.requests.get(url, headers=self.headers, params=params)
-
-            if not response.ok:
-                raise NotionAPIException(
-                    f"Failed to fetch blocks: {response.status} - {response.text()}",
-                    response.status,
-                )
-
-            data = response.json()
-            current_blocks = data.get("results", [])
-
-            # If recursive, fetch children for blocks that have them
-            if recursive:
-                for block in current_blocks:
-                    if block.get("has_children"):
-                        block["children"] = await self.get_blocks(
-                            block["id"], recursive=True
-                        )
-
-            blocks.extend(current_blocks)
-
-            if not data.get("has_more"):
-                break
-            cursor = data.get("next_cursor")
-
-        return blocks
-
-    async def query_database(
-        self,
-        database_id: str,
-        filter_obj: Optional[dict] = None,
-        sorts: Optional[List[dict]] = None,
-        page_size: int = 100,
-    ) -> dict:
-        """
-        Query a database with optional filters and sorts.
-
-        Args:
-            database_id: The ID of the database to query.
-            filter_obj: Optional filter object for the query.
-            sorts: Optional list of sort objects.
-            page_size: Number of results per page.
-
-        Returns:
-            Query results including pages and pagination info.
-        """
-        url = f"https://api.notion.com/v1/databases/{database_id}/query"
-
-        payload: Dict[str, Any] = {"page_size": page_size}
-        if filter_obj:
-            payload["filter"] = filter_obj
-        if sorts:
-            payload["sorts"] = sorts
-
-        response = await self.requests.post(url, headers=self.headers, json=payload)
-
-        if not response.ok:
-            raise NotionAPIException(
-                f"Failed to query database: {response.status} - {response.text()}",
-                response.status,
-            )
-
-        return response.json()
-
-    async def create_page(
-        self,
-        parent: dict,
-        properties: dict,
-        children: Optional[List[dict]] = None,
-        icon: Optional[dict] = None,
-        cover: Optional[dict] = None,
-    ) -> dict:
-        """
-        Create a new page.
-
-        Args:
-            parent: Parent object (page_id or database_id).
-            properties: Page properties.
-            children: Optional list of block children.
-            icon: Optional icon object.
-            cover: Optional cover object.
-
-        Returns:
-            The created page object.
-        """
-        url = "https://api.notion.com/v1/pages"
-
-        payload: Dict[str, Any] = {"parent": parent, "properties": properties}
-
-        if children:
-            payload["children"] = children
-        if icon:
-            payload["icon"] = icon
-        if cover:
-            payload["cover"] = cover
-
-        response = await self.requests.post(url, headers=self.headers, json=payload)
-
-        if not response.ok:
-            raise NotionAPIException(
-                f"Failed to create page: {response.status} - {response.text()}",
-                response.status,
-            )
-
-        return response.json()
-
-    async def update_page(self, page_id: str, properties: dict) -> dict:
-        """
-        Update a page's properties.
-
-        Args:
-            page_id: The ID of the page to update.
-            properties: Properties to update.
-
-        Returns:
-            The updated page object.
-        """
-        url = f"https://api.notion.com/v1/pages/{page_id}"
-
-        response = await self.requests.patch(
-            url, headers=self.headers, json={"properties": properties}
-        )
-
-        if not response.ok:
-            raise NotionAPIException(
-                f"Failed to update page: {response.status} - {response.text()}",
-                response.status,
-            )
-
-        return response.json()
-
-    async def append_blocks(self, block_id: str, children: List[dict]) -> dict:
-        """
-        Append blocks to a page or block.
-
-        Args:
-            block_id: The ID of the page or block to append to.
-            children: List of block objects to append.
-
-        Returns:
-            Response with the created blocks.
-        """
-        url = f"https://api.notion.com/v1/blocks/{block_id}/children"
-
-        response = await self.requests.patch(
-            url, headers=self.headers, json={"children": children}
-        )
-
-        if not response.ok:
-            raise NotionAPIException(
-                f"Failed to append blocks: {response.status} - {response.text()}",
-                response.status,
-            )
-
-        return response.json()
-
-    async def search(
-        self,
-        query: str = "",
-        filter_obj: Optional[dict] = None,
-        sort: Optional[dict] = None,
-        page_size: int = 100,
-    ) -> dict:
-        """
-        Search for pages and databases.
-
-        Args:
-            query: Search query text.
-            filter_obj: Optional filter object.
-            sort: Optional sort object.
-            page_size: Number of results per page.
-
-        Returns:
-            Search results.
-        """
-        url = "https://api.notion.com/v1/search"
-
-        payload: Dict[str, Any] = {"page_size": page_size}
-        if query:
-            payload["query"] = query
-        if filter_obj:
-            payload["filter"] = filter_obj
-        if sort:
-            payload["sort"] = sort
-
-        response = await self.requests.post(url, headers=self.headers, json=payload)
-
-        if not response.ok:
-            raise NotionAPIException(
-                f"Search failed: {response.status} - {response.text()}", response.status
-            )
-
-        return response.json()
-
-
-# Conversion helper functions
-
-
-def parse_rich_text(rich_text_array: List[dict]) -> str:
-    """
-    Extract plain text from a Notion rich text array.
-
-    Args:
-        rich_text_array: Array of rich text objects from Notion.
-
-    Returns:
-        Plain text string.
-    """
-    if not rich_text_array:
-        return ""
-
-    text_parts = []
-    for text_obj in rich_text_array:
-        if "plain_text" in text_obj:
-            text_parts.append(text_obj["plain_text"])
-
-    return "".join(text_parts)
-
-
-def rich_text_to_markdown(rich_text_array: List[dict]) -> str:
-    """
-    Convert Notion rich text array to markdown with formatting.
-
-    Args:
-        rich_text_array: Array of rich text objects from Notion.
-
-    Returns:
-        Markdown formatted string.
-    """
-    if not rich_text_array:
-        return ""
-
-    markdown_parts = []
-
-    for text_obj in rich_text_array:
-        text = text_obj.get("plain_text", "")
-        annotations = text_obj.get("annotations", {})
-
-        # Apply formatting based on annotations
-        if annotations.get("code"):
-            text = f"`{text}`"
-        else:
-            if annotations.get("bold"):
-                text = f"**{text}**"
-            if annotations.get("italic"):
-                text = f"*{text}*"
-            if annotations.get("strikethrough"):
-                text = f"~~{text}~~"
-            if annotations.get("underline"):
-                text = f"<u>{text}</u>"
-
-        # Handle links
-        if text_obj.get("href"):
-            text = f"[{text}]({text_obj['href']})"
-
-        markdown_parts.append(text)
-
-    return "".join(markdown_parts)
-
-
-def block_to_markdown(block: dict, indent_level: int = 0) -> str:
-    """
-    Convert a single Notion block to markdown.
-
-    Args:
-        block: Block object from Notion API.
-        indent_level: Current indentation level for nested blocks.
-
-    Returns:
-        Markdown string representation of the block.
-    """
-    block_type = block.get("type")
-    indent = "  " * indent_level
-    markdown_lines = []
-
-    # Handle different block types
-    if block_type == "paragraph":
-        text = rich_text_to_markdown(block["paragraph"].get("rich_text", []))
-        if text:
-            markdown_lines.append(f"{indent}{text}")
-
-    elif block_type == "heading_1":
-        text = parse_rich_text(block["heading_1"].get("rich_text", []))
-        markdown_lines.append(f"{indent}# {text}")
-
-    elif block_type == "heading_2":
-        text = parse_rich_text(block["heading_2"].get("rich_text", []))
-        markdown_lines.append(f"{indent}## {text}")
-
-    elif block_type == "heading_3":
-        text = parse_rich_text(block["heading_3"].get("rich_text", []))
-        markdown_lines.append(f"{indent}### {text}")
-
-    elif block_type == "bulleted_list_item":
-        text = rich_text_to_markdown(block["bulleted_list_item"].get("rich_text", []))
-        markdown_lines.append(f"{indent}- {text}")
-
-    elif block_type == "numbered_list_item":
-        text = rich_text_to_markdown(block["numbered_list_item"].get("rich_text", []))
-        # Note: This is simplified - proper numbering would need context
-        markdown_lines.append(f"{indent}1. {text}")
-
-    elif block_type == "to_do":
-        text = rich_text_to_markdown(block["to_do"].get("rich_text", []))
-        checked = "x" if block["to_do"].get("checked") else " "
-        markdown_lines.append(f"{indent}- [{checked}] {text}")
-
-    elif block_type == "toggle":
-        text = rich_text_to_markdown(block["toggle"].get("rich_text", []))
-        markdown_lines.append(f"{indent}<details>")
-        markdown_lines.append(f"{indent}<summary>{text}</summary>")
-        markdown_lines.append(f"{indent}")
-        # Process children if they exist
-        if block.get("children"):
-            for child in block["children"]:
-                child_markdown = block_to_markdown(child, indent_level + 1)
-                if child_markdown:
-                    markdown_lines.append(child_markdown)
-        markdown_lines.append(f"{indent}</details>")
-
-    elif block_type == "code":
-        code = parse_rich_text(block["code"].get("rich_text", []))
-        language = block["code"].get("language", "")
-        markdown_lines.append(f"{indent}```{language}")
-        markdown_lines.append(f"{indent}{code}")
-        markdown_lines.append(f"{indent}```")
-
-    elif block_type == "quote":
-        text = rich_text_to_markdown(block["quote"].get("rich_text", []))
-        markdown_lines.append(f"{indent}> {text}")
-
-    elif block_type == "divider":
-        markdown_lines.append(f"{indent}---")
-
-    elif block_type == "image":
-        image = block["image"]
-        url = image.get("external", {}).get("url") or image.get("file", {}).get(
-            "url", ""
-        )
-        caption = parse_rich_text(image.get("caption", []))
-        alt_text = caption if caption else "Image"
-        markdown_lines.append(f"{indent}![{alt_text}]({url})")
-        if caption:
-            markdown_lines.append(f"{indent}*{caption}*")
-
-    elif block_type == "video":
-        video = block["video"]
-        url = video.get("external", {}).get("url") or video.get("file", {}).get(
-            "url", ""
-        )
-        caption = parse_rich_text(video.get("caption", []))
-        markdown_lines.append(f"{indent}[Video]({url})")
-        if caption:
-            markdown_lines.append(f"{indent}*{caption}*")
-
-    elif block_type == "file":
-        file = block["file"]
-        url = file.get("external", {}).get("url") or file.get("file", {}).get("url", "")
-        caption = parse_rich_text(file.get("caption", []))
-        name = caption if caption else "File"
-        markdown_lines.append(f"{indent}[{name}]({url})")
-
-    elif block_type == "bookmark":
-        url = block["bookmark"].get("url", "")
-        caption = parse_rich_text(block["bookmark"].get("caption", []))
-        markdown_lines.append(f"{indent}[{caption if caption else url}]({url})")
-
-    elif block_type == "equation":
-        expression = block["equation"].get("expression", "")
-        markdown_lines.append(f"{indent}$${expression}$$")
-
-    elif block_type == "callout":
-        text = rich_text_to_markdown(block["callout"].get("rich_text", []))
-        icon = block["callout"].get("icon", {})
-        if icon.get("emoji"):
-            markdown_lines.append(f"{indent}> {icon['emoji']} {text}")
-        else:
-            markdown_lines.append(f"{indent}> ℹ️ {text}")
-
-    elif block_type == "child_page":
-        title = block["child_page"].get("title", "Untitled")
-        markdown_lines.append(f"{indent}📄 [{title}](notion://page/{block['id']})")
-
-    elif block_type == "child_database":
-        title = block["child_database"].get("title", "Untitled Database")
-        markdown_lines.append(f"{indent}🗂️ [{title}](notion://database/{block['id']})")
-
-    elif block_type == "table":
-        # Tables are complex - for now just indicate there's a table
-        markdown_lines.append(
-            f"{indent}[Table with {block['table'].get('table_width', 0)} columns]"
-        )
-
-    elif block_type == "column_list":
-        # Process columns
-        if block.get("children"):
-            markdown_lines.append(f"{indent}<div style='display: flex'>")
-            for column in block["children"]:
-                markdown_lines.append(f"{indent}<div style='flex: 1'>")
-                if column.get("children"):
-                    for child in column["children"]:
-                        child_markdown = block_to_markdown(child, indent_level + 1)
-                        if child_markdown:
-                            markdown_lines.append(child_markdown)
-                markdown_lines.append(f"{indent}</div>")
-            markdown_lines.append(f"{indent}</div>")
-
-    # Handle children for blocks that haven't been processed yet
-    elif block.get("children") and block_type not in ["toggle", "column_list"]:
-        for child in block["children"]:
-            child_markdown = block_to_markdown(child, indent_level)
-            if child_markdown:
-                markdown_lines.append(child_markdown)
-
-    return "\n".join(markdown_lines) if markdown_lines else ""
-
-
-def blocks_to_markdown(blocks: List[dict]) -> str:
-    """
-    Convert a list of Notion blocks to a markdown document.
-
-    Args:
-        blocks: List of block objects from Notion API.
-
-    Returns:
-        Complete markdown document as a string.
-    """
-    markdown_parts = []
-
-    for i, block in enumerate(blocks):
-        markdown = block_to_markdown(block)
-        if markdown:
-            markdown_parts.append(markdown)
-            # Add spacing between top-level blocks (except lists)
-            if i < len(blocks) - 1:
-                next_type = blocks[i + 1].get("type", "")
-                current_type = block.get("type", "")
-                # Don't add extra spacing between list items
-                list_types = {"bulleted_list_item", "numbered_list_item", "to_do"}
-                if not (current_type in list_types and next_type in list_types):
-                    markdown_parts.append("")
-
-    return "\n".join(markdown_parts)
-
-
-def extract_page_title(page: dict) -> str:
-    """
-    Extract the title from a Notion page object.
-
-    Args:
-        page: Page object from Notion API.
-
-    Returns:
-        Page title as a string.
-    """
-    properties = page.get("properties", {})
-
-    # Find the title property (it has type "title")
-    for prop_name, prop_value in properties.items():
-        if prop_value.get("type") == "title":
-            return parse_rich_text(prop_value.get("title", []))
-
-    return "Untitled"

autogpt_platform/backend/backend/blocks/notion/_auth.py

@@ -1,42 +0,0 @@
-from typing import Literal
-
-from pydantic import SecretStr
-
-from backend.data.model import CredentialsField, CredentialsMetaInput, OAuth2Credentials
-from backend.integrations.providers import ProviderName
-from backend.util.settings import Secrets
-
-secrets = Secrets()
-NOTION_OAUTH_IS_CONFIGURED = bool(
-    secrets.notion_client_id and secrets.notion_client_secret
-)
-
-NotionCredentials = OAuth2Credentials
-NotionCredentialsInput = CredentialsMetaInput[
-    Literal[ProviderName.NOTION], Literal["oauth2"]
-]
-
-
-def NotionCredentialsField() -> NotionCredentialsInput:
-    """Creates a Notion OAuth2 credentials field."""
-    return CredentialsField(
-        description="Connect your Notion account. Ensure the pages/databases are shared with the integration."
-    )
-
-
-# Test credentials for Notion OAuth2
-TEST_CREDENTIALS = OAuth2Credentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="notion",
-    access_token=SecretStr("test_access_token"),
-    title="Mock Notion OAuth",
-    scopes=["read_content", "insert_content", "update_content"],
-    username="testuser",
-)
-
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.title,
-}

autogpt_platform/backend/backend/blocks/notion/create_page.py

@@ -1,360 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from pydantic import model_validator
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import OAuth2Credentials, SchemaField
-
-from ._api import NotionClient
-from ._auth import (
-    NOTION_OAUTH_IS_CONFIGURED,
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    NotionCredentialsField,
-    NotionCredentialsInput,
-)
-
-
-class NotionCreatePageBlock(Block):
-    """Create a new page in Notion with content."""
-
-    class Input(BlockSchema):
-        credentials: NotionCredentialsInput = NotionCredentialsField()
-        parent_page_id: Optional[str] = SchemaField(
-            description="Parent page ID to create the page under. Either this OR parent_database_id is required.",
-            default=None,
-        )
-        parent_database_id: Optional[str] = SchemaField(
-            description="Parent database ID to create the page in. Either this OR parent_page_id is required.",
-            default=None,
-        )
-        title: str = SchemaField(
-            description="Title of the new page",
-        )
-        content: Optional[str] = SchemaField(
-            description="Content for the page. Can be plain text or markdown - will be converted to Notion blocks.",
-            default=None,
-        )
-        properties: Optional[Dict[str, Any]] = SchemaField(
-            description="Additional properties for database pages (e.g., {'Status': 'In Progress', 'Priority': 'High'})",
-            default=None,
-        )
-        icon_emoji: Optional[str] = SchemaField(
-            description="Emoji to use as the page icon (e.g., '📄', '🚀')", default=None
-        )
-
-        @model_validator(mode="after")
-        def validate_parent(self):
-            """Ensure either parent_page_id or parent_database_id is provided."""
-            if not self.parent_page_id and not self.parent_database_id:
-                raise ValueError(
-                    "Either parent_page_id or parent_database_id must be provided"
-                )
-            if self.parent_page_id and self.parent_database_id:
-                raise ValueError(
-                    "Only one of parent_page_id or parent_database_id should be provided, not both"
-                )
-            return self
-
-    class Output(BlockSchema):
-        page_id: str = SchemaField(description="ID of the created page.")
-        page_url: str = SchemaField(description="URL of the created page.")
-        error: str = SchemaField(description="Error message if the operation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="c15febe0-66ce-4c6f-aebd-5ab351653804",
-            description="Create a new page in Notion. Requires EITHER a parent_page_id OR parent_database_id. Supports markdown content.",
-            categories={BlockCategory.PRODUCTIVITY},
-            input_schema=NotionCreatePageBlock.Input,
-            output_schema=NotionCreatePageBlock.Output,
-            disabled=not NOTION_OAUTH_IS_CONFIGURED,
-            test_input={
-                "parent_page_id": "00000000-0000-0000-0000-000000000000",
-                "title": "Test Page",
-                "content": "This is test content.",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_output=[
-                ("page_id", "12345678-1234-1234-1234-123456789012"),
-                (
-                    "page_url",
-                    "https://notion.so/Test-Page-12345678123412341234123456789012",
-                ),
-            ],
-            test_credentials=TEST_CREDENTIALS,
-            test_mock={
-                "create_page": lambda *args, **kwargs: (
-                    "12345678-1234-1234-1234-123456789012",
-                    "https://notion.so/Test-Page-12345678123412341234123456789012",
-                )
-            },
-        )
-
-    @staticmethod
-    def _markdown_to_blocks(content: str) -> List[dict]:
-        """Convert markdown content to Notion block objects."""
-        if not content:
-            return []
-
-        blocks = []
-        lines = content.split("\n")
-        i = 0
-
-        while i < len(lines):
-            line = lines[i]
-
-            # Skip empty lines
-            if not line.strip():
-                i += 1
-                continue
-
-            # Headings
-            if line.startswith("### "):
-                blocks.append(
-                    {
-                        "type": "heading_3",
-                        "heading_3": {
-                            "rich_text": [
-                                {"type": "text", "text": {"content": line[4:].strip()}}
-                            ]
-                        },
-                    }
-                )
-            elif line.startswith("## "):
-                blocks.append(
-                    {
-                        "type": "heading_2",
-                        "heading_2": {
-                            "rich_text": [
-                                {"type": "text", "text": {"content": line[3:].strip()}}
-                            ]
-                        },
-                    }
-                )
-            elif line.startswith("# "):
-                blocks.append(
-                    {
-                        "type": "heading_1",
-                        "heading_1": {
-                            "rich_text": [
-                                {"type": "text", "text": {"content": line[2:].strip()}}
-                            ]
-                        },
-                    }
-                )
-            # Bullet points
-            elif line.strip().startswith("- "):
-                blocks.append(
-                    {
-                        "type": "bulleted_list_item",
-                        "bulleted_list_item": {
-                            "rich_text": [
-                                {
-                                    "type": "text",
-                                    "text": {"content": line.strip()[2:].strip()},
-                                }
-                            ]
-                        },
-                    }
-                )
-            # Numbered list
-            elif line.strip() and line.strip()[0].isdigit() and ". " in line:
-                content_start = line.find(". ") + 2
-                blocks.append(
-                    {
-                        "type": "numbered_list_item",
-                        "numbered_list_item": {
-                            "rich_text": [
-                                {
-                                    "type": "text",
-                                    "text": {"content": line[content_start:].strip()},
-                                }
-                            ]
-                        },
-                    }
-                )
-            # Code block
-            elif line.strip().startswith("```"):
-                code_lines = []
-                language = line[3:].strip() or "plain text"
-                i += 1
-                while i < len(lines) and not lines[i].strip().startswith("```"):
-                    code_lines.append(lines[i])
-                    i += 1
-                blocks.append(
-                    {
-                        "type": "code",
-                        "code": {
-                            "rich_text": [
-                                {
-                                    "type": "text",
-                                    "text": {"content": "\n".join(code_lines)},
-                                }
-                            ],
-                            "language": language,
-                        },
-                    }
-                )
-            # Quote
-            elif line.strip().startswith("> "):
-                blocks.append(
-                    {
-                        "type": "quote",
-                        "quote": {
-                            "rich_text": [
-                                {
-                                    "type": "text",
-                                    "text": {"content": line.strip()[2:].strip()},
-                                }
-                            ]
-                        },
-                    }
-                )
-            # Horizontal rule
-            elif line.strip() in ["---", "***", "___"]:
-                blocks.append({"type": "divider", "divider": {}})
-            # Regular paragraph
-            else:
-                # Parse for basic markdown formatting
-                text_content = line.strip()
-                rich_text = []
-
-                # Simple bold/italic parsing (this is simplified)
-                if "**" in text_content or "*" in text_content:
-                    # For now, just pass as plain text
-                    # A full implementation would parse and create proper annotations
-                    rich_text = [{"type": "text", "text": {"content": text_content}}]
-                else:
-                    rich_text = [{"type": "text", "text": {"content": text_content}}]
-
-                blocks.append(
-                    {"type": "paragraph", "paragraph": {"rich_text": rich_text}}
-                )
-
-            i += 1
-
-        return blocks
-
-    @staticmethod
-    def _build_properties(
-        title: str, additional_properties: Optional[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
-        """Build properties object for page creation."""
-        properties: Dict[str, Any] = {
-            "title": {"title": [{"type": "text", "text": {"content": title}}]}
-        }
-
-        if additional_properties:
-            for key, value in additional_properties.items():
-                if key.lower() == "title":
-                    continue  # Skip title as we already have it
-
-                # Try to intelligently map property types
-                if isinstance(value, bool):
-                    properties[key] = {"checkbox": value}
-                elif isinstance(value, (int, float)):
-                    properties[key] = {"number": value}
-                elif isinstance(value, list):
-                    # Assume multi-select
-                    properties[key] = {
-                        "multi_select": [{"name": str(item)} for item in value]
-                    }
-                elif isinstance(value, str):
-                    # Could be select, rich_text, or other types
-                    # For simplicity, try common patterns
-                    if key.lower() in ["status", "priority", "type", "category"]:
-                        properties[key] = {"select": {"name": value}}
-                    elif key.lower() in ["url", "link"]:
-                        properties[key] = {"url": value}
-                    elif key.lower() in ["email"]:
-                        properties[key] = {"email": value}
-                    else:
-                        properties[key] = {
-                            "rich_text": [{"type": "text", "text": {"content": value}}]
-                        }
-
-        return properties
-
-    @staticmethod
-    async def create_page(
-        credentials: OAuth2Credentials,
-        title: str,
-        parent_page_id: Optional[str] = None,
-        parent_database_id: Optional[str] = None,
-        content: Optional[str] = None,
-        properties: Optional[Dict[str, Any]] = None,
-        icon_emoji: Optional[str] = None,
-    ) -> tuple[str, str]:
-        """
-        Create a new Notion page.
-
-        Returns:
-            Tuple of (page_id, page_url)
-        """
-        if not parent_page_id and not parent_database_id:
-            raise ValueError(
-                "Either parent_page_id or parent_database_id must be provided"
-            )
-        if parent_page_id and parent_database_id:
-            raise ValueError(
-                "Only one of parent_page_id or parent_database_id should be provided, not both"
-            )
-
-        client = NotionClient(credentials)
-
-        # Build parent object
-        if parent_page_id:
-            parent = {"type": "page_id", "page_id": parent_page_id}
-        else:
-            parent = {"type": "database_id", "database_id": parent_database_id}
-
-        # Build properties
-        page_properties = NotionCreatePageBlock._build_properties(title, properties)
-
-        # Convert content to blocks if provided
-        children = None
-        if content:
-            children = NotionCreatePageBlock._markdown_to_blocks(content)
-
-        # Build icon if provided
-        icon = None
-        if icon_emoji:
-            icon = {"type": "emoji", "emoji": icon_emoji}
-
-        # Create the page
-        result = await client.create_page(
-            parent=parent, properties=page_properties, children=children, icon=icon
-        )
-
-        page_id = result.get("id", "")
-        page_url = result.get("url", "")
-
-        if not page_id or not page_url:
-            raise ValueError("Failed to get page ID or URL from Notion response")
-
-        return page_id, page_url
-
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: OAuth2Credentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            page_id, page_url = await self.create_page(
-                credentials,
-                input_data.title,
-                input_data.parent_page_id,
-                input_data.parent_database_id,
-                input_data.content,
-                input_data.properties,
-                input_data.icon_emoji,
-            )
-            yield "page_id", page_id
-            yield "page_url", page_url
-        except Exception as e:
-            yield "error", str(e) if str(e) else "Unknown error"

autogpt_platform/backend/backend/blocks/notion/read_database.py

@@ -1,285 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import OAuth2Credentials, SchemaField
-
-from ._api import NotionClient, parse_rich_text
-from ._auth import (
-    NOTION_OAUTH_IS_CONFIGURED,
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    NotionCredentialsField,
-    NotionCredentialsInput,
-)
-
-
-class NotionReadDatabaseBlock(Block):
-    """Query a Notion database and retrieve entries with their properties."""
-
-    class Input(BlockSchema):
-        credentials: NotionCredentialsInput = NotionCredentialsField()
-        database_id: str = SchemaField(
-            description="Notion database ID. Must be accessible by the connected integration.",
-        )
-        filter_property: Optional[str] = SchemaField(
-            description="Property name to filter by (e.g., 'Status', 'Priority')",
-            default=None,
-        )
-        filter_value: Optional[str] = SchemaField(
-            description="Value to filter for in the specified property", default=None
-        )
-        sort_property: Optional[str] = SchemaField(
-            description="Property name to sort by", default=None
-        )
-        sort_direction: Optional[str] = SchemaField(
-            description="Sort direction: 'ascending' or 'descending'",
-            default="ascending",
-        )
-        limit: int = SchemaField(
-            description="Maximum number of entries to retrieve",
-            default=100,
-            ge=1,
-            le=100,
-        )
-
-    class Output(BlockSchema):
-        entries: List[Dict[str, Any]] = SchemaField(
-            description="List of database entries with their properties."
-        )
-        entry: Dict[str, Any] = SchemaField(
-            description="Individual database entry (yields one per entry found)."
-        )
-        entry_ids: List[str] = SchemaField(
-            description="List of entry IDs for batch operations."
-        )
-        entry_id: str = SchemaField(
-            description="Individual entry ID (yields one per entry found)."
-        )
-        count: int = SchemaField(description="Number of entries retrieved.")
-        database_title: str = SchemaField(description="Title of the database.")
-        error: str = SchemaField(description="Error message if the operation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="fcd53135-88c9-4ba3-be50-cc6936286e6c",
-            description="Query a Notion database with optional filtering and sorting, returning structured entries.",
-            categories={BlockCategory.PRODUCTIVITY},
-            input_schema=NotionReadDatabaseBlock.Input,
-            output_schema=NotionReadDatabaseBlock.Output,
-            disabled=not NOTION_OAUTH_IS_CONFIGURED,
-            test_input={
-                "database_id": "00000000-0000-0000-0000-000000000000",
-                "limit": 10,
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_output=[
-                (
-                    "entries",
-                    [{"Name": "Test Entry", "Status": "Active", "_id": "test-123"}],
-                ),
-                ("entry_ids", ["test-123"]),
-                (
-                    "entry",
-                    {"Name": "Test Entry", "Status": "Active", "_id": "test-123"},
-                ),
-                ("entry_id", "test-123"),
-                ("count", 1),
-                ("database_title", "Test Database"),
-            ],
-            test_credentials=TEST_CREDENTIALS,
-            test_mock={
-                "query_database": lambda *args, **kwargs: (
-                    [{"Name": "Test Entry", "Status": "Active", "_id": "test-123"}],
-                    1,
-                    "Test Database",
-                )
-            },
-        )
-
-    @staticmethod
-    def _parse_property_value(prop: dict) -> Any:
-        """Parse a Notion property value into a simple Python type."""
-        prop_type = prop.get("type")
-
-        if prop_type == "title":
-            return parse_rich_text(prop.get("title", []))
-        elif prop_type == "rich_text":
-            return parse_rich_text(prop.get("rich_text", []))
-        elif prop_type == "number":
-            return prop.get("number")
-        elif prop_type == "select":
-            select = prop.get("select")
-            return select.get("name") if select else None
-        elif prop_type == "multi_select":
-            return [item.get("name") for item in prop.get("multi_select", [])]
-        elif prop_type == "date":
-            date = prop.get("date")
-            if date:
-                return date.get("start")
-            return None
-        elif prop_type == "checkbox":
-            return prop.get("checkbox", False)
-        elif prop_type == "url":
-            return prop.get("url")
-        elif prop_type == "email":
-            return prop.get("email")
-        elif prop_type == "phone_number":
-            return prop.get("phone_number")
-        elif prop_type == "people":
-            return [
-                person.get("name", person.get("id"))
-                for person in prop.get("people", [])
-            ]
-        elif prop_type == "files":
-            files = prop.get("files", [])
-            return [
-                f.get(
-                    "name",
-                    f.get("external", {}).get("url", f.get("file", {}).get("url")),
-                )
-                for f in files
-            ]
-        elif prop_type == "relation":
-            return [rel.get("id") for rel in prop.get("relation", [])]
-        elif prop_type == "formula":
-            formula = prop.get("formula", {})
-            return formula.get(formula.get("type"))
-        elif prop_type == "rollup":
-            rollup = prop.get("rollup", {})
-            return rollup.get(rollup.get("type"))
-        elif prop_type == "created_time":
-            return prop.get("created_time")
-        elif prop_type == "created_by":
-            return prop.get("created_by", {}).get(
-                "name", prop.get("created_by", {}).get("id")
-            )
-        elif prop_type == "last_edited_time":
-            return prop.get("last_edited_time")
-        elif prop_type == "last_edited_by":
-            return prop.get("last_edited_by", {}).get(
-                "name", prop.get("last_edited_by", {}).get("id")
-            )
-        else:
-            # Return the raw value for unknown types
-            return prop
-
-    @staticmethod
-    def _build_filter(property_name: str, value: str) -> dict:
-        """Build a simple filter object for a property."""
-        # This is a simplified filter - in reality, you'd need to know the property type
-        # For now, we'll try common filter types
-        return {
-            "or": [
-                {"property": property_name, "rich_text": {"contains": value}},
-                {"property": property_name, "title": {"contains": value}},
-                {"property": property_name, "select": {"equals": value}},
-                {"property": property_name, "multi_select": {"contains": value}},
-            ]
-        }
-
-    @staticmethod
-    async def query_database(
-        credentials: OAuth2Credentials,
-        database_id: str,
-        filter_property: Optional[str] = None,
-        filter_value: Optional[str] = None,
-        sort_property: Optional[str] = None,
-        sort_direction: str = "ascending",
-        limit: int = 100,
-    ) -> tuple[List[Dict[str, Any]], int, str]:
-        """
-        Query a Notion database and parse the results.
-
-        Returns:
-            Tuple of (entries_list, count, database_title)
-        """
-        client = NotionClient(credentials)
-
-        # Build filter if specified
-        filter_obj = None
-        if filter_property and filter_value:
-            filter_obj = NotionReadDatabaseBlock._build_filter(
-                filter_property, filter_value
-            )
-
-        # Build sorts if specified
-        sorts = None
-        if sort_property:
-            sorts = [{"property": sort_property, "direction": sort_direction}]
-
-        # Query the database
-        result = await client.query_database(
-            database_id, filter_obj=filter_obj, sorts=sorts, page_size=limit
-        )
-
-        # Parse the entries
-        entries = []
-        for page in result.get("results", []):
-            entry = {}
-            properties = page.get("properties", {})
-
-            for prop_name, prop_value in properties.items():
-                entry[prop_name] = NotionReadDatabaseBlock._parse_property_value(
-                    prop_value
-                )
-
-            # Add metadata
-            entry["_id"] = page.get("id")
-            entry["_url"] = page.get("url")
-            entry["_created_time"] = page.get("created_time")
-            entry["_last_edited_time"] = page.get("last_edited_time")
-
-            entries.append(entry)
-
-        # Get database title (we need to make a separate call for this)
-        try:
-            database_url = f"https://api.notion.com/v1/databases/{database_id}"
-            db_response = await client.requests.get(
-                database_url, headers=client.headers
-            )
-            if db_response.ok:
-                db_data = db_response.json()
-                db_title = parse_rich_text(db_data.get("title", []))
-            else:
-                db_title = "Unknown Database"
-        except Exception:
-            db_title = "Unknown Database"
-
-        return entries, len(entries), db_title
-
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: OAuth2Credentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            entries, count, db_title = await self.query_database(
-                credentials,
-                input_data.database_id,
-                input_data.filter_property,
-                input_data.filter_value,
-                input_data.sort_property,
-                input_data.sort_direction or "ascending",
-                input_data.limit,
-            )
-            # Yield the complete list for batch operations
-            yield "entries", entries
-
-            # Extract and yield IDs as a list for batch operations
-            entry_ids = [entry["_id"] for entry in entries if "_id" in entry]
-            yield "entry_ids", entry_ids
-
-            # Yield each individual entry and its ID for single connections
-            for entry in entries:
-                yield "entry", entry
-                if "_id" in entry:
-                    yield "entry_id", entry["_id"]
-
-            yield "count", count
-            yield "database_title", db_title
-        except Exception as e:
-            yield "error", str(e) if str(e) else "Unknown error"

autogpt_platform/backend/backend/blocks/notion/read_page.py

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import OAuth2Credentials, SchemaField
-
-from ._api import NotionClient
-from ._auth import (
-    NOTION_OAUTH_IS_CONFIGURED,
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    NotionCredentialsField,
-    NotionCredentialsInput,
-)
-
-
-class NotionReadPageBlock(Block):
-    """Read a Notion page by ID and return its raw JSON."""
-
-    class Input(BlockSchema):
-        credentials: NotionCredentialsInput = NotionCredentialsField()
-        page_id: str = SchemaField(
-            description="Notion page ID. Must be accessible by the connected integration. You can get this from the page URL notion.so/A-Page-586edd711467478da59fe3ce29a1ffab would be 586edd711467478da59fe35e29a1ffab",
-        )
-
-    class Output(BlockSchema):
-        page: dict = SchemaField(description="Raw Notion page JSON.")
-        error: str = SchemaField(description="Error message if the operation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="5246cc1d-34b7-452b-8fc5-3fb25fd8f542",
-            description="Read a Notion page by its ID and return its raw JSON.",
-            categories={BlockCategory.PRODUCTIVITY},
-            input_schema=NotionReadPageBlock.Input,
-            output_schema=NotionReadPageBlock.Output,
-            disabled=not NOTION_OAUTH_IS_CONFIGURED,
-            test_input={
-                "page_id": "00000000-0000-0000-0000-000000000000",
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_output=[("page", dict)],
-            test_credentials=TEST_CREDENTIALS,
-            test_mock={
-                "get_page": lambda *args, **kwargs: {"object": "page", "id": "mocked"}
-            },
-        )
-
-    @staticmethod
-    async def get_page(credentials: OAuth2Credentials, page_id: str) -> dict:
-        client = NotionClient(credentials)
-        return await client.get_page(page_id)
-
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: OAuth2Credentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            page = await self.get_page(credentials, input_data.page_id)
-            yield "page", page
-        except Exception as e:
-            yield "error", str(e) if str(e) else "Unknown error"

autogpt_platform/backend/backend/blocks/notion/read_page_markdown.py

@@ -1,109 +0,0 @@
-from __future__ import annotations
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import OAuth2Credentials, SchemaField
-
-from ._api import NotionClient, blocks_to_markdown, extract_page_title
-from ._auth import (
-    NOTION_OAUTH_IS_CONFIGURED,
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    NotionCredentialsField,
-    NotionCredentialsInput,
-)
-
-
-class NotionReadPageMarkdownBlock(Block):
-    """Read a Notion page and convert it to clean Markdown format."""
-
-    class Input(BlockSchema):
-        credentials: NotionCredentialsInput = NotionCredentialsField()
-        page_id: str = SchemaField(
-            description="Notion page ID. Must be accessible by the connected integration. You can get this from the page URL notion.so/A-Page-586edd711467478da59fe35e29a1ffab would be 586edd711467478da59fe35e29a1ffab",
-        )
-        include_title: bool = SchemaField(
-            description="Whether to include the page title as a header in the markdown",
-            default=True,
-        )
-
-    class Output(BlockSchema):
-        markdown: str = SchemaField(description="Page content in Markdown format.")
-        title: str = SchemaField(description="Page title.")
-        error: str = SchemaField(description="Error message if the operation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="d1312c4d-fae2-4e70-893d-f4d07cce1d4e",
-            description="Read a Notion page and convert it to Markdown format with proper formatting for headings, lists, links, and rich text.",
-            categories={BlockCategory.PRODUCTIVITY},
-            input_schema=NotionReadPageMarkdownBlock.Input,
-            output_schema=NotionReadPageMarkdownBlock.Output,
-            disabled=not NOTION_OAUTH_IS_CONFIGURED,
-            test_input={
-                "page_id": "00000000-0000-0000-0000-000000000000",
-                "include_title": True,
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_output=[
-                ("markdown", "# Test Page\n\nThis is test content."),
-                ("title", "Test Page"),
-            ],
-            test_credentials=TEST_CREDENTIALS,
-            test_mock={
-                "get_page_markdown": lambda *args, **kwargs: (
-                    "# Test Page\n\nThis is test content.",
-                    "Test Page",
-                )
-            },
-        )
-
-    @staticmethod
-    async def get_page_markdown(
-        credentials: OAuth2Credentials, page_id: str, include_title: bool = True
-    ) -> tuple[str, str]:
-        """
-        Get a Notion page and convert it to markdown.
-
-        Args:
-            credentials: OAuth2 credentials for Notion.
-            page_id: The ID of the page to fetch.
-            include_title: Whether to include the page title in the markdown.
-
-        Returns:
-            Tuple of (markdown_content, title)
-        """
-        client = NotionClient(credentials)
-
-        # Get page metadata
-        page = await client.get_page(page_id)
-        title = extract_page_title(page)
-
-        # Get all blocks from the page
-        blocks = await client.get_blocks(page_id, recursive=True)
-
-        # Convert blocks to markdown
-        content_markdown = blocks_to_markdown(blocks)
-
-        # Combine title and content if requested
-        if include_title and title:
-            full_markdown = f"# {title}\n\n{content_markdown}"
-        else:
-            full_markdown = content_markdown
-
-        return full_markdown, title
-
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: OAuth2Credentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            markdown, title = await self.get_page_markdown(
-                credentials, input_data.page_id, input_data.include_title
-            )
-            yield "markdown", markdown
-            yield "title", title
-        except Exception as e:
-            yield "error", str(e) if str(e) else "Unknown error"

autogpt_platform/backend/backend/blocks/notion/search.py

@@ -1,225 +0,0 @@
-from __future__ import annotations
-
-from typing import List, Optional
-
-from pydantic import BaseModel
-
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
-from backend.data.model import OAuth2Credentials, SchemaField
-
-from ._api import NotionClient, extract_page_title, parse_rich_text
-from ._auth import (
-    NOTION_OAUTH_IS_CONFIGURED,
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    NotionCredentialsField,
-    NotionCredentialsInput,
-)
-
-
-class NotionSearchResult(BaseModel):
-    """Typed model for Notion search results."""
-
-    id: str
-    type: str  # 'page' or 'database'
-    title: str
-    url: str
-    created_time: Optional[str] = None
-    last_edited_time: Optional[str] = None
-    parent_type: Optional[str] = None  # 'page', 'database', or 'workspace'
-    parent_id: Optional[str] = None
-    icon: Optional[str] = None  # emoji icon if present
-    is_inline: Optional[bool] = None  # for databases only
-
-
-class NotionSearchBlock(Block):
-    """Search across your Notion workspace for pages and databases."""
-
-    class Input(BlockSchema):
-        credentials: NotionCredentialsInput = NotionCredentialsField()
-        query: str = SchemaField(
-            description="Search query text. Leave empty to get all accessible pages/databases.",
-            default="",
-        )
-        filter_type: Optional[str] = SchemaField(
-            description="Filter results by type: 'page' or 'database'. Leave empty for both.",
-            default=None,
-        )
-        limit: int = SchemaField(
-            description="Maximum number of results to return", default=20, ge=1, le=100
-        )
-
-    class Output(BlockSchema):
-        results: List[NotionSearchResult] = SchemaField(
-            description="List of search results with title, type, URL, and metadata."
-        )
-        result: NotionSearchResult = SchemaField(
-            description="Individual search result (yields one per result found)."
-        )
-        result_ids: List[str] = SchemaField(
-            description="List of IDs from search results for batch operations."
-        )
-        count: int = SchemaField(description="Number of results found.")
-        error: str = SchemaField(description="Error message if the operation failed.")
-
-    def __init__(self):
-        super().__init__(
-            id="313515dd-9848-46ea-9cd6-3c627c892c56",
-            description="Search your Notion workspace for pages and databases by text query.",
-            categories={BlockCategory.PRODUCTIVITY, BlockCategory.SEARCH},
-            input_schema=NotionSearchBlock.Input,
-            output_schema=NotionSearchBlock.Output,
-            disabled=not NOTION_OAUTH_IS_CONFIGURED,
-            test_input={
-                "query": "project",
-                "limit": 5,
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_output=[
-                (
-                    "results",
-                    [
-                        NotionSearchResult(
-                            id="123",
-                            type="page",
-                            title="Project Plan",
-                            url="https://notion.so/Project-Plan-123",
-                        )
-                    ],
-                ),
-                ("result_ids", ["123"]),
-                (
-                    "result",
-                    NotionSearchResult(
-                        id="123",
-                        type="page",
-                        title="Project Plan",
-                        url="https://notion.so/Project-Plan-123",
-                    ),
-                ),
-                ("count", 1),
-            ],
-            test_credentials=TEST_CREDENTIALS,
-            test_mock={
-                "search_workspace": lambda *args, **kwargs: (
-                    [
-                        NotionSearchResult(
-                            id="123",
-                            type="page",
-                            title="Project Plan",
-                            url="https://notion.so/Project-Plan-123",
-                        )
-                    ],
-                    1,
-                )
-            },
-        )
-
-    @staticmethod
-    async def search_workspace(
-        credentials: OAuth2Credentials,
-        query: str = "",
-        filter_type: Optional[str] = None,
-        limit: int = 20,
-    ) -> tuple[List[NotionSearchResult], int]:
-        """
-        Search the Notion workspace.
-
-        Returns:
-            Tuple of (results_list, count)
-        """
-        client = NotionClient(credentials)
-
-        # Build filter if type is specified
-        filter_obj = None
-        if filter_type:
-            filter_obj = {"property": "object", "value": filter_type}
-
-        # Execute search
-        response = await client.search(
-            query=query, filter_obj=filter_obj, page_size=limit
-        )
-
-        # Parse results
-        results = []
-        for item in response.get("results", []):
-            result_data = {
-                "id": item.get("id", ""),
-                "type": item.get("object", ""),
-                "url": item.get("url", ""),
-                "created_time": item.get("created_time"),
-                "last_edited_time": item.get("last_edited_time"),
-                "title": "",  # Will be set below
-            }
-
-            # Extract title based on type
-            if item.get("object") == "page":
-                # For pages, get the title from properties
-                result_data["title"] = extract_page_title(item)
-
-                # Add parent info
-                parent = item.get("parent", {})
-                if parent.get("type") == "page_id":
-                    result_data["parent_type"] = "page"
-                    result_data["parent_id"] = parent.get("page_id")
-                elif parent.get("type") == "database_id":
-                    result_data["parent_type"] = "database"
-                    result_data["parent_id"] = parent.get("database_id")
-                elif parent.get("type") == "workspace":
-                    result_data["parent_type"] = "workspace"
-
-                # Add icon if present
-                icon = item.get("icon")
-                if icon and icon.get("type") == "emoji":
-                    result_data["icon"] = icon.get("emoji")
-
-            elif item.get("object") == "database":
-                # For databases, get title from the title array
-                result_data["title"] = parse_rich_text(item.get("title", []))
-
-                # Add database-specific metadata
-                result_data["is_inline"] = item.get("is_inline", False)
-
-                # Add parent info
-                parent = item.get("parent", {})
-                if parent.get("type") == "page_id":
-                    result_data["parent_type"] = "page"
-                    result_data["parent_id"] = parent.get("page_id")
-                elif parent.get("type") == "workspace":
-                    result_data["parent_type"] = "workspace"
-
-                # Add icon if present
-                icon = item.get("icon")
-                if icon and icon.get("type") == "emoji":
-                    result_data["icon"] = icon.get("emoji")
-
-            results.append(NotionSearchResult(**result_data))
-
-        return results, len(results)
-
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: OAuth2Credentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            results, count = await self.search_workspace(
-                credentials, input_data.query, input_data.filter_type, input_data.limit
-            )
-
-            # Yield the complete list for batch operations
-            yield "results", results
-
-            # Extract and yield IDs as a list for batch operations
-            result_ids = [r.id for r in results]
-            yield "result_ids", result_ids
-
-            # Yield each individual result for single connections
-            for result in results:
-                yield "result", result
-
-            yield "count", count
-        except Exception as e:
-            yield "error", str(e) if str(e) else "Unknown error"

autogpt_platform/backend/backend/blocks/smart_decision_maker.py

@@ -523,6 +523,7 @@ class SmartDecisionMakerBlock(Block):
             credentials=credentials,
             llm_model=input_data.model,
             prompt=prompt,
+            json_format=False,
             max_tokens=input_data.max_tokens,
             tools=tool_functions,
             ollama_host=input_data.ollama_host,

autogpt_platform/backend/backend/blocks/test/test_llm.py

@@ -30,6 +30,7 @@ class TestLLMStatsTracking:
                 credentials=llm.TEST_CREDENTIALS,
                 llm_model=llm.LlmModel.GPT4O,
                 prompt=[{"role": "user", "content": "Hello"}],
+                json_format=False,
                 max_tokens=100,
             )
 
@@ -41,8 +42,6 @@ class TestLLMStatsTracking:
     @pytest.mark.asyncio
     async def test_ai_structured_response_block_tracks_stats(self):
         """Test that AIStructuredResponseGeneratorBlock correctly tracks stats."""
-        from unittest.mock import patch
-
         import backend.blocks.llm as llm
 
         block = llm.AIStructuredResponseGeneratorBlock()
@@ -52,7 +51,7 @@ class TestLLMStatsTracking:
             return llm.LLMResponse(
                 raw_response="",
                 prompt=[],
-                response='<json_output id="test123456">{"key1": "value1", "key2": "value2"}</json_output>',
+                response='{"key1": "value1", "key2": "value2"}',
                 tool_calls=None,
                 prompt_tokens=15,
                 completion_tokens=25,
@@ -70,12 +69,10 @@ class TestLLMStatsTracking:
         )
 
         outputs = {}
-        # Mock secrets.token_hex to return consistent ID
-        with patch("secrets.token_hex", return_value="test123456"):
-            async for output_name, output_data in block.run(
-                input_data, credentials=llm.TEST_CREDENTIALS
-            ):
-                outputs[output_name] = output_data
+        async for output_name, output_data in block.run(
+            input_data, credentials=llm.TEST_CREDENTIALS
+        ):
+            outputs[output_name] = output_data
 
         # Check stats
         assert block.execution_stats.input_token_count == 15
@@ -146,7 +143,7 @@ class TestLLMStatsTracking:
                 return llm.LLMResponse(
                     raw_response="",
                     prompt=[],
-                    response='<json_output id="test123456">{"wrong": "format"}</json_output>',
+                    response='{"wrong": "format"}',
                     tool_calls=None,
                     prompt_tokens=10,
                     completion_tokens=15,
@@ -157,7 +154,7 @@ class TestLLMStatsTracking:
                 return llm.LLMResponse(
                     raw_response="",
                     prompt=[],
-                    response='<json_output id="test123456">{"key1": "value1", "key2": "value2"}</json_output>',
+                    response='{"key1": "value1", "key2": "value2"}',
                     tool_calls=None,
                     prompt_tokens=20,
                     completion_tokens=25,
@@ -176,12 +173,10 @@ class TestLLMStatsTracking:
         )
 
         outputs = {}
-        # Mock secrets.token_hex to return consistent ID
-        with patch("secrets.token_hex", return_value="test123456"):
-            async for output_name, output_data in block.run(
-                input_data, credentials=llm.TEST_CREDENTIALS
-            ):
-                outputs[output_name] = output_data
+        async for output_name, output_data in block.run(
+            input_data, credentials=llm.TEST_CREDENTIALS
+        ):
+            outputs[output_name] = output_data
 
         # Check stats - should accumulate both calls
         # For 2 attempts: attempt 1 (failed) + attempt 2 (success) = 2 total
@@ -274,8 +269,7 @@ class TestLLMStatsTracking:
                 mock_response.choices = [
                     MagicMock(
                         message=MagicMock(
-                            content='<json_output id="test123456">{"summary": "Test chunk summary"}</json_output>',
-                            tool_calls=None,
+                            content='{"summary": "Test chunk summary"}', tool_calls=None
                         )
                     )
                 ]
@@ -283,7 +277,7 @@ class TestLLMStatsTracking:
                 mock_response.choices = [
                     MagicMock(
                         message=MagicMock(
-                            content='<json_output id="test123456">{"final_summary": "Test final summary"}</json_output>',
+                            content='{"final_summary": "Test final summary"}',
                             tool_calls=None,
                         )
                     )
@@ -304,13 +298,11 @@ class TestLLMStatsTracking:
                 max_tokens=1000,  # Large enough to avoid chunking
             )
 
-            # Mock secrets.token_hex to return consistent ID
-            with patch("secrets.token_hex", return_value="test123456"):
-                outputs = {}
-                async for output_name, output_data in block.run(
-                    input_data, credentials=llm.TEST_CREDENTIALS
-                ):
-                    outputs[output_name] = output_data
+            outputs = {}
+            async for output_name, output_data in block.run(
+                input_data, credentials=llm.TEST_CREDENTIALS
+            ):
+                outputs[output_name] = output_data
 
             print(f"Actual calls made: {call_count}")
             print(f"Block stats: {block.execution_stats}")
@@ -465,7 +457,7 @@ class TestLLMStatsTracking:
             return llm.LLMResponse(
                 raw_response="",
                 prompt=[],
-                response='<json_output id="test123456">{"result": "test"}</json_output>',
+                response='{"result": "test"}',
                 tool_calls=None,
                 prompt_tokens=10,
                 completion_tokens=20,
@@ -484,12 +476,10 @@ class TestLLMStatsTracking:
 
         # Run the block
         outputs = {}
-        # Mock secrets.token_hex to return consistent ID
-        with patch("secrets.token_hex", return_value="test123456"):
-            async for output_name, output_data in block.run(
-                input_data, credentials=llm.TEST_CREDENTIALS
-            ):
-                outputs[output_name] = output_data
+        async for output_name, output_data in block.run(
+            input_data, credentials=llm.TEST_CREDENTIALS
+        ):
+            outputs[output_name] = output_data
 
         # Block finished - now grab and assert stats
         assert block.execution_stats is not None

autogpt_platform/backend/backend/blocks/text.py

@@ -172,11 +172,6 @@ class FillTextTemplateBlock(Block):
         format: str = SchemaField(
             description="Template to format the text using `values`. Use Jinja2 syntax."
         )
-        escape_html: bool = SchemaField(
-            default=False,
-            advanced=True,
-            description="Whether to escape special characters in the inserted values to be HTML-safe. Enable for HTML output, disable for plain text.",
-        )
 
     class Output(BlockSchema):
         output: str = SchemaField(description="Formatted text")
@@ -210,7 +205,6 @@ class FillTextTemplateBlock(Block):
         )
 
     async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        formatter = text.TextFormatter(autoescape=input_data.escape_html)
         yield "output", formatter.format_string(input_data.format, input_data.values)
 
 

autogpt_platform/backend/backend/data/block.py

@@ -1,3 +1,4 @@
+import functools
 import inspect
 import logging
 import os
@@ -20,7 +21,6 @@ from typing import (
 
 import jsonref
 import jsonschema
-from autogpt_libs.utils.cache import cached
 from prisma.models import AgentBlock
 from prisma.types import AgentBlockCreateInput
 from pydantic import BaseModel
@@ -722,7 +722,7 @@ def get_block(block_id: str) -> Block[BlockSchema, BlockSchema] | None:
     return cls() if cls else None
 
 
-@cached()
+@functools.cache
 def get_webhook_block_ids() -> Sequence[str]:
     return [
         id
@@ -731,7 +731,7 @@ def get_webhook_block_ids() -> Sequence[str]:
     ]
 
 
-@cached()
+@functools.cache
 def get_io_block_ids() -> Sequence[str]:
     return [
         id

autogpt_platform/backend/backend/data/db.py

@@ -83,7 +83,7 @@ async def disconnect():
 
 
 # Transaction timeout constant (in milliseconds)
-TRANSACTION_TIMEOUT = 30000  # 30 seconds - Increased from 15s to prevent timeout errors during graph creation under load
+TRANSACTION_TIMEOUT = 15000  # 15 seconds - Increased from 5s to prevent timeout errors
 
 
 @asynccontextmanager

autogpt_platform/backend/backend/data/execution.py

@@ -92,31 +92,6 @@ ExecutionStatus = AgentExecutionStatus
 NodeInputMask = Mapping[str, JsonValue]
 NodesInputMasks = Mapping[str, NodeInputMask]
 
-# dest: source
-VALID_STATUS_TRANSITIONS = {
-    ExecutionStatus.QUEUED: [
-        ExecutionStatus.INCOMPLETE,
-    ],
-    ExecutionStatus.RUNNING: [
-        ExecutionStatus.INCOMPLETE,
-        ExecutionStatus.QUEUED,
-        ExecutionStatus.TERMINATED,  # For resuming halted execution
-    ],
-    ExecutionStatus.COMPLETED: [
-        ExecutionStatus.RUNNING,
-    ],
-    ExecutionStatus.FAILED: [
-        ExecutionStatus.INCOMPLETE,
-        ExecutionStatus.QUEUED,
-        ExecutionStatus.RUNNING,
-    ],
-    ExecutionStatus.TERMINATED: [
-        ExecutionStatus.INCOMPLETE,
-        ExecutionStatus.QUEUED,
-        ExecutionStatus.RUNNING,
-    ],
-}
-
 
 class GraphExecutionMeta(BaseDbModel):
     id: str  # type: ignore # Override base class to make this required
@@ -130,8 +105,6 @@ class GraphExecutionMeta(BaseDbModel):
     status: ExecutionStatus
     started_at: datetime
     ended_at: datetime
-    is_shared: bool = False
-    share_token: Optional[str] = None
 
     class Stats(BaseModel):
         model_config = ConfigDict(
@@ -248,8 +221,6 @@ class GraphExecutionMeta(BaseDbModel):
                 if stats
                 else None
             ),
-            is_shared=_graph_exec.isShared,
-            share_token=_graph_exec.shareToken,
         )
 
 
@@ -609,7 +580,7 @@ async def create_graph_execution(
         data={
             "agentGraphId": graph_id,
             "agentGraphVersion": graph_version,
-            "executionStatus": ExecutionStatus.INCOMPLETE,
+            "executionStatus": ExecutionStatus.QUEUED,
             "inputs": SafeJson(inputs),
             "credentialInputs": (
                 SafeJson(credential_inputs) if credential_inputs else Json({})
@@ -756,11 +727,6 @@ async def update_graph_execution_stats(
     status: ExecutionStatus | None = None,
     stats: GraphExecutionStats | None = None,
 ) -> GraphExecution | None:
-    if not status and not stats:
-        raise ValueError(
-            f"Must provide either status or stats to update for execution {graph_exec_id}"
-        )
-
     update_data: AgentGraphExecutionUpdateManyMutationInput = {}
 
     if stats:
@@ -772,25 +738,20 @@ async def update_graph_execution_stats(
     if status:
         update_data["executionStatus"] = status
 
-    where_clause: AgentGraphExecutionWhereInput = {"id": graph_exec_id}
-
-    if status:
-        if allowed_from := VALID_STATUS_TRANSITIONS.get(status, []):
-            # Add OR clause to check if current status is one of the allowed source statuses
-            where_clause["AND"] = [
-                {"id": graph_exec_id},
-                {"OR": [{"executionStatus": s} for s in allowed_from]},
-            ]
-        else:
-            raise ValueError(
-                f"Status {status} cannot be set via update for execution {graph_exec_id}. "
-                f"This status can only be set at creation or is not a valid target status."
-            )
-
-    await AgentGraphExecution.prisma().update_many(
-        where=where_clause,
+    updated_count = await AgentGraphExecution.prisma().update_many(
+        where={
+            "id": graph_exec_id,
+            "OR": [
+                {"executionStatus": ExecutionStatus.RUNNING},
+                {"executionStatus": ExecutionStatus.QUEUED},
+                # Terminated graph can be resumed.
+                {"executionStatus": ExecutionStatus.TERMINATED},
+            ],
+        },
         data=update_data,
     )
+    if updated_count == 0:
+        return None
 
     graph_exec = await AgentGraphExecution.prisma().find_unique_or_raise(
         where={"id": graph_exec_id},
@@ -798,7 +759,6 @@ async def update_graph_execution_stats(
             [*get_io_block_ids(), *get_webhook_block_ids()]
         ),
     )
-
     return GraphExecution.from_db(graph_exec)
 
 
@@ -1025,18 +985,6 @@ class NodeExecutionEvent(NodeExecutionResult):
     )
 
 
-class SharedExecutionResponse(BaseModel):
-    """Public-safe response for shared executions"""
-
-    id: str
-    graph_name: str
-    graph_description: Optional[str]
-    status: ExecutionStatus
-    created_at: datetime
-    outputs: CompletedBlockOutput  # Only the final outputs, no intermediate data
-    # Deliberately exclude: user_id, inputs, credentials, node details
-
-
 ExecutionEvent = Annotated[
     GraphExecutionEvent | NodeExecutionEvent, Field(discriminator="event_type")
 ]
@@ -1214,98 +1162,3 @@ async def get_block_error_stats(
         )
         for row in result
     ]
-
-
-async def update_graph_execution_share_status(
-    execution_id: str,
-    user_id: str,
-    is_shared: bool,
-    share_token: str | None,
-    shared_at: datetime | None,
-) -> None:
-    """Update the sharing status of a graph execution."""
-    await AgentGraphExecution.prisma().update(
-        where={"id": execution_id},
-        data={
-            "isShared": is_shared,
-            "shareToken": share_token,
-            "sharedAt": shared_at,
-        },
-    )
-
-
-async def get_graph_execution_by_share_token(
-    share_token: str,
-) -> SharedExecutionResponse | None:
-    """Get a shared execution with limited public-safe data."""
-    execution = await AgentGraphExecution.prisma().find_first(
-        where={
-            "shareToken": share_token,
-            "isShared": True,
-            "isDeleted": False,
-        },
-        include={
-            "AgentGraph": True,
-            "NodeExecutions": {
-                "include": {
-                    "Output": True,
-                    "Node": {
-                        "include": {
-                            "AgentBlock": True,
-                        }
-                    },
-                },
-            },
-        },
-    )
-
-    if not execution:
-        return None
-
-    # Extract outputs from OUTPUT blocks only (consistent with GraphExecution.from_db)
-    outputs: CompletedBlockOutput = defaultdict(list)
-    if execution.NodeExecutions:
-        for node_exec in execution.NodeExecutions:
-            if node_exec.Node and node_exec.Node.agentBlockId:
-                # Get the block definition to check its type
-                block = get_block(node_exec.Node.agentBlockId)
-
-                if block and block.block_type == BlockType.OUTPUT:
-                    # For OUTPUT blocks, the data is stored in executionData or Input
-                    # The executionData contains the structured input with 'name' and 'value' fields
-                    if hasattr(node_exec, "executionData") and node_exec.executionData:
-                        exec_data = type_utils.convert(
-                            node_exec.executionData, dict[str, Any]
-                        )
-                        if "name" in exec_data:
-                            name = exec_data["name"]
-                            value = exec_data.get("value")
-                            outputs[name].append(value)
-                    elif node_exec.Input:
-                        # Build input_data from Input relation
-                        input_data = {}
-                        for data in node_exec.Input:
-                            if data.name and data.data is not None:
-                                input_data[data.name] = type_utils.convert(
-                                    data.data, JsonValue
-                                )
-
-                        if "name" in input_data:
-                            name = input_data["name"]
-                            value = input_data.get("value")
-                            outputs[name].append(value)
-
-    return SharedExecutionResponse(
-        id=execution.id,
-        graph_name=(
-            execution.AgentGraph.name
-            if (execution.AgentGraph and execution.AgentGraph.name)
-            else "Untitled Agent"
-        ),
-        graph_description=(
-            execution.AgentGraph.description if execution.AgentGraph else None
-        ),
-        status=ExecutionStatus(execution.executionStatus),
-        created_at=execution.createdAt,
-        outputs=outputs,
-    )

autogpt_platform/backend/backend/data/graph.py

@@ -1,7 +1,6 @@
 import logging
 import uuid
 from collections import defaultdict
-from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any, Literal, Optional, cast
 
 from prisma.enums import SubmissionStatus
@@ -29,7 +28,6 @@ from backend.data.model import (
 from backend.integrations.providers import ProviderName
 from backend.util import type as type_utils
 from backend.util.json import SafeJson
-from backend.util.models import Pagination
 
 from .block import Block, BlockInput, BlockSchema, BlockType, get_block, get_blocks
 from .db import BaseDbModel, query_raw_with_schema, transaction
@@ -162,7 +160,6 @@ class BaseGraph(BaseDbModel):
     is_active: bool = True
     name: str
     description: str
-    instructions: str | None = None
     recommended_schedule_cron: str | None = None
     nodes: list[Node] = []
     links: list[Link] = []
@@ -384,8 +381,6 @@ class GraphModel(Graph):
     user_id: str
     nodes: list[NodeModel] = []  # type: ignore
 
-    created_at: datetime
-
     @property
     def starting_nodes(self) -> list[NodeModel]:
         outbound_nodes = {link.sink_id for link in self.links}
@@ -398,10 +393,6 @@ class GraphModel(Graph):
             if node.id not in outbound_nodes or node.id in input_nodes
         ]
 
-    @property
-    def webhook_input_node(self) -> NodeModel | None:  # type: ignore
-        return cast(NodeModel, super().webhook_input_node)
-
     def meta(self) -> "GraphMeta":
         """
         Returns a GraphMeta object with metadata about the graph.
@@ -703,11 +694,9 @@ class GraphModel(Graph):
             version=graph.version,
             forked_from_id=graph.forkedFromId,
             forked_from_version=graph.forkedFromVersion,
-            created_at=graph.createdAt,
             is_active=graph.isActive,
             name=graph.name or "",
             description=graph.description or "",
-            instructions=graph.instructions,
             recommended_schedule_cron=graph.recommendedScheduleCron,
             nodes=[NodeModel.from_db(node, for_export) for node in graph.Nodes or []],
             links=list(
@@ -747,13 +736,6 @@ class GraphMeta(Graph):
         return GraphMeta(**graph.model_dump())
 
 
-class GraphsPaginated(BaseModel):
-    """Response schema for paginated graphs."""
-
-    graphs: list[GraphMeta]
-    pagination: Pagination
-
-
 # --------------------- CRUD functions --------------------- #
 
 
@@ -782,42 +764,31 @@ async def set_node_webhook(node_id: str, webhook_id: str | None) -> NodeModel:
     return NodeModel.from_db(node)
 
 
-async def list_graphs_paginated(
+async def list_graphs(
     user_id: str,
-    page: int = 1,
-    page_size: int = 25,
     filter_by: Literal["active"] | None = "active",
-) -> GraphsPaginated:
+) -> list[GraphMeta]:
     """
-    Retrieves paginated graph metadata objects.
+    Retrieves graph metadata objects.
+    Default behaviour is to get all currently active graphs.
 
     Args:
-        user_id: The ID of the user that owns the graphs.
-        page: Page number (1-based).
-        page_size: Number of graphs per page.
         filter_by: An optional filter to either select graphs.
+        user_id: The ID of the user that owns the graph.
 
     Returns:
-        GraphsPaginated: Paginated list of graph metadata.
+        list[GraphMeta]: A list of objects representing the retrieved graphs.
     """
     where_clause: AgentGraphWhereInput = {"userId": user_id}
 
     if filter_by == "active":
         where_clause["isActive"] = True
 
-    # Get total count
-    total_count = await AgentGraph.prisma().count(where=where_clause)
-    total_pages = (total_count + page_size - 1) // page_size
-
-    # Get paginated results
-    offset = (page - 1) * page_size
     graphs = await AgentGraph.prisma().find_many(
         where=where_clause,
         distinct=["id"],
         order={"version": "desc"},
         include=AGENT_GRAPH_INCLUDE,
-        skip=offset,
-        take=page_size,
     )
 
     graph_models: list[GraphMeta] = []
@@ -831,15 +802,7 @@ async def list_graphs_paginated(
             logger.error(f"Error processing graph {graph.id}: {e}")
             continue
 
-    return GraphsPaginated(
-        graphs=graph_models,
-        pagination=Pagination(
-            total_items=total_count,
-            total_pages=total_pages,
-            current_page=page,
-            page_size=page_size,
-        ),
-    )
+    return graph_models
 
 
 async def get_graph_metadata(graph_id: str, version: int | None = None) -> Graph | None:
@@ -1181,7 +1144,6 @@ def make_graph_model(creatable_graph: Graph, user_id: str) -> GraphModel:
     return GraphModel(
         **creatable_graph.model_dump(exclude={"nodes"}),
         user_id=user_id,
-        created_at=datetime.now(tz=timezone.utc),
         nodes=[
             NodeModel(
                 **creatable_node.model_dump(),

autogpt_platform/backend/backend/data/redis_client.py

@@ -1,7 +1,8 @@
 import logging
 import os
+from functools import cache
 
-from autogpt_libs.utils.cache import cached, thread_cached
+from autogpt_libs.utils.cache import thread_cached
 from dotenv import load_dotenv
 from redis import Redis
 from redis.asyncio import Redis as AsyncRedis
@@ -12,7 +13,7 @@ load_dotenv()
 
 HOST = os.getenv("REDIS_HOST", "localhost")
 PORT = int(os.getenv("REDIS_PORT", "6379"))
-PASSWORD = os.getenv("REDIS_PASSWORD", None)
+PASSWORD = os.getenv("REDIS_PASSWORD", "password")
 
 logger = logging.getLogger(__name__)
 
@@ -34,7 +35,7 @@ def disconnect():
     get_redis().close()
 
 
-@cached()
+@cache
 def get_redis() -> Redis:
     return connect()
 

autogpt_platform/backend/backend/data/user.py

@@ -7,7 +7,6 @@ from typing import Optional, cast
 from urllib.parse import quote_plus
 
 from autogpt_libs.auth.models import DEFAULT_USER_ID
-from autogpt_libs.utils.cache import cached
 from fastapi import HTTPException
 from prisma.enums import NotificationType
 from prisma.models import User as PrismaUser
@@ -24,11 +23,7 @@ from backend.util.settings import Settings
 logger = logging.getLogger(__name__)
 settings = Settings()
 
-# Cache decorator alias for consistent user lookup caching
-cache_user_lookup = cached(maxsize=1000, ttl_seconds=300)
 
-
-@cache_user_lookup
 async def get_or_create_user(user_data: dict) -> User:
     try:
         user_id = user_data.get("sub")
@@ -54,7 +49,6 @@ async def get_or_create_user(user_data: dict) -> User:
         raise DatabaseError(f"Failed to get or create user {user_data}: {e}") from e
 
 
-@cache_user_lookup
 async def get_user_by_id(user_id: str) -> User:
     user = await prisma.user.find_unique(where={"id": user_id})
     if not user:
@@ -70,7 +64,6 @@ async def get_user_email_by_id(user_id: str) -> Optional[str]:
         raise DatabaseError(f"Failed to get user email for user {user_id}: {e}") from e
 
 
-@cache_user_lookup
 async def get_user_by_email(email: str) -> Optional[User]:
     try:
         user = await prisma.user.find_unique(where={"email": email})
@@ -81,17 +74,7 @@ async def get_user_by_email(email: str) -> Optional[User]:
 
 async def update_user_email(user_id: str, email: str):
     try:
-        # Get old email first for cache invalidation
-        old_user = await prisma.user.find_unique(where={"id": user_id})
-        old_email = old_user.email if old_user else None
-
         await prisma.user.update(where={"id": user_id}, data={"email": email})
-
-        # Selectively invalidate only the specific user entries
-        get_user_by_id.cache_delete(user_id)
-        if old_email:
-            get_user_by_email.cache_delete(old_email)
-        get_user_by_email.cache_delete(email)
     except Exception as e:
         raise DatabaseError(
             f"Failed to update user email for user {user_id}: {e}"
@@ -131,8 +114,6 @@ async def update_user_integrations(user_id: str, data: UserIntegrations):
         where={"id": user_id},
         data={"integrations": encrypted_data},
     )
-    # Invalidate cache for this user
-    get_user_by_id.cache_delete(user_id)
 
 
 async def migrate_and_encrypt_user_integrations():
@@ -304,10 +285,6 @@ async def update_user_notification_preference(
         )
         if not user:
             raise ValueError(f"User not found with ID: {user_id}")
-
-        # Invalidate cache for this user since notification preferences are part of user data
-        get_user_by_id.cache_delete(user_id)
-
         preferences: dict[NotificationType, bool] = {
             NotificationType.AGENT_RUN: user.notifyOnAgentRun or True,
             NotificationType.ZERO_BALANCE: user.notifyOnZeroBalance or True,
@@ -346,8 +323,6 @@ async def set_user_email_verification(user_id: str, verified: bool) -> None:
             where={"id": user_id},
             data={"emailVerified": verified},
         )
-        # Invalidate cache for this user
-        get_user_by_id.cache_delete(user_id)
     except Exception as e:
         raise DatabaseError(
             f"Failed to set email verification status for user {user_id}: {e}"
@@ -432,10 +407,6 @@ async def update_user_timezone(user_id: str, timezone: str) -> User:
         )
         if not user:
             raise ValueError(f"User not found with ID: {user_id}")
-
-        # Invalidate cache for this user
-        get_user_by_id.cache_delete(user_id)
-
         return User.from_db(user)
     except Exception as e:
         raise DatabaseError(f"Failed to update timezone for user {user_id}: {e}") from e

autogpt_platform/backend/backend/executor/activity_status_generator.py

@@ -107,7 +107,7 @@ async def generate_activity_status_for_execution(
     # Check if we have OpenAI API key
     try:
         settings = Settings()
-        if not settings.secrets.openai_internal_api_key:
+        if not settings.secrets.openai_api_key:
             logger.debug(
                 "OpenAI API key not configured, skipping activity status generation"
             )
@@ -187,7 +187,7 @@ async def generate_activity_status_for_execution(
         credentials = APIKeyCredentials(
             id="openai",
             provider="openai",
-            api_key=SecretStr(settings.secrets.openai_internal_api_key),
+            api_key=SecretStr(settings.secrets.openai_api_key),
             title="System OpenAI",
         )
 
@@ -423,6 +423,7 @@ async def _call_llm_direct(
         credentials=credentials,
         llm_model=LlmModel.GPT4O_MINI,
         prompt=prompt,
+        json_format=False,
         max_tokens=150,
         compress_prompt_to_fit=True,
     )

autogpt_platform/backend/backend/executor/activity_status_generator_test.py

@@ -468,7 +468,7 @@ class TestGenerateActivityStatusForExecution:
         ):
 
             mock_get_block.side_effect = lambda block_id: mock_blocks.get(block_id)
-            mock_settings.return_value.secrets.openai_internal_api_key = "test_key"
+            mock_settings.return_value.secrets.openai_api_key = "test_key"
             mock_llm.return_value = (
                 "I analyzed your data and provided the requested insights."
             )
@@ -520,7 +520,7 @@ class TestGenerateActivityStatusForExecution:
             "backend.executor.activity_status_generator.is_feature_enabled",
             return_value=True,
         ):
-            mock_settings.return_value.secrets.openai_internal_api_key = ""
+            mock_settings.return_value.secrets.openai_api_key = ""
 
             result = await generate_activity_status_for_execution(
                 graph_exec_id="test_exec",
@@ -546,7 +546,7 @@ class TestGenerateActivityStatusForExecution:
             "backend.executor.activity_status_generator.is_feature_enabled",
             return_value=True,
         ):
-            mock_settings.return_value.secrets.openai_internal_api_key = "test_key"
+            mock_settings.return_value.secrets.openai_api_key = "test_key"
 
             result = await generate_activity_status_for_execution(
                 graph_exec_id="test_exec",
@@ -581,7 +581,7 @@ class TestGenerateActivityStatusForExecution:
         ):
 
             mock_get_block.side_effect = lambda block_id: mock_blocks.get(block_id)
-            mock_settings.return_value.secrets.openai_internal_api_key = "test_key"
+            mock_settings.return_value.secrets.openai_api_key = "test_key"
             mock_llm.return_value = "Agent completed execution."
 
             result = await generate_activity_status_for_execution(
@@ -633,7 +633,7 @@ class TestIntegration:
         ):
 
             mock_get_block.side_effect = lambda block_id: mock_blocks.get(block_id)
-            mock_settings.return_value.secrets.openai_internal_api_key = "test_key"
+            mock_settings.return_value.secrets.openai_api_key = "test_key"
 
             mock_response = LLMResponse(
                 raw_response={},

autogpt_platform/backend/backend/executor/database.py

@@ -85,16 +85,6 @@ class DatabaseManager(AppService):
     async def health_check(self) -> str:
         if not db.is_connected():
             raise UnhealthyServiceError("Database is not connected")
-
-        try:
-            # Test actual database connectivity by executing a simple query
-            # This will fail if Prisma query engine is not responding
-            result = await db.query_raw_with_schema("SELECT 1 as health_check")
-            if not result or result[0].get("health_check") != 1:
-                raise UnhealthyServiceError("Database query test failed")
-        except Exception as e:
-            raise UnhealthyServiceError(f"Database health check failed: {e}")
-
         return await super().health_check()
 
     @classmethod

autogpt_platform/backend/backend/executor/manager.py

@@ -605,7 +605,7 @@ class ExecutionProcessor:
             )
             return
 
-        if exec_meta.status in [ExecutionStatus.QUEUED, ExecutionStatus.INCOMPLETE]:
+        if exec_meta.status == ExecutionStatus.QUEUED:
             log_metadata.info(f"⚙️ Starting graph execution #{graph_exec.graph_exec_id}")
             exec_meta.status = ExecutionStatus.RUNNING
             send_execution_update(

autogpt_platform/backend/backend/executor/scheduler.py

@@ -191,22 +191,15 @@ class GraphExecutionJobInfo(GraphExecutionJobArgs):
     id: str
     name: str
     next_run_time: str
-    timezone: str = Field(default="UTC", description="Timezone used for scheduling")
 
     @staticmethod
     def from_db(
         job_args: GraphExecutionJobArgs, job_obj: JobObj
     ) -> "GraphExecutionJobInfo":
-        # Extract timezone from the trigger if it's a CronTrigger
-        timezone_str = "UTC"
-        if hasattr(job_obj.trigger, "timezone"):
-            timezone_str = str(job_obj.trigger.timezone)
-
         return GraphExecutionJobInfo(
             id=job_obj.id,
             name=job_obj.name,
             next_run_time=job_obj.next_run_time.isoformat(),
-            timezone=timezone_str,
             **job_args.model_dump(),
         )
 
@@ -402,7 +395,6 @@ class Scheduler(AppService):
         input_data: BlockInput,
         input_credentials: dict[str, CredentialsMetaInput],
         name: Optional[str] = None,
-        user_timezone: str | None = None,
     ) -> GraphExecutionJobInfo:
         # Validate the graph before scheduling to prevent runtime failures
         # We don't need the return value, just want the validation to run
@@ -416,18 +408,7 @@ class Scheduler(AppService):
             )
         )
 
-        # Use provided timezone or default to UTC
-        # Note: Timezone should be passed from the client to avoid database lookups
-        if not user_timezone:
-            user_timezone = "UTC"
-            logger.warning(
-                f"No timezone provided for user {user_id}, using UTC for scheduling. "
-                f"Client should pass user's timezone for correct scheduling."
-            )
-
-        logger.info(
-            f"Scheduling job for user {user_id} with timezone {user_timezone} (cron: {cron})"
-        )
+        logger.info(f"Scheduling job for user {user_id} in UTC (cron: {cron})")
 
         job_args = GraphExecutionJobArgs(
             user_id=user_id,
@@ -441,12 +422,12 @@ class Scheduler(AppService):
             execute_graph,
             kwargs=job_args.model_dump(),
             name=name,
-            trigger=CronTrigger.from_crontab(cron, timezone=user_timezone),
+            trigger=CronTrigger.from_crontab(cron, timezone="UTC"),
             jobstore=Jobstores.EXECUTION.value,
             replace_existing=True,
         )
         logger.info(
-            f"Added job {job.id} with cron schedule '{cron}' in timezone {user_timezone}, input data: {input_data}"
+            f"Added job {job.id} with cron schedule '{cron}' in UTC, input data: {input_data}"
         )
         return GraphExecutionJobInfo.from_db(job_args, job)
 

autogpt_platform/backend/backend/executor/utils.py

@@ -914,30 +914,29 @@ async def add_graph_execution(
             preset_id=preset_id,
         )
 
+        # Fetch user context for the graph execution
+        user_context = await get_user_context(user_id)
+
+        queue = await get_async_execution_queue()
         graph_exec_entry = graph_exec.to_graph_execution_entry(
-            user_context=await get_user_context(user_id),
-            compiled_nodes_input_masks=compiled_nodes_input_masks,
+            user_context, compiled_nodes_input_masks
         )
+
         logger.info(
             f"Created graph execution #{graph_exec.id} for graph "
             f"#{graph_id} with {len(starting_nodes_input)} starting nodes. "
             f"Now publishing to execution queue."
         )
 
-        exec_queue = await get_async_execution_queue()
-        await exec_queue.publish_message(
+        await queue.publish_message(
             routing_key=GRAPH_EXECUTION_ROUTING_KEY,
             message=graph_exec_entry.model_dump_json(),
             exchange=GRAPH_EXECUTION_EXCHANGE,
         )
         logger.info(f"Published execution {graph_exec.id} to RabbitMQ queue")
 
-        graph_exec.status = ExecutionStatus.QUEUED
-        await edb.update_graph_execution_stats(
-            graph_exec_id=graph_exec.id,
-            status=graph_exec.status,
-        )
-        await get_async_execution_event_bus().publish(graph_exec)
+        bus = get_async_execution_event_bus()
+        await bus.publish(graph_exec)
 
         return graph_exec
     except BaseException as e:

autogpt_platform/backend/backend/executor/utils_test.py

@@ -316,7 +316,6 @@ async def test_add_graph_execution_is_repeatable(mocker: MockerFixture):
     # Mock the graph execution object
     mock_graph_exec = mocker.MagicMock(spec=GraphExecutionWithNodes)
     mock_graph_exec.id = "execution-id-123"
-    mock_graph_exec.node_executions = []  # Add this to avoid AttributeError
     mock_graph_exec.to_graph_execution_entry.return_value = mocker.MagicMock()
 
     # Mock user context
@@ -347,10 +346,6 @@ async def test_add_graph_execution_is_repeatable(mocker: MockerFixture):
     )
     mock_prisma.is_connected.return_value = True
     mock_edb.create_graph_execution = mocker.AsyncMock(return_value=mock_graph_exec)
-    mock_edb.update_graph_execution_stats = mocker.AsyncMock(
-        return_value=mock_graph_exec
-    )
-    mock_edb.update_node_execution_status_batch = mocker.AsyncMock()
     mock_get_user_context.return_value = mock_user_context
     mock_get_queue.return_value = mock_queue
     mock_get_event_bus.return_value = mock_event_bus

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

@@ -1,14 +1,13 @@
+import functools
 from typing import TYPE_CHECKING
 
-from autogpt_libs.utils.cache import cached
-
 if TYPE_CHECKING:
     from ..providers import ProviderName
     from ._base import BaseWebhooksManager
 
 
 # --8<-- [start:load_webhook_managers]
-@cached()
+@functools.cache
 def load_webhook_managers() -> dict["ProviderName", type["BaseWebhooksManager"]]:
     webhook_managers = {}
 

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

@@ -7,9 +7,10 @@ from backend.data.graph import set_node_webhook
 from backend.integrations.creds_manager import IntegrationCredentialsManager
 
 from . import get_webhook_manager, supports_webhooks
+from .utils import setup_webhook_for_block
 
 if TYPE_CHECKING:
-    from backend.data.graph import BaseGraph, GraphModel, NodeModel
+    from backend.data.graph import BaseGraph, GraphModel, Node, NodeModel
     from backend.data.model import Credentials
 
     from ._base import BaseWebhooksManager
@@ -42,19 +43,32 @@ async def _on_graph_activate(graph: "BaseGraph", user_id: str) -> "BaseGraph": .
 
 async def _on_graph_activate(graph: "BaseGraph | GraphModel", user_id: str):
     get_credentials = credentials_manager.cached_getter(user_id)
+    updated_nodes = []
     for new_node in graph.nodes:
         block_input_schema = cast(BlockSchema, new_node.block.input_schema)
 
-        for creds_field_name in block_input_schema.get_credentials_fields().keys():
-            # Prevent saving graph with non-existent credentials
-            if (
-                creds_meta := new_node.input_default.get(creds_field_name)
-            ) and not await get_credentials(creds_meta["id"]):
-                raise ValueError(
-                    f"Node #{new_node.id} input '{creds_field_name}' updated with "
-                    f"non-existent credentials #{creds_meta['id']}"
+        node_credentials = None
+        if (
+            # Webhook-triggered blocks are only allowed to have 1 credentials input
+            (
+                creds_field_name := next(
+                    iter(block_input_schema.get_credentials_fields()), None
                 )
+            )
+            and (creds_meta := new_node.input_default.get(creds_field_name))
+            and not (node_credentials := await get_credentials(creds_meta["id"]))
+        ):
+            raise ValueError(
+                f"Node #{new_node.id} input '{creds_field_name}' updated with "
+                f"non-existent credentials #{creds_meta['id']}"
+            )
 
+        updated_node = await on_node_activate(
+            user_id, graph.id, new_node, credentials=node_credentials
+        )
+        updated_nodes.append(updated_node)
+
+    graph.nodes = updated_nodes
     return graph
 
 
@@ -71,14 +85,20 @@ async def on_graph_deactivate(graph: "GraphModel", user_id: str):
         block_input_schema = cast(BlockSchema, node.block.input_schema)
 
         node_credentials = None
-        for creds_field_name in block_input_schema.get_credentials_fields().keys():
-            if (creds_meta := node.input_default.get(creds_field_name)) and not (
-                node_credentials := await get_credentials(creds_meta["id"])
-            ):
-                logger.warning(
-                    f"Node #{node.id} input '{creds_field_name}' referenced "
-                    f"non-existent credentials #{creds_meta['id']}"
+        if (
+            # Webhook-triggered blocks are only allowed to have 1 credentials input
+            (
+                creds_field_name := next(
+                    iter(block_input_schema.get_credentials_fields()), None
                 )
+            )
+            and (creds_meta := node.input_default.get(creds_field_name))
+            and not (node_credentials := await get_credentials(creds_meta["id"]))
+        ):
+            logger.error(
+                f"Node #{node.id} input '{creds_field_name}' referenced non-existent "
+                f"credentials #{creds_meta['id']}"
+            )
 
         updated_node = await on_node_deactivate(
             user_id, node, credentials=node_credentials
@@ -89,6 +109,32 @@ async def on_graph_deactivate(graph: "GraphModel", user_id: str):
     return graph
 
 
+async def on_node_activate(
+    user_id: str,
+    graph_id: str,
+    node: "Node",
+    *,
+    credentials: Optional["Credentials"] = None,
+) -> "Node":
+    """Hook to be called when the node is activated/created"""
+
+    if node.block.webhook_config:
+        new_webhook, feedback = await setup_webhook_for_block(
+            user_id=user_id,
+            trigger_block=node.block,
+            trigger_config=node.input_default,
+            for_graph_id=graph_id,
+        )
+        if new_webhook:
+            node = await set_node_webhook(node.id, new_webhook.id)
+        else:
+            logger.debug(
+                f"Node #{node.id} does not have everything for a webhook: {feedback}"
+            )
+
+    return node
+
+
 async def on_node_deactivate(
     user_id: str,
     node: "NodeModel",

autogpt_platform/backend/backend/integrations/webhooks/utils.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Optional, cast
 from pydantic import JsonValue
 
 from backend.integrations.creds_manager import IntegrationCredentialsManager
+from backend.integrations.providers import ProviderName
 from backend.util.settings import Config
 
 from . import get_webhook_manager, supports_webhooks
@@ -12,7 +13,6 @@ if TYPE_CHECKING:
     from backend.data.block import Block, BlockSchema
     from backend.data.integrations import Webhook
     from backend.data.model import Credentials
-    from backend.integrations.providers import ProviderName
 
 logger = logging.getLogger(__name__)
 app_config = Config()
@@ -20,7 +20,7 @@ credentials_manager = IntegrationCredentialsManager()
 
 
 # TODO: add test to assert this matches the actual API route
-def webhook_ingress_url(provider_name: "ProviderName", webhook_id: str) -> str:
+def webhook_ingress_url(provider_name: ProviderName, webhook_id: str) -> str:
     return (
         f"{app_config.platform_base_url}/api/integrations/{provider_name.value}"
         f"/webhooks/{webhook_id}/ingress"
@@ -144,69 +144,3 @@ async def setup_webhook_for_block(
         )
     logger.debug(f"Acquired webhook: {webhook}")
     return webhook, None
-
-
-async def migrate_legacy_triggered_graphs():
-    from prisma.models import AgentGraph
-
-    from backend.data.graph import AGENT_GRAPH_INCLUDE, GraphModel, set_node_webhook
-    from backend.data.model import is_credentials_field_name
-    from backend.server.v2.library.db import create_preset
-    from backend.server.v2.library.model import LibraryAgentPresetCreatable
-
-    triggered_graphs = [
-        GraphModel.from_db(_graph)
-        for _graph in await AgentGraph.prisma().find_many(
-            where={
-                "isActive": True,
-                "Nodes": {"some": {"NOT": [{"webhookId": None}]}},
-            },
-            include=AGENT_GRAPH_INCLUDE,
-        )
-    ]
-
-    n_migrated_webhooks = 0
-
-    for graph in triggered_graphs:
-        try:
-            if not (
-                (trigger_node := graph.webhook_input_node) and trigger_node.webhook_id
-            ):
-                continue
-
-            # Use trigger node's inputs for the preset
-            preset_credentials = {
-                field_name: creds_meta
-                for field_name, creds_meta in trigger_node.input_default.items()
-                if is_credentials_field_name(field_name)
-            }
-            preset_inputs = {
-                field_name: value
-                for field_name, value in trigger_node.input_default.items()
-                if not is_credentials_field_name(field_name)
-            }
-
-            # Create a triggered preset for the graph
-            await create_preset(
-                graph.user_id,
-                LibraryAgentPresetCreatable(
-                    graph_id=graph.id,
-                    graph_version=graph.version,
-                    inputs=preset_inputs,
-                    credentials=preset_credentials,
-                    name=graph.name,
-                    description=graph.description,
-                    webhook_id=trigger_node.webhook_id,
-                    is_active=True,
-                ),
-            )
-
-            # Detach webhook from the graph node
-            await set_node_webhook(trigger_node.id, None)
-
-            n_migrated_webhooks += 1
-        except Exception as e:
-            logger.error(f"Failed to migrate graph #{graph.id} trigger to preset: {e}")
-            continue
-
-    logger.info(f"Migrated {n_migrated_webhooks} node triggers to triggered presets")

autogpt_platform/backend/backend/monitoring/instrumentation.py

@@ -1,287 +0,0 @@
-"""
-Prometheus instrumentation for FastAPI services.
-
-This module provides centralized metrics collection and instrumentation
-for all FastAPI services in the AutoGPT platform.
-"""
-
-import logging
-from typing import Optional
-
-from fastapi import FastAPI
-from prometheus_client import Counter, Gauge, Histogram, Info
-from prometheus_fastapi_instrumentator import Instrumentator, metrics
-
-logger = logging.getLogger(__name__)
-
-# Custom business metrics with controlled cardinality
-GRAPH_EXECUTIONS = Counter(
-    "autogpt_graph_executions_total",
-    "Total number of graph executions",
-    labelnames=[
-        "status"
-    ],  # Removed graph_id and user_id to prevent cardinality explosion
-)
-
-GRAPH_EXECUTIONS_BY_USER = Counter(
-    "autogpt_graph_executions_by_user_total",
-    "Total number of graph executions by user (sampled)",
-    labelnames=["status"],  # Only status, user_id tracked separately when needed
-)
-
-BLOCK_EXECUTIONS = Counter(
-    "autogpt_block_executions_total",
-    "Total number of block executions",
-    labelnames=["block_type", "status"],  # block_type is bounded
-)
-
-BLOCK_DURATION = Histogram(
-    "autogpt_block_duration_seconds",
-    "Duration of block executions in seconds",
-    labelnames=["block_type"],
-    buckets=[0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60],
-)
-
-WEBSOCKET_CONNECTIONS = Gauge(
-    "autogpt_websocket_connections_total",
-    "Total number of active WebSocket connections",
-    # Removed user_id label - track total only to prevent cardinality explosion
-)
-
-SCHEDULER_JOBS = Gauge(
-    "autogpt_scheduler_jobs",
-    "Current number of scheduled jobs",
-    labelnames=["job_type", "status"],
-)
-
-DATABASE_QUERIES = Histogram(
-    "autogpt_database_query_duration_seconds",
-    "Duration of database queries in seconds",
-    labelnames=["operation", "table"],
-    buckets=[0.01, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5],
-)
-
-RABBITMQ_MESSAGES = Counter(
-    "autogpt_rabbitmq_messages_total",
-    "Total number of RabbitMQ messages",
-    labelnames=["queue", "status"],
-)
-
-AUTHENTICATION_ATTEMPTS = Counter(
-    "autogpt_auth_attempts_total",
-    "Total number of authentication attempts",
-    labelnames=["method", "status"],
-)
-
-API_KEY_USAGE = Counter(
-    "autogpt_api_key_usage_total",
-    "API key usage by provider",
-    labelnames=["provider", "block_type", "status"],
-)
-
-# Function/operation level metrics with controlled cardinality
-GRAPH_OPERATIONS = Counter(
-    "autogpt_graph_operations_total",
-    "Graph operations by type",
-    labelnames=["operation", "status"],  # create, update, delete, execute, etc.
-)
-
-USER_OPERATIONS = Counter(
-    "autogpt_user_operations_total",
-    "User operations by type",
-    labelnames=["operation", "status"],  # login, register, update_profile, etc.
-)
-
-RATE_LIMIT_HITS = Counter(
-    "autogpt_rate_limit_hits_total",
-    "Number of rate limit hits",
-    labelnames=["endpoint"],  # Removed user_id to prevent cardinality explosion
-)
-
-SERVICE_INFO = Info(
-    "autogpt_service",
-    "Service information",
-)
-
-
-def instrument_fastapi(
-    app: FastAPI,
-    service_name: str,
-    expose_endpoint: bool = True,
-    endpoint: str = "/metrics",
-    include_in_schema: bool = False,
-    excluded_handlers: Optional[list] = None,
-) -> Instrumentator:
-    """
-    Instrument a FastAPI application with Prometheus metrics.
-
-    Args:
-        app: FastAPI application instance
-        service_name: Name of the service for metrics labeling
-        expose_endpoint: Whether to expose /metrics endpoint
-        endpoint: Path for metrics endpoint
-        include_in_schema: Whether to include metrics endpoint in OpenAPI schema
-        excluded_handlers: List of paths to exclude from metrics
-
-    Returns:
-        Configured Instrumentator instance
-    """
-
-    # Set service info
-    try:
-        from importlib.metadata import version
-
-        service_version = version("autogpt-platform-backend")
-    except Exception:
-        service_version = "unknown"
-
-    SERVICE_INFO.info(
-        {
-            "service": service_name,
-            "version": service_version,
-        }
-    )
-
-    # Create instrumentator with default metrics
-    instrumentator = Instrumentator(
-        should_group_status_codes=True,
-        should_ignore_untemplated=True,
-        should_respect_env_var=True,
-        should_instrument_requests_inprogress=True,
-        excluded_handlers=excluded_handlers or ["/health", "/readiness"],
-        env_var_name="ENABLE_METRICS",
-        inprogress_name="autogpt_http_requests_inprogress",
-        inprogress_labels=True,
-    )
-
-    # Add default HTTP metrics
-    instrumentator.add(
-        metrics.default(
-            metric_namespace="autogpt",
-            metric_subsystem=service_name.replace("-", "_"),
-        )
-    )
-
-    # Add request size metrics
-    instrumentator.add(
-        metrics.request_size(
-            metric_namespace="autogpt",
-            metric_subsystem=service_name.replace("-", "_"),
-        )
-    )
-
-    # Add response size metrics
-    instrumentator.add(
-        metrics.response_size(
-            metric_namespace="autogpt",
-            metric_subsystem=service_name.replace("-", "_"),
-        )
-    )
-
-    # Add latency metrics with custom buckets for better granularity
-    instrumentator.add(
-        metrics.latency(
-            metric_namespace="autogpt",
-            metric_subsystem=service_name.replace("-", "_"),
-            buckets=[0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60],
-        )
-    )
-
-    # Add combined metrics (requests by method and status)
-    instrumentator.add(
-        metrics.combined_size(
-            metric_namespace="autogpt",
-            metric_subsystem=service_name.replace("-", "_"),
-        )
-    )
-
-    # Instrument the app
-    instrumentator.instrument(app)
-
-    # Expose metrics endpoint if requested
-    if expose_endpoint:
-        instrumentator.expose(
-            app,
-            endpoint=endpoint,
-            include_in_schema=include_in_schema,
-            tags=["monitoring"] if include_in_schema else None,
-        )
-        logger.info(f"Metrics endpoint exposed at {endpoint} for {service_name}")
-
-    return instrumentator
-
-
-def record_graph_execution(graph_id: str, status: str, user_id: str):
-    """Record a graph execution event.
-
-    Args:
-        graph_id: Graph identifier (kept for future sampling/debugging)
-        status: Execution status (success/error/validation_error)
-        user_id: User identifier (kept for future sampling/debugging)
-    """
-    # Track overall executions without high-cardinality labels
-    GRAPH_EXECUTIONS.labels(status=status).inc()
-
-    # Optionally track per-user executions (implement sampling if needed)
-    # For now, just track status to avoid cardinality explosion
-    GRAPH_EXECUTIONS_BY_USER.labels(status=status).inc()
-
-
-def record_block_execution(block_type: str, status: str, duration: float):
-    """Record a block execution event with duration."""
-    BLOCK_EXECUTIONS.labels(block_type=block_type, status=status).inc()
-    BLOCK_DURATION.labels(block_type=block_type).observe(duration)
-
-
-def update_websocket_connections(user_id: str, delta: int):
-    """Update the number of active WebSocket connections.
-
-    Args:
-        user_id: User identifier (kept for future sampling/debugging)
-        delta: Change in connection count (+1 for connect, -1 for disconnect)
-    """
-    # Track total connections without user_id to prevent cardinality explosion
-    if delta > 0:
-        WEBSOCKET_CONNECTIONS.inc(delta)
-    else:
-        WEBSOCKET_CONNECTIONS.dec(abs(delta))
-
-
-def record_database_query(operation: str, table: str, duration: float):
-    """Record a database query with duration."""
-    DATABASE_QUERIES.labels(operation=operation, table=table).observe(duration)
-
-
-def record_rabbitmq_message(queue: str, status: str):
-    """Record a RabbitMQ message event."""
-    RABBITMQ_MESSAGES.labels(queue=queue, status=status).inc()
-
-
-def record_authentication_attempt(method: str, status: str):
-    """Record an authentication attempt."""
-    AUTHENTICATION_ATTEMPTS.labels(method=method, status=status).inc()
-
-
-def record_api_key_usage(provider: str, block_type: str, status: str):
-    """Record API key usage by provider and block."""
-    API_KEY_USAGE.labels(provider=provider, block_type=block_type, status=status).inc()
-
-
-def record_rate_limit_hit(endpoint: str, user_id: str):
-    """Record a rate limit hit.
-
-    Args:
-        endpoint: API endpoint that was rate limited
-        user_id: User identifier (kept for future sampling/debugging)
-    """
-    RATE_LIMIT_HITS.labels(endpoint=endpoint).inc()
-
-
-def record_graph_operation(operation: str, status: str):
-    """Record a graph operation (create, update, delete, execute, etc.)."""
-    GRAPH_OPERATIONS.labels(operation=operation, status=status).inc()
-
-
-def record_user_operation(operation: str, status: str):
-    """Record a user operation (login, register, etc.)."""
-    USER_OPERATIONS.labels(operation=operation, status=status).inc()

autogpt_platform/backend/backend/sdk/registry.py

@@ -6,10 +6,10 @@ import logging
 import threading
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type
 
-from pydantic import BaseModel
+from pydantic import BaseModel, SecretStr
 
 from backend.blocks.basic import Block
-from backend.data.model import Credentials
+from backend.data.model import APIKeyCredentials, Credentials
 from backend.integrations.oauth.base import BaseOAuthHandler
 from backend.integrations.providers import ProviderName
 from backend.integrations.webhooks._base import BaseWebhooksManager
@@ -17,8 +17,6 @@ from backend.integrations.webhooks._base import BaseWebhooksManager
 if TYPE_CHECKING:
     from backend.sdk.provider import Provider
 
-logger = logging.getLogger(__name__)
-
 
 class SDKOAuthCredentials(BaseModel):
     """OAuth credentials configuration for SDK providers."""
@@ -104,8 +102,21 @@ class AutoRegistry:
         """Register an environment variable as an API key for a provider."""
         with cls._lock:
             cls._api_key_mappings[provider] = env_var_name
-            # Note: The credential itself is created by ProviderBuilder.with_api_key()
-            # We only store the mapping here to avoid duplication
+
+            # Dynamically check if the env var exists and create credential
+            import os
+
+            api_key = os.getenv(env_var_name)
+            if api_key:
+                credential = APIKeyCredentials(
+                    id=f"{provider}-default",
+                    provider=provider,
+                    api_key=SecretStr(api_key),
+                    title=f"Default {provider} credentials",
+                )
+                # Check if credential already exists to avoid duplicates
+                if not any(c.id == credential.id for c in cls._default_credentials):
+                    cls._default_credentials.append(credential)
 
     @classmethod
     def get_all_credentials(cls) -> List[Credentials]:
@@ -199,43 +210,3 @@ class AutoRegistry:
                 webhooks.load_webhook_managers = patched_load
         except Exception as e:
             logging.warning(f"Failed to patch webhook managers: {e}")
-
-        # Patch credentials store to include SDK-registered credentials
-        try:
-            import sys
-            from typing import Any
-
-            # Get the module from sys.modules to respect mocking
-            if "backend.integrations.credentials_store" in sys.modules:
-                creds_store: Any = sys.modules["backend.integrations.credentials_store"]
-            else:
-                import backend.integrations.credentials_store
-
-                creds_store: Any = backend.integrations.credentials_store
-
-            if hasattr(creds_store, "IntegrationCredentialsStore"):
-                store_class = creds_store.IntegrationCredentialsStore
-                if hasattr(store_class, "get_all_creds"):
-                    original_get_all_creds = store_class.get_all_creds
-
-                    async def patched_get_all_creds(self, user_id: str):
-                        # Get original credentials
-                        original_creds = await original_get_all_creds(self, user_id)
-
-                        # Add SDK-registered credentials
-                        sdk_creds = cls.get_all_credentials()
-
-                        # Combine credentials, avoiding duplicates by ID
-                        existing_ids = {c.id for c in original_creds}
-                        for cred in sdk_creds:
-                            if cred.id not in existing_ids:
-                                original_creds.append(cred)
-
-                        return original_creds
-
-                    store_class.get_all_creds = patched_get_all_creds
-                    logger.info(
-                        "Successfully patched IntegrationCredentialsStore.get_all_creds"
-                    )
-        except Exception as e:
-            logging.warning(f"Failed to patch credentials store: {e}")

autogpt_platform/backend/backend/server/external/api.py

@@ -1,6 +1,5 @@
 from fastapi import FastAPI
 
-from backend.monitoring.instrumentation import instrument_fastapi
 from backend.server.middleware.security import SecurityHeadersMiddleware
 
 from .routes.v1 import v1_router
@@ -14,12 +13,3 @@ external_app = FastAPI(
 
 external_app.add_middleware(SecurityHeadersMiddleware)
 external_app.include_router(v1_router, prefix="/v1")
-
-# Add Prometheus instrumentation
-instrument_fastapi(
-    external_app,
-    service_name="external-api",
-    expose_endpoint=True,
-    endpoint="/metrics",
-    include_in_schema=True,
-)

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

@@ -49,7 +49,7 @@ class GraphExecutionResult(TypedDict):
     tags=["blocks"],
     dependencies=[Security(require_permission(APIKeyPermission.READ_BLOCK))],
 )
-async def get_graph_blocks() -> Sequence[dict[Any, Any]]:
+def get_graph_blocks() -> Sequence[dict[Any, Any]]:
     blocks = [block() for block in backend.data.block.get_blocks().values()]
     return [b.to_dict() for b in blocks if not b.disabled]
 

autogpt_platform/backend/backend/server/middleware/security.py

@@ -81,10 +81,6 @@ class SecurityHeadersMiddleware(BaseHTTPMiddleware):
         response.headers["X-XSS-Protection"] = "1; mode=block"
         response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"
 
-        # Add noindex header for shared execution pages
-        if "/public/shared" in request.url.path:
-            response.headers["X-Robots-Tag"] = "noindex, nofollow"
-
         # Default: Disable caching for all endpoints
         # Only allow caching for explicitly permitted paths
         if not self.is_cacheable_path(request.url.path):

autogpt_platform/backend/backend/server/rest_api.py

@@ -18,7 +18,6 @@ import backend.data.block
 import backend.data.db
 import backend.data.graph
 import backend.data.user
-import backend.integrations.webhooks.utils
 import backend.server.routers.postmark.postmark
 import backend.server.routers.v1
 import backend.server.v2.admin.credit_admin_routes
@@ -37,7 +36,6 @@ import backend.util.settings
 from backend.blocks.llm import LlmModel
 from backend.data.model import Credentials
 from backend.integrations.providers import ProviderName
-from backend.monitoring.instrumentation import instrument_fastapi
 from backend.server.external.api import external_app
 from backend.server.middleware.security import SecurityHeadersMiddleware
 from backend.util import json
@@ -80,8 +78,6 @@ async def lifespan_context(app: fastapi.FastAPI):
     await backend.data.user.migrate_and_encrypt_user_integrations()
     await backend.data.graph.fix_llm_provider_credentials()
     await backend.data.graph.migrate_llm_models(LlmModel.GPT4O)
-    await backend.integrations.webhooks.utils.migrate_legacy_triggered_graphs()
-
     with launch_darkly_context():
         yield
 
@@ -143,16 +139,6 @@ app.add_middleware(SecurityHeadersMiddleware)
 # Add 401 responses to authenticated endpoints in OpenAPI spec
 add_auth_responses_to_openapi(app)
 
-# Add Prometheus instrumentation
-instrument_fastapi(
-    app,
-    service_name="rest-api",
-    expose_endpoint=True,
-    endpoint="/metrics",
-    include_in_schema=settings.config.app_env
-    == backend.util.settings.AppEnvironment.LOCAL,
-)
-
 
 def handle_internal_http_error(status_code: int = 500, log_error: bool = True):
     def handler(request: fastapi.Request, exc: Exception):
@@ -266,13 +252,19 @@ async def health():
 
 class AgentServer(backend.util.service.AppProcess):
     def run(self):
-        server_app = starlette.middleware.cors.CORSMiddleware(
-            app=app,
-            allow_origins=settings.config.backend_cors_allow_origins,
-            allow_credentials=True,
-            allow_methods=["*"],  # Allows all methods
-            allow_headers=["*"],  # Allows all headers
-        )
+
+        if settings.config.enable_cors_all_origins:
+            server_app = starlette.middleware.cors.CORSMiddleware(
+                app=app,
+                allow_origins=settings.config.backend_cors_allow_origins,
+                allow_credentials=True,
+                allow_methods=["*"],  # Allows all methods
+                allow_headers=["*"],  # Allows all headers
+            )
+        else:
+            logger.info("CORS is disabled")
+            server_app = app
+
         uvicorn.run(
             server_app,
             host=backend.util.settings.Config().agent_api_host,

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

@@ -1,17 +1,14 @@
 import asyncio
 import base64
 import logging
-import time
-import uuid
 from collections import defaultdict
-from datetime import datetime, timezone
+from datetime import datetime
 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.utils.cache import cached
 from fastapi import (
     APIRouter,
     Body,
@@ -39,10 +36,10 @@ from backend.data.credit import (
     RefundRequest,
     TransactionHistory,
     get_auto_top_up,
+    get_block_costs,
     get_user_credit_model,
     set_auto_top_up,
 )
-from backend.data.execution import UserContext
 from backend.data.model import CredentialsMetaInput
 from backend.data.notifications import NotificationPreference, NotificationPreferenceDTO
 from backend.data.onboarding import (
@@ -66,11 +63,6 @@ from backend.integrations.webhooks.graph_lifecycle_hooks import (
     on_graph_activate,
     on_graph_deactivate,
 )
-from backend.monitoring.instrumentation import (
-    record_block_execution,
-    record_graph_execution,
-    record_graph_operation,
-)
 from backend.server.model import (
     CreateAPIKeyRequest,
     CreateAPIKeyResponse,
@@ -87,6 +79,7 @@ from backend.util.cloud_storage import get_cloud_storage_handler
 from backend.util.exceptions import GraphValidationError, NotFoundError
 from backend.util.settings import Settings
 from backend.util.timezone_utils import (
+    convert_cron_to_utc,
     convert_utc_time_to_user_timezone,
     get_user_timezone_or_utc,
 )
@@ -104,7 +97,6 @@ def _create_file_size_error(size_bytes: int, max_size_mb: int) -> HTTPException:
 settings = Settings()
 logger = logging.getLogger(__name__)
 
-
 _user_credit_model = get_user_credit_model()
 
 # Define the API routes
@@ -263,37 +255,18 @@ async def is_onboarding_enabled():
 ########################################################
 
 
-@cached()
-def _get_cached_blocks() -> Sequence[dict[Any, Any]]:
-    """
-    Get cached blocks with thundering herd protection.
-
-    Uses sync_cache decorator to prevent multiple concurrent requests
-    from all executing the expensive block loading operation.
-    """
-    from backend.data.credit import get_block_cost
-
-    block_classes = get_blocks()
-    result = []
-
-    for block_class in block_classes.values():
-        block_instance = block_class()
-        if not block_instance.disabled:
-            # Get costs for this specific block class without creating another instance
-            costs = get_block_cost(block_instance)
-            result.append({**block_instance.to_dict(), "costs": costs})
-
-    return result
-
-
 @v1_router.get(
     path="/blocks",
     summary="List available blocks",
     tags=["blocks"],
     dependencies=[Security(requires_user)],
 )
-async def get_graph_blocks() -> Sequence[dict[Any, Any]]:
-    return _get_cached_blocks()
+def get_graph_blocks() -> Sequence[dict[Any, Any]]:
+    blocks = [block() for block in get_blocks().values()]
+    costs = get_block_costs()
+    return [
+        {**b.to_dict(), "costs": costs.get(b.id, [])} for b in blocks if not b.disabled
+    ]
 
 
 @v1_router.post(
@@ -302,45 +275,15 @@ async def get_graph_blocks() -> Sequence[dict[Any, Any]]:
     tags=["blocks"],
     dependencies=[Security(requires_user)],
 )
-async def execute_graph_block(
-    block_id: str, data: BlockInput, user_id: Annotated[str, Security(get_user_id)]
-) -> CompletedBlockOutput:
+async def execute_graph_block(block_id: str, data: BlockInput) -> CompletedBlockOutput:
     obj = get_block(block_id)
     if not obj:
         raise HTTPException(status_code=404, detail=f"Block #{block_id} not found.")
 
-    # Get user context for block execution
-    user = await get_user_by_id(user_id)
-    if not user:
-        raise HTTPException(status_code=404, detail="User not found.")
-
-    user_context = UserContext(timezone=user.timezone)
-
-    start_time = time.time()
-    try:
-        output = defaultdict(list)
-        async for name, data in obj.execute(
-            data,
-            user_context=user_context,
-            user_id=user_id,
-            # Note: graph_exec_id and graph_id are not available for direct block execution
-        ):
-            output[name].append(data)
-
-        # Record successful block execution with duration
-        duration = time.time() - start_time
-        block_type = obj.__class__.__name__
-        record_block_execution(
-            block_type=block_type, status="success", duration=duration
-        )
-
-        return output
-    except Exception:
-        # Record failed block execution
-        duration = time.time() - start_time
-        block_type = obj.__class__.__name__
-        record_block_execution(block_type=block_type, status="error", duration=duration)
-        raise
+    output = defaultdict(list)
+    async for name, data in obj.execute(data):
+        output[name].append(data)
+    return output
 
 
 @v1_router.post(
@@ -633,13 +576,7 @@ class DeleteGraphResponse(TypedDict):
 async def list_graphs(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> Sequence[graph_db.GraphMeta]:
-    paginated_result = await graph_db.list_graphs_paginated(
-        user_id=user_id,
-        page=1,
-        page_size=250,
-        filter_by="active",
-    )
-    return paginated_result.graphs
+    return await graph_db.list_graphs(filter_by="active", user_id=user_id)
 
 
 @v1_router.get(
@@ -842,7 +779,7 @@ async def execute_graph(
         )
 
     try:
-        result = await execution_utils.add_graph_execution(
+        return await execution_utils.add_graph_execution(
             graph_id=graph_id,
             user_id=user_id,
             inputs=inputs,
@@ -850,16 +787,7 @@ async def execute_graph(
             graph_version=graph_version,
             graph_credentials_inputs=credentials_inputs,
         )
-        # Record successful graph execution
-        record_graph_execution(graph_id=graph_id, status="success", user_id=user_id)
-        record_graph_operation(operation="execute", status="success")
-        return result
     except GraphValidationError as e:
-        # Record failed graph execution
-        record_graph_execution(
-            graph_id=graph_id, status="validation_error", user_id=user_id
-        )
-        record_graph_operation(operation="execute", status="validation_error")
         # Return structured validation errors that the frontend can parse
         raise HTTPException(
             status_code=400,
@@ -870,11 +798,6 @@ async def execute_graph(
                 "node_errors": e.node_errors,
             },
         )
-    except Exception:
-        # Record any other failures
-        record_graph_execution(graph_id=graph_id, status="error", user_id=user_id)
-        record_graph_operation(operation="execute", status="error")
-        raise
 
 
 @v1_router.post(
@@ -928,12 +851,7 @@ async def _stop_graph_run(
 async def list_graphs_executions(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> list[execution_db.GraphExecutionMeta]:
-    paginated_result = await execution_db.get_graph_executions_paginated(
-        user_id=user_id,
-        page=1,
-        page_size=250,
-    )
-    return paginated_result.executions
+    return await execution_db.get_graph_executions(user_id=user_id)
 
 
 @v1_router.get(
@@ -1004,99 +922,6 @@ async def delete_graph_execution(
     )
 
 
-class ShareRequest(pydantic.BaseModel):
-    """Optional request body for share endpoint."""
-
-    pass  # Empty body is fine
-
-
-class ShareResponse(pydantic.BaseModel):
-    """Response from share endpoints."""
-
-    share_url: str
-    share_token: str
-
-
-@v1_router.post(
-    "/graphs/{graph_id}/executions/{graph_exec_id}/share",
-    dependencies=[Security(requires_user)],
-)
-async def enable_execution_sharing(
-    graph_id: Annotated[str, Path],
-    graph_exec_id: Annotated[str, Path],
-    user_id: Annotated[str, Security(get_user_id)],
-    _body: ShareRequest = Body(default=ShareRequest()),
-) -> ShareResponse:
-    """Enable sharing for a graph execution."""
-    # Verify the execution belongs to the user
-    execution = await execution_db.get_graph_execution(
-        user_id=user_id, execution_id=graph_exec_id
-    )
-    if not execution:
-        raise HTTPException(status_code=404, detail="Execution not found")
-
-    # Generate a unique share token
-    share_token = str(uuid.uuid4())
-
-    # Update the execution with share info
-    await execution_db.update_graph_execution_share_status(
-        execution_id=graph_exec_id,
-        user_id=user_id,
-        is_shared=True,
-        share_token=share_token,
-        shared_at=datetime.now(timezone.utc),
-    )
-
-    # Return the share URL
-    frontend_url = Settings().config.frontend_base_url or "http://localhost:3000"
-    share_url = f"{frontend_url}/share/{share_token}"
-
-    return ShareResponse(share_url=share_url, share_token=share_token)
-
-
-@v1_router.delete(
-    "/graphs/{graph_id}/executions/{graph_exec_id}/share",
-    status_code=HTTP_204_NO_CONTENT,
-    dependencies=[Security(requires_user)],
-)
-async def disable_execution_sharing(
-    graph_id: Annotated[str, Path],
-    graph_exec_id: Annotated[str, Path],
-    user_id: Annotated[str, Security(get_user_id)],
-) -> None:
-    """Disable sharing for a graph execution."""
-    # Verify the execution belongs to the user
-    execution = await execution_db.get_graph_execution(
-        user_id=user_id, execution_id=graph_exec_id
-    )
-    if not execution:
-        raise HTTPException(status_code=404, detail="Execution not found")
-
-    # Remove share info
-    await execution_db.update_graph_execution_share_status(
-        execution_id=graph_exec_id,
-        user_id=user_id,
-        is_shared=False,
-        share_token=None,
-        shared_at=None,
-    )
-
-
-@v1_router.get("/public/shared/{share_token}")
-async def get_shared_execution(
-    share_token: Annotated[
-        str,
-        Path(regex=r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"),
-    ],
-) -> execution_db.SharedExecutionResponse:
-    """Get a shared graph execution by share token (no auth required)."""
-    execution = await execution_db.get_graph_execution_by_share_token(share_token)
-    if not execution:
-        raise HTTPException(status_code=404, detail="Shared execution not found")
-
-    return execution
-
-
 ########################################################
 ##################### Schedules ########################
 ########################################################
@@ -1108,10 +933,6 @@ class ScheduleCreationRequest(pydantic.BaseModel):
     cron: str
     inputs: dict[str, Any]
     credentials: dict[str, CredentialsMetaInput] = pydantic.Field(default_factory=dict)
-    timezone: Optional[str] = pydantic.Field(
-        default=None,
-        description="User's timezone for scheduling (e.g., 'America/New_York'). If not provided, will use user's saved timezone or UTC.",
-    )
 
 
 @v1_router.post(
@@ -1136,22 +957,26 @@ async def create_graph_execution_schedule(
             detail=f"Graph #{graph_id} v{schedule_params.graph_version} not found.",
         )
 
-    # Use timezone from request if provided, otherwise fetch from user profile
-    if schedule_params.timezone:
-        user_timezone = schedule_params.timezone
-    else:
-        user = await get_user_by_id(user_id)
-        user_timezone = get_user_timezone_or_utc(user.timezone if user else None)
+    user = await get_user_by_id(user_id)
+    user_timezone = get_user_timezone_or_utc(user.timezone if user else None)
+
+    # Convert cron expression from user timezone to UTC
+    try:
+        utc_cron = convert_cron_to_utc(schedule_params.cron, user_timezone)
+    except ValueError as e:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid cron expression for timezone {user_timezone}: {e}",
+        )
 
     result = await get_scheduler_client().add_execution_schedule(
         user_id=user_id,
         graph_id=graph_id,
         graph_version=graph.version,
         name=schedule_params.name,
-        cron=schedule_params.cron,
+        cron=utc_cron,  # Send UTC cron to scheduler
         input_data=schedule_params.inputs,
         input_credentials=schedule_params.credentials,
-        user_timezone=user_timezone,
     )
 
     # Convert the next_run_time back to user timezone for display
@@ -1173,11 +998,24 @@ async def list_graph_execution_schedules(
     user_id: Annotated[str, Security(get_user_id)],
     graph_id: str = Path(),
 ) -> list[scheduler.GraphExecutionJobInfo]:
-    return await get_scheduler_client().get_execution_schedules(
+    schedules = await get_scheduler_client().get_execution_schedules(
         user_id=user_id,
         graph_id=graph_id,
     )
 
+    # Get user timezone for conversion
+    user = await get_user_by_id(user_id)
+    user_timezone = get_user_timezone_or_utc(user.timezone if user else None)
+
+    # Convert next_run_time to user timezone for display
+    for schedule in schedules:
+        if schedule.next_run_time:
+            schedule.next_run_time = convert_utc_time_to_user_timezone(
+                schedule.next_run_time, user_timezone
+            )
+
+    return schedules
+
 
 @v1_router.get(
     path="/schedules",
@@ -1188,7 +1026,20 @@ async def list_graph_execution_schedules(
 async def list_all_graphs_execution_schedules(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> list[scheduler.GraphExecutionJobInfo]:
-    return await get_scheduler_client().get_execution_schedules(user_id=user_id)
+    schedules = await get_scheduler_client().get_execution_schedules(user_id=user_id)
+
+    # Get user timezone for conversion
+    user = await get_user_by_id(user_id)
+    user_timezone = get_user_timezone_or_utc(user.timezone if user else None)
+
+    # Convert UTC next_run_time to user timezone for display
+    for schedule in schedules:
+        if schedule.next_run_time:
+            schedule.next_run_time = convert_utc_time_to_user_timezone(
+                schedule.next_run_time, user_timezone
+            )
+
+    return schedules
 
 
 @v1_router.delete(

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

@@ -1,5 +1,4 @@
 import json
-from datetime import datetime
 from io import BytesIO
 from unittest.mock import AsyncMock, Mock, patch
 
@@ -110,8 +109,8 @@ def test_get_graph_blocks(
 
     # Mock block costs
     mocker.patch(
-        "backend.data.credit.get_block_cost",
-        return_value=[{"cost": 10, "type": "credit"}],
+        "backend.server.routers.v1.get_block_costs",
+        return_value={"test-block": [{"cost": 10, "type": "credit"}]},
     )
 
     response = client.get("/blocks")
@@ -147,15 +146,6 @@ def test_execute_graph_block(
         return_value=mock_block,
     )
 
-    # Mock user for user_context
-    mock_user = Mock()
-    mock_user.timezone = "UTC"
-
-    mocker.patch(
-        "backend.server.routers.v1.get_user_by_id",
-        return_value=mock_user,
-    )
-
     request_data = {
         "input_name": "test_input",
         "input_value": "test_value",
@@ -275,12 +265,11 @@ def test_get_graphs(
         name="Test Graph",
         description="A test graph",
         user_id=test_user_id,
-        created_at=datetime(2025, 9, 4, 13, 37),
     )
 
     mocker.patch(
-        "backend.data.graph.list_graphs_paginated",
-        return_value=Mock(graphs=[mock_graph]),
+        "backend.server.routers.v1.graph_db.list_graphs",
+        return_value=[mock_graph],
     )
 
     response = client.get("/graphs")
@@ -310,7 +299,6 @@ def test_get_graph(
         name="Test Graph",
         description="A test graph",
         user_id=test_user_id,
-        created_at=datetime(2025, 9, 4, 13, 37),
     )
 
     mocker.patch(
@@ -360,7 +348,6 @@ def test_delete_graph(
         name="Test Graph",
         description="A test graph",
         user_id=test_user_id,
-        created_at=datetime(2025, 9, 4, 13, 37),
     )
 
     mocker.patch(

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

@@ -1,8 +1,8 @@
+import functools
 import logging
 from datetime import datetime, timedelta, timezone
 
 import prisma
-from autogpt_libs.utils.cache import cached
 
 import backend.data.block
 from backend.blocks import load_all_blocks
@@ -296,7 +296,7 @@ def _matches_llm_model(schema_cls: type[BlockSchema], query: str) -> bool:
     return False
 
 
-@cached()
+@functools.cache
 def _get_all_providers() -> dict[ProviderName, Provider]:
     providers: dict[ProviderName, Provider] = {}
 

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

@@ -144,92 +144,6 @@ async def list_library_agents(
         raise store_exceptions.DatabaseError("Failed to fetch library agents") from e
 
 
-async def list_favorite_library_agents(
-    user_id: str,
-    page: int = 1,
-    page_size: int = 50,
-) -> library_model.LibraryAgentResponse:
-    """
-    Retrieves a paginated list of favorite LibraryAgent records for a given user.
-
-    Args:
-        user_id: The ID of the user whose favorite LibraryAgents we want to retrieve.
-        page: Current page (1-indexed).
-        page_size: Number of items per page.
-
-    Returns:
-        A LibraryAgentResponse containing the list of favorite agents and pagination details.
-
-    Raises:
-        DatabaseError: If there is an issue fetching from Prisma.
-    """
-    logger.debug(
-        f"Fetching favorite library agents for user_id={user_id}, "
-        f"page={page}, page_size={page_size}"
-    )
-
-    if page < 1 or page_size < 1:
-        logger.warning(f"Invalid pagination: page={page}, page_size={page_size}")
-        raise store_exceptions.DatabaseError("Invalid pagination input")
-
-    where_clause: prisma.types.LibraryAgentWhereInput = {
-        "userId": user_id,
-        "isDeleted": False,
-        "isArchived": False,
-        "isFavorite": True,  # Only fetch favorites
-    }
-
-    # Sort favorites by updated date descending
-    order_by: prisma.types.LibraryAgentOrderByInput = {"updatedAt": "desc"}
-
-    try:
-        library_agents = await prisma.models.LibraryAgent.prisma().find_many(
-            where=where_clause,
-            include=library_agent_include(user_id),
-            order=order_by,
-            skip=(page - 1) * page_size,
-            take=page_size,
-        )
-        agent_count = await prisma.models.LibraryAgent.prisma().count(
-            where=where_clause
-        )
-
-        logger.debug(
-            f"Retrieved {len(library_agents)} favorite library agents for user #{user_id}"
-        )
-
-        # Only pass valid agents to the response
-        valid_library_agents: list[library_model.LibraryAgent] = []
-
-        for agent in library_agents:
-            try:
-                library_agent = library_model.LibraryAgent.from_db(agent)
-                valid_library_agents.append(library_agent)
-            except Exception as e:
-                # Skip this agent if there was an error
-                logger.error(
-                    f"Error parsing LibraryAgent #{agent.id} from DB item: {e}"
-                )
-                continue
-
-        # Return the response with only valid agents
-        return library_model.LibraryAgentResponse(
-            agents=valid_library_agents,
-            pagination=Pagination(
-                total_items=agent_count,
-                total_pages=(agent_count + page_size - 1) // page_size,
-                current_page=page,
-                page_size=page_size,
-            ),
-        )
-
-    except prisma.errors.PrismaError as e:
-        logger.error(f"Database error fetching favorite library agents: {e}")
-        raise store_exceptions.DatabaseError(
-            "Failed to fetch favorite library agents"
-        ) from e
-
-
 async def get_library_agent(id: str, user_id: str) -> library_model.LibraryAgent:
     """
     Get a specific agent from the user's library.
@@ -795,7 +709,10 @@ async def create_preset(
                         )
                         for name, data in {
                             **preset.inputs,
-                            **preset.credentials,
+                            **{
+                                key: creds_meta.model_dump(exclude_none=True)
+                                for key, creds_meta in preset.credentials.items()
+                            },
                         }.items()
                     ]
                 },

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

@@ -43,7 +43,6 @@ class LibraryAgent(pydantic.BaseModel):
 
     name: str
     description: str
-    instructions: str | None = None
 
     input_schema: dict[str, Any]  # Should be BlockIOObjectSubSchema in frontend
     output_schema: dict[str, Any]
@@ -65,9 +64,6 @@ class LibraryAgent(pydantic.BaseModel):
     # Indicates if this agent is the latest version
     is_latest_version: bool
 
-    # Whether the agent is marked as favorite by the user
-    is_favorite: bool
-
     # Recommended schedule cron (from marketplace agents)
     recommended_schedule_cron: str | None = None
 
@@ -127,7 +123,6 @@ class LibraryAgent(pydantic.BaseModel):
             updated_at=updated_at,
             name=graph.name,
             description=graph.description,
-            instructions=graph.instructions,
             input_schema=graph.input_schema,
             output_schema=graph.output_schema,
             credentials_input_schema=(
@@ -138,7 +133,6 @@ class LibraryAgent(pydantic.BaseModel):
             new_output=new_output,
             can_access_graph=can_access_graph,
             is_latest_version=is_latest_version,
-            is_favorite=agent.isFavorite,
             recommended_schedule_cron=agent.AgentGraph.recommendedScheduleCron,
         )
 
@@ -263,7 +257,6 @@ class LibraryAgentPreset(LibraryAgentPresetCreatable):
 
     id: str
     user_id: str
-    created_at: datetime.datetime
     updated_at: datetime.datetime
 
     webhook: "Webhook | None"
@@ -293,7 +286,6 @@ class LibraryAgentPreset(LibraryAgentPresetCreatable):
         return cls(
             id=preset.id,
             user_id=preset.userId,
-            created_at=preset.createdAt,
             updated_at=preset.updatedAt,
             graph_id=preset.agentGraphId,
             graph_version=preset.agentGraphVersion,

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

@@ -79,54 +79,6 @@ async def list_library_agents(
         ) from e
 
 
-@router.get(
-    "/favorites",
-    summary="List Favorite Library Agents",
-    responses={
-        500: {"description": "Server error", "content": {"application/json": {}}},
-    },
-)
-async def list_favorite_library_agents(
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
-    page: int = Query(
-        1,
-        ge=1,
-        description="Page number to retrieve (must be >= 1)",
-    ),
-    page_size: int = Query(
-        15,
-        ge=1,
-        description="Number of agents per page (must be >= 1)",
-    ),
-) -> library_model.LibraryAgentResponse:
-    """
-    Get all favorite agents in the user's library.
-
-    Args:
-        user_id: ID of the authenticated user.
-        page: Page number to retrieve.
-        page_size: Number of agents per page.
-
-    Returns:
-        A LibraryAgentResponse containing favorite agents and pagination metadata.
-
-    Raises:
-        HTTPException: If a server/database error occurs.
-    """
-    try:
-        return await library_db.list_favorite_library_agents(
-            user_id=user_id,
-            page=page,
-            page_size=page_size,
-        )
-    except Exception as e:
-        logger.error(f"Could not list favorite library agents for user #{user_id}: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e),
-        ) from e
-
-
 @router.get("/{library_agent_id}", summary="Get Library Agent")
 async def get_library_agent(
     library_agent_id: str,

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

@@ -54,7 +54,6 @@ async def test_get_library_agents_success(
                 new_output=False,
                 can_access_graph=True,
                 is_latest_version=True,
-                is_favorite=False,
                 updated_at=datetime.datetime(2023, 1, 1, 0, 0, 0),
             ),
             library_model.LibraryAgent(
@@ -75,7 +74,6 @@ async def test_get_library_agents_success(
                 new_output=False,
                 can_access_graph=False,
                 is_latest_version=True,
-                is_favorite=False,
                 updated_at=datetime.datetime(2023, 1, 1, 0, 0, 0),
             ),
         ],
@@ -123,76 +121,6 @@ def test_get_library_agents_error(mocker: pytest_mock.MockFixture, test_user_id:
     )
 
 
-@pytest.mark.asyncio
-async def test_get_favorite_library_agents_success(
-    mocker: pytest_mock.MockFixture,
-    test_user_id: str,
-) -> None:
-    mocked_value = library_model.LibraryAgentResponse(
-        agents=[
-            library_model.LibraryAgent(
-                id="test-agent-1",
-                graph_id="test-agent-1",
-                graph_version=1,
-                name="Favorite Agent 1",
-                description="Test Favorite Description 1",
-                image_url=None,
-                creator_name="Test Creator",
-                creator_image_url="",
-                input_schema={"type": "object", "properties": {}},
-                output_schema={"type": "object", "properties": {}},
-                credentials_input_schema={"type": "object", "properties": {}},
-                has_external_trigger=False,
-                status=library_model.LibraryAgentStatus.COMPLETED,
-                recommended_schedule_cron=None,
-                new_output=False,
-                can_access_graph=True,
-                is_latest_version=True,
-                is_favorite=True,
-                updated_at=datetime.datetime(2023, 1, 1, 0, 0, 0),
-            ),
-        ],
-        pagination=Pagination(
-            total_items=1, total_pages=1, current_page=1, page_size=15
-        ),
-    )
-    mock_db_call = mocker.patch(
-        "backend.server.v2.library.db.list_favorite_library_agents"
-    )
-    mock_db_call.return_value = mocked_value
-
-    response = client.get("/agents/favorites")
-    assert response.status_code == 200
-
-    data = library_model.LibraryAgentResponse.model_validate(response.json())
-    assert len(data.agents) == 1
-    assert data.agents[0].is_favorite is True
-    assert data.agents[0].name == "Favorite Agent 1"
-
-    mock_db_call.assert_called_once_with(
-        user_id=test_user_id,
-        page=1,
-        page_size=15,
-    )
-
-
-def test_get_favorite_library_agents_error(
-    mocker: pytest_mock.MockFixture, test_user_id: str
-):
-    mock_db_call = mocker.patch(
-        "backend.server.v2.library.db.list_favorite_library_agents"
-    )
-    mock_db_call.side_effect = Exception("Test error")
-
-    response = client.get("/agents/favorites")
-    assert response.status_code == 500
-    mock_db_call.assert_called_once_with(
-        user_id=test_user_id,
-        page=1,
-        page_size=15,
-    )
-
-
 def test_add_agent_to_library_success(
     mocker: pytest_mock.MockFixture, test_user_id: str
 ):
@@ -213,7 +141,6 @@ def test_add_agent_to_library_success(
         new_output=False,
         can_access_graph=True,
         is_latest_version=True,
-        is_favorite=False,
         updated_at=FIXED_NOW,
     )
 

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

@@ -183,29 +183,6 @@ async def get_store_agent_details(
             store_listing.hasApprovedVersion if store_listing else False
         )
 
-        if active_version_id:
-            agent_by_active = await prisma.models.StoreAgent.prisma().find_first(
-                where={"storeListingVersionId": active_version_id}
-            )
-            if agent_by_active:
-                agent = agent_by_active
-        elif store_listing:
-            latest_approved = (
-                await prisma.models.StoreListingVersion.prisma().find_first(
-                    where={
-                        "storeListingId": store_listing.id,
-                        "submissionStatus": prisma.enums.SubmissionStatus.APPROVED,
-                    },
-                    order=[{"version": "desc"}],
-                )
-            )
-            if latest_approved:
-                agent_latest = await prisma.models.StoreAgent.prisma().find_first(
-                    where={"storeListingVersionId": latest_approved.id}
-                )
-                if agent_latest:
-                    agent = agent_latest
-
         if store_listing and store_listing.ActiveVersion:
             recommended_schedule_cron = (
                 store_listing.ActiveVersion.recommendedScheduleCron
@@ -499,7 +476,6 @@ async def get_store_submissions(
                 sub_heading=sub.sub_heading,
                 slug=sub.slug,
                 description=sub.description,
-                instructions=getattr(sub, "instructions", None),
                 image_urls=sub.image_urls or [],
                 date_submitted=sub.date_submitted or datetime.now(tz=timezone.utc),
                 status=sub.status,
@@ -591,7 +567,6 @@ async def create_store_submission(
     video_url: str | None = None,
     image_urls: list[str] = [],
     description: str = "",
-    instructions: str | None = None,
     sub_heading: str = "",
     categories: list[str] = [],
     changes_summary: str | None = "Initial Submission",
@@ -663,7 +638,6 @@ async def create_store_submission(
                 video_url=video_url,
                 image_urls=image_urls,
                 description=description,
-                instructions=instructions,
                 sub_heading=sub_heading,
                 categories=categories,
                 changes_summary=changes_summary,
@@ -685,7 +659,6 @@ async def create_store_submission(
                         videoUrl=video_url,
                         imageUrls=image_urls,
                         description=description,
-                        instructions=instructions,
                         categories=categories,
                         subHeading=sub_heading,
                         submissionStatus=prisma.enums.SubmissionStatus.PENDING,
@@ -716,7 +689,6 @@ async def create_store_submission(
             slug=slug,
             sub_heading=sub_heading,
             description=description,
-            instructions=instructions,
             image_urls=image_urls,
             date_submitted=listing.createdAt,
             status=prisma.enums.SubmissionStatus.PENDING,
@@ -749,7 +721,6 @@ async def edit_store_submission(
     categories: list[str] = [],
     changes_summary: str | None = "Update submission",
     recommended_schedule_cron: str | None = None,
-    instructions: str | None = None,
 ) -> backend.server.v2.store.model.StoreSubmission:
     """
     Edit an existing store listing submission.
@@ -830,7 +801,6 @@ async def edit_store_submission(
                 categories=categories,
                 changes_summary=changes_summary,
                 recommended_schedule_cron=recommended_schedule_cron,
-                instructions=instructions,
             )
 
         # For PENDING submissions, we can update the existing version
@@ -847,7 +817,6 @@ async def edit_store_submission(
                     subHeading=sub_heading,
                     changesSummary=changes_summary,
                     recommendedScheduleCron=recommended_schedule_cron,
-                    instructions=instructions,
                 ),
             )
 
@@ -866,7 +835,6 @@ async def edit_store_submission(
                 sub_heading=sub_heading,
                 slug=current_version.StoreListing.slug,
                 description=description,
-                instructions=instructions,
                 image_urls=image_urls,
                 date_submitted=updated_version.submittedAt or updated_version.createdAt,
                 status=updated_version.submissionStatus,
@@ -908,7 +876,6 @@ async def create_store_version(
     video_url: str | None = None,
     image_urls: list[str] = [],
     description: str = "",
-    instructions: str | None = None,
     sub_heading: str = "",
     categories: list[str] = [],
     changes_summary: str | None = "Initial submission",
@@ -977,7 +944,6 @@ async def create_store_version(
                 videoUrl=video_url,
                 imageUrls=image_urls,
                 description=description,
-                instructions=instructions,
                 categories=categories,
                 subHeading=sub_heading,
                 submissionStatus=prisma.enums.SubmissionStatus.PENDING,
@@ -999,7 +965,6 @@ async def create_store_version(
             slug=listing.slug,
             sub_heading=sub_heading,
             description=description,
-            instructions=instructions,
             image_urls=image_urls,
             date_submitted=datetime.now(),
             status=prisma.enums.SubmissionStatus.PENDING,
@@ -1176,20 +1141,7 @@ async def get_my_agents(
     try:
         search_filter: prisma.types.LibraryAgentWhereInput = {
             "userId": user_id,
-            "AgentGraph": {
-                "is": {
-                    "StoreListings": {
-                        "none": {
-                            "isDeleted": False,
-                            "Versions": {
-                                "some": {
-                                    "isAvailable": True,
-                                }
-                            },
-                        }
-                    }
-                }
-            },
+            "AgentGraph": {"is": {"StoreListings": {"none": {"isDeleted": False}}}},
             "isArchived": False,
             "isDeleted": False,
         }
@@ -1427,7 +1379,6 @@ async def review_store_submission(
                         "name": store_listing_version.name,
                         "description": store_listing_version.description,
                         "recommendedScheduleCron": store_listing_version.recommendedScheduleCron,
-                        "instructions": store_listing_version.instructions,
                     },
                 )
 
@@ -1593,7 +1544,6 @@ async def review_store_submission(
                 else ""
             ),
             description=submission.description,
-            instructions=submission.instructions,
             image_urls=submission.imageUrls or [],
             date_submitted=submission.submittedAt or submission.createdAt,
             status=submission.submissionStatus,
@@ -1729,7 +1679,6 @@ async def get_admin_listings_with_versions(
                     sub_heading=version.subHeading,
                     slug=listing.slug,
                     description=version.description,
-                    instructions=version.instructions,
                     image_urls=version.imageUrls or [],
                     date_submitted=version.submittedAt or version.createdAt,
                     status=version.submissionStatus,

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

@@ -86,27 +86,6 @@ async def test_get_store_agent_details(mocker):
         is_available=False,
     )
 
-    # Mock active version agent (what we want to return for active version)
-    mock_active_agent = prisma.models.StoreAgent(
-        listing_id="test-id",
-        storeListingVersionId="active-version-id",
-        slug="test-agent",
-        agent_name="Test Agent Active",
-        agent_video="active_video.mp4",
-        agent_image=["active_image.jpg"],
-        featured=False,
-        creator_username="creator",
-        creator_avatar="avatar.jpg",
-        sub_heading="Test heading active",
-        description="Test description active",
-        categories=["test"],
-        runs=15,
-        rating=4.8,
-        versions=["1.0", "2.0"],
-        updated_at=datetime.now(),
-        is_available=True,
-    )
-
     # Create a mock StoreListing result
     mock_store_listing = mocker.MagicMock()
     mock_store_listing.activeVersionId = "active-version-id"
@@ -114,22 +93,9 @@ async def test_get_store_agent_details(mocker):
     mock_store_listing.ActiveVersion = mocker.MagicMock()
     mock_store_listing.ActiveVersion.recommendedScheduleCron = None
 
-    # Mock StoreAgent prisma call - need to handle multiple calls
+    # Mock StoreAgent prisma call
     mock_store_agent = mocker.patch("prisma.models.StoreAgent.prisma")
-
-    # Set up side_effect to return different results for different calls
-    def mock_find_first_side_effect(*args, **kwargs):
-        where_clause = kwargs.get("where", {})
-        if "storeListingVersionId" in where_clause:
-            # Second call for active version
-            return mock_active_agent
-        else:
-            # First call for initial lookup
-            return mock_agent
-
-    mock_store_agent.return_value.find_first = mocker.AsyncMock(
-        side_effect=mock_find_first_side_effect
-    )
+    mock_store_agent.return_value.find_first = mocker.AsyncMock(return_value=mock_agent)
 
     # Mock Profile prisma call
     mock_profile = mocker.MagicMock()
@@ -139,7 +105,7 @@ async def test_get_store_agent_details(mocker):
         return_value=mock_profile
     )
 
-    # Mock StoreListing prisma call
+    # Mock StoreListing prisma call - this is what was missing
     mock_store_listing_db = mocker.patch("prisma.models.StoreListing.prisma")
     mock_store_listing_db.return_value.find_first = mocker.AsyncMock(
         return_value=mock_store_listing
@@ -148,25 +114,16 @@ async def test_get_store_agent_details(mocker):
     # Call function
     result = await db.get_store_agent_details("creator", "test-agent")
 
-    # Verify results - should use active version data
+    # Verify results
     assert result.slug == "test-agent"
-    assert result.agent_name == "Test Agent Active"  # From active version
+    assert result.agent_name == "Test Agent"
     assert result.active_version_id == "active-version-id"
     assert result.has_approved_version is True
-    assert (
-        result.store_listing_version_id == "active-version-id"
-    )  # Should be active version ID
 
-    # Verify mocks called correctly - now expecting 2 calls
-    assert mock_store_agent.return_value.find_first.call_count == 2
-
-    # Check the specific calls
-    calls = mock_store_agent.return_value.find_first.call_args_list
-    assert calls[0] == mocker.call(
+    # Verify mocks called correctly
+    mock_store_agent.return_value.find_first.assert_called_once_with(
         where={"creator_username": "creator", "slug": "test-agent"}
     )
-    assert calls[1] == mocker.call(where={"storeListingVersionId": "active-version-id"})
-
     mock_store_listing_db.return_value.find_first.assert_called_once()
 
 

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

@@ -49,7 +49,6 @@ class StoreAgentDetails(pydantic.BaseModel):
     creator_avatar: str
     sub_heading: str
     description: str
-    instructions: str | None = None
     categories: list[str]
     runs: int
     rating: float
@@ -104,7 +103,6 @@ class StoreSubmission(pydantic.BaseModel):
     sub_heading: str
     slug: str
     description: str
-    instructions: str | None = None
     image_urls: list[str]
     date_submitted: datetime.datetime
     status: prisma.enums.SubmissionStatus
@@ -159,7 +157,6 @@ class StoreSubmissionRequest(pydantic.BaseModel):
     video_url: str | None = None
     image_urls: list[str] = []
     description: str = ""
-    instructions: str | None = None
     categories: list[str] = []
     changes_summary: str | None = None
     recommended_schedule_cron: str | None = None
@@ -171,7 +168,6 @@ class StoreSubmissionEditRequest(pydantic.BaseModel):
     video_url: str | None = None
     image_urls: list[str] = []
     description: str = ""
-    instructions: str | None = None
     categories: list[str] = []
     changes_summary: str | None = None
     recommended_schedule_cron: str | None = None

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

@@ -6,7 +6,6 @@ import urllib.parse
 import autogpt_libs.auth
 import fastapi
 import fastapi.responses
-from autogpt_libs.utils.cache import cached
 
 import backend.data.graph
 import backend.server.v2.store.db
@@ -21,117 +20,6 @@ logger = logging.getLogger(__name__)
 router = fastapi.APIRouter()
 
 
-##############################################
-############### Caches #######################
-##############################################
-
-
-# Cache user profiles for 1 hour per user
-@cached(maxsize=1000, ttl_seconds=3600)
-async def _get_cached_user_profile(user_id: str):
-    """Cached helper to get user profile."""
-    return await backend.server.v2.store.db.get_user_profile(user_id)
-
-
-# Cache store agents list for 15 minutes
-# Different cache entries for different query combinations
-@cached(maxsize=5000, ttl_seconds=900)
-async def _get_cached_store_agents(
-    featured: bool,
-    creator: str | None,
-    sorted_by: str | None,
-    search_query: str | None,
-    category: str | None,
-    page: int,
-    page_size: int,
-):
-    """Cached helper to get store agents."""
-    return await backend.server.v2.store.db.get_store_agents(
-        featured=featured,
-        creators=[creator] if creator else None,
-        sorted_by=sorted_by,
-        search_query=search_query,
-        category=category,
-        page=page,
-        page_size=page_size,
-    )
-
-
-# Cache individual agent details for 15 minutes
-@cached(maxsize=200, ttl_seconds=900)
-async def _get_cached_agent_details(username: str, agent_name: str):
-    """Cached helper to get agent details."""
-    return await backend.server.v2.store.db.get_store_agent_details(
-        username=username, agent_name=agent_name
-    )
-
-
-# Cache agent graphs for 1 hour
-@cached(maxsize=200, ttl_seconds=3600)
-async def _get_cached_agent_graph(store_listing_version_id: str):
-    """Cached helper to get agent graph."""
-    return await backend.server.v2.store.db.get_available_graph(
-        store_listing_version_id
-    )
-
-
-# Cache agent by version for 1 hour
-@cached(maxsize=200, ttl_seconds=3600)
-async def _get_cached_store_agent_by_version(store_listing_version_id: str):
-    """Cached helper to get store agent by version ID."""
-    return await backend.server.v2.store.db.get_store_agent_by_version_id(
-        store_listing_version_id
-    )
-
-
-# Cache creators list for 1 hour
-@cached(maxsize=200, ttl_seconds=3600)
-async def _get_cached_store_creators(
-    featured: bool,
-    search_query: str | None,
-    sorted_by: str | None,
-    page: int,
-    page_size: int,
-):
-    """Cached helper to get store creators."""
-    return await backend.server.v2.store.db.get_store_creators(
-        featured=featured,
-        search_query=search_query,
-        sorted_by=sorted_by,
-        page=page,
-        page_size=page_size,
-    )
-
-
-# Cache individual creator details for 1 hour
-@cached(maxsize=100, ttl_seconds=3600)
-async def _get_cached_creator_details(username: str):
-    """Cached helper to get creator details."""
-    return await backend.server.v2.store.db.get_store_creator_details(
-        username=username.lower()
-    )
-
-
-# Cache user's own agents for 5 mins (shorter TTL as this changes more frequently)
-@cached(maxsize=500, ttl_seconds=300)
-async def _get_cached_my_agents(user_id: str, page: int, page_size: int):
-    """Cached helper to get user's agents."""
-    return await backend.server.v2.store.db.get_my_agents(
-        user_id, page=page, page_size=page_size
-    )
-
-
-# Cache user's submissions for 1 hour (shorter TTL as this changes frequently)
-@cached(maxsize=500, ttl_seconds=3600)
-async def _get_cached_submissions(user_id: str, page: int, page_size: int):
-    """Cached helper to get user's submissions."""
-    return await backend.server.v2.store.db.get_store_submissions(
-        user_id=user_id,
-        page=page,
-        page_size=page_size,
-    )
-
-
 ##############################################
 ############### Profile Endpoints ############
 ##############################################
@@ -149,10 +37,9 @@ async def get_profile(
 ):
     """
     Get the profile details for the authenticated user.
-    Cached for 1 hour per user.
     """
     try:
-        profile = await _get_cached_user_profile(user_id)
+        profile = await backend.server.v2.store.db.get_user_profile(user_id)
         if profile is None:
             return fastapi.responses.JSONResponse(
                 status_code=404,
@@ -198,8 +85,6 @@ async def update_or_create_profile(
         updated_profile = await backend.server.v2.store.db.update_profile(
             user_id=user_id, profile=profile
         )
-        # Clear the cache for this user after profile update
-        _get_cached_user_profile.cache_delete(user_id)
         return updated_profile
     except Exception as e:
         logger.exception("Failed to update profile for user %s: %s", user_id, e)
@@ -234,7 +119,6 @@ async def get_agents(
 ):
     """
     Get a paginated list of agents from the store with optional filtering and sorting.
-    Results are cached for 15 minutes.
 
     Args:
         featured (bool, optional): Filter to only show featured agents. Defaults to False.
@@ -270,9 +154,9 @@ async def get_agents(
         )
 
     try:
-        agents = await _get_cached_store_agents(
+        agents = await backend.server.v2.store.db.get_store_agents(
             featured=featured,
-            creator=creator,
+            creators=[creator] if creator else None,
             sorted_by=sorted_by,
             search_query=search_query,
             category=category,
@@ -299,8 +183,7 @@ async def get_agents(
 )
 async def get_agent(username: str, agent_name: str):
     """
-    This is only used on the AgentDetails Page.
-    Results are cached for 15 minutes.
+    This is only used on the AgentDetails Page
 
     It returns the store listing agents details.
     """
@@ -308,7 +191,7 @@ async def get_agent(username: str, agent_name: str):
         username = urllib.parse.unquote(username).lower()
         # URL decode the agent name since it comes from the URL path
         agent_name = urllib.parse.unquote(agent_name).lower()
-        agent = await _get_cached_agent_details(
+        agent = await backend.server.v2.store.db.get_store_agent_details(
             username=username, agent_name=agent_name
         )
         return agent
@@ -331,10 +214,11 @@ async def get_agent(username: str, agent_name: str):
 async def get_graph_meta_by_store_listing_version_id(store_listing_version_id: str):
     """
     Get Agent Graph from Store Listing Version ID.
-    Results are cached for 1 hour.
     """
     try:
-        graph = await _get_cached_agent_graph(store_listing_version_id)
+        graph = await backend.server.v2.store.db.get_available_graph(
+            store_listing_version_id
+        )
         return graph
     except Exception:
         logger.exception("Exception occurred whilst getting agent graph")
@@ -354,10 +238,11 @@ async def get_graph_meta_by_store_listing_version_id(store_listing_version_id: s
 async def get_store_agent(store_listing_version_id: str):
     """
     Get Store Agent Details from Store Listing Version ID.
-    Results are cached for 1 hour.
     """
     try:
-        agent = await _get_cached_store_agent_by_version(store_listing_version_id)
+        agent = await backend.server.v2.store.db.get_store_agent_by_version_id(
+            store_listing_version_id
+        )
         return agent
     except Exception:
         logger.exception("Exception occurred whilst getting store agent")
@@ -394,7 +279,7 @@ async def create_review(
     """
     try:
         username = urllib.parse.unquote(username).lower()
-        agent_name = urllib.parse.unquote(agent_name).lower()
+        agent_name = urllib.parse.unquote(agent_name)
         # Create the review
         created_review = await backend.server.v2.store.db.create_store_review(
             user_id=user_id,
@@ -435,8 +320,6 @@ async def get_creators(
     - Home Page Featured Creators
     - Search Results Page
 
-    Results are cached for 1 hour.
-
     ---
 
     To support this functionality we need:
@@ -455,7 +338,7 @@ async def get_creators(
         )
 
     try:
-        creators = await _get_cached_store_creators(
+        creators = await backend.server.v2.store.db.get_store_creators(
             featured=featured,
             search_query=search_query,
             sorted_by=sorted_by,
@@ -481,13 +364,14 @@ async def get_creator(
     username: str,
 ):
     """
-    Get the details of a creator.
-    Results are cached for 1 hour.
+    Get the details of a creator
     - Creator Details Page
     """
     try:
         username = urllib.parse.unquote(username).lower()
-        creator = await _get_cached_creator_details(username=username)
+        creator = await backend.server.v2.store.db.get_store_creator_details(
+            username=username.lower()
+        )
         return creator
     except Exception:
         logger.exception("Exception occurred whilst getting creator details")
@@ -502,8 +386,6 @@ async def get_creator(
 ############################################
 ############# Store Submissions ###############
 ############################################
-
-
 @router.get(
     "/myagents",
     summary="Get my agents",
@@ -516,12 +398,10 @@ async def get_my_agents(
     page: typing.Annotated[int, fastapi.Query(ge=1)] = 1,
     page_size: typing.Annotated[int, fastapi.Query(ge=1)] = 20,
 ):
-    """
-    Get user's own agents.
-    Results are cached for 5 minutes per user.
-    """
     try:
-        agents = await _get_cached_my_agents(user_id, page=page, page_size=page_size)
+        agents = await backend.server.v2.store.db.get_my_agents(
+            user_id, page=page, page_size=page_size
+        )
         return agents
     except Exception:
         logger.exception("Exception occurred whilst getting my agents")
@@ -557,14 +437,6 @@ async def delete_submission(
             user_id=user_id,
             submission_id=submission_id,
         )
-
-        # Clear submissions cache for this specific user after deletion
-        if result:
-            # Clear user's own agents cache - we don't know all page/size combinations
-            for page in range(1, 20):
-                # Clear user's submissions cache for common defaults
-                _get_cached_submissions.cache_delete(user_id, page=page, page_size=20)
-
         return result
     except Exception:
         logger.exception("Exception occurred whilst deleting store submission")
@@ -588,7 +460,6 @@ async def get_submissions(
 ):
     """
     Get a paginated list of store submissions for the authenticated user.
-    Results are cached for 1 hour per user.
 
     Args:
         user_id (str): ID of the authenticated user
@@ -611,8 +482,10 @@ async def get_submissions(
             status_code=422, detail="Page size must be greater than 0"
         )
     try:
-        listings = await _get_cached_submissions(
-            user_id, page=page, page_size=page_size
+        listings = await backend.server.v2.store.db.get_store_submissions(
+            user_id=user_id,
+            page=page,
+            page_size=page_size,
         )
         return listings
     except Exception:
@@ -650,7 +523,7 @@ async def create_submission(
         HTTPException: If there is an error creating the submission
     """
     try:
-        result = await backend.server.v2.store.db.create_store_submission(
+        return await backend.server.v2.store.db.create_store_submission(
             user_id=user_id,
             agent_id=submission_request.agent_id,
             agent_version=submission_request.agent_version,
@@ -659,19 +532,11 @@ async def create_submission(
             video_url=submission_request.video_url,
             image_urls=submission_request.image_urls,
             description=submission_request.description,
-            instructions=submission_request.instructions,
             sub_heading=submission_request.sub_heading,
             categories=submission_request.categories,
             changes_summary=submission_request.changes_summary or "Initial Submission",
             recommended_schedule_cron=submission_request.recommended_schedule_cron,
         )
-
-        # Clear user's own agents cache - we don't know all page/size combinations
-        for page in range(1, 20):
-            # Clear user's submissions cache for common defaults
-            _get_cached_submissions.cache_delete(user_id, page=page, page_size=20)
-
-        return result
     except Exception:
         logger.exception("Exception occurred whilst creating store submission")
         return fastapi.responses.JSONResponse(
@@ -706,27 +571,19 @@ async def edit_submission(
     Raises:
         HTTPException: If there is an error editing the submission
     """
-    result = await backend.server.v2.store.db.edit_store_submission(
+    return await backend.server.v2.store.db.edit_store_submission(
         user_id=user_id,
         store_listing_version_id=store_listing_version_id,
         name=submission_request.name,
         video_url=submission_request.video_url,
         image_urls=submission_request.image_urls,
         description=submission_request.description,
-        instructions=submission_request.instructions,
         sub_heading=submission_request.sub_heading,
         categories=submission_request.categories,
         changes_summary=submission_request.changes_summary,
         recommended_schedule_cron=submission_request.recommended_schedule_cron,
     )
 
-    # Clear user's own agents cache - we don't know all page/size combinations
-    for page in range(1, 20):
-        # Clear user's submissions cache for common defaults
-        _get_cached_submissions.cache_delete(user_id, page=page, page_size=20)
-
-    return result
-
 
 @router.post(
     "/submissions/media",
@@ -878,63 +735,3 @@ async def download_agent_file(
         return fastapi.responses.FileResponse(
             tmp_file.name, filename=file_name, media_type="application/json"
         )
-
-
-##############################################
-############### Cache Management #############
-##############################################
-
-
-@router.get(
-    "/metrics/cache",
-    summary="Get cache metrics in Prometheus format",
-    tags=["store", "metrics"],
-    response_class=fastapi.responses.PlainTextResponse,
-)
-async def get_cache_metrics():
-    """
-    Get cache metrics in Prometheus text format.
-
-    Returns Prometheus-compatible metrics for monitoring cache performance.
-    Metrics include size, maxsize, TTL, and hit rate for each cache.
-
-    Returns:
-        str: Prometheus-formatted metrics text
-    """
-    metrics = []
-
-    # Helper to add metrics for a cache
-    def add_cache_metrics(cache_name: str, cache_func):
-        info = cache_func.cache_info()
-        # Cache size metric (dynamic - changes as items are cached/expired)
-        metrics.append(f'store_cache_entries{{cache="{cache_name}"}} {info["size"]}')
-        # Cache utilization percentage (dynamic - useful for monitoring)
-        utilization = (
-            (info["size"] / info["maxsize"] * 100) if info["maxsize"] > 0 else 0
-        )
-        metrics.append(
-            f'store_cache_utilization_percent{{cache="{cache_name}"}} {utilization:.2f}'
-        )
-
-    # Add metrics for each cache
-    add_cache_metrics("user_profile", _get_cached_user_profile)
-    add_cache_metrics("store_agents", _get_cached_store_agents)
-    add_cache_metrics("agent_details", _get_cached_agent_details)
-    add_cache_metrics("agent_graph", _get_cached_agent_graph)
-    add_cache_metrics("agent_by_version", _get_cached_store_agent_by_version)
-    add_cache_metrics("store_creators", _get_cached_store_creators)
-    add_cache_metrics("creator_details", _get_cached_creator_details)
-    add_cache_metrics("my_agents", _get_cached_my_agents)
-    add_cache_metrics("submissions", _get_cached_submissions)
-
-    # Add metadata/help text at the beginning
-    prometheus_output = [
-        "# HELP store_cache_entries Number of entries currently in cache",
-        "# TYPE store_cache_entries gauge",
-        "# HELP store_cache_utilization_percent Cache utilization as percentage (0-100)",
-        "# TYPE store_cache_utilization_percent gauge",
-        "",  # Empty line before metrics
-    ]
-    prometheus_output.extend(metrics)
-
-    return "\n".join(prometheus_output)

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

@@ -1,351 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test suite for verifying cache_delete functionality in store routes.
-Tests that specific cache entries can be deleted while preserving others.
-"""
-
-import datetime
-from unittest.mock import AsyncMock, patch
-
-import pytest
-
-from backend.server.v2.store import routes
-from backend.server.v2.store.model import (
-    ProfileDetails,
-    StoreAgent,
-    StoreAgentDetails,
-    StoreAgentsResponse,
-)
-from backend.util.models import Pagination
-
-
-class TestCacheDeletion:
-    """Test cache deletion functionality for store routes."""
-
-    @pytest.mark.asyncio
-    async def test_store_agents_cache_delete(self):
-        """Test that specific agent list cache entries can be deleted."""
-        # Mock the database function
-        mock_response = StoreAgentsResponse(
-            agents=[
-                StoreAgent(
-                    slug="test-agent",
-                    agent_name="Test Agent",
-                    agent_image="https://example.com/image.jpg",
-                    creator="testuser",
-                    creator_avatar="https://example.com/avatar.jpg",
-                    sub_heading="Test subheading",
-                    description="Test description",
-                    runs=100,
-                    rating=4.5,
-                )
-            ],
-            pagination=Pagination(
-                total_items=1,
-                total_pages=1,
-                current_page=1,
-                page_size=20,
-            ),
-        )
-
-        with patch(
-            "backend.server.v2.store.db.get_store_agents",
-            new_callable=AsyncMock,
-            return_value=mock_response,
-        ) as mock_db:
-            # Clear cache first
-            routes._get_cached_store_agents.cache_clear()
-
-            # First call - should hit database
-            result1 = await routes._get_cached_store_agents(
-                featured=False,
-                creator=None,
-                sorted_by=None,
-                search_query="test",
-                category=None,
-                page=1,
-                page_size=20,
-            )
-            assert mock_db.call_count == 1
-            assert result1.agents[0].agent_name == "Test Agent"
-
-            # Second call with same params - should use cache
-            await routes._get_cached_store_agents(
-                featured=False,
-                creator=None,
-                sorted_by=None,
-                search_query="test",
-                category=None,
-                page=1,
-                page_size=20,
-            )
-            assert mock_db.call_count == 1  # No additional DB call
-
-            # Third call with different params - should hit database
-            await routes._get_cached_store_agents(
-                featured=True,  # Different param
-                creator=None,
-                sorted_by=None,
-                search_query="test",
-                category=None,
-                page=1,
-                page_size=20,
-            )
-            assert mock_db.call_count == 2  # New DB call
-
-            # Delete specific cache entry
-            deleted = routes._get_cached_store_agents.cache_delete(
-                featured=False,
-                creator=None,
-                sorted_by=None,
-                search_query="test",
-                category=None,
-                page=1,
-                page_size=20,
-            )
-            assert deleted is True  # Entry was deleted
-
-            # Try to delete non-existent entry
-            deleted = routes._get_cached_store_agents.cache_delete(
-                featured=False,
-                creator="nonexistent",
-                sorted_by=None,
-                search_query="test",
-                category=None,
-                page=1,
-                page_size=20,
-            )
-            assert deleted is False  # Entry didn't exist
-
-            # Call with deleted params - should hit database again
-            await routes._get_cached_store_agents(
-                featured=False,
-                creator=None,
-                sorted_by=None,
-                search_query="test",
-                category=None,
-                page=1,
-                page_size=20,
-            )
-            assert mock_db.call_count == 3  # New DB call after deletion
-
-            # Call with featured=True - should still be cached
-            await routes._get_cached_store_agents(
-                featured=True,
-                creator=None,
-                sorted_by=None,
-                search_query="test",
-                category=None,
-                page=1,
-                page_size=20,
-            )
-            assert mock_db.call_count == 3  # No additional DB call
-
-    @pytest.mark.asyncio
-    async def test_agent_details_cache_delete(self):
-        """Test that specific agent details cache entries can be deleted."""
-        mock_response = StoreAgentDetails(
-            store_listing_version_id="version1",
-            slug="test-agent",
-            agent_name="Test Agent",
-            agent_video="https://example.com/video.mp4",
-            agent_image=["https://example.com/image.jpg"],
-            creator="testuser",
-            creator_avatar="https://example.com/avatar.jpg",
-            sub_heading="Test subheading",
-            description="Test description",
-            categories=["productivity"],
-            runs=100,
-            rating=4.5,
-            versions=[],
-            last_updated=datetime.datetime(2024, 1, 1),
-        )
-
-        with patch(
-            "backend.server.v2.store.db.get_store_agent_details",
-            new_callable=AsyncMock,
-            return_value=mock_response,
-        ) as mock_db:
-            # Clear cache first
-            routes._get_cached_agent_details.cache_clear()
-
-            # First call - should hit database
-            await routes._get_cached_agent_details(
-                username="testuser", agent_name="testagent"
-            )
-            assert mock_db.call_count == 1
-
-            # Second call - should use cache
-            await routes._get_cached_agent_details(
-                username="testuser", agent_name="testagent"
-            )
-            assert mock_db.call_count == 1  # No additional DB call
-
-            # Delete specific entry
-            deleted = routes._get_cached_agent_details.cache_delete(
-                username="testuser", agent_name="testagent"
-            )
-            assert deleted is True
-
-            # Call again - should hit database
-            await routes._get_cached_agent_details(
-                username="testuser", agent_name="testagent"
-            )
-            assert mock_db.call_count == 2  # New DB call after deletion
-
-    @pytest.mark.asyncio
-    async def test_user_profile_cache_delete(self):
-        """Test that user profile cache entries can be deleted."""
-        mock_response = ProfileDetails(
-            name="Test User",
-            username="testuser",
-            description="Test profile",
-            links=["https://example.com"],
-        )
-
-        with patch(
-            "backend.server.v2.store.db.get_user_profile",
-            new_callable=AsyncMock,
-            return_value=mock_response,
-        ) as mock_db:
-            # Clear cache first
-            routes._get_cached_user_profile.cache_clear()
-
-            # First call - should hit database
-            await routes._get_cached_user_profile("user123")
-            assert mock_db.call_count == 1
-
-            # Second call - should use cache
-            await routes._get_cached_user_profile("user123")
-            assert mock_db.call_count == 1
-
-            # Different user - should hit database
-            await routes._get_cached_user_profile("user456")
-            assert mock_db.call_count == 2
-
-            # Delete specific user's cache
-            deleted = routes._get_cached_user_profile.cache_delete("user123")
-            assert deleted is True
-
-            # user123 should hit database again
-            await routes._get_cached_user_profile("user123")
-            assert mock_db.call_count == 3
-
-            # user456 should still be cached
-            await routes._get_cached_user_profile("user456")
-            assert mock_db.call_count == 3  # No additional DB call
-
-    @pytest.mark.asyncio
-    async def test_cache_info_after_deletions(self):
-        """Test that cache_info correctly reflects deletions."""
-        # Clear all caches first
-        routes._get_cached_store_agents.cache_clear()
-
-        mock_response = StoreAgentsResponse(
-            agents=[],
-            pagination=Pagination(
-                total_items=0,
-                total_pages=1,
-                current_page=1,
-                page_size=20,
-            ),
-        )
-
-        with patch(
-            "backend.server.v2.store.db.get_store_agents",
-            new_callable=AsyncMock,
-            return_value=mock_response,
-        ):
-            # Add multiple entries
-            for i in range(5):
-                await routes._get_cached_store_agents(
-                    featured=False,
-                    creator=f"creator{i}",
-                    sorted_by=None,
-                    search_query=None,
-                    category=None,
-                    page=1,
-                    page_size=20,
-                )
-
-            # Check cache size
-            info = routes._get_cached_store_agents.cache_info()
-            assert info["size"] == 5
-
-            # Delete some entries
-            for i in range(2):
-                deleted = routes._get_cached_store_agents.cache_delete(
-                    featured=False,
-                    creator=f"creator{i}",
-                    sorted_by=None,
-                    search_query=None,
-                    category=None,
-                    page=1,
-                    page_size=20,
-                )
-                assert deleted is True
-
-            # Check cache size after deletion
-            info = routes._get_cached_store_agents.cache_info()
-            assert info["size"] == 3
-
-    @pytest.mark.asyncio
-    async def test_cache_delete_with_complex_params(self):
-        """Test cache deletion with various parameter combinations."""
-        mock_response = StoreAgentsResponse(
-            agents=[],
-            pagination=Pagination(
-                total_items=0,
-                total_pages=1,
-                current_page=1,
-                page_size=20,
-            ),
-        )
-
-        with patch(
-            "backend.server.v2.store.db.get_store_agents",
-            new_callable=AsyncMock,
-            return_value=mock_response,
-        ) as mock_db:
-            routes._get_cached_store_agents.cache_clear()
-
-            # Test with all parameters
-            await routes._get_cached_store_agents(
-                featured=True,
-                creator="testuser",
-                sorted_by="rating",
-                search_query="AI assistant",
-                category="productivity",
-                page=2,
-                page_size=50,
-            )
-            assert mock_db.call_count == 1
-
-            # Delete with exact same parameters
-            deleted = routes._get_cached_store_agents.cache_delete(
-                featured=True,
-                creator="testuser",
-                sorted_by="rating",
-                search_query="AI assistant",
-                category="productivity",
-                page=2,
-                page_size=50,
-            )
-            assert deleted is True
-
-            # Try to delete with slightly different parameters
-            deleted = routes._get_cached_store_agents.cache_delete(
-                featured=True,
-                creator="testuser",
-                sorted_by="rating",
-                search_query="AI assistant",
-                category="productivity",
-                page=2,
-                page_size=51,  # Different page_size
-            )
-            assert deleted is False  # Different parameters, not in cache
-
-
-if __name__ == "__main__":
-    # Run the tests
-    pytest.main([__file__, "-v"])

autogpt_platform/backend/backend/server/ws_api.py

@@ -11,10 +11,6 @@ from starlette.middleware.cors import CORSMiddleware
 
 from backend.data.execution import AsyncRedisExecutionEventBus
 from backend.data.user import DEFAULT_USER_ID
-from backend.monitoring.instrumentation import (
-    instrument_fastapi,
-    update_websocket_connections,
-)
 from backend.server.conn_manager import ConnectionManager
 from backend.server.model import (
     WSMessage,
@@ -42,15 +38,6 @@ docs_url = "/docs" if settings.config.app_env == AppEnvironment.LOCAL else None
 app = FastAPI(lifespan=lifespan, docs_url=docs_url)
 _connection_manager = None
 
-# Add Prometheus instrumentation
-instrument_fastapi(
-    app,
-    service_name="websocket-server",
-    expose_endpoint=True,
-    endpoint="/metrics",
-    include_in_schema=settings.config.app_env == AppEnvironment.LOCAL,
-)
-
 
 def get_connection_manager():
     global _connection_manager
@@ -229,10 +216,6 @@ async def websocket_router(
     if not user_id:
         return
     await manager.connect_socket(websocket)
-
-    # Track WebSocket connection
-    update_websocket_connections(user_id, 1)
-
     try:
         while True:
             data = await websocket.receive_text()
@@ -303,8 +286,6 @@ async def websocket_router(
     except WebSocketDisconnect:
         manager.disconnect_socket(websocket)
         logger.debug("WebSocket client disconnected")
-    finally:
-        update_websocket_connections(user_id, -1)
 
 
 @app.get("/")
@@ -314,14 +295,17 @@ async def health():
 
 class WebsocketServer(AppProcess):
     def run(self):
-        logger.info(f"CORS allow origins: {settings.config.backend_cors_allow_origins}")
-        server_app = CORSMiddleware(
-            app=app,
-            allow_origins=settings.config.backend_cors_allow_origins,
-            allow_credentials=True,
-            allow_methods=["*"],
-            allow_headers=["*"],
-        )
+        if settings.config.enable_cors_all_origins:
+            server_app = CORSMiddleware(
+                app=app,
+                allow_origins=settings.config.backend_cors_allow_origins,
+                allow_credentials=True,
+                allow_methods=["*"],
+                allow_headers=["*"],
+            )
+        else:
+            logger.info("CORS is disabled")
+            server_app = app
 
         uvicorn.run(
             server_app,

autogpt_platform/backend/backend/util/clients.py

@@ -2,9 +2,10 @@
 Centralized service client helpers with thread caching.
 """
 
+from functools import cache
 from typing import TYPE_CHECKING
 
-from autogpt_libs.utils.cache import cached, thread_cached
+from autogpt_libs.utils.cache import async_cache, thread_cached
 
 from backend.util.settings import Settings
 
@@ -118,7 +119,7 @@ def get_integration_credentials_store() -> "IntegrationCredentialsStore":
 # ============ Supabase Clients ============ #
 
 
-@cached()
+@cache
 def get_supabase() -> "Client":
     """Get a process-cached synchronous Supabase client instance."""
     from supabase import create_client
@@ -128,7 +129,7 @@ def get_supabase() -> "Client":
     )
 
 
-@cached()
+@async_cache
 async def get_async_supabase() -> "AClient":
     """Get a process-cached asynchronous Supabase client instance."""
     from supabase import create_async_client

autogpt_platform/backend/backend/util/cloud_storage.py

@@ -9,7 +9,6 @@ import uuid
 from datetime import datetime, timedelta, timezone
 from typing import Tuple
 
-import aiohttp
 from gcloud.aio import storage as async_gcs_storage
 from google.cloud import storage as gcs_storage
 
@@ -39,59 +38,20 @@ class CloudStorageHandler:
         self.config = config
         self._async_gcs_client = None
         self._sync_gcs_client = None  # Only for signed URLs
-        self._session = None
-
-    async def _get_async_gcs_client(self):
-        """Get or create async GCS client, ensuring it's created in proper async context."""
-        # Check if we already have a client
-        if self._async_gcs_client is not None:
-            return self._async_gcs_client
-
-        current_task = asyncio.current_task()
-        if not current_task:
-            # If we're not in a task, create a temporary client
-            logger.warning(
-                "[CloudStorage] Creating GCS client outside of task context - using temporary client"
-            )
-            timeout = aiohttp.ClientTimeout(total=300)
-            session = aiohttp.ClientSession(
-                timeout=timeout,
-                connector=aiohttp.TCPConnector(limit=100, force_close=False),
-            )
-            return async_gcs_storage.Storage(session=session)
-
-        # Create a reusable session with proper configuration
-        # Key fix: Don't set timeout on session, let gcloud-aio handle it
-        self._session = aiohttp.ClientSession(
-            connector=aiohttp.TCPConnector(
-                limit=100,  # Connection pool limit
-                force_close=False,  # Reuse connections
-                enable_cleanup_closed=True,
-            )
-        )
-
-        # Create the GCS client with our session
-        # The key is NOT setting timeout on the session but letting the library handle it
-        self._async_gcs_client = async_gcs_storage.Storage(session=self._session)
 
+    def _get_async_gcs_client(self):
+        """Lazy initialization of async GCS client."""
+        if self._async_gcs_client is None:
+            # Use Application Default Credentials (ADC)
+            self._async_gcs_client = async_gcs_storage.Storage()
         return self._async_gcs_client
 
     async def close(self):
         """Close all client connections properly."""
         if self._async_gcs_client is not None:
-            try:
-                await self._async_gcs_client.close()
-            except Exception as e:
-                logger.warning(f"[CloudStorage] Error closing GCS client: {e}")
+            await self._async_gcs_client.close()
             self._async_gcs_client = None
 
-        if self._session is not None:
-            try:
-                await self._session.close()
-            except Exception as e:
-                logger.warning(f"[CloudStorage] Error closing session: {e}")
-            self._session = None
-
     async def __aenter__(self):
         """Async context manager entry."""
         return self
@@ -181,7 +141,7 @@ class CloudStorageHandler:
         if user_id and graph_exec_id:
             raise ValueError("Provide either user_id OR graph_exec_id, not both")
 
-        async_client = await self._get_async_gcs_client()
+        async_client = self._get_async_gcs_client()
 
         # Generate unique path with appropriate scope
         unique_id = str(uuid.uuid4())
@@ -243,15 +203,6 @@ class CloudStorageHandler:
         self, path: str, user_id: str | None = None, graph_exec_id: str | None = None
     ) -> bytes:
         """Retrieve file from Google Cloud Storage with authorization."""
-        # Log context for debugging
-        current_task = asyncio.current_task()
-        logger.info(
-            f"[CloudStorage]"
-            f"_retrieve_file_gcs called - "
-            f"current_task: {current_task}, "
-            f"in_task: {current_task is not None}"
-        )
-
         # Parse bucket and blob name from path
         parts = path.split("/", 1)
         if len(parts) != 2:
@@ -262,65 +213,13 @@ class CloudStorageHandler:
         # Authorization check
         self._validate_file_access(blob_name, user_id, graph_exec_id)
 
-        # Use a fresh client for each download to avoid session issues
-        # This is less efficient but more reliable with the executor's event loop
-        logger.info("[CloudStorage] Creating fresh GCS client for download")
+        async_client = self._get_async_gcs_client()
 
-        # Create a new session specifically for this download
-        session = aiohttp.ClientSession(
-            connector=aiohttp.TCPConnector(limit=10, force_close=True)
-        )
-
-        async_client = None
         try:
-            # Create a new GCS client with the fresh session
-            async_client = async_gcs_storage.Storage(session=session)
-
-            logger.info(
-                f"[CloudStorage] About to download from GCS - bucket: {bucket_name}, blob: {blob_name}"
-            )
-
-            # Download content using the fresh client
+            # Download content using pure async client
             content = await async_client.download(bucket_name, blob_name)
-            logger.info(
-                f"[CloudStorage] GCS download successful - size: {len(content)} bytes"
-            )
-
-            # Clean up
-            await async_client.close()
-            await session.close()
-
             return content
-
         except Exception as e:
-            # Always try to clean up
-            if async_client is not None:
-                try:
-                    await async_client.close()
-                except Exception as cleanup_error:
-                    logger.warning(
-                        f"[CloudStorage] Error closing GCS client: {cleanup_error}"
-                    )
-            try:
-                await session.close()
-            except Exception as cleanup_error:
-                logger.warning(f"[CloudStorage] Error closing session: {cleanup_error}")
-
-            # Log the specific error for debugging
-            logger.error(
-                f"[CloudStorage] GCS download failed - error: {str(e)}, "
-                f"error_type: {type(e).__name__}, "
-                f"bucket: {bucket_name}, blob: redacted for privacy"
-            )
-
-            # Special handling for timeout error
-            if "Timeout context manager" in str(e):
-                logger.critical(
-                    f"[CloudStorage] TIMEOUT ERROR in GCS download! "
-                    f"current_task: {current_task}, "
-                    f"bucket: {bucket_name}, blob: redacted for privacy"
-                )
-
             # Convert gcloud-aio exceptions to standard ones
             if "404" in str(e) or "Not Found" in str(e):
                 raise FileNotFoundError(f"File not found: gcs://{path}")
@@ -404,7 +303,7 @@ class CloudStorageHandler:
 
         # Legacy uploads directory (uploads/*) - allow for backwards compatibility with warning
         # Note: We already validated it starts with "uploads/" above, so this is guaranteed to match
-        logger.warning(f"[CloudStorage] Accessing legacy upload path: {blob_name}")
+        logger.warning(f"Accessing legacy upload path: {blob_name}")
         return
 
     async def generate_signed_url(
@@ -492,7 +391,7 @@ class CloudStorageHandler:
         if not self.config.gcs_bucket_name:
             raise ValueError("GCS_BUCKET_NAME not configured")
 
-        async_client = await self._get_async_gcs_client()
+        async_client = self._get_async_gcs_client()
         current_time = datetime.now(timezone.utc)
 
         try:
@@ -532,7 +431,7 @@ class CloudStorageHandler:
                     except Exception as e:
                         # Log specific errors for debugging
                         logger.warning(
-                            f"[CloudStorage] Failed to process file {blob_name} during cleanup: {e}"
+                            f"Failed to process file {blob_name} during cleanup: {e}"
                         )
                         # Skip files with invalid metadata or delete errors
                         pass
@@ -548,7 +447,7 @@ class CloudStorageHandler:
 
         except Exception as e:
             # Log the error for debugging but continue operation
-            logger.error(f"[CloudStorage] Cleanup operation failed: {e}")
+            logger.error(f"Cleanup operation failed: {e}")
             # Return 0 - we'll try again next cleanup cycle
             return 0
 
@@ -577,7 +476,7 @@ class CloudStorageHandler:
 
         bucket_name, blob_name = parts
 
-        async_client = await self._get_async_gcs_client()
+        async_client = self._get_async_gcs_client()
 
         try:
             # Get object metadata using pure async client
@@ -591,15 +490,11 @@ class CloudStorageHandler:
         except Exception as e:
             # If file doesn't exist or we can't read metadata
             if "404" in str(e) or "Not Found" in str(e):
-                logger.warning(
-                    f"[CloudStorage] File not found during expiration check: {blob_name}"
-                )
+                logger.debug(f"File not found during expiration check: {blob_name}")
                 return True  # File doesn't exist, consider it expired
 
             # Log other types of errors for debugging
-            logger.warning(
-                f"[CloudStorage] Failed to check expiration for {blob_name}: {e}"
-            )
+            logger.warning(f"Failed to check expiration for {blob_name}: {e}")
             # If we can't read metadata for other reasons, assume not expired
             return False
 
@@ -649,15 +544,11 @@ async def cleanup_expired_files_async() -> int:
     # Use cleanup lock to prevent concurrent cleanup operations
     async with _cleanup_lock:
         try:
-            logger.info(
-                "[CloudStorage] Starting cleanup of expired cloud storage files"
-            )
+            logger.info("Starting cleanup of expired cloud storage files")
             handler = await get_cloud_storage_handler()
             deleted_count = await handler.delete_expired_files()
-            logger.info(
-                f"[CloudStorage] Cleaned up {deleted_count} expired files from cloud storage"
-            )
+            logger.info(f"Cleaned up {deleted_count} expired files from cloud storage")
             return deleted_count
         except Exception as e:
-            logger.error(f"[CloudStorage] Error during cloud storage cleanup: {e}")
+            logger.error(f"Error during cloud storage cleanup: {e}")
             return 0

autogpt_platform/backend/backend/util/cloud_storage_test.py

@@ -72,17 +72,16 @@ class TestCloudStorageHandler:
         assert call_args[0][2] == content  # file content
         assert "metadata" in call_args[1]  # metadata argument
 
-    @patch("backend.util.cloud_storage.async_gcs_storage.Storage")
+    @patch.object(CloudStorageHandler, "_get_async_gcs_client")
     @pytest.mark.asyncio
-    async def test_retrieve_file_gcs(self, mock_storage_class, handler):
+    async def test_retrieve_file_gcs(self, mock_get_async_client, handler):
         """Test retrieving file from GCS."""
-        # Mock async GCS client instance
+        # Mock async GCS client
         mock_async_client = AsyncMock()
-        mock_storage_class.return_value = mock_async_client
+        mock_get_async_client.return_value = mock_async_client
 
-        # Mock the download and close methods
+        # Mock the download method
         mock_async_client.download = AsyncMock(return_value=b"test content")
-        mock_async_client.close = AsyncMock()
 
         result = await handler.retrieve_file(
             "gcs://test-bucket/uploads/system/uuid123/file.txt"
@@ -93,17 +92,16 @@ class TestCloudStorageHandler:
             "test-bucket", "uploads/system/uuid123/file.txt"
         )
 
-    @patch("backend.util.cloud_storage.async_gcs_storage.Storage")
+    @patch.object(CloudStorageHandler, "_get_async_gcs_client")
     @pytest.mark.asyncio
-    async def test_retrieve_file_not_found(self, mock_storage_class, handler):
+    async def test_retrieve_file_not_found(self, mock_get_async_client, handler):
         """Test retrieving non-existent file from GCS."""
-        # Mock async GCS client instance
+        # Mock async GCS client
         mock_async_client = AsyncMock()
-        mock_storage_class.return_value = mock_async_client
+        mock_get_async_client.return_value = mock_async_client
 
         # Mock the download method to raise a 404 exception
         mock_async_client.download = AsyncMock(side_effect=Exception("404 Not Found"))
-        mock_async_client.close = AsyncMock()
 
         with pytest.raises(FileNotFoundError):
             await handler.retrieve_file(
@@ -289,15 +287,14 @@ class TestCloudStorageHandler:
         ):
             handler._validate_file_access("invalid/path/file.txt", "user123")
 
-    @patch("backend.util.cloud_storage.async_gcs_storage.Storage")
+    @patch.object(CloudStorageHandler, "_get_async_gcs_client")
     @pytest.mark.asyncio
-    async def test_retrieve_file_with_authorization(self, mock_storage_class, handler):
+    async def test_retrieve_file_with_authorization(self, mock_get_client, handler):
         """Test file retrieval with authorization."""
-        # Mock async GCS client instance
+        # Mock async GCS client
         mock_client = AsyncMock()
-        mock_storage_class.return_value = mock_client
+        mock_get_client.return_value = mock_client
         mock_client.download = AsyncMock(return_value=b"test content")
-        mock_client.close = AsyncMock()
 
         # Test successful retrieval of user's own file
         result = await handler.retrieve_file(
@@ -415,19 +412,18 @@ class TestCloudStorageHandler:
                 "uploads/executions/exec123/uuid456/file.txt", graph_exec_id="exec456"
             )
 
-    @patch("backend.util.cloud_storage.async_gcs_storage.Storage")
+    @patch.object(CloudStorageHandler, "_get_async_gcs_client")
     @pytest.mark.asyncio
     async def test_retrieve_file_with_exec_authorization(
-        self, mock_storage_class, handler
+        self, mock_get_async_client, handler
     ):
         """Test file retrieval with execution authorization."""
-        # Mock async GCS client instance
+        # Mock async GCS client
         mock_async_client = AsyncMock()
-        mock_storage_class.return_value = mock_async_client
+        mock_get_async_client.return_value = mock_async_client
 
-        # Mock the download and close methods
+        # Mock the download method
         mock_async_client.download = AsyncMock(return_value=b"test content")
-        mock_async_client.close = AsyncMock()
 
         # Test successful retrieval of execution's own file
         result = await handler.retrieve_file(

autogpt_platform/backend/backend/util/feature_flag.py

@@ -5,7 +5,7 @@ from functools import wraps
 from typing import Any, Awaitable, Callable, TypeVar
 
 import ldclient
-from autogpt_libs.utils.cache import cached
+from autogpt_libs.utils.cache import async_ttl_cache
 from fastapi import HTTPException
 from ldclient import Context, LDClient
 from ldclient.config import Config
@@ -72,7 +72,7 @@ def shutdown_launchdarkly() -> None:
         logger.info("LaunchDarkly client closed successfully")
 
 
-@cached(maxsize=1000, ttl_seconds=86400)  # 1000 entries, 24 hours TTL
+@async_ttl_cache(maxsize=1000, ttl_seconds=86400)  # 1000 entries, 24 hours TTL
 async def _fetch_user_context_data(user_id: str) -> Context:
     """
     Fetch user context for LaunchDarkly from Supabase.

autogpt_platform/backend/backend/util/json.py

@@ -8,14 +8,6 @@ from pydantic import BaseModel
 
 from .type import type_match
 
-# Try to import orjson for better performance
-try:
-    import orjson
-
-    HAS_ORJSON = True
-except ImportError:
-    HAS_ORJSON = False
-
 
 def to_dict(data) -> dict:
     if isinstance(data, BaseModel):
@@ -29,16 +21,16 @@ def dumps(data: Any, *args: Any, **kwargs: Any) -> str:
 
     This function converts the input data to a JSON-serializable format using FastAPI's
     jsonable_encoder before dumping to JSON. It handles Pydantic models, complex types,
-    and ensures proper serialization. Uses orjson for better performance when available.
+    and ensures proper serialization.
 
     Parameters
     ----------
     data : Any
         The data to serialize. Can be any type including Pydantic models, dicts, lists, etc.
     *args : Any
-        Additional positional arguments passed to json.dumps() (ignored if using orjson)
+        Additional positional arguments passed to json.dumps()
     **kwargs : Any
-        Additional keyword arguments passed to json.dumps() (limited support with orjson)
+        Additional keyword arguments passed to json.dumps() (e.g., indent, separators)
 
     Returns
     -------
@@ -53,18 +45,7 @@ def dumps(data: Any, *args: Any, **kwargs: Any) -> str:
     >>> dumps(pydantic_model_instance, indent=2)
     '{\n  "field1": "value1",\n  "field2": "value2"\n}'
     """
-    serializable_data = to_dict(data)
-
-    if HAS_ORJSON:
-        # orjson is faster but has limited options support
-        option = 0
-        if kwargs.get("indent") is not None:
-            option |= orjson.OPT_INDENT_2
-        # orjson.dumps returns bytes, so we decode to str
-        return orjson.dumps(serializable_data, option=option).decode("utf-8")
-    else:
-        # Fallback to standard json
-        return json.dumps(serializable_data, *args, **kwargs)
+    return json.dumps(to_dict(data), *args, **kwargs)
 
 
 T = TypeVar("T")
@@ -81,15 +62,9 @@ def loads(data: str | bytes, *args, **kwargs) -> Any: ...
 def loads(
     data: str | bytes, *args, target_type: Type[T] | None = None, **kwargs
 ) -> Any:
-    if HAS_ORJSON:
-        # orjson can handle both str and bytes directly
-        parsed = orjson.loads(data)
-    else:
-        # Standard json requires string input
-        if isinstance(data, bytes):
-            data = data.decode("utf-8")
-        parsed = json.loads(data, *args, **kwargs)
-
+    if isinstance(data, bytes):
+        data = data.decode("utf-8")
+    parsed = json.loads(data, *args, **kwargs)
     if target_type:
         return type_match(parsed, target_type)
     return parsed
@@ -123,35 +98,11 @@ def convert_pydantic_to_json(output_data: Any) -> Any:
     return output_data
 
 
-def _sanitize_null_bytes(data: Any) -> Any:
-    """
-    Recursively sanitize null bytes from data structures to prevent PostgreSQL 22P05 errors.
-    PostgreSQL cannot store null bytes (\u0000) in text fields.
-    """
-    if isinstance(data, str):
-        return data.replace("\u0000", "")
-    elif isinstance(data, dict):
-        return {key: _sanitize_null_bytes(value) for key, value in data.items()}
-    elif isinstance(data, list):
-        return [_sanitize_null_bytes(item) for item in data]
-    elif isinstance(data, tuple):
-        return tuple(_sanitize_null_bytes(item) for item in data)
-    else:
-        # For other types (int, float, bool, None, etc.), return as-is
-        return data
-
-
 def SafeJson(data: Any) -> Json:
-    """
-    Safely serialize data and return Prisma's Json type.
-    Sanitizes null bytes to prevent PostgreSQL 22P05 errors.
-    """
-    # Sanitize null bytes before serialization
-    sanitized_data = _sanitize_null_bytes(data)
-
-    if isinstance(sanitized_data, BaseModel):
+    """Safely serialize data and return Prisma's Json type."""
+    if isinstance(data, BaseModel):
         return Json(
-            sanitized_data.model_dump(
+            data.model_dump(
                 mode="json",
                 warnings="error",
                 exclude_none=True,
@@ -159,5 +110,5 @@ def SafeJson(data: Any) -> Json:
             )
         )
     # Round-trip through JSON to ensure proper serialization with fallback for non-serializable values
-    json_string = dumps(sanitized_data, default=lambda v: None)
+    json_string = dumps(data, default=lambda v: None)
     return Json(json.loads(json_string))

autogpt_platform/backend/backend/util/retry.py

@@ -17,37 +17,6 @@ from backend.util.process import get_service_name
 
 logger = logging.getLogger(__name__)
 
-# Alert threshold for excessive retries
-EXCESSIVE_RETRY_THRESHOLD = 50
-
-
-def _send_retry_alert(
-    func_name: str, attempt_number: int, exception: Exception, context: str = ""
-):
-    """Send alert for excessive retry attempts."""
-    try:
-        # Import here to avoid circular imports
-        from backend.util.clients import get_notification_manager_client
-
-        notification_client = get_notification_manager_client()
-
-        prefix = f"{context}: " if context else ""
-        alert_msg = (
-            f"🚨 Excessive Retry Alert: {prefix}'{func_name}' has failed {attempt_number} times!\n\n"
-            f"Error: {type(exception).__name__}: {exception}\n\n"
-            f"This indicates a persistent issue that requires investigation. "
-            f"The operation has been retrying for an extended period."
-        )
-
-        notification_client.discord_system_alert(alert_msg)
-        logger.critical(
-            f"ALERT SENT: Excessive retries detected for {func_name} after {attempt_number} attempts"
-        )
-
-    except Exception as alert_error:
-        logger.error(f"Failed to send retry alert: {alert_error}")
-        # Don't let alerting failures break the main flow
-
 
 def _create_retry_callback(context: str = ""):
     """Create a retry callback with optional context."""
@@ -59,10 +28,6 @@ def _create_retry_callback(context: str = ""):
 
         prefix = f"{context}: " if context else ""
 
-        # Send alert if we've exceeded the threshold
-        if attempt_number >= EXCESSIVE_RETRY_THRESHOLD:
-            _send_retry_alert(func_name, attempt_number, exception, context)
-
         if retry_state.outcome.failed and retry_state.next_action is None:
             # Final failure
             logger.error(
@@ -138,13 +103,6 @@ def conn_retry(
     def on_retry(retry_state):
         prefix = _log_prefix(resource_name, conn_id)
         exception = retry_state.outcome.exception()
-        attempt_number = retry_state.attempt_number
-
-        # Send alert if we've exceeded the threshold
-        if attempt_number >= EXCESSIVE_RETRY_THRESHOLD:
-            func_name = f"{resource_name}:{action_name}"
-            context = f"Connection retry {resource_name}"
-            _send_retry_alert(func_name, attempt_number, exception, context)
 
         if retry_state.outcome.failed and retry_state.next_action is None:
             logger.error(f"{prefix} {action_name} failed after retries: {exception}")

autogpt_platform/backend/backend/util/service.py

@@ -43,7 +43,6 @@ api_host = config.pyro_host
 api_comm_retry = config.pyro_client_comm_retry
 api_comm_timeout = config.pyro_client_comm_timeout
 api_call_timeout = config.rpc_client_call_timeout
-api_comm_max_wait = config.pyro_client_max_wait
 
 
 def _validate_no_prisma_objects(obj: Any, path: str = "result") -> None:
@@ -353,7 +352,7 @@ def get_service_client(
         # Use preconfigured retry decorator for service communication
         return create_retry_decorator(
             max_attempts=api_comm_retry,
-            max_wait=api_comm_max_wait,
+            max_wait=5.0,
             context="Service communication",
             exclude_exceptions=(
                 # Don't retry these specific exceptions that won't be fixed by retrying

autogpt_platform/backend/backend/util/settings.py

@@ -68,13 +68,9 @@ class Config(UpdateTrackingModel["Config"], BaseSettings):
         description="The default timeout in seconds, for Pyro client connections.",
     )
     pyro_client_comm_retry: int = Field(
-        default=100,
+        default=5,
         description="The default number of retries for Pyro client connections.",
     )
-    pyro_client_max_wait: float = Field(
-        default=30.0,
-        description="The maximum wait time in seconds for Pyro client retries.",
-    )
     rpc_client_call_timeout: int = Field(
         default=300,
         description="The default timeout in seconds, for RPC client calls.",
@@ -372,6 +368,11 @@ class Config(UpdateTrackingModel["Config"], BaseSettings):
         description="Maximum message size limit for communication with the message bus",
     )
 
+    enable_cors_all_origins: bool = Field(
+        default=True,
+        description="Whether to enable all CORS origins",
+    )
+
     backend_cors_allow_origins: List[str] = Field(default=["http://localhost:3000"])
 
     @field_validator("backend_cors_allow_origins")
@@ -483,9 +484,6 @@ class Secrets(UpdateTrackingModel["Secrets"], BaseSettings):
     )
 
     openai_api_key: str = Field(default="", description="OpenAI API key")
-    openai_internal_api_key: str = Field(
-        default="", description="OpenAI Internal API key"
-    )
     aiml_api_key: str = Field(default="", description="'AI/ML API' key")
     anthropic_api_key: str = Field(default="", description="Anthropic API key")
     groq_api_key: str = Field(default="", description="Groq API key")

autogpt_platform/backend/backend/util/text.py

@@ -16,8 +16,8 @@ def format_filter_for_jinja2(value, format_string=None):
 
 
 class TextFormatter:
-    def __init__(self, autoescape: bool = True):
-        self.env = SandboxedEnvironment(loader=BaseLoader(), autoescape=autoescape)
+    def __init__(self):
+        self.env = SandboxedEnvironment(loader=BaseLoader(), autoescape=True)
         self.env.globals.clear()
 
         # Instead of clearing all filters, just remove potentially unsafe ones

autogpt_platform/backend/load-tests/.gitignore

@@ -1,18 +0,0 @@
-# Load testing credentials and sensitive data
-configs/pre-authenticated-tokens.js
-configs/k6-credentials.env
-results/
-k6-cloud-results.txt
-
-# Node.js
-node_modules/
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Environment files
-.env
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local

autogpt_platform/backend/load-tests/README.md

@@ -1,283 +0,0 @@
-# AutoGPT Platform Load Tests
-
-Clean, streamlined load testing infrastructure for the AutoGPT Platform using k6.
-
-## 🚀 Quick Start
-
-```bash
-# 1. Set up Supabase service key (required for token generation)
-export SUPABASE_SERVICE_KEY="your-supabase-service-key"
-
-# 2. Generate pre-authenticated tokens (first time setup - creates 150+ tokens with 24-hour expiry)
-node generate-tokens.js
-
-# 3. Set up k6 cloud credentials (for cloud testing)
-export K6_CLOUD_TOKEN="your-k6-cloud-token"
-export K6_CLOUD_PROJECT_ID="4254406"
-
-# 4. Verify setup and run quick test
-node run-tests.js verify
-
-# 5. Run tests locally (development/debugging)
-node run-tests.js run all DEV
-
-# 6. Run tests in k6 cloud (performance testing)
-node run-tests.js cloud all DEV
-```
-
-## 📋 Unified Test Runner
-
-The AutoGPT Platform uses a single unified test runner (`run-tests.js`) for both local and cloud execution:
-
-### Available Tests
-
-#### Basic Tests (Simple validation)
-
-- **connectivity-test**: Basic connectivity and authentication validation
-- **single-endpoint-test**: Individual API endpoint testing with high concurrency
-
-#### API Tests (Core functionality)
-
-- **core-api-test**: Core API endpoints (`/api/credits`, `/api/graphs`, `/api/blocks`, `/api/executions`)
-- **graph-execution-test**: Complete graph creation and execution pipeline
-
-#### Marketplace Tests (User-facing features)
-
-- **marketplace-public-test**: Public marketplace browsing and search
-- **marketplace-library-test**: Authenticated marketplace and user library operations
-
-#### Comprehensive Tests (End-to-end scenarios)
-
-- **comprehensive-test**: Complete user journey simulation with multiple operations
-
-### Test Modes
-
-- **Local Mode**: 5 VUs × 30s - Quick validation and debugging
-- **Cloud Mode**: 80-150 VUs × 3-5m - Real performance testing
-
-## 🛠️ Usage
-
-### Basic Commands
-
-```bash
-# List available tests and show cloud credentials status
-node run-tests.js list
-
-# Quick setup verification
-node run-tests.js verify
-
-# Run specific test locally
-node run-tests.js run core-api-test DEV
-
-# Run multiple tests sequentially (comma-separated)
-node run-tests.js run connectivity-test,core-api-test,marketplace-public-test DEV
-
-# Run all tests locally
-node run-tests.js run all DEV
-
-# Run specific test in k6 cloud
-node run-tests.js cloud core-api-test DEV
-
-# Run all tests in k6 cloud
-node run-tests.js cloud all DEV
-```
-
-### NPM Scripts
-
-```bash
-# Quick verification
-npm run verify
-
-# Run all tests locally
-npm test
-
-# Run all tests in k6 cloud
-npm run cloud
-```
-
-## 🔧 Test Configuration
-
-### Pre-Authenticated Tokens
-
-- **Generation**: Run `node generate-tokens.js` to create tokens
-- **File**: `configs/pre-authenticated-tokens.js` (gitignored for security)
-- **Capacity**: 150+ tokens supporting high-concurrency testing
-- **Expiry**: 24 hours (86400 seconds) - extended for long-duration testing
-- **Benefit**: Eliminates Supabase auth rate limiting at scale
-- **Regeneration**: Run `node generate-tokens.js` when tokens expire after 24 hours
-
-### Environment Configuration
-
-- **LOCAL**: `http://localhost:8006` (local development)
-- **DEV**: `https://dev-api.agpt.co` (development environment)
-- **PROD**: `https://api.agpt.co` (production environment - coordinate with team!)
-
-## 📊 Performance Testing Features
-
-### Real-Time Monitoring
-
-- **k6 Cloud Dashboard**: Live performance metrics during cloud test execution
-- **URL Tracking**: Test URLs automatically saved to `k6-cloud-results.txt`
-- **Error Tracking**: Detailed failure analysis and HTTP status monitoring
-- **Custom Metrics**: Request success/failure rates, response times, user journey tracking
-- **Authentication Monitoring**: Tracks auth success/failure rates separately from HTTP errors
-
-### Load Testing Capabilities
-
-- **High Concurrency**: Up to 150+ virtual users per test
-- **Authentication Scaling**: Pre-auth tokens support 150+ concurrent users (10 tokens generated by default)
-- **Sequential Execution**: Multiple tests run one after another with proper delays
-- **Cloud Infrastructure**: Tests run on k6 cloud servers for consistent results
-- **ES Module Support**: Full ES module compatibility with modern JavaScript features
-
-## 📈 Performance Expectations
-
-### Validated Performance Limits
-
-- **Core API**: 100 VUs successfully handling `/api/credits`, `/api/graphs`, `/api/blocks`, `/api/executions`
-- **Graph Execution**: 80 VUs for complete workflow pipeline
-- **Marketplace Browsing**: 150 VUs for public marketplace access
-- **Authentication**: 150+ concurrent users with pre-authenticated tokens
-
-### Target Metrics
-
-- **P95 Latency**: Target < 5 seconds (marketplace), < 2 seconds (core API)
-- **P99 Latency**: Target < 10 seconds (marketplace), < 5 seconds (core API)
-- **Success Rate**: Target > 95% under normal load
-- **Error Rate**: Target < 5% for all endpoints
-
-## 🔍 Troubleshooting
-
-### Common Issues
-
-**1. Authentication Failures**
-
-```
-❌ No valid authentication token available
-❌ Token has expired
-```
-
-- **Solution**: Run `node generate-tokens.js` to create fresh 24-hour tokens
-- **Note**: Default generates 10 tokens (increase with `--count=50` for higher concurrency)
-
-**2. Cloud Credentials Missing**
-
-```
-❌ Missing k6 cloud credentials
-```
-
-- **Solution**: Set `K6_CLOUD_TOKEN` and `K6_CLOUD_PROJECT_ID=4254406`
-
-**3. Setup Verification Failed**
-
-```
-❌ Verification failed
-```
-
-- **Solution**: Check tokens exist and local API is accessible
-
-### Required Setup
-
-**1. Supabase Service Key (Required for all testing):**
-
-```bash
-# Get service key from environment or Kubernetes
-export SUPABASE_SERVICE_KEY="your-supabase-service-key"
-```
-
-**2. Generate Pre-Authenticated Tokens (Required):**
-
-```bash
-# Creates 10 tokens with 24-hour expiry - prevents auth rate limiting
-node generate-tokens.js
-
-# Generate more tokens for higher concurrency
-node generate-tokens.js --count=50
-
-# Regenerate when tokens expire (every 24 hours)
-node generate-tokens.js
-```
-
-**3. k6 Cloud Credentials (Required for cloud testing):**
-
-```bash
-export K6_CLOUD_TOKEN="your-k6-cloud-token"
-export K6_CLOUD_PROJECT_ID="4254406"  # AutoGPT Platform project ID
-```
-
-## 📂 File Structure
-
-```
-load-tests/
-├── README.md                              # This documentation
-├── run-tests.js                           # Unified test runner (MAIN ENTRY POINT)
-├── generate-tokens.js                     # Generate pre-auth tokens
-├── package.json                           # Node.js dependencies and scripts
-├── configs/
-│   ├── environment.js                     # Environment URLs and configuration
-│   └── pre-authenticated-tokens.js        # Generated tokens (gitignored)
-├── tests/
-│   ├── basic/
-│   │   ├── connectivity-test.js           # Basic connectivity validation
-│   │   └── single-endpoint-test.js        # Individual API endpoint testing
-│   ├── api/
-│   │   ├── core-api-test.js               # Core authenticated API endpoints
-│   │   └── graph-execution-test.js        # Graph workflow pipeline testing
-│   ├── marketplace/
-│   │   ├── public-access-test.js          # Public marketplace browsing
-│   │   └── library-access-test.js         # Authenticated marketplace/library
-│   └── comprehensive/
-│       └── platform-journey-test.js       # Complete user journey simulation
-├── orchestrator/
-│   └── comprehensive-orchestrator.js      # Full 25-test orchestration suite
-├── results/                               # Local test results (auto-created)
-├── k6-cloud-results.txt                   # Cloud test URLs (auto-created)
-└── *.json                                 # Test output files (auto-created)
-```
-
-## 🎯 Best Practices
-
-1. **Start with Verification**: Always run `node run-tests.js verify` first
-2. **Local for Development**: Use `run` command for debugging and development
-3. **Cloud for Performance**: Use `cloud` command for actual performance testing
-4. **Monitor Real-Time**: Check k6 cloud dashboards during test execution
-5. **Regenerate Tokens**: Refresh tokens every 24 hours when they expire
-6. **Sequential Testing**: Use comma-separated tests for organized execution
-
-## 🚀 Advanced Usage
-
-### Direct k6 Execution
-
-For granular control over individual test scripts:
-
-```bash
-# k6 Cloud execution (recommended for performance testing)
-K6_ENVIRONMENT=DEV VUS=100 DURATION=5m \
-k6 cloud run --env K6_ENVIRONMENT=DEV --env VUS=100 --env DURATION=5m tests/api/core-api-test.js
-
-# Local execution with cloud output (debugging)
-K6_ENVIRONMENT=DEV VUS=10 DURATION=1m \
-k6 run tests/api/core-api-test.js --out cloud
-
-# Local execution with JSON output (offline testing)
-K6_ENVIRONMENT=DEV VUS=10 DURATION=1m \
-k6 run tests/api/core-api-test.js --out json=results.json
-```
-
-### Custom Token Generation
-
-```bash
-# Generate specific number of tokens
-node generate-tokens.js --count=200
-
-# Generate tokens with custom timeout
-node generate-tokens.js --count=100 --timeout=60
-```
-
-## 🔗 Related Documentation
-
-- [k6 Documentation](https://k6.io/docs/)
-- [AutoGPT Platform API Documentation](https://docs.agpt.co/)
-- [k6 Cloud Dashboard](https://significantgravitas.grafana.net/a/k6-app/)
-
-For questions or issues, please refer to the [AutoGPT Platform issues](https://github.com/Significant-Gravitas/AutoGPT/issues).

autogpt_platform/backend/load-tests/configs/environment.js

@@ -1,141 +0,0 @@
-// Environment configuration for AutoGPT Platform load tests
-export const ENV_CONFIG = {
-  DEV: {
-    API_BASE_URL: "https://dev-server.agpt.co",
-    BUILDER_BASE_URL: "https://dev-builder.agpt.co",
-    WS_BASE_URL: "wss://dev-ws-server.agpt.co",
-    SUPABASE_URL: "https://adfjtextkuilwuhzdjpf.supabase.co",
-    SUPABASE_ANON_KEY:
-      "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFkZmp0ZXh0a3VpbHd1aHpkanBmIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzAyNTE3MDIsImV4cCI6MjA0NTgyNzcwMn0.IuQNXsHEKJNxtS9nyFeqO0BGMYN8sPiObQhuJLSK9xk",
-  },
-  LOCAL: {
-    API_BASE_URL: "http://localhost:8006",
-    BUILDER_BASE_URL: "http://localhost:3000",
-    WS_BASE_URL: "ws://localhost:8001",
-    SUPABASE_URL: "http://localhost:8000",
-    SUPABASE_ANON_KEY:
-      "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJhbm9uIiwKICAgICJpc3MiOiAic3VwYWJhc2UtZGVtbyIsCiAgICAiaWF0IjogMTY0MTc2OTIwMCwKICAgICJleHAiOiAxNzk5NTM1NjAwCn0.dc_X5iR_VP_qT0zsiyj_I_OZ2T9FtRU2BBNWN8Bu4GE",
-  },
-  PROD: {
-    API_BASE_URL: "https://api.agpt.co",
-    BUILDER_BASE_URL: "https://builder.agpt.co",
-    WS_BASE_URL: "wss://ws-server.agpt.co",
-    SUPABASE_URL: "https://supabase.agpt.co",
-    SUPABASE_ANON_KEY:
-      "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImJnd3B3ZHN4YmxyeWloaW51dGJ4Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzAyODYzMDUsImV4cCI6MjA0NTg2MjMwNX0.ISa2IofTdQIJmmX5JwKGGNajqjsD8bjaGBzK90SubE0",
-  },
-};
-
-// Get environment config based on K6_ENVIRONMENT variable (default: DEV)
-export function getEnvironmentConfig() {
-  const env = __ENV.K6_ENVIRONMENT || "DEV";
-  return ENV_CONFIG[env];
-}
-
-// Authentication configuration
-export const AUTH_CONFIG = {
-  // Test user credentials - REPLACE WITH ACTUAL TEST ACCOUNTS
-  TEST_USERS: [
-    {
-      email: "loadtest1@example.com",
-      password: "LoadTest123!",
-      user_id: "test-user-1",
-    },
-    {
-      email: "loadtest2@example.com",
-      password: "LoadTest123!",
-      user_id: "test-user-2",
-    },
-    {
-      email: "loadtest3@example.com",
-      password: "LoadTest123!",
-      user_id: "test-user-3",
-    },
-  ],
-
-  // JWT token for API access (will be set during test execution)
-  JWT_TOKEN: null,
-};
-
-// Performance test configurations - Environment variable overrides supported
-export const PERFORMANCE_CONFIG = {
-  // Default load test parameters (override with env vars: VUS, DURATION, RAMP_UP, RAMP_DOWN)
-  DEFAULT_VUS: parseInt(__ENV.VUS) || 10,
-  DEFAULT_DURATION: __ENV.DURATION || "2m",
-  DEFAULT_RAMP_UP: __ENV.RAMP_UP || "30s",
-  DEFAULT_RAMP_DOWN: __ENV.RAMP_DOWN || "30s",
-
-  // Stress test parameters (override with env vars: STRESS_VUS, STRESS_DURATION, etc.)
-  STRESS_VUS: parseInt(__ENV.STRESS_VUS) || 50,
-  STRESS_DURATION: __ENV.STRESS_DURATION || "5m",
-  STRESS_RAMP_UP: __ENV.STRESS_RAMP_UP || "1m",
-  STRESS_RAMP_DOWN: __ENV.STRESS_RAMP_DOWN || "1m",
-
-  // Spike test parameters (override with env vars: SPIKE_VUS, SPIKE_DURATION, etc.)
-  SPIKE_VUS: parseInt(__ENV.SPIKE_VUS) || 100,
-  SPIKE_DURATION: __ENV.SPIKE_DURATION || "30s",
-  SPIKE_RAMP_UP: __ENV.SPIKE_RAMP_UP || "10s",
-  SPIKE_RAMP_DOWN: __ENV.SPIKE_RAMP_DOWN || "10s",
-
-  // Volume test parameters (override with env vars: VOLUME_VUS, VOLUME_DURATION, etc.)
-  VOLUME_VUS: parseInt(__ENV.VOLUME_VUS) || 20,
-  VOLUME_DURATION: __ENV.VOLUME_DURATION || "10m",
-  VOLUME_RAMP_UP: __ENV.VOLUME_RAMP_UP || "2m",
-  VOLUME_RAMP_DOWN: __ENV.VOLUME_RAMP_DOWN || "2m",
-
-  // SLA thresholds (adjustable via env vars: THRESHOLD_P95, THRESHOLD_P99, etc.)
-  THRESHOLDS: {
-    http_req_duration: [
-      `p(95)<${__ENV.THRESHOLD_P95 || "2000"}`,
-      `p(99)<${__ENV.THRESHOLD_P99 || "5000"}`,
-    ],
-    http_req_failed: [`rate<${__ENV.THRESHOLD_ERROR_RATE || "0.05"}`],
-    http_reqs: [`rate>${__ENV.THRESHOLD_RPS || "10"}`],
-    checks: [`rate>${__ENV.THRESHOLD_CHECK_RATE || "0.95"}`],
-  },
-};
-
-// Helper function to get load test configuration based on test type
-export function getLoadTestConfig(testType = "default") {
-  const configs = {
-    default: {
-      vus: PERFORMANCE_CONFIG.DEFAULT_VUS,
-      duration: PERFORMANCE_CONFIG.DEFAULT_DURATION,
-      rampUp: PERFORMANCE_CONFIG.DEFAULT_RAMP_UP,
-      rampDown: PERFORMANCE_CONFIG.DEFAULT_RAMP_DOWN,
-    },
-    stress: {
-      vus: PERFORMANCE_CONFIG.STRESS_VUS,
-      duration: PERFORMANCE_CONFIG.STRESS_DURATION,
-      rampUp: PERFORMANCE_CONFIG.STRESS_RAMP_UP,
-      rampDown: PERFORMANCE_CONFIG.STRESS_RAMP_DOWN,
-    },
-    spike: {
-      vus: PERFORMANCE_CONFIG.SPIKE_VUS,
-      duration: PERFORMANCE_CONFIG.SPIKE_DURATION,
-      rampUp: PERFORMANCE_CONFIG.SPIKE_RAMP_UP,
-      rampDown: PERFORMANCE_CONFIG.SPIKE_RAMP_DOWN,
-    },
-    volume: {
-      vus: PERFORMANCE_CONFIG.VOLUME_VUS,
-      duration: PERFORMANCE_CONFIG.VOLUME_DURATION,
-      rampUp: PERFORMANCE_CONFIG.VOLUME_RAMP_UP,
-      rampDown: PERFORMANCE_CONFIG.VOLUME_RAMP_DOWN,
-    },
-  };
-
-  return configs[testType] || configs.default;
-}
-
-// Grafana Cloud K6 configuration
-export const GRAFANA_CONFIG = {
-  PROJECT_ID: __ENV.K6_CLOUD_PROJECT_ID || "",
-  TOKEN: __ENV.K6_CLOUD_TOKEN || "",
-  // Tags for organizing test results
-  TEST_TAGS: {
-    team: "platform",
-    service: "autogpt-platform",
-    environment: __ENV.K6_ENVIRONMENT || "dev",
-    version: __ENV.GIT_COMMIT || "unknown",
-  },
-};

autogpt_platform/backend/load-tests/configs/k6-credentials.env.example

@@ -1,9 +0,0 @@
-# k6 Cloud Credentials (EXAMPLE FILE)
-# Copy this to k6-credentials.env and fill in your actual credentials
-# 
-# Get these from: https://app.k6.io/
-# - K6_CLOUD_TOKEN: Your k6 cloud API token
-# - K6_CLOUD_PROJECT_ID: Your project ID
-
-K6_CLOUD_TOKEN=your-k6-cloud-token-here
-K6_CLOUD_PROJECT_ID=your-project-id-here

autogpt_platform/backend/load-tests/configs/pre-authenticated-tokens.example.js

@@ -1,51 +0,0 @@
-// Pre-authenticated tokens for load testing (EXAMPLE FILE)
-// Copy this to pre-authenticated-tokens.js and run generate-tokens.js to populate
-//
-// ⚠️  SECURITY: The real file contains authentication tokens
-// ⚠️  DO NOT COMMIT TO GIT - Real file is gitignored
-
-export const PRE_AUTHENTICATED_TOKENS = [
-  // Will be populated by generate-tokens.js with 350+ real tokens
-  // Example structure:
-  // {
-  //   token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
-  //   user: "loadtest4@example.com",
-  //   generated: "2025-01-24T10:08:04.123Z",
-  //   round: 1
-  // }
-];
-
-export function getPreAuthenticatedToken(vuId = 1) {
-  if (PRE_AUTHENTICATED_TOKENS.length === 0) {
-    throw new Error(
-      "No pre-authenticated tokens available. Run: node generate-tokens.js",
-    );
-  }
-
-  const tokenIndex = (vuId - 1) % PRE_AUTHENTICATED_TOKENS.length;
-  const tokenData = PRE_AUTHENTICATED_TOKENS[tokenIndex];
-
-  return {
-    access_token: tokenData.token,
-    user: { email: tokenData.user },
-    generated: tokenData.generated,
-  };
-}
-
-export function getPreAuthenticatedHeaders(vuId = 1) {
-  const authData = getPreAuthenticatedToken(vuId);
-  return {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${authData.access_token}`,
-  };
-}
-
-export const TOKEN_STATS = {
-  total: PRE_AUTHENTICATED_TOKENS.length,
-  users: [...new Set(PRE_AUTHENTICATED_TOKENS.map((t) => t.user))].length,
-  generated: PRE_AUTHENTICATED_TOKENS[0]?.generated || "unknown",
-};
-
-console.log(
-  `🔐 Loaded ${TOKEN_STATS.total} pre-authenticated tokens from ${TOKEN_STATS.users} users`,
-);

autogpt_platform/backend/load-tests/generate-tokens.js

@@ -1,236 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Generate Pre-Authenticated Tokens for Load Testing
- * Creates configs/pre-authenticated-tokens.js with 350+ tokens
- *
- * This replaces the old token generation scripts with a clean, single script
- */
-
-import https from "https";
-import fs from "fs";
-import path from "path";
-
-// Get Supabase service key from environment (REQUIRED for token generation)
-const SUPABASE_SERVICE_KEY = process.env.SUPABASE_SERVICE_KEY;
-
-if (!SUPABASE_SERVICE_KEY) {
-  console.error("❌ SUPABASE_SERVICE_KEY environment variable is required");
-  console.error("Get service key from kubectl or environment:");
-  console.error('export SUPABASE_SERVICE_KEY="your-service-key"');
-  process.exit(1);
-}
-
-// Generate test users (loadtest4-50 are known to work)
-const TEST_USERS = [];
-for (let i = 4; i <= 50; i++) {
-  TEST_USERS.push({
-    email: `loadtest${i}@example.com`,
-    password: "password123",
-  });
-}
-
-console.log(
-  `🔐 Generating pre-authenticated tokens from ${TEST_USERS.length} users...`,
-);
-
-async function authenticateUser(user, attempt = 1) {
-  return new Promise((resolve) => {
-    const postData = JSON.stringify({
-      email: user.email,
-      password: user.password,
-      expires_in: 86400, // 24 hours in seconds (24 * 60 * 60)
-    });
-
-    const options = {
-      hostname: "adfjtextkuilwuhzdjpf.supabase.co",
-      path: "/auth/v1/token?grant_type=password",
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${SUPABASE_SERVICE_KEY}`,
-        apikey: SUPABASE_SERVICE_KEY,
-        "Content-Type": "application/json",
-        "Content-Length": postData.length,
-      },
-    };
-
-    const req = https.request(options, (res) => {
-      let data = "";
-      res.on("data", (chunk) => (data += chunk));
-      res.on("end", () => {
-        try {
-          if (res.statusCode === 200) {
-            const authData = JSON.parse(data);
-            resolve(authData.access_token);
-          } else if (res.statusCode === 429) {
-            // Rate limited - wait and retry
-            console.log(
-              `⏳ Rate limited for ${user.email}, waiting 5s (attempt ${attempt}/3)...`,
-            );
-            setTimeout(() => {
-              if (attempt < 3) {
-                authenticateUser(user, attempt + 1).then(resolve);
-              } else {
-                console.log(`❌ Max retries exceeded for ${user.email}`);
-                resolve(null);
-              }
-            }, 5000);
-          } else {
-            console.log(`❌ Auth failed for ${user.email}: ${res.statusCode}`);
-            resolve(null);
-          }
-        } catch (e) {
-          console.log(`❌ Parse error for ${user.email}:`, e.message);
-          resolve(null);
-        }
-      });
-    });
-
-    req.on("error", (err) => {
-      console.log(`❌ Request error for ${user.email}:`, err.message);
-      resolve(null);
-    });
-
-    req.write(postData);
-    req.end();
-  });
-}
-
-async function generateTokens() {
-  console.log("🚀 Starting token generation...");
-  console.log("Rate limit aware - this will take ~10-15 minutes");
-  console.log("===========================================\n");
-
-  const tokens = [];
-  const startTime = Date.now();
-
-  // Generate tokens - configurable via --count argument or default to 150
-  const targetTokens =
-    parseInt(
-      process.argv.find((arg) => arg.startsWith("--count="))?.split("=")[1],
-    ) ||
-    parseInt(process.env.TOKEN_COUNT) ||
-    150;
-  const tokensPerUser = Math.ceil(targetTokens / TEST_USERS.length);
-  console.log(
-    `📊 Generating ${tokensPerUser} tokens per user (${TEST_USERS.length} users) - Target: ${targetTokens}\n`,
-  );
-
-  for (let round = 1; round <= tokensPerUser; round++) {
-    console.log(`🔄 Round ${round}/${tokensPerUser}:`);
-
-    for (
-      let i = 0;
-      i < TEST_USERS.length && tokens.length < targetTokens;
-      i++
-    ) {
-      const user = TEST_USERS[i];
-
-      process.stdout.write(`   ${user.email.padEnd(25)} ... `);
-
-      const token = await authenticateUser(user);
-
-      if (token) {
-        tokens.push({
-          token,
-          user: user.email,
-          generated: new Date().toISOString(),
-          round: round,
-        });
-        console.log(`✅ (${tokens.length}/${targetTokens})`);
-      } else {
-        console.log(`❌`);
-      }
-
-      // Respect rate limits - wait 500ms between requests
-      if (tokens.length < targetTokens) {
-        await new Promise((resolve) => setTimeout(resolve, 500));
-      }
-    }
-
-    if (tokens.length >= targetTokens) break;
-
-    // Wait longer between rounds
-    if (round < tokensPerUser) {
-      console.log(`   ⏸️  Waiting 3s before next round...\n`);
-      await new Promise((resolve) => setTimeout(resolve, 3000));
-    }
-  }
-
-  const duration = Math.round((Date.now() - startTime) / 1000);
-  console.log(`\n✅ Generated ${tokens.length} tokens in ${duration}s`);
-
-  // Create configs directory if it doesn't exist
-  const configsDir = path.join(process.cwd(), "configs");
-  if (!fs.existsSync(configsDir)) {
-    fs.mkdirSync(configsDir, { recursive: true });
-  }
-
-  // Write tokens to secure file
-  const jsContent = `// Pre-authenticated tokens for load testing
-// Generated: ${new Date().toISOString()}
-// Total tokens: ${tokens.length}
-// Generation time: ${duration} seconds
-// 
-// ⚠️  SECURITY: This file contains real authentication tokens
-// ⚠️  DO NOT COMMIT TO GIT - File is gitignored
-
-export const PRE_AUTHENTICATED_TOKENS = ${JSON.stringify(tokens, null, 2)};
-
-export function getPreAuthenticatedToken(vuId = 1) {
-  if (PRE_AUTHENTICATED_TOKENS.length === 0) {
-    throw new Error('No pre-authenticated tokens available');
-  }
-  
-  const tokenIndex = (vuId - 1) % PRE_AUTHENTICATED_TOKENS.length;
-  const tokenData = PRE_AUTHENTICATED_TOKENS[tokenIndex];
-  
-  return {
-    access_token: tokenData.token,
-    user: { email: tokenData.user },
-    generated: tokenData.generated
-  };
-}
-
-// Generate single session ID for this test run
-const LOAD_TEST_SESSION_ID = '${new Date().toISOString().slice(0, 16).replace(/:/g, "-")}-' + Math.random().toString(36).substr(2, 8);
-
-export function getPreAuthenticatedHeaders(vuId = 1) {
-  const authData = getPreAuthenticatedToken(vuId);
-  
-  return {
-    'Content-Type': 'application/json',
-    'Authorization': \`Bearer \${authData.access_token}\`,
-    'X-Load-Test-Session': LOAD_TEST_SESSION_ID,
-    'X-Load-Test-VU': vuId.toString(),
-    'X-Load-Test-User': authData.user.email,
-  };
-}
-
-export const TOKEN_STATS = {
-  total: PRE_AUTHENTICATED_TOKENS.length,
-  users: [...new Set(PRE_AUTHENTICATED_TOKENS.map(t => t.user))].length,
-  generated: PRE_AUTHENTICATED_TOKENS[0]?.generated || 'unknown'
-};
-
-console.log(\`🔐 Loaded \${TOKEN_STATS.total} pre-authenticated tokens from \${TOKEN_STATS.users} users\`);
-`;
-
-  const tokenFile = path.join(configsDir, "pre-authenticated-tokens.js");
-  fs.writeFileSync(tokenFile, jsContent);
-
-  console.log(`💾 Saved to configs/pre-authenticated-tokens.js`);
-  console.log(`🚀 Ready for ${tokens.length} concurrent VU load testing!`);
-  console.log(
-    `\n🔒 Security Note: Token file is gitignored and will not be committed`,
-  );
-
-  return tokens.length;
-}
-
-// Run if called directly
-if (process.argv[1] === new URL(import.meta.url).pathname) {
-  generateTokens().catch(console.error);
-}
-
-export { generateTokens };

autogpt_platform/backend/load-tests/orchestrator/comprehensive-orchestrator.js

@@ -1,611 +0,0 @@
-#!/usr/bin/env node
-
-// AutoGPT Platform Load Test Orchestrator
-// Runs comprehensive test suite locally or in k6 cloud
-// Collects URLs, statistics, and generates reports
-
-const { spawn } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-
-console.log("🎯 AUTOGPT PLATFORM LOAD TEST ORCHESTRATOR\n");
-console.log("===========================================\n");
-
-// Parse command line arguments
-const args = process.argv.slice(2);
-const environment = args[0] || "DEV"; // LOCAL, DEV, PROD
-const executionMode = args[1] || "cloud"; // local, cloud
-const testScale = args[2] || "full"; // small, full
-
-console.log(`🌍 Target Environment: ${environment}`);
-console.log(`🚀 Execution Mode: ${executionMode}`);
-console.log(`📏 Test Scale: ${testScale}`);
-
-// Test scenario definitions
-const testScenarios = {
-  // Small scale for validation (3 tests, ~5 minutes)
-  small: [
-    {
-      name: "Basic_Connectivity_Test",
-      file: "tests/basic/connectivity-test.js",
-      vus: 5,
-      duration: "30s",
-    },
-    {
-      name: "Core_API_Quick_Test",
-      file: "tests/api/core-api-test.js",
-      vus: 10,
-      duration: "1m",
-    },
-    {
-      name: "Marketplace_Quick_Test",
-      file: "tests/marketplace/public-access-test.js",
-      vus: 15,
-      duration: "1m",
-    },
-  ],
-
-  // Full comprehensive test suite (25 tests, ~2 hours)
-  full: [
-    // Marketplace Viewing Tests
-    {
-      name: "Viewing_Marketplace_Logged_Out_Day1",
-      file: "tests/marketplace/public-access-test.js",
-      vus: 106,
-      duration: "3m",
-    },
-    {
-      name: "Viewing_Marketplace_Logged_Out_VeryHigh",
-      file: "tests/marketplace/public-access-test.js",
-      vus: 314,
-      duration: "3m",
-    },
-    {
-      name: "Viewing_Marketplace_Logged_In_Day1",
-      file: "tests/marketplace/library-access-test.js",
-      vus: 53,
-      duration: "3m",
-    },
-    {
-      name: "Viewing_Marketplace_Logged_In_VeryHigh",
-      file: "tests/marketplace/library-access-test.js",
-      vus: 157,
-      duration: "3m",
-    },
-
-    // Library Management Tests
-    {
-      name: "Adding_Agent_to_Library_Day1",
-      file: "tests/marketplace/library-access-test.js",
-      vus: 32,
-      duration: "3m",
-    },
-    {
-      name: "Adding_Agent_to_Library_VeryHigh",
-      file: "tests/marketplace/library-access-test.js",
-      vus: 95,
-      duration: "3m",
-    },
-    {
-      name: "Viewing_Library_Home_0_Agents_Day1",
-      file: "tests/marketplace/library-access-test.js",
-      vus: 53,
-      duration: "3m",
-    },
-    {
-      name: "Viewing_Library_Home_0_Agents_VeryHigh",
-      file: "tests/marketplace/library-access-test.js",
-      vus: 157,
-      duration: "3m",
-    },
-
-    // Core API Tests
-    {
-      name: "Core_API_Load_Test",
-      file: "tests/api/core-api-test.js",
-      vus: 100,
-      duration: "3m",
-    },
-    {
-      name: "Graph_Execution_Load_Test",
-      file: "tests/api/graph-execution-test.js",
-      vus: 100,
-      duration: "3m",
-    },
-
-    // Single API Endpoint Tests
-    {
-      name: "Credits_API_Single_Endpoint",
-      file: "tests/basic/single-endpoint-test.js",
-      vus: 50,
-      duration: "3m",
-      env: { ENDPOINT: "credits", CONCURRENT_REQUESTS: 10 },
-    },
-    {
-      name: "Graphs_API_Single_Endpoint",
-      file: "tests/basic/single-endpoint-test.js",
-      vus: 50,
-      duration: "3m",
-      env: { ENDPOINT: "graphs", CONCURRENT_REQUESTS: 10 },
-    },
-    {
-      name: "Blocks_API_Single_Endpoint",
-      file: "tests/basic/single-endpoint-test.js",
-      vus: 50,
-      duration: "3m",
-      env: { ENDPOINT: "blocks", CONCURRENT_REQUESTS: 10 },
-    },
-    {
-      name: "Executions_API_Single_Endpoint",
-      file: "tests/basic/single-endpoint-test.js",
-      vus: 50,
-      duration: "3m",
-      env: { ENDPOINT: "executions", CONCURRENT_REQUESTS: 10 },
-    },
-
-    // Comprehensive Platform Tests
-    {
-      name: "Comprehensive_Platform_Low",
-      file: "tests/comprehensive/platform-journey-test.js",
-      vus: 25,
-      duration: "3m",
-    },
-    {
-      name: "Comprehensive_Platform_Medium",
-      file: "tests/comprehensive/platform-journey-test.js",
-      vus: 50,
-      duration: "3m",
-    },
-    {
-      name: "Comprehensive_Platform_High",
-      file: "tests/comprehensive/platform-journey-test.js",
-      vus: 100,
-      duration: "3m",
-    },
-
-    // User Authentication Workflows
-    {
-      name: "User_Auth_Workflows_Day1",
-      file: "tests/basic/connectivity-test.js",
-      vus: 50,
-      duration: "3m",
-    },
-    {
-      name: "User_Auth_Workflows_VeryHigh",
-      file: "tests/basic/connectivity-test.js",
-      vus: 100,
-      duration: "3m",
-    },
-
-    // Mixed Load Tests
-    {
-      name: "Mixed_Load_Light",
-      file: "tests/api/core-api-test.js",
-      vus: 75,
-      duration: "5m",
-    },
-    {
-      name: "Mixed_Load_Heavy",
-      file: "tests/marketplace/public-access-test.js",
-      vus: 200,
-      duration: "5m",
-    },
-
-    // Stress Tests
-    {
-      name: "Marketplace_Stress_Test",
-      file: "tests/marketplace/public-access-test.js",
-      vus: 500,
-      duration: "3m",
-    },
-    {
-      name: "Core_API_Stress_Test",
-      file: "tests/api/core-api-test.js",
-      vus: 300,
-      duration: "3m",
-    },
-
-    // Extended Duration Tests
-    {
-      name: "Long_Duration_Marketplace",
-      file: "tests/marketplace/library-access-test.js",
-      vus: 100,
-      duration: "10m",
-    },
-    {
-      name: "Long_Duration_Core_API",
-      file: "tests/api/core-api-test.js",
-      vus: 100,
-      duration: "10m",
-    },
-  ],
-};
-
-const scenarios = testScenarios[testScale];
-console.log(`📊 Running ${scenarios.length} test scenarios`);
-
-// Results collection
-const results = [];
-const cloudUrls = [];
-const detailedMetrics = [];
-
-// Create results directory
-const timestamp = new Date()
-  .toISOString()
-  .replace(/[:.]/g, "-")
-  .substring(0, 16);
-const resultsDir = `results-${environment.toLowerCase()}-${executionMode}-${testScale}-${timestamp}`;
-if (!fs.existsSync(resultsDir)) {
-  fs.mkdirSync(resultsDir);
-}
-
-// Function to run a single test
-function runTest(scenario, testIndex) {
-  return new Promise((resolve, reject) => {
-    console.log(`\n🚀 Test ${testIndex}/${scenarios.length}: ${scenario.name}`);
-    console.log(
-      `📊 Config: ${scenario.vus} VUs × ${scenario.duration} (${executionMode} mode)`,
-    );
-    console.log(`📁 Script: ${scenario.file}`);
-
-    // Build k6 command
-    let k6Command, k6Args;
-
-    // Determine k6 binary location
-    const isInPod = fs.existsSync("/app/k6-v0.54.0-linux-amd64/k6");
-    const k6Binary = isInPod ? "/app/k6-v0.54.0-linux-amd64/k6" : "k6";
-
-    // Build environment variables
-    const envVars = [
-      `K6_ENVIRONMENT=${environment}`,
-      `VUS=${scenario.vus}`,
-      `DURATION=${scenario.duration}`,
-      `RAMP_UP=30s`,
-      `RAMP_DOWN=30s`,
-      `THRESHOLD_P95=60000`,
-      `THRESHOLD_P99=60000`,
-    ];
-
-    // Add scenario-specific environment variables
-    if (scenario.env) {
-      Object.keys(scenario.env).forEach((key) => {
-        envVars.push(`${key}=${scenario.env[key]}`);
-      });
-    }
-
-    // Configure command based on execution mode
-    if (executionMode === "cloud") {
-      k6Command = k6Binary;
-      k6Args = ["cloud", "run", scenario.file];
-      // Add environment variables as --env flags
-      envVars.forEach((env) => {
-        k6Args.push("--env", env);
-      });
-    } else {
-      k6Command = k6Binary;
-      k6Args = ["run", scenario.file];
-
-      // Add local output files
-      const outputFile = path.join(resultsDir, `${scenario.name}.json`);
-      const summaryFile = path.join(
-        resultsDir,
-        `${scenario.name}_summary.json`,
-      );
-      k6Args.push("--out", `json=${outputFile}`);
-      k6Args.push("--summary-export", summaryFile);
-    }
-
-    const startTime = Date.now();
-    let testUrl = "";
-    let stdout = "";
-    let stderr = "";
-
-    console.log(`⏱️ Test started: ${new Date().toISOString()}`);
-
-    // Set environment variables for spawned process
-    const processEnv = { ...process.env };
-    envVars.forEach((env) => {
-      const [key, value] = env.split("=");
-      processEnv[key] = value;
-    });
-
-    const childProcess = spawn(k6Command, k6Args, {
-      env: processEnv,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    // Handle stdout
-    childProcess.stdout.on("data", (data) => {
-      const output = data.toString();
-      stdout += output;
-
-      // Extract k6 cloud URL
-      if (executionMode === "cloud") {
-        const urlMatch = output.match(/output:\s*(https:\/\/[^\s]+)/);
-        if (urlMatch) {
-          testUrl = urlMatch[1];
-          console.log(`🔗 Test URL: ${testUrl}`);
-        }
-      }
-
-      // Show progress indicators
-      if (output.includes("Run    [")) {
-        const progressMatch = output.match(/Run\s+\[\s*(\d+)%\s*\]/);
-        if (progressMatch) {
-          process.stdout.write(`\r⏳ Progress: ${progressMatch[1]}%`);
-        }
-      }
-    });
-
-    // Handle stderr
-    childProcess.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-
-    // Handle process completion
-    childProcess.on("close", (code) => {
-      const endTime = Date.now();
-      const duration = Math.round((endTime - startTime) / 1000);
-
-      console.log(`\n⏱️ Completed in ${duration}s`);
-
-      if (code === 0) {
-        console.log(`✅ ${scenario.name} SUCCESS`);
-
-        const result = {
-          test: scenario.name,
-          status: "SUCCESS",
-          duration: `${duration}s`,
-          vus: scenario.vus,
-          target_duration: scenario.duration,
-          url: testUrl || "N/A",
-          execution_mode: executionMode,
-          environment: environment,
-          completed_at: new Date().toISOString(),
-        };
-
-        results.push(result);
-
-        if (testUrl) {
-          cloudUrls.push(`${scenario.name}: ${testUrl}`);
-        }
-
-        // Store detailed output for analysis
-        detailedMetrics.push({
-          test: scenario.name,
-          stdout_lines: stdout.split("\n").length,
-          stderr_lines: stderr.split("\n").length,
-          has_url: !!testUrl,
-        });
-
-        resolve(result);
-      } else {
-        console.error(`❌ ${scenario.name} FAILED (exit code ${code})`);
-
-        const result = {
-          test: scenario.name,
-          status: "FAILED",
-          error: `Exit code ${code}`,
-          duration: `${duration}s`,
-          vus: scenario.vus,
-          execution_mode: executionMode,
-          environment: environment,
-          completed_at: new Date().toISOString(),
-        };
-
-        results.push(result);
-        reject(new Error(`Test failed with exit code ${code}`));
-      }
-    });
-
-    // Handle spawn errors
-    childProcess.on("error", (error) => {
-      console.error(`❌ ${scenario.name} ERROR:`, error.message);
-
-      results.push({
-        test: scenario.name,
-        status: "ERROR",
-        error: error.message,
-        execution_mode: executionMode,
-        environment: environment,
-      });
-
-      reject(error);
-    });
-  });
-}
-
-// Main orchestration function
-async function runOrchestrator() {
-  const estimatedMinutes = scenarios.length * (testScale === "small" ? 2 : 5);
-  console.log(`\n🎯 Starting ${testScale} test suite on ${environment}`);
-  console.log(`📈 Estimated time: ~${estimatedMinutes} minutes`);
-  console.log(`🌩️ Execution: ${executionMode} mode\n`);
-
-  const startTime = Date.now();
-  let successCount = 0;
-  let failureCount = 0;
-
-  // Run tests sequentially
-  for (let i = 0; i < scenarios.length; i++) {
-    try {
-      await runTest(scenarios[i], i + 1);
-      successCount++;
-
-      // Pause between tests (avoid overwhelming k6 cloud API)
-      if (i < scenarios.length - 1) {
-        const pauseSeconds = testScale === "small" ? 10 : 30;
-        console.log(`\n⏸️ Pausing ${pauseSeconds}s before next test...\n`);
-        await new Promise((resolve) =>
-          setTimeout(resolve, pauseSeconds * 1000),
-        );
-      }
-    } catch (error) {
-      failureCount++;
-      console.log(`💥 Continuing after failure...\n`);
-
-      // Brief pause before continuing
-      if (i < scenarios.length - 1) {
-        await new Promise((resolve) => setTimeout(resolve, 15000));
-      }
-    }
-  }
-
-  const totalTime = Math.round((Date.now() - startTime) / 1000);
-  await generateReports(successCount, failureCount, totalTime);
-}
-
-// Generate comprehensive reports
-async function generateReports(successCount, failureCount, totalTime) {
-  console.log("\n🎉 LOAD TEST ORCHESTRATOR COMPLETE\n");
-  console.log("===================================\n");
-
-  // Summary statistics
-  const successRate = Math.round((successCount / scenarios.length) * 100);
-  console.log("📊 EXECUTION SUMMARY:");
-  console.log(
-    `✅ Successful tests: ${successCount}/${scenarios.length} (${successRate}%)`,
-  );
-  console.log(`❌ Failed tests: ${failureCount}/${scenarios.length}`);
-  console.log(`⏱️ Total execution time: ${Math.round(totalTime / 60)} minutes`);
-  console.log(`🌍 Environment: ${environment}`);
-  console.log(`🚀 Mode: ${executionMode}`);
-
-  // Generate CSV report
-  const csvHeaders =
-    "Test Name,Status,VUs,Target Duration,Actual Duration,Environment,Mode,Test URL,Error,Completed At";
-  const csvRows = results.map(
-    (r) =>
-      `"${r.test}","${r.status}",${r.vus},"${r.target_duration || "N/A"}","${r.duration || "N/A"}","${r.environment}","${r.execution_mode}","${r.url || "N/A"}","${r.error || "None"}","${r.completed_at || "N/A"}"`,
-  );
-
-  const csvContent = [csvHeaders, ...csvRows].join("\n");
-  const csvFile = path.join(resultsDir, "orchestrator_results.csv");
-  fs.writeFileSync(csvFile, csvContent);
-  console.log(`\n📁 CSV Report: ${csvFile}`);
-
-  // Generate cloud URLs file
-  if (executionMode === "cloud" && cloudUrls.length > 0) {
-    const urlsContent = [
-      `# AutoGPT Platform Load Test URLs`,
-      `# Environment: ${environment}`,
-      `# Generated: ${new Date().toISOString()}`,
-      `# Dashboard: https://significantgravitas.grafana.net/a/k6-app/`,
-      "",
-      ...cloudUrls,
-      "",
-      "# Direct Dashboard Access:",
-      "https://significantgravitas.grafana.net/a/k6-app/",
-    ].join("\n");
-
-    const urlsFile = path.join(resultsDir, "cloud_test_urls.txt");
-    fs.writeFileSync(urlsFile, urlsContent);
-    console.log(`📁 Cloud URLs: ${urlsFile}`);
-  }
-
-  // Generate detailed JSON report
-  const jsonReport = {
-    meta: {
-      orchestrator_version: "1.0",
-      environment: environment,
-      execution_mode: executionMode,
-      test_scale: testScale,
-      total_scenarios: scenarios.length,
-      generated_at: new Date().toISOString(),
-      results_directory: resultsDir,
-    },
-    summary: {
-      successful_tests: successCount,
-      failed_tests: failureCount,
-      success_rate: `${successRate}%`,
-      total_execution_time_seconds: totalTime,
-      total_execution_time_minutes: Math.round(totalTime / 60),
-    },
-    test_results: results,
-    detailed_metrics: detailedMetrics,
-    cloud_urls: cloudUrls,
-  };
-
-  const jsonFile = path.join(resultsDir, "orchestrator_results.json");
-  fs.writeFileSync(jsonFile, JSON.stringify(jsonReport, null, 2));
-  console.log(`📁 JSON Report: ${jsonFile}`);
-
-  // Display immediate results
-  if (executionMode === "cloud" && cloudUrls.length > 0) {
-    console.log("\n🔗 K6 CLOUD TEST DASHBOARD URLS:");
-    console.log("================================");
-    cloudUrls.slice(0, 5).forEach((url) => console.log(url));
-    if (cloudUrls.length > 5) {
-      console.log(`... and ${cloudUrls.length - 5} more URLs in ${urlsFile}`);
-    }
-    console.log(
-      "\n📈 Main Dashboard: https://significantgravitas.grafana.net/a/k6-app/",
-    );
-  }
-
-  console.log(`\n📂 All results saved in: ${resultsDir}/`);
-  console.log("🏁 Load Test Orchestrator finished successfully!");
-}
-
-// Show usage help
-function showUsage() {
-  console.log("🎯 AutoGPT Platform Load Test Orchestrator\n");
-  console.log(
-    "Usage: node load-test-orchestrator.js [ENVIRONMENT] [MODE] [SCALE]\n",
-  );
-  console.log("ENVIRONMENT:");
-  console.log("  LOCAL  - http://localhost:8006 (local development)");
-  console.log("  DEV    - https://dev-api.agpt.co (development server)");
-  console.log(
-    "  PROD   - https://api.agpt.co (production - coordinate with team!)\n",
-  );
-  console.log("MODE:");
-  console.log("  local  - Run locally with JSON output files");
-  console.log("  cloud  - Run in k6 cloud with dashboard monitoring\n");
-  console.log("SCALE:");
-  console.log("  small  - 3 validation tests (~5 minutes)");
-  console.log("  full   - 25 comprehensive tests (~2 hours)\n");
-  console.log("Examples:");
-  console.log("  node load-test-orchestrator.js DEV cloud small");
-  console.log("  node load-test-orchestrator.js LOCAL local small");
-  console.log("  node load-test-orchestrator.js DEV cloud full");
-  console.log(
-    "  node load-test-orchestrator.js PROD cloud full  # Coordinate with team!\n",
-  );
-  console.log("Requirements:");
-  console.log(
-    "  - Pre-authenticated tokens generated (node generate-tokens.js)",
-  );
-  console.log("  - k6 installed locally or run from Kubernetes pod");
-  console.log("  - For cloud mode: K6_CLOUD_TOKEN and K6_CLOUD_PROJECT_ID set");
-}
-
-// Handle command line help
-if (args.includes("--help") || args.includes("-h")) {
-  showUsage();
-  process.exit(0);
-}
-
-// Handle graceful shutdown
-process.on("SIGINT", () => {
-  console.log("\n🛑 Orchestrator interrupted by user");
-  console.log("📊 Generating partial results...");
-  generateReports(
-    results.filter((r) => r.status === "SUCCESS").length,
-    results.filter((r) => r.status === "FAILED").length,
-    0,
-  ).then(() => {
-    console.log("🏃‍♂️ Partial results saved");
-    process.exit(0);
-  });
-});
-
-// Start orchestrator
-if (require.main === module) {
-  runOrchestrator().catch((error) => {
-    console.error("💥 Orchestrator failed:", error);
-    process.exit(1);
-  });
-}
-
-module.exports = { runOrchestrator, testScenarios };

autogpt_platform/backend/load-tests/run-tests.js

@@ -1,268 +0,0 @@
-#!/usr/bin/env node
-/**
- * Unified Load Test Runner
- *
- * Supports both local execution and k6 cloud execution with the same interface.
- * Automatically detects cloud credentials and provides seamless switching.
- *
- * Usage:
- *   node run-tests.js verify                     # Quick verification (1 VU, 10s)
- *   node run-tests.js run core-api-test DEV      # Run specific test locally
- *   node run-tests.js run all DEV                # Run all tests locally
- *   node run-tests.js cloud core-api DEV         # Run specific test in k6 cloud
- *   node run-tests.js cloud all DEV              # Run all tests in k6 cloud
- */
-
-import { execSync } from "child_process";
-import fs from "fs";
-
-const TESTS = {
-  "connectivity-test": {
-    script: "tests/basic/connectivity-test.js",
-    description: "Basic connectivity validation",
-    cloudConfig: { vus: 10, duration: "2m" },
-  },
-  "single-endpoint-test": {
-    script: "tests/basic/single-endpoint-test.js",
-    description: "Individual API endpoint testing",
-    cloudConfig: { vus: 25, duration: "3m" },
-  },
-  "core-api-test": {
-    script: "tests/api/core-api-test.js",
-    description: "Core API endpoints performance test",
-    cloudConfig: { vus: 100, duration: "5m" },
-  },
-  "graph-execution-test": {
-    script: "tests/api/graph-execution-test.js",
-    description: "Graph creation and execution pipeline test",
-    cloudConfig: { vus: 80, duration: "5m" },
-  },
-  "marketplace-public-test": {
-    script: "tests/marketplace/public-access-test.js",
-    description: "Public marketplace browsing test",
-    cloudConfig: { vus: 150, duration: "3m" },
-  },
-  "marketplace-library-test": {
-    script: "tests/marketplace/library-access-test.js",
-    description: "Authenticated marketplace/library test",
-    cloudConfig: { vus: 100, duration: "4m" },
-  },
-  "comprehensive-test": {
-    script: "tests/comprehensive/platform-journey-test.js",
-    description: "Complete user journey simulation",
-    cloudConfig: { vus: 50, duration: "6m" },
-  },
-};
-
-function checkCloudCredentials() {
-  const token = process.env.K6_CLOUD_TOKEN;
-  const projectId = process.env.K6_CLOUD_PROJECT_ID;
-
-  if (!token || !projectId) {
-    console.log("❌ Missing k6 cloud credentials");
-    console.log("Set: K6_CLOUD_TOKEN and K6_CLOUD_PROJECT_ID");
-    return false;
-  }
-  return true;
-}
-
-function verifySetup() {
-  console.log("🔍 Quick Setup Verification");
-
-  // Check tokens
-  if (!fs.existsSync("configs/pre-authenticated-tokens.js")) {
-    console.log("❌ No tokens found. Run: node generate-tokens.js");
-    return false;
-  }
-
-  // Quick test
-  try {
-    execSync(
-      "K6_ENVIRONMENT=DEV VUS=1 DURATION=10s k6 run tests/basic/connectivity-test.js --quiet",
-      { stdio: "inherit", cwd: process.cwd() },
-    );
-    console.log("✅ Verification successful");
-    return true;
-  } catch (error) {
-    console.log("❌ Verification failed");
-    return false;
-  }
-}
-
-function runLocalTest(testName, environment) {
-  const test = TESTS[testName];
-  if (!test) {
-    console.log(`❌ Unknown test: ${testName}`);
-    console.log("Available tests:", Object.keys(TESTS).join(", "));
-    return;
-  }
-
-  console.log(`🚀 Running ${test.description} locally on ${environment}`);
-
-  try {
-    const cmd = `K6_ENVIRONMENT=${environment} VUS=5 DURATION=30s k6 run ${test.script}`;
-    execSync(cmd, { stdio: "inherit", cwd: process.cwd() });
-    console.log("✅ Test completed");
-  } catch (error) {
-    console.log("❌ Test failed");
-  }
-}
-
-function runCloudTest(testName, environment) {
-  const test = TESTS[testName];
-  if (!test) {
-    console.log(`❌ Unknown test: ${testName}`);
-    console.log("Available tests:", Object.keys(TESTS).join(", "));
-    return;
-  }
-
-  const { vus, duration } = test.cloudConfig;
-  console.log(`☁️ Running ${test.description} in k6 cloud`);
-  console.log(`   Environment: ${environment}`);
-  console.log(`   Config: ${vus} VUs × ${duration}`);
-
-  try {
-    const cmd = `k6 cloud run --env K6_ENVIRONMENT=${environment} --env VUS=${vus} --env DURATION=${duration} --env RAMP_UP=30s --env RAMP_DOWN=30s ${test.script}`;
-    const output = execSync(cmd, {
-      stdio: "pipe",
-      cwd: process.cwd(),
-      encoding: "utf8",
-    });
-
-    // Extract and display URL
-    const urlMatch = output.match(/https:\/\/[^\s]*grafana[^\s]*/);
-    if (urlMatch) {
-      const url = urlMatch[0];
-      console.log(`🔗 Test URL: ${url}`);
-
-      // Save to results file
-      const timestamp = new Date().toISOString();
-      const result = `${timestamp} - ${testName}: ${url}\n`;
-      fs.appendFileSync("k6-cloud-results.txt", result);
-    }
-
-    console.log("✅ Cloud test started successfully");
-  } catch (error) {
-    console.log("❌ Cloud test failed to start");
-    console.log(error.message);
-  }
-}
-
-function runAllLocalTests(environment) {
-  console.log(`🚀 Running all tests locally on ${environment}`);
-
-  for (const [testName, test] of Object.entries(TESTS)) {
-    console.log(`\n📊 ${test.description}`);
-    runLocalTest(testName, environment);
-  }
-}
-
-function runAllCloudTests(environment) {
-  console.log(`☁️ Running all tests in k6 cloud on ${environment}`);
-
-  const testNames = Object.keys(TESTS);
-  for (let i = 0; i < testNames.length; i++) {
-    const testName = testNames[i];
-    console.log(`\n📊 Test ${i + 1}/${testNames.length}: ${testName}`);
-
-    runCloudTest(testName, environment);
-
-    // Brief pause between cloud tests (except last one)
-    if (i < testNames.length - 1) {
-      console.log("⏸️ Waiting 2 minutes before next cloud test...");
-      execSync("sleep 120");
-    }
-  }
-}
-
-function listTests() {
-  console.log("📋 Available Tests:");
-  console.log("==================");
-
-  Object.entries(TESTS).forEach(([name, test]) => {
-    const { vus, duration } = test.cloudConfig;
-    console.log(`  ${name.padEnd(20)} - ${test.description}`);
-    console.log(`  ${" ".repeat(20)}   Cloud: ${vus} VUs × ${duration}`);
-  });
-
-  console.log("\n🌍 Available Environments: LOCAL, DEV, PROD");
-  console.log("\n💡 Examples:");
-  console.log("  # Local execution (5 VUs, 30s)");
-  console.log("  node run-tests.js verify");
-  console.log("  node run-tests.js run core-api-test DEV");
-  console.log("  node run-tests.js run core-api-test,marketplace-test DEV");
-  console.log("  node run-tests.js run all DEV");
-  console.log("");
-  console.log("  # Cloud execution (high VUs, longer duration)");
-  console.log("  node run-tests.js cloud core-api DEV");
-  console.log("  node run-tests.js cloud all DEV");
-
-  const hasCloudCreds = checkCloudCredentials();
-  console.log(
-    `\n☁️ Cloud Status: ${hasCloudCreds ? "✅ Configured" : "❌ Missing credentials"}`,
-  );
-}
-
-function runSequentialTests(testNames, environment, isCloud = false) {
-  const tests = testNames.split(",").map((t) => t.trim());
-  const mode = isCloud ? "cloud" : "local";
-  console.log(
-    `🚀 Running ${tests.length} tests sequentially in ${mode} mode on ${environment}`,
-  );
-
-  for (let i = 0; i < tests.length; i++) {
-    const testName = tests[i];
-    console.log(`\n📊 Test ${i + 1}/${tests.length}: ${testName}`);
-
-    if (isCloud) {
-      runCloudTest(testName, environment);
-    } else {
-      runLocalTest(testName, environment);
-    }
-
-    // Brief pause between tests (except last one)
-    if (i < tests.length - 1) {
-      const pauseTime = isCloud ? "2 minutes" : "10 seconds";
-      const pauseCmd = isCloud ? "sleep 120" : "sleep 10";
-      console.log(`⏸️ Waiting ${pauseTime} before next test...`);
-      if (!isCloud) {
-        // Note: In real implementation, would use setTimeout/sleep for local tests
-      }
-    }
-  }
-}
-
-// Main CLI
-const [, , command, testOrEnv, environment] = process.argv;
-
-switch (command) {
-  case "verify":
-    verifySetup();
-    break;
-  case "list":
-    listTests();
-    break;
-  case "run":
-    if (testOrEnv === "all") {
-      runAllLocalTests(environment || "DEV");
-    } else if (testOrEnv?.includes(",")) {
-      runSequentialTests(testOrEnv, environment || "DEV", false);
-    } else {
-      runLocalTest(testOrEnv, environment || "DEV");
-    }
-    break;
-  case "cloud":
-    if (!checkCloudCredentials()) {
-      process.exit(1);
-    }
-    if (testOrEnv === "all") {
-      runAllCloudTests(environment || "DEV");
-    } else if (testOrEnv?.includes(",")) {
-      runSequentialTests(testOrEnv, environment || "DEV", true);
-    } else {
-      runCloudTest(testOrEnv, environment || "DEV");
-    }
-    break;
-  default:
-    listTests();
-}

autogpt_platform/backend/load-tests/tests/api/core-api-test.js

@@ -1,197 +0,0 @@
-// Simple API diagnostic test
-import http from "k6/http";
-import { check } from "k6";
-import { getEnvironmentConfig } from "../../configs/environment.js";
-import { getPreAuthenticatedHeaders } from "../../configs/pre-authenticated-tokens.js";
-
-const config = getEnvironmentConfig();
-
-export const options = {
-  stages: [
-    { duration: __ENV.RAMP_UP || "1m", target: parseInt(__ENV.VUS) || 1 },
-    { duration: __ENV.DURATION || "5m", target: parseInt(__ENV.VUS) || 1 },
-    { duration: __ENV.RAMP_DOWN || "1m", target: 0 },
-  ],
-  // Thresholds disabled to prevent test abortion - collect all performance data
-  // thresholds: {
-  //   checks: ['rate>0.70'],
-  //   http_req_duration: ['p(95)<30000'],
-  //   http_req_failed: ['rate<0.3'],
-  // },
-  cloud: {
-    projectID: __ENV.K6_CLOUD_PROJECT_ID,
-    name: "AutoGPT Platform - Core API Validation Test",
-  },
-  // Timeout configurations to prevent early termination
-  setupTimeout: "60s",
-  teardownTimeout: "60s",
-  noConnectionReuse: false,
-  userAgent: "k6-load-test/1.0",
-};
-
-export default function () {
-  // Get load multiplier - how many concurrent requests each VU should make
-  const requestsPerVU = parseInt(__ENV.REQUESTS_PER_VU) || 1;
-
-  try {
-    // Step 1: Get pre-authenticated headers (no auth API calls during test)
-    const headers = getPreAuthenticatedHeaders(__VU);
-
-    // Handle missing token gracefully
-    if (!headers || !headers.Authorization) {
-      console.log(
-        `⚠️ VU ${__VU} has no valid pre-authenticated token - skipping core API test`,
-      );
-      check(null, {
-        "Core API: Failed gracefully without crashing VU": () => true,
-      });
-      return; // Exit iteration gracefully without crashing
-    }
-
-    console.log(
-      `🚀 VU ${__VU} making ${requestsPerVU} concurrent API requests...`,
-    );
-
-    // Create array of API requests to run concurrently
-    const requests = [];
-
-    for (let i = 0; i < requestsPerVU; i++) {
-      // Add core API requests that represent realistic user workflows
-      requests.push({
-        method: "GET",
-        url: `${config.API_BASE_URL}/api/credits`,
-        params: { headers },
-      });
-
-      requests.push({
-        method: "GET",
-        url: `${config.API_BASE_URL}/api/graphs`,
-        params: { headers },
-      });
-
-      requests.push({
-        method: "GET",
-        url: `${config.API_BASE_URL}/api/blocks`,
-        params: { headers },
-      });
-    }
-
-    // Execute all requests concurrently
-    const responses = http.batch(requests);
-
-    // Validate results
-    let creditsSuccesses = 0;
-    let graphsSuccesses = 0;
-    let blocksSuccesses = 0;
-
-    for (let i = 0; i < responses.length; i++) {
-      const response = responses[i];
-      const apiType = i % 3; // 0=credits, 1=graphs, 2=blocks
-
-      if (apiType === 0) {
-        // Credits API request
-        check(response, {
-          "Credits API: HTTP Status is 200": (r) => r.status === 200,
-          "Credits API: Not Auth Error (401/403)": (r) =>
-            r.status !== 401 && r.status !== 403,
-          "Credits API: Response has valid JSON": (r) => {
-            try {
-              JSON.parse(r.body);
-              return true;
-            } catch (e) {
-              return false;
-            }
-          },
-          "Credits API: Response has credits field": (r) => {
-            try {
-              const data = JSON.parse(r.body);
-              return data && typeof data.credits === "number";
-            } catch (e) {
-              return false;
-            }
-          },
-          "Credits API: Overall Success": (r) => {
-            try {
-              if (r.status !== 200) return false;
-              const data = JSON.parse(r.body);
-              return data && typeof data.credits === "number";
-            } catch (e) {
-              return false;
-            }
-          },
-        });
-      } else if (apiType === 1) {
-        // Graphs API request
-        check(response, {
-          "Graphs API: HTTP Status is 200": (r) => r.status === 200,
-          "Graphs API: Not Auth Error (401/403)": (r) =>
-            r.status !== 401 && r.status !== 403,
-          "Graphs API: Response has valid JSON": (r) => {
-            try {
-              JSON.parse(r.body);
-              return true;
-            } catch (e) {
-              return false;
-            }
-          },
-          "Graphs API: Response is array": (r) => {
-            try {
-              const data = JSON.parse(r.body);
-              return Array.isArray(data);
-            } catch (e) {
-              return false;
-            }
-          },
-          "Graphs API: Overall Success": (r) => {
-            try {
-              if (r.status !== 200) return false;
-              const data = JSON.parse(r.body);
-              return Array.isArray(data);
-            } catch (e) {
-              return false;
-            }
-          },
-        });
-      } else {
-        // Blocks API request
-        check(response, {
-          "Blocks API: HTTP Status is 200": (r) => r.status === 200,
-          "Blocks API: Not Auth Error (401/403)": (r) =>
-            r.status !== 401 && r.status !== 403,
-          "Blocks API: Response has valid JSON": (r) => {
-            try {
-              JSON.parse(r.body);
-              return true;
-            } catch (e) {
-              return false;
-            }
-          },
-          "Blocks API: Response has blocks data": (r) => {
-            try {
-              const data = JSON.parse(r.body);
-              return data && (Array.isArray(data) || typeof data === "object");
-            } catch (e) {
-              return false;
-            }
-          },
-          "Blocks API: Overall Success": (r) => {
-            try {
-              if (r.status !== 200) return false;
-              const data = JSON.parse(r.body);
-              return data && (Array.isArray(data) || typeof data === "object");
-            } catch (e) {
-              return false;
-            }
-          },
-        });
-      }
-    }
-
-    console.log(
-      `✅ VU ${__VU} completed ${responses.length} API requests with detailed auth/validation tracking`,
-    );
-  } catch (error) {
-    console.error(`💥 Test failed: ${error.message}`);
-    console.error(`💥 Stack: ${error.stack}`);
-  }
-}

autogpt_platform/backend/load-tests/tests/api/graph-execution-test.js

@@ -1,249 +0,0 @@
-// Dedicated graph execution load testing
-import http from "k6/http";
-import { check, sleep, group } from "k6";
-import { Rate, Trend, Counter } from "k6/metrics";
-import { getEnvironmentConfig } from "../../configs/environment.js";
-import { getPreAuthenticatedHeaders } from "../../configs/pre-authenticated-tokens.js";
-// Test data generation functions
-function generateTestGraph(name = null) {
-  const graphName =
-    name || `Load Test Graph ${Math.random().toString(36).substr(2, 9)}`;
-  return {
-    name: graphName,
-    description: "Generated graph for load testing purposes",
-    graph: {
-      name: graphName,
-      description: "Load testing graph",
-      nodes: [
-        {
-          id: "input_node",
-          name: "Agent Input",
-          block_id: "c0a8e994-ebf1-4a9c-a4d8-89d09c86741b",
-          input_default: {
-            name: "Load Test Input",
-            description: "Test input for load testing",
-            placeholder_values: {},
-          },
-          input_nodes: [],
-          output_nodes: ["output_node"],
-          metadata: { position: { x: 100, y: 100 } },
-        },
-        {
-          id: "output_node",
-          name: "Agent Output",
-          block_id: "363ae599-353e-4804-937e-b2ee3cef3da4",
-          input_default: {
-            name: "Load Test Output",
-            description: "Test output for load testing",
-            value: "Test output value",
-          },
-          input_nodes: ["input_node"],
-          output_nodes: [],
-          metadata: { position: { x: 300, y: 100 } },
-        },
-      ],
-      links: [
-        {
-          source_id: "input_node",
-          sink_id: "output_node",
-          source_name: "result",
-          sink_name: "value",
-        },
-      ],
-    },
-  };
-}
-
-function generateExecutionInputs() {
-  return {
-    "Load Test Input": {
-      name: "Load Test Input",
-      description: "Test input for load testing",
-      placeholder_values: {
-        test_data: `Test execution at ${new Date().toISOString()}`,
-        test_parameter: Math.random().toString(36).substr(2, 9),
-        numeric_value: Math.floor(Math.random() * 1000),
-      },
-    },
-  };
-}
-
-const config = getEnvironmentConfig();
-
-// Custom metrics for graph execution testing
-const graphCreations = new Counter("graph_creations_total");
-const graphExecutions = new Counter("graph_executions_total");
-const graphExecutionTime = new Trend("graph_execution_duration");
-const graphCreationTime = new Trend("graph_creation_duration");
-const executionErrors = new Rate("execution_errors");
-
-// Configurable options for easy load adjustment
-export const options = {
-  stages: [
-    { duration: __ENV.RAMP_UP || "1m", target: parseInt(__ENV.VUS) || 5 },
-    { duration: __ENV.DURATION || "5m", target: parseInt(__ENV.VUS) || 5 },
-    { duration: __ENV.RAMP_DOWN || "1m", target: 0 },
-  ],
-  // Thresholds disabled to prevent test abortion - collect all performance data
-  // thresholds: {
-  //   checks: ['rate>0.60'],
-  //   http_req_duration: ['p(95)<45000', 'p(99)<60000'],
-  //   http_req_failed: ['rate<0.4'],
-  //   graph_execution_duration: ['p(95)<45000'],
-  //   graph_creation_duration: ['p(95)<30000'],
-  // },
-  cloud: {
-    projectID: __ENV.K6_CLOUD_PROJECT_ID,
-    name: "AutoGPT Platform - Graph Creation & Execution Test",
-  },
-  // Timeout configurations to prevent early termination
-  setupTimeout: "60s",
-  teardownTimeout: "60s",
-  noConnectionReuse: false,
-  userAgent: "k6-load-test/1.0",
-};
-
-export function setup() {
-  console.log("🎯 Setting up graph execution load test...");
-  console.log(
-    `Configuration: VUs=${parseInt(__ENV.VUS) || 5}, Duration=${__ENV.DURATION || "2m"}`,
-  );
-  return {
-    timestamp: Date.now(),
-  };
-}
-
-export default function (data) {
-  // Get load multiplier - how many concurrent operations each VU should perform
-  const requestsPerVU = parseInt(__ENV.REQUESTS_PER_VU) || 1;
-
-  // Get pre-authenticated headers (no auth API calls during test)
-  const headers = getPreAuthenticatedHeaders(__VU);
-
-  // Handle missing token gracefully
-  if (!headers || !headers.Authorization) {
-    console.log(
-      `⚠️ VU ${__VU} has no valid pre-authenticated token - skipping graph execution`,
-    );
-    check(null, {
-      "Graph Execution: Failed gracefully without crashing VU": () => true,
-    });
-    return; // Exit iteration gracefully without crashing
-  }
-
-  console.log(
-    `🚀 VU ${__VU} performing ${requestsPerVU} concurrent graph operations...`,
-  );
-
-  // Create requests for concurrent execution
-  const graphRequests = [];
-
-  for (let i = 0; i < requestsPerVU; i++) {
-    // Generate graph data
-    const graphData = generateTestGraph();
-
-    // Add graph creation request
-    graphRequests.push({
-      method: "POST",
-      url: `${config.API_BASE_URL}/api/graphs`,
-      body: JSON.stringify(graphData),
-      params: { headers },
-    });
-  }
-
-  // Execute all graph creations concurrently
-  console.log(`📊 Creating ${requestsPerVU} graphs concurrently...`);
-  const responses = http.batch(graphRequests);
-
-  // Process results
-  let successCount = 0;
-  const createdGraphs = [];
-
-  for (let i = 0; i < responses.length; i++) {
-    const response = responses[i];
-
-    const success = check(response, {
-      [`Graph ${i + 1} created successfully`]: (r) => r.status === 200,
-    });
-
-    if (success && response.status === 200) {
-      successCount++;
-      try {
-        const graph = JSON.parse(response.body);
-        createdGraphs.push(graph);
-        graphCreations.add(1);
-      } catch (e) {
-        console.error(`Error parsing graph ${i + 1} response:`, e);
-      }
-    } else {
-      console.log(`❌ Graph ${i + 1} creation failed: ${response.status}`);
-    }
-  }
-
-  console.log(
-    `✅ VU ${__VU} created ${successCount}/${requestsPerVU} graphs concurrently`,
-  );
-
-  // Execute a subset of created graphs (to avoid overloading execution)
-  const graphsToExecute = createdGraphs.slice(
-    0,
-    Math.min(5, createdGraphs.length),
-  );
-
-  if (graphsToExecute.length > 0) {
-    console.log(`⚡ Executing ${graphsToExecute.length} graphs...`);
-
-    const executionRequests = [];
-
-    for (const graph of graphsToExecute) {
-      const executionInputs = generateExecutionInputs();
-
-      executionRequests.push({
-        method: "POST",
-        url: `${config.API_BASE_URL}/api/graphs/${graph.id}/execute/${graph.version}`,
-        body: JSON.stringify({
-          inputs: executionInputs,
-          credentials_inputs: {},
-        }),
-        params: { headers },
-      });
-    }
-
-    // Execute graphs concurrently
-    const executionResponses = http.batch(executionRequests);
-
-    let executionSuccessCount = 0;
-    for (let i = 0; i < executionResponses.length; i++) {
-      const response = executionResponses[i];
-
-      const success = check(response, {
-        [`Graph ${i + 1} execution initiated`]: (r) =>
-          r.status === 200 || r.status === 402,
-      });
-
-      if (success) {
-        executionSuccessCount++;
-        graphExecutions.add(1);
-      }
-    }
-
-    console.log(
-      `✅ VU ${__VU} executed ${executionSuccessCount}/${graphsToExecute.length} graphs`,
-    );
-  }
-
-  // Think time between iterations
-  sleep(Math.random() * 2 + 1); // 1-3 seconds
-}
-
-// Legacy functions removed - replaced by concurrent execution in main function
-// These functions are no longer used since implementing http.batch() for true concurrency
-
-export function teardown(data) {
-  console.log("🧹 Cleaning up graph execution load test...");
-  console.log(`Total graph creations: ${graphCreations.value || 0}`);
-  console.log(`Total graph executions: ${graphExecutions.value || 0}`);
-
-  const testDuration = Date.now() - data.timestamp;
-  console.log(`Test completed in ${testDuration}ms`);
-}

autogpt_platform/backend/load-tests/tests/basic/connectivity-test.js

@@ -1,137 +0,0 @@
-/**
- * Basic Connectivity Test
- *
- * Tests basic connectivity and authentication without requiring backend API access
- * This test validates that the core infrastructure is working correctly
- */
-
-import http from "k6/http";
-import { check } from "k6";
-import { getEnvironmentConfig } from "../../configs/environment.js";
-import { getPreAuthenticatedHeaders } from "../../configs/pre-authenticated-tokens.js";
-
-const config = getEnvironmentConfig();
-
-export const options = {
-  stages: [
-    { duration: __ENV.RAMP_UP || "1m", target: parseInt(__ENV.VUS) || 1 },
-    { duration: __ENV.DURATION || "5m", target: parseInt(__ENV.VUS) || 1 },
-    { duration: __ENV.RAMP_DOWN || "1m", target: 0 },
-  ],
-  thresholds: {
-    checks: ["rate>0.70"], // Reduced from 0.85 due to auth timeouts under load
-    http_req_duration: ["p(95)<30000"], // Increased for cloud testing with high concurrency
-    http_req_failed: ["rate<0.6"], // Increased to account for auth timeouts
-  },
-  cloud: {
-    projectID: __ENV.K6_CLOUD_PROJECT_ID,
-    name: "AutoGPT Platform - Basic Connectivity & Auth Test",
-  },
-  // Timeout configurations to prevent early termination
-  setupTimeout: "60s",
-  teardownTimeout: "60s",
-  noConnectionReuse: false,
-  userAgent: "k6-load-test/1.0",
-};
-
-export default function () {
-  // Get load multiplier - how many concurrent requests each VU should make
-  const requestsPerVU = parseInt(__ENV.REQUESTS_PER_VU) || 1;
-
-  try {
-    // Get pre-authenticated headers
-    const headers = getPreAuthenticatedHeaders(__VU);
-
-    // Handle authentication failure gracefully
-    if (!headers || !headers.Authorization) {
-      console.log(
-        `⚠️ VU ${__VU} has no valid pre-authentication token - skipping iteration`,
-      );
-      check(null, {
-        "Authentication: Failed gracefully without crashing VU": () => true,
-      });
-      return; // Exit iteration gracefully without crashing
-    }
-
-    console.log(`🚀 VU ${__VU} making ${requestsPerVU} concurrent requests...`);
-
-    // Create array of request functions to run concurrently
-    const requests = [];
-
-    for (let i = 0; i < requestsPerVU; i++) {
-      requests.push({
-        method: "GET",
-        url: `${config.SUPABASE_URL}/rest/v1/`,
-        params: { headers: { apikey: config.SUPABASE_ANON_KEY } },
-      });
-
-      requests.push({
-        method: "GET",
-        url: `${config.API_BASE_URL}/health`,
-        params: { headers },
-      });
-    }
-
-    // Execute all requests concurrently
-    const responses = http.batch(requests);
-
-    // Validate results
-    let supabaseSuccesses = 0;
-    let backendSuccesses = 0;
-
-    for (let i = 0; i < responses.length; i++) {
-      const response = responses[i];
-
-      if (i % 2 === 0) {
-        // Supabase request
-        const connectivityCheck = check(response, {
-          "Supabase connectivity: Status is not 500": (r) => r.status !== 500,
-          "Supabase connectivity: Response time < 5s": (r) =>
-            r.timings.duration < 5000,
-        });
-        if (connectivityCheck) supabaseSuccesses++;
-      } else {
-        // Backend request
-        const backendCheck = check(response, {
-          "Backend server: Responds (any status)": (r) => r.status > 0,
-          "Backend server: Response time < 5s": (r) =>
-            r.timings.duration < 5000,
-        });
-        if (backendCheck) backendSuccesses++;
-      }
-    }
-
-    console.log(
-      `✅ VU ${__VU} completed: ${supabaseSuccesses}/${requestsPerVU} Supabase, ${backendSuccesses}/${requestsPerVU} backend requests successful`,
-    );
-
-    // Basic auth validation (once per iteration)
-    const authCheck = check(headers, {
-      "Authentication: Pre-auth token available": (h) =>
-        h && h.Authorization && h.Authorization.length > 0,
-    });
-
-    // JWT structure validation (once per iteration)
-    const token = headers.Authorization.replace("Bearer ", "");
-    const tokenParts = token.split(".");
-    const tokenStructureCheck = check(tokenParts, {
-      "JWT token: Has 3 parts (header.payload.signature)": (parts) =>
-        parts.length === 3,
-      "JWT token: Header is base64": (parts) =>
-        parts[0] && parts[0].length > 10,
-      "JWT token: Payload is base64": (parts) =>
-        parts[1] && parts[1].length > 50,
-      "JWT token: Signature exists": (parts) =>
-        parts[2] && parts[2].length > 10,
-    });
-  } catch (error) {
-    console.error(`💥 Test failed: ${error.message}`);
-    check(null, {
-      "Test execution: No errors": () => false,
-    });
-  }
-}
-
-export function teardown(data) {
-  console.log(`🏁 Basic connectivity test completed`);
-}

autogpt_platform/backend/load-tests/tests/basic/single-endpoint-test.js

@@ -1,104 +0,0 @@
-// Test individual API endpoints to isolate performance bottlenecks
-import http from "k6/http";
-import { check } from "k6";
-import { getEnvironmentConfig } from "../../configs/environment.js";
-import { getPreAuthenticatedHeaders } from "../../configs/pre-authenticated-tokens.js";
-
-const config = getEnvironmentConfig();
-
-export const options = {
-  stages: [
-    { duration: __ENV.RAMP_UP || "10s", target: parseInt(__ENV.VUS) || 3 },
-    { duration: __ENV.DURATION || "20s", target: parseInt(__ENV.VUS) || 3 },
-    { duration: __ENV.RAMP_DOWN || "10s", target: 0 },
-  ],
-  thresholds: {
-    checks: ["rate>0.50"], // 50% success rate (was 70%)
-    http_req_duration: ["p(95)<60000"], // P95 under 60s (was 5s)
-    http_req_failed: ["rate<0.5"], // 50% failure rate allowed (was 30%)
-  },
-  cloud: {
-    projectID: parseInt(__ENV.K6_CLOUD_PROJECT_ID) || 4254406,
-    name: `AutoGPT Single Endpoint Test - ${__ENV.ENDPOINT || "credits"} API`,
-  },
-};
-
-export default function () {
-  const endpoint = __ENV.ENDPOINT || "credits"; // credits, graphs, blocks, executions
-  const concurrentRequests = parseInt(__ENV.CONCURRENT_REQUESTS) || 1;
-
-  try {
-    const headers = getPreAuthenticatedHeaders(__VU);
-
-    if (!headers || !headers.Authorization) {
-      console.log(
-        `⚠️ VU ${__VU} has no valid pre-authentication token - skipping test`,
-      );
-      return;
-    }
-
-    console.log(
-      `🚀 VU ${__VU} testing /api/${endpoint} with ${concurrentRequests} concurrent requests`,
-    );
-
-    if (concurrentRequests === 1) {
-      // Single request mode (original behavior)
-      const response = http.get(`${config.API_BASE_URL}/api/${endpoint}`, {
-        headers,
-      });
-
-      const success = check(response, {
-        [`${endpoint} API: Status is 200`]: (r) => r.status === 200,
-        [`${endpoint} API: Response time < 3s`]: (r) =>
-          r.timings.duration < 3000,
-      });
-
-      if (success) {
-        console.log(
-          `✅ VU ${__VU} /api/${endpoint} successful: ${response.timings.duration}ms`,
-        );
-      } else {
-        console.log(
-          `❌ VU ${__VU} /api/${endpoint} failed: ${response.status}, ${response.timings.duration}ms`,
-        );
-      }
-    } else {
-      // Concurrent requests mode using http.batch()
-      const requests = [];
-      for (let i = 0; i < concurrentRequests; i++) {
-        requests.push({
-          method: "GET",
-          url: `${config.API_BASE_URL}/api/${endpoint}`,
-          params: { headers },
-        });
-      }
-
-      const responses = http.batch(requests);
-
-      let successCount = 0;
-      let totalTime = 0;
-
-      for (let i = 0; i < responses.length; i++) {
-        const response = responses[i];
-        const success = check(response, {
-          [`${endpoint} API Request ${i + 1}: Status is 200`]: (r) =>
-            r.status === 200,
-          [`${endpoint} API Request ${i + 1}: Response time < 5s`]: (r) =>
-            r.timings.duration < 5000,
-        });
-
-        if (success) {
-          successCount++;
-        }
-        totalTime += response.timings.duration;
-      }
-
-      const avgTime = totalTime / responses.length;
-      console.log(
-        `✅ VU ${__VU} /api/${endpoint}: ${successCount}/${concurrentRequests} successful, avg: ${avgTime.toFixed(0)}ms`,
-      );
-    }
-  } catch (error) {
-    console.error(`💥 VU ${__VU} error: ${error.message}`);
-  }
-}

autogpt_platform/backend/load-tests/tests/comprehensive/platform-journey-test.js

@@ -1,508 +0,0 @@
-import http from "k6/http";
-import { check, sleep, group } from "k6";
-import { Rate, Trend, Counter } from "k6/metrics";
-import {
-  getEnvironmentConfig,
-  PERFORMANCE_CONFIG,
-} from "../../configs/environment.js";
-import { getPreAuthenticatedHeaders } from "../../configs/pre-authenticated-tokens.js";
-
-// Inline test data generators (simplified from utils/test-data.js)
-function generateTestGraph(name = null) {
-  const graphName =
-    name || `Load Test Graph ${Math.random().toString(36).substr(2, 9)}`;
-  return {
-    name: graphName,
-    description: "Generated graph for load testing purposes",
-    graph: {
-      nodes: [],
-      links: [],
-    },
-  };
-}
-
-function generateExecutionInputs() {
-  return { test_input: "load_test_value" };
-}
-
-function generateScheduleData() {
-  return { enabled: false };
-}
-
-function generateAPIKeyRequest() {
-  return { name: "Load Test API Key" };
-}
-
-const config = getEnvironmentConfig();
-
-// Custom metrics
-const userOperations = new Counter("user_operations_total");
-const graphOperations = new Counter("graph_operations_total");
-const executionOperations = new Counter("execution_operations_total");
-const apiResponseTime = new Trend("api_response_time");
-const authErrors = new Rate("auth_errors");
-
-// Test configuration for normal load testing
-export const options = {
-  stages: [
-    {
-      duration: __ENV.RAMP_UP || "1m",
-      target: parseInt(__ENV.VUS) || PERFORMANCE_CONFIG.DEFAULT_VUS,
-    },
-    {
-      duration: __ENV.DURATION || "5m",
-      target: parseInt(__ENV.VUS) || PERFORMANCE_CONFIG.DEFAULT_VUS,
-    },
-    { duration: __ENV.RAMP_DOWN || "1m", target: 0 },
-  ],
-  // maxDuration: '15m', // Removed - not supported in k6 cloud
-  thresholds: {
-    checks: ["rate>0.50"], // Reduced for high concurrency complex operations
-    http_req_duration: ["p(95)<60000", "p(99)<60000"], // Allow up to 60s response times
-    http_req_failed: ["rate<0.5"], // Allow 50% failure rate for stress testing
-  },
-  cloud: {
-    projectID: __ENV.K6_CLOUD_PROJECT_ID,
-    name: "AutoGPT Platform - Full Platform Integration Test",
-  },
-  // Timeout configurations to prevent early termination
-  setupTimeout: "60s",
-  teardownTimeout: "60s",
-  noConnectionReuse: false,
-  userAgent: "k6-load-test/1.0",
-};
-
-export function setup() {
-  console.log("🎯 Setting up load test scenario...");
-  return {
-    timestamp: Date.now(),
-  };
-}
-
-export default function (data) {
-  // Get load multiplier - how many concurrent user journeys each VU should simulate
-  const requestsPerVU = parseInt(__ENV.REQUESTS_PER_VU) || 1;
-
-  let headers;
-
-  try {
-    headers = getPreAuthenticatedHeaders(__VU);
-  } catch (error) {
-    console.error(`❌ Authentication failed:`, error);
-    authErrors.add(1);
-    return;
-  }
-
-  // Handle authentication failure gracefully
-  if (!headers || !headers.Authorization) {
-    console.log(
-      `⚠️ VU ${__VU} has no valid pre-authentication token - skipping comprehensive platform test`,
-    );
-    check(null, {
-      "Comprehensive Platform: Failed gracefully without crashing VU": () =>
-        true,
-    });
-    return; // Exit iteration gracefully without crashing
-  }
-
-  console.log(
-    `🚀 VU ${__VU} simulating ${requestsPerVU} realistic user workflows...`,
-  );
-
-  // Create concurrent requests for all user journeys
-  const requests = [];
-
-  // Simulate realistic user workflows instead of just API hammering
-  for (let i = 0; i < requestsPerVU; i++) {
-    // Workflow 1: User checking their dashboard
-    requests.push({
-      method: "GET",
-      url: `${config.API_BASE_URL}/api/credits`,
-      params: { headers },
-    });
-    requests.push({
-      method: "GET",
-      url: `${config.API_BASE_URL}/api/graphs`,
-      params: { headers },
-    });
-
-    // Workflow 2: User exploring available blocks for building agents
-    requests.push({
-      method: "GET",
-      url: `${config.API_BASE_URL}/api/blocks`,
-      params: { headers },
-    });
-
-    // Workflow 3: User monitoring their recent executions
-    requests.push({
-      method: "GET",
-      url: `${config.API_BASE_URL}/api/executions`,
-      params: { headers },
-    });
-  }
-
-  console.log(
-    `📊 Executing ${requests.length} requests across realistic user workflows...`,
-  );
-
-  // Execute all requests concurrently
-  const responses = http.batch(requests);
-
-  // Process results and count successes
-  let creditsSuccesses = 0,
-    graphsSuccesses = 0,
-    blocksSuccesses = 0,
-    executionsSuccesses = 0;
-
-  for (let i = 0; i < responses.length; i++) {
-    const response = responses[i];
-    const operationType = i % 4; // Each set of 4 requests: 0=credits, 1=graphs, 2=blocks, 3=executions
-
-    switch (operationType) {
-      case 0: // Dashboard: Check credits
-        if (
-          check(response, {
-            "Dashboard: User credits loaded successfully": (r) =>
-              r.status === 200,
-          })
-        ) {
-          creditsSuccesses++;
-          userOperations.add(1);
-        }
-        break;
-      case 1: // Dashboard: View graphs
-        if (
-          check(response, {
-            "Dashboard: User graphs loaded successfully": (r) =>
-              r.status === 200,
-          })
-        ) {
-          graphsSuccesses++;
-          graphOperations.add(1);
-        }
-        break;
-      case 2: // Exploration: Browse available blocks
-        if (
-          check(response, {
-            "Block Explorer: Available blocks loaded successfully": (r) =>
-              r.status === 200,
-          })
-        ) {
-          blocksSuccesses++;
-          userOperations.add(1);
-        }
-        break;
-      case 3: // Monitoring: Check execution history
-        if (
-          check(response, {
-            "Execution Monitor: Recent executions loaded successfully": (r) =>
-              r.status === 200,
-          })
-        ) {
-          executionsSuccesses++;
-          userOperations.add(1);
-        }
-        break;
-    }
-  }
-
-  console.log(
-    `✅ VU ${__VU} completed realistic workflows: ${creditsSuccesses} dashboard checks, ${graphsSuccesses} graph views, ${blocksSuccesses} block explorations, ${executionsSuccesses} execution monitors`,
-  );
-
-  // Think time between user sessions
-  sleep(Math.random() * 3 + 1); // 1-4 seconds
-}
-
-function userProfileJourney(headers) {
-  const startTime = Date.now();
-
-  // 1. Get user credits (JWT-only endpoint)
-  const creditsResponse = http.get(`${config.API_BASE_URL}/api/credits`, {
-    headers,
-  });
-
-  userOperations.add(1);
-
-  check(creditsResponse, {
-    "User credits loaded successfully": (r) => r.status === 200,
-  });
-
-  // 2. Check onboarding status
-  const onboardingResponse = http.get(`${config.API_BASE_URL}/api/onboarding`, {
-    headers,
-  });
-
-  userOperations.add(1);
-
-  check(onboardingResponse, {
-    "Onboarding status loaded": (r) => r.status === 200,
-  });
-
-  apiResponseTime.add(Date.now() - startTime);
-}
-
-function graphManagementJourney(headers) {
-  const startTime = Date.now();
-
-  // 1. List existing graphs
-  const listResponse = http.get(`${config.API_BASE_URL}/api/graphs`, {
-    headers,
-  });
-
-  graphOperations.add(1);
-
-  const listSuccess = check(listResponse, {
-    "Graphs list loaded successfully": (r) => r.status === 200,
-  });
-
-  // 2. Create a new graph (20% of users)
-  if (Math.random() < 0.2) {
-    const graphData = generateTestGraph();
-
-    const createResponse = http.post(
-      `${config.API_BASE_URL}/api/graphs`,
-      JSON.stringify(graphData),
-      { headers },
-    );
-
-    graphOperations.add(1);
-
-    const createSuccess = check(createResponse, {
-      "Graph created successfully": (r) => r.status === 200,
-    });
-
-    if (createSuccess && createResponse.status === 200) {
-      try {
-        const createdGraph = JSON.parse(createResponse.body);
-
-        // 3. Get the created graph details
-        const getResponse = http.get(
-          `${config.API_BASE_URL}/api/graphs/${createdGraph.id}`,
-          { headers },
-        );
-
-        graphOperations.add(1);
-
-        check(getResponse, {
-          "Graph details loaded": (r) => r.status === 200,
-        });
-
-        // 4. Execute the graph (50% chance)
-        if (Math.random() < 0.5) {
-          executeGraphScenario(createdGraph, headers);
-        }
-
-        // 5. Create schedule for graph (10% chance)
-        if (Math.random() < 0.1) {
-          createScheduleScenario(createdGraph.id, headers);
-        }
-      } catch (error) {
-        console.error("Error handling created graph:", error);
-      }
-    }
-  }
-
-  // 3. Work with existing graphs (if any)
-  if (listSuccess && listResponse.status === 200) {
-    try {
-      const existingGraphs = JSON.parse(listResponse.body);
-
-      if (existingGraphs.length > 0) {
-        // Pick a random existing graph
-        const randomGraph =
-          existingGraphs[Math.floor(Math.random() * existingGraphs.length)];
-
-        // Get graph details
-        const getResponse = http.get(
-          `${config.API_BASE_URL}/api/graphs/${randomGraph.id}`,
-          { headers },
-        );
-
-        graphOperations.add(1);
-
-        check(getResponse, {
-          "Existing graph details loaded": (r) => r.status === 200,
-        });
-
-        // Execute existing graph (30% chance)
-        if (Math.random() < 0.3) {
-          executeGraphScenario(randomGraph, headers);
-        }
-      }
-    } catch (error) {
-      console.error("Error working with existing graphs:", error);
-    }
-  }
-
-  apiResponseTime.add(Date.now() - startTime);
-}
-
-function executeGraphScenario(graph, headers) {
-  const startTime = Date.now();
-
-  const executionInputs = generateExecutionInputs();
-
-  const executeResponse = http.post(
-    `${config.API_BASE_URL}/api/graphs/${graph.id}/execute/${graph.version}`,
-    JSON.stringify({
-      inputs: executionInputs,
-      credentials_inputs: {},
-    }),
-    { headers },
-  );
-
-  executionOperations.add(1);
-
-  const executeSuccess = check(executeResponse, {
-    "Graph execution initiated": (r) => r.status === 200 || r.status === 402, // 402 = insufficient credits
-  });
-
-  if (executeSuccess && executeResponse.status === 200) {
-    try {
-      const execution = JSON.parse(executeResponse.body);
-
-      // Monitor execution status (simulate user checking results)
-      // Note: setTimeout doesn't work in k6, so we'll check status immediately
-      const statusResponse = http.get(
-        `${config.API_BASE_URL}/api/graphs/${graph.id}/executions/${execution.id}`,
-        { headers },
-      );
-
-      executionOperations.add(1);
-
-      check(statusResponse, {
-        "Execution status retrieved": (r) => r.status === 200,
-      });
-    } catch (error) {
-      console.error("Error monitoring execution:", error);
-    }
-  }
-
-  apiResponseTime.add(Date.now() - startTime);
-}
-
-function createScheduleScenario(graphId, headers) {
-  const scheduleData = generateScheduleData(graphId);
-
-  const scheduleResponse = http.post(
-    `${config.API_BASE_URL}/api/graphs/${graphId}/schedules`,
-    JSON.stringify(scheduleData),
-    { headers },
-  );
-
-  graphOperations.add(1);
-
-  check(scheduleResponse, {
-    "Schedule created successfully": (r) => r.status === 200,
-  });
-}
-
-function blockOperationsJourney(headers) {
-  const startTime = Date.now();
-
-  // 1. Get available blocks
-  const blocksResponse = http.get(`${config.API_BASE_URL}/api/blocks`, {
-    headers,
-  });
-
-  userOperations.add(1);
-
-  const blocksSuccess = check(blocksResponse, {
-    "Blocks list loaded": (r) => r.status === 200,
-  });
-
-  // 2. Execute some blocks directly (simulate testing)
-  if (blocksSuccess && Math.random() < 0.3) {
-    // Execute GetCurrentTimeBlock (simple, fast block)
-    const timeBlockResponse = http.post(
-      `${config.API_BASE_URL}/api/blocks/a892b8d9-3e4e-4e9c-9c1e-75f8efcf1bfa/execute`,
-      JSON.stringify({
-        trigger: "test",
-        format_type: {
-          discriminator: "iso8601",
-          timezone: "UTC",
-        },
-      }),
-      { headers },
-    );
-
-    userOperations.add(1);
-
-    check(timeBlockResponse, {
-      "Time block executed or handled gracefully": (r) =>
-        r.status === 200 || r.status === 500, // 500 = user_context missing (expected)
-    });
-  }
-
-  apiResponseTime.add(Date.now() - startTime);
-}
-
-function systemOperationsJourney(headers) {
-  const startTime = Date.now();
-
-  // 1. Check executions list (simulate monitoring)
-  const executionsResponse = http.get(`${config.API_BASE_URL}/api/executions`, {
-    headers,
-  });
-
-  userOperations.add(1);
-
-  check(executionsResponse, {
-    "Executions list loaded": (r) => r.status === 200,
-  });
-
-  // 2. Check schedules (if any)
-  const schedulesResponse = http.get(`${config.API_BASE_URL}/api/schedules`, {
-    headers,
-  });
-
-  userOperations.add(1);
-
-  check(schedulesResponse, {
-    "Schedules list loaded": (r) => r.status === 200,
-  });
-
-  // 3. Check API keys (simulate user managing access)
-  if (Math.random() < 0.1) {
-    // 10% of users check API keys
-    const apiKeysResponse = http.get(`${config.API_BASE_URL}/api/api-keys`, {
-      headers,
-    });
-
-    userOperations.add(1);
-
-    check(apiKeysResponse, {
-      "API keys list loaded": (r) => r.status === 200,
-    });
-
-    // Occasionally create new API key (5% chance)
-    if (Math.random() < 0.05) {
-      const keyData = generateAPIKeyRequest();
-
-      const createKeyResponse = http.post(
-        `${config.API_BASE_URL}/api/api-keys`,
-        JSON.stringify(keyData),
-        { headers },
-      );
-
-      userOperations.add(1);
-
-      check(createKeyResponse, {
-        "API key created successfully": (r) => r.status === 200,
-      });
-    }
-  }
-
-  apiResponseTime.add(Date.now() - startTime);
-}
-
-export function teardown(data) {
-  console.log("🧹 Cleaning up load test...");
-  console.log(`Total user operations: ${userOperations.value}`);
-  console.log(`Total graph operations: ${graphOperations.value}`);
-  console.log(`Total execution operations: ${executionOperations.value}`);
-
-  const testDuration = Date.now() - data.timestamp;
-  console.log(`Test completed in ${testDuration}ms`);
-}

autogpt_platform/backend/load-tests/tests/marketplace/library-access-test.js

@@ -1,536 +0,0 @@
-import { check } from "k6";
-import http from "k6/http";
-import { Counter } from "k6/metrics";
-
-import { getEnvironmentConfig } from "../../configs/environment.js";
-import { getPreAuthenticatedHeaders } from "../../configs/pre-authenticated-tokens.js";
-
-const config = getEnvironmentConfig();
-const BASE_URL = config.API_BASE_URL;
-
-// Custom metrics
-const libraryRequests = new Counter("library_requests_total");
-const successfulRequests = new Counter("successful_requests_total");
-const failedRequests = new Counter("failed_requests_total");
-const authenticationAttempts = new Counter("authentication_attempts_total");
-const authenticationSuccesses = new Counter("authentication_successes_total");
-
-// Test configuration
-const VUS = parseInt(__ENV.VUS) || 5;
-const DURATION = __ENV.DURATION || "2m";
-const RAMP_UP = __ENV.RAMP_UP || "30s";
-const RAMP_DOWN = __ENV.RAMP_DOWN || "30s";
-const REQUESTS_PER_VU = parseInt(__ENV.REQUESTS_PER_VU) || 5;
-
-// Performance thresholds for authenticated endpoints
-const THRESHOLD_P95 = parseInt(__ENV.THRESHOLD_P95) || 10000; // 10s for authenticated endpoints
-const THRESHOLD_P99 = parseInt(__ENV.THRESHOLD_P99) || 20000; // 20s for authenticated endpoints
-const THRESHOLD_ERROR_RATE = parseFloat(__ENV.THRESHOLD_ERROR_RATE) || 0.1; // 10% error rate
-const THRESHOLD_CHECK_RATE = parseFloat(__ENV.THRESHOLD_CHECK_RATE) || 0.85; // 85% success rate
-
-export const options = {
-  stages: [
-    { duration: RAMP_UP, target: VUS },
-    { duration: DURATION, target: VUS },
-    { duration: RAMP_DOWN, target: 0 },
-  ],
-  thresholds: {
-    http_req_duration: [
-      { threshold: `p(95)<${THRESHOLD_P95}`, abortOnFail: false },
-      { threshold: `p(99)<${THRESHOLD_P99}`, abortOnFail: false },
-    ],
-    http_req_failed: [
-      { threshold: `rate<${THRESHOLD_ERROR_RATE}`, abortOnFail: false },
-    ],
-    checks: [{ threshold: `rate>${THRESHOLD_CHECK_RATE}`, abortOnFail: false }],
-  },
-  tags: {
-    test_type: "marketplace_library_authorized",
-    environment: __ENV.K6_ENVIRONMENT || "DEV",
-  },
-};
-
-export default function () {
-  console.log(`📚 VU ${__VU} starting authenticated library journey...`);
-
-  // Get pre-authenticated headers
-  const headers = getPreAuthenticatedHeaders(__VU);
-  if (!headers || !headers.Authorization) {
-    console.log(`❌ VU ${__VU} authentication failed, skipping iteration`);
-    authenticationAttempts.add(1);
-    return;
-  }
-
-  authenticationAttempts.add(1);
-  authenticationSuccesses.add(1);
-
-  // Run multiple library operations per iteration
-  for (let i = 0; i < REQUESTS_PER_VU; i++) {
-    console.log(
-      `🔄 VU ${__VU} starting library operation ${i + 1}/${REQUESTS_PER_VU}...`,
-    );
-    authenticatedLibraryJourney(headers);
-  }
-}
-
-function authenticatedLibraryJourney(headers) {
-  const journeyStart = Date.now();
-
-  // Step 1: Get user's library agents
-  console.log(`📖 VU ${__VU} fetching user library agents...`);
-  const libraryAgentsResponse = http.get(
-    `${BASE_URL}/api/library/agents?page=1&page_size=20`,
-    { headers },
-  );
-
-  libraryRequests.add(1);
-  const librarySuccess = check(libraryAgentsResponse, {
-    "Library agents endpoint returns 200": (r) => r.status === 200,
-    "Library agents response has data": (r) => {
-      try {
-        const json = r.json();
-        return json && json.agents && Array.isArray(json.agents);
-      } catch {
-        return false;
-      }
-    },
-    "Library agents response time < 10s": (r) => r.timings.duration < 10000,
-  });
-
-  if (librarySuccess) {
-    successfulRequests.add(1);
-  } else {
-    failedRequests.add(1);
-    console.log(
-      `⚠️ VU ${__VU} library agents request failed: ${libraryAgentsResponse.status} - ${libraryAgentsResponse.body}`,
-    );
-  }
-
-  // Step 2: Get favorite agents
-  console.log(`⭐ VU ${__VU} fetching favorite library agents...`);
-  const favoriteAgentsResponse = http.get(
-    `${BASE_URL}/api/library/agents/favorites?page=1&page_size=10`,
-    { headers },
-  );
-
-  libraryRequests.add(1);
-  const favoritesSuccess = check(favoriteAgentsResponse, {
-    "Favorite agents endpoint returns 200": (r) => r.status === 200,
-    "Favorite agents response has data": (r) => {
-      try {
-        const json = r.json();
-        return json && json.agents !== undefined && Array.isArray(json.agents);
-      } catch {
-        return false;
-      }
-    },
-    "Favorite agents response time < 10s": (r) => r.timings.duration < 10000,
-  });
-
-  if (favoritesSuccess) {
-    successfulRequests.add(1);
-  } else {
-    failedRequests.add(1);
-    console.log(
-      `⚠️ VU ${__VU} favorite agents request failed: ${favoriteAgentsResponse.status}`,
-    );
-  }
-
-  // Step 3: Add marketplace agent to library (simulate discovering and adding an agent)
-  console.log(`🛍️ VU ${__VU} browsing marketplace to add agent...`);
-
-  // First get available store agents to find one to add
-  const storeAgentsResponse = http.get(
-    `${BASE_URL}/api/store/agents?page=1&page_size=5`,
-  );
-
-  libraryRequests.add(1);
-  const storeAgentsSuccess = check(storeAgentsResponse, {
-    "Store agents endpoint returns 200": (r) => r.status === 200,
-    "Store agents response has data": (r) => {
-      try {
-        const json = r.json();
-        return (
-          json &&
-          json.agents &&
-          Array.isArray(json.agents) &&
-          json.agents.length > 0
-        );
-      } catch {
-        return false;
-      }
-    },
-  });
-
-  if (storeAgentsSuccess) {
-    successfulRequests.add(1);
-
-    try {
-      const storeAgentsJson = storeAgentsResponse.json();
-      if (storeAgentsJson?.agents && storeAgentsJson.agents.length > 0) {
-        const randomStoreAgent =
-          storeAgentsJson.agents[
-            Math.floor(Math.random() * storeAgentsJson.agents.length)
-          ];
-
-        if (randomStoreAgent?.store_listing_version_id) {
-          console.log(
-            `➕ VU ${__VU} adding agent "${randomStoreAgent.name || "Unknown"}" to library...`,
-          );
-
-          const addAgentPayload = {
-            store_listing_version_id: randomStoreAgent.store_listing_version_id,
-          };
-
-          const addAgentResponse = http.post(
-            `${BASE_URL}/api/library/agents`,
-            JSON.stringify(addAgentPayload),
-            { headers },
-          );
-
-          libraryRequests.add(1);
-          const addAgentSuccess = check(addAgentResponse, {
-            "Add agent returns 201 or 200 (created/already exists)": (r) =>
-              r.status === 201 || r.status === 200,
-            "Add agent response has id": (r) => {
-              try {
-                const json = r.json();
-                return json && json.id;
-              } catch {
-                return false;
-              }
-            },
-            "Add agent response time < 15s": (r) => r.timings.duration < 15000,
-          });
-
-          if (addAgentSuccess) {
-            successfulRequests.add(1);
-
-            // Step 4: Update the added agent (mark as favorite)
-            try {
-              const addedAgentJson = addAgentResponse.json();
-              if (addedAgentJson?.id) {
-                console.log(`⭐ VU ${__VU} marking agent as favorite...`);
-
-                const updatePayload = {
-                  is_favorite: true,
-                  auto_update_version: true,
-                };
-
-                const updateAgentResponse = http.patch(
-                  `${BASE_URL}/api/library/agents/${addedAgentJson.id}`,
-                  JSON.stringify(updatePayload),
-                  { headers },
-                );
-
-                libraryRequests.add(1);
-                const updateSuccess = check(updateAgentResponse, {
-                  "Update agent returns 200": (r) => r.status === 200,
-                  "Update agent response has updated data": (r) => {
-                    try {
-                      const json = r.json();
-                      return json && json.id && json.is_favorite === true;
-                    } catch {
-                      return false;
-                    }
-                  },
-                  "Update agent response time < 10s": (r) =>
-                    r.timings.duration < 10000,
-                });
-
-                if (updateSuccess) {
-                  successfulRequests.add(1);
-                } else {
-                  failedRequests.add(1);
-                  console.log(
-                    `⚠️ VU ${__VU} update agent failed: ${updateAgentResponse.status}`,
-                  );
-                }
-
-                // Step 5: Get specific library agent details
-                console.log(`📄 VU ${__VU} fetching agent details...`);
-                const agentDetailsResponse = http.get(
-                  `${BASE_URL}/api/library/agents/${addedAgentJson.id}`,
-                  { headers },
-                );
-
-                libraryRequests.add(1);
-                const detailsSuccess = check(agentDetailsResponse, {
-                  "Agent details returns 200": (r) => r.status === 200,
-                  "Agent details response has complete data": (r) => {
-                    try {
-                      const json = r.json();
-                      return json && json.id && json.name && json.graph_id;
-                    } catch {
-                      return false;
-                    }
-                  },
-                  "Agent details response time < 10s": (r) =>
-                    r.timings.duration < 10000,
-                });
-
-                if (detailsSuccess) {
-                  successfulRequests.add(1);
-                } else {
-                  failedRequests.add(1);
-                  console.log(
-                    `⚠️ VU ${__VU} agent details failed: ${agentDetailsResponse.status}`,
-                  );
-                }
-
-                // Step 6: Fork the library agent (simulate user customization)
-                console.log(`🍴 VU ${__VU} forking agent for customization...`);
-                const forkAgentResponse = http.post(
-                  `${BASE_URL}/api/library/agents/${addedAgentJson.id}/fork`,
-                  "",
-                  { headers },
-                );
-
-                libraryRequests.add(1);
-                const forkSuccess = check(forkAgentResponse, {
-                  "Fork agent returns 200": (r) => r.status === 200,
-                  "Fork agent response has new agent data": (r) => {
-                    try {
-                      const json = r.json();
-                      return json && json.id && json.id !== addedAgentJson.id; // Should be different ID
-                    } catch {
-                      return false;
-                    }
-                  },
-                  "Fork agent response time < 15s": (r) =>
-                    r.timings.duration < 15000,
-                });
-
-                if (forkSuccess) {
-                  successfulRequests.add(1);
-                } else {
-                  failedRequests.add(1);
-                  console.log(
-                    `⚠️ VU ${__VU} fork agent failed: ${forkAgentResponse.status}`,
-                  );
-                }
-              }
-            } catch (e) {
-              console.warn(
-                `⚠️ VU ${__VU} failed to parse added agent response: ${e}`,
-              );
-              failedRequests.add(1);
-            }
-          } else {
-            failedRequests.add(1);
-            console.log(
-              `⚠️ VU ${__VU} add agent failed: ${addAgentResponse.status} - ${addAgentResponse.body}`,
-            );
-          }
-        }
-      }
-    } catch (e) {
-      console.warn(`⚠️ VU ${__VU} failed to parse store agents data: ${e}`);
-      failedRequests.add(1);
-    }
-  } else {
-    failedRequests.add(1);
-    console.log(
-      `⚠️ VU ${__VU} store agents request failed: ${storeAgentsResponse.status}`,
-    );
-  }
-
-  // Step 7: Search library agents
-  const searchTerms = ["automation", "api", "data", "social", "productivity"];
-  const randomSearchTerm =
-    searchTerms[Math.floor(Math.random() * searchTerms.length)];
-
-  console.log(`🔍 VU ${__VU} searching library for "${randomSearchTerm}"...`);
-  const searchLibraryResponse = http.get(
-    `${BASE_URL}/api/library/agents?search_term=${encodeURIComponent(randomSearchTerm)}&page=1&page_size=10`,
-    { headers },
-  );
-
-  libraryRequests.add(1);
-  const searchLibrarySuccess = check(searchLibraryResponse, {
-    "Search library returns 200": (r) => r.status === 200,
-    "Search library response has data": (r) => {
-      try {
-        const json = r.json();
-        return json && json.agents !== undefined && Array.isArray(json.agents);
-      } catch {
-        return false;
-      }
-    },
-    "Search library response time < 10s": (r) => r.timings.duration < 10000,
-  });
-
-  if (searchLibrarySuccess) {
-    successfulRequests.add(1);
-  } else {
-    failedRequests.add(1);
-    console.log(
-      `⚠️ VU ${__VU} search library failed: ${searchLibraryResponse.status}`,
-    );
-  }
-
-  // Step 8: Get library agent by graph ID (simulate finding agent by backend graph)
-  if (libraryAgentsResponse.status === 200) {
-    try {
-      const libraryJson = libraryAgentsResponse.json();
-      if (libraryJson?.agents && libraryJson.agents.length > 0) {
-        const randomLibraryAgent =
-          libraryJson.agents[
-            Math.floor(Math.random() * libraryJson.agents.length)
-          ];
-
-        if (randomLibraryAgent?.graph_id) {
-          console.log(
-            `🔗 VU ${__VU} fetching agent by graph ID "${randomLibraryAgent.graph_id}"...`,
-          );
-          const agentByGraphResponse = http.get(
-            `${BASE_URL}/api/library/agents/by-graph/${randomLibraryAgent.graph_id}`,
-            { headers },
-          );
-
-          libraryRequests.add(1);
-          const agentByGraphSuccess = check(agentByGraphResponse, {
-            "Agent by graph ID returns 200": (r) => r.status === 200,
-            "Agent by graph response has data": (r) => {
-              try {
-                const json = r.json();
-                return (
-                  json &&
-                  json.id &&
-                  json.graph_id === randomLibraryAgent.graph_id
-                );
-              } catch {
-                return false;
-              }
-            },
-            "Agent by graph response time < 10s": (r) =>
-              r.timings.duration < 10000,
-          });
-
-          if (agentByGraphSuccess) {
-            successfulRequests.add(1);
-          } else {
-            failedRequests.add(1);
-            console.log(
-              `⚠️ VU ${__VU} agent by graph request failed: ${agentByGraphResponse.status}`,
-            );
-          }
-        }
-      }
-    } catch (e) {
-      console.warn(
-        `⚠️ VU ${__VU} failed to parse library agents for graph lookup: ${e}`,
-      );
-      failedRequests.add(1);
-    }
-  }
-
-  const journeyDuration = Date.now() - journeyStart;
-  console.log(
-    `✅ VU ${__VU} completed authenticated library journey in ${journeyDuration}ms`,
-  );
-}
-
-export function handleSummary(data) {
-  const summary = {
-    test_type: "Marketplace Library Authorized Access Load Test",
-    environment: __ENV.K6_ENVIRONMENT || "DEV",
-    configuration: {
-      virtual_users: VUS,
-      duration: DURATION,
-      ramp_up: RAMP_UP,
-      ramp_down: RAMP_DOWN,
-      requests_per_vu: REQUESTS_PER_VU,
-    },
-    performance_metrics: {
-      total_requests: data.metrics.http_reqs?.count || 0,
-      failed_requests: data.metrics.http_req_failed?.values?.passes || 0,
-      avg_response_time: data.metrics.http_req_duration?.values?.avg || 0,
-      p95_response_time: data.metrics.http_req_duration?.values?.p95 || 0,
-      p99_response_time: data.metrics.http_req_duration?.values?.p99 || 0,
-    },
-    custom_metrics: {
-      library_requests: data.metrics.library_requests_total?.values?.count || 0,
-      successful_requests:
-        data.metrics.successful_requests_total?.values?.count || 0,
-      failed_requests: data.metrics.failed_requests_total?.values?.count || 0,
-      authentication_attempts:
-        data.metrics.authentication_attempts_total?.values?.count || 0,
-      authentication_successes:
-        data.metrics.authentication_successes_total?.values?.count || 0,
-    },
-    thresholds_met: {
-      p95_threshold:
-        (data.metrics.http_req_duration?.values?.p95 || 0) < THRESHOLD_P95,
-      p99_threshold:
-        (data.metrics.http_req_duration?.values?.p99 || 0) < THRESHOLD_P99,
-      error_rate_threshold:
-        (data.metrics.http_req_failed?.values?.rate || 0) <
-        THRESHOLD_ERROR_RATE,
-      check_rate_threshold:
-        (data.metrics.checks?.values?.rate || 0) > THRESHOLD_CHECK_RATE,
-    },
-    authentication_metrics: {
-      auth_success_rate:
-        (data.metrics.authentication_successes_total?.values?.count || 0) /
-        Math.max(
-          1,
-          data.metrics.authentication_attempts_total?.values?.count || 0,
-        ),
-    },
-    user_journey_coverage: [
-      "Authenticate with valid credentials",
-      "Fetch user library agents",
-      "Browse favorite library agents",
-      "Discover marketplace agents",
-      "Add marketplace agent to library",
-      "Update agent preferences (favorites)",
-      "View detailed agent information",
-      "Fork agent for customization",
-      "Search library agents by term",
-      "Lookup agent by graph ID",
-    ],
-  };
-
-  console.log("\n📚 MARKETPLACE LIBRARY AUTHORIZED TEST SUMMARY");
-  console.log("==============================================");
-  console.log(`Environment: ${summary.environment}`);
-  console.log(`Virtual Users: ${summary.configuration.virtual_users}`);
-  console.log(`Duration: ${summary.configuration.duration}`);
-  console.log(`Requests per VU: ${summary.configuration.requests_per_vu}`);
-  console.log(`Total Requests: ${summary.performance_metrics.total_requests}`);
-  console.log(
-    `Successful Requests: ${summary.custom_metrics.successful_requests}`,
-  );
-  console.log(`Failed Requests: ${summary.custom_metrics.failed_requests}`);
-  console.log(
-    `Auth Success Rate: ${Math.round(summary.authentication_metrics.auth_success_rate * 100)}%`,
-  );
-  console.log(
-    `Average Response Time: ${Math.round(summary.performance_metrics.avg_response_time)}ms`,
-  );
-  console.log(
-    `95th Percentile: ${Math.round(summary.performance_metrics.p95_response_time)}ms`,
-  );
-  console.log(
-    `99th Percentile: ${Math.round(summary.performance_metrics.p99_response_time)}ms`,
-  );
-
-  console.log("\n🎯 Threshold Status:");
-  console.log(
-    `P95 < ${THRESHOLD_P95}ms: ${summary.thresholds_met.p95_threshold ? "✅" : "❌"}`,
-  );
-  console.log(
-    `P99 < ${THRESHOLD_P99}ms: ${summary.thresholds_met.p99_threshold ? "✅" : "❌"}`,
-  );
-  console.log(
-    `Error Rate < ${THRESHOLD_ERROR_RATE * 100}%: ${summary.thresholds_met.error_rate_threshold ? "✅" : "❌"}`,
-  );
-  console.log(
-    `Check Rate > ${THRESHOLD_CHECK_RATE * 100}%: ${summary.thresholds_met.check_rate_threshold ? "✅" : "❌"}`,
-  );
-
-  return {
-    stdout: JSON.stringify(summary, null, 2),
-  };
-}

autogpt_platform/backend/load-tests/tests/marketplace/public-access-test.js

@@ -1,465 +0,0 @@
-import { check } from "k6";
-import http from "k6/http";
-import { Counter } from "k6/metrics";
-
-import { getEnvironmentConfig } from "../../configs/environment.js";
-
-const config = getEnvironmentConfig();
-const BASE_URL = config.API_BASE_URL;
-
-// Custom metrics
-const marketplaceRequests = new Counter("marketplace_requests_total");
-const successfulRequests = new Counter("successful_requests_total");
-const failedRequests = new Counter("failed_requests_total");
-
-// HTTP error tracking
-const httpErrors = new Counter("http_errors_by_status");
-
-// Enhanced error logging function
-function logHttpError(response, endpoint, method = "GET") {
-  if (response.status !== 200) {
-    console.error(
-      `❌ VU ${__VU} ${method} ${endpoint} failed: status=${response.status}, error=${response.error || "unknown"}, body=${response.body ? response.body.substring(0, 200) : "empty"}`,
-    );
-    httpErrors.add(1, {
-      status: response.status,
-      endpoint: endpoint,
-      method: method,
-    });
-  }
-}
-
-// Test configuration
-const VUS = parseInt(__ENV.VUS) || 10;
-const DURATION = __ENV.DURATION || "2m";
-const RAMP_UP = __ENV.RAMP_UP || "30s";
-const RAMP_DOWN = __ENV.RAMP_DOWN || "30s";
-
-// Performance thresholds for marketplace browsing
-const REQUEST_TIMEOUT = 60000; // 60s per request timeout
-const THRESHOLD_P95 = parseInt(__ENV.THRESHOLD_P95) || 5000; // 5s for public endpoints
-const THRESHOLD_P99 = parseInt(__ENV.THRESHOLD_P99) || 10000; // 10s for public endpoints
-const THRESHOLD_ERROR_RATE = parseFloat(__ENV.THRESHOLD_ERROR_RATE) || 0.05; // 5% error rate
-const THRESHOLD_CHECK_RATE = parseFloat(__ENV.THRESHOLD_CHECK_RATE) || 0.95; // 95% success rate
-
-export const options = {
-  stages: [
-    { duration: RAMP_UP, target: VUS },
-    { duration: DURATION, target: VUS },
-    { duration: RAMP_DOWN, target: 0 },
-  ],
-  // Thresholds disabled to collect all results regardless of performance
-  // thresholds: {
-  //   http_req_duration: [
-  //     { threshold: `p(95)<${THRESHOLD_P95}`, abortOnFail: false },
-  //     { threshold: `p(99)<${THRESHOLD_P99}`, abortOnFail: false },
-  //   ],
-  //   http_req_failed: [{ threshold: `rate<${THRESHOLD_ERROR_RATE}`, abortOnFail: false }],
-  //   checks: [{ threshold: `rate>${THRESHOLD_CHECK_RATE}`, abortOnFail: false }],
-  // },
-  tags: {
-    test_type: "marketplace_public_access",
-    environment: __ENV.K6_ENVIRONMENT || "DEV",
-  },
-};
-
-export default function () {
-  console.log(`🛒 VU ${__VU} starting marketplace browsing journey...`);
-
-  // Simulate realistic user marketplace browsing journey
-  marketplaceBrowsingJourney();
-}
-
-function marketplaceBrowsingJourney() {
-  const journeyStart = Date.now();
-
-  // Step 1: Browse marketplace homepage - get featured agents
-  console.log(`🏪 VU ${__VU} browsing marketplace homepage...`);
-  const featuredAgentsResponse = http.get(
-    `${BASE_URL}/api/store/agents?featured=true&page=1&page_size=10`,
-  );
-  logHttpError(
-    featuredAgentsResponse,
-    "/api/store/agents?featured=true",
-    "GET",
-  );
-
-  marketplaceRequests.add(1);
-  const featuredSuccess = check(featuredAgentsResponse, {
-    "Featured agents endpoint returns 200": (r) => r.status === 200,
-    "Featured agents response has data": (r) => {
-      try {
-        const json = r.json();
-        return json && json.agents && Array.isArray(json.agents);
-      } catch {
-        return false;
-      }
-    },
-    "Featured agents responds within 60s": (r) =>
-      r.timings.duration < REQUEST_TIMEOUT,
-  });
-
-  if (featuredSuccess) {
-    successfulRequests.add(1);
-  } else {
-    failedRequests.add(1);
-  }
-
-  // Step 2: Browse all agents with pagination
-  console.log(`📋 VU ${__VU} browsing all agents...`);
-  const allAgentsResponse = http.get(
-    `${BASE_URL}/api/store/agents?page=1&page_size=20`,
-  );
-  logHttpError(allAgentsResponse, "/api/store/agents", "GET");
-
-  marketplaceRequests.add(1);
-  const allAgentsSuccess = check(allAgentsResponse, {
-    "All agents endpoint returns 200": (r) => r.status === 200,
-    "All agents response has data": (r) => {
-      try {
-        const json = r.json();
-        return (
-          json &&
-          json.agents &&
-          Array.isArray(json.agents) &&
-          json.agents.length > 0
-        );
-      } catch {
-        return false;
-      }
-    },
-    "All agents responds within 60s": (r) =>
-      r.timings.duration < REQUEST_TIMEOUT,
-  });
-
-  if (allAgentsSuccess) {
-    successfulRequests.add(1);
-  } else {
-    failedRequests.add(1);
-  }
-
-  // Step 3: Search for specific agents
-  const searchQueries = [
-    "automation",
-    "social media",
-    "data analysis",
-    "productivity",
-  ];
-  const randomQuery =
-    searchQueries[Math.floor(Math.random() * searchQueries.length)];
-
-  console.log(`🔍 VU ${__VU} searching for "${randomQuery}" agents...`);
-  const searchResponse = http.get(
-    `${BASE_URL}/api/store/agents?search_query=${encodeURIComponent(randomQuery)}&page=1&page_size=10`,
-  );
-  logHttpError(searchResponse, "/api/store/agents (search)", "GET");
-
-  marketplaceRequests.add(1);
-  const searchSuccess = check(searchResponse, {
-    "Search agents endpoint returns 200": (r) => r.status === 200,
-    "Search agents response has data": (r) => {
-      try {
-        const json = r.json();
-        return json && json.agents && Array.isArray(json.agents);
-      } catch {
-        return false;
-      }
-    },
-    "Search agents responds within 60s": (r) =>
-      r.timings.duration < REQUEST_TIMEOUT,
-  });
-
-  if (searchSuccess) {
-    successfulRequests.add(1);
-  } else {
-    failedRequests.add(1);
-  }
-
-  // Step 4: Browse agents by category
-  const categories = ["AI", "PRODUCTIVITY", "COMMUNICATION", "DATA", "SOCIAL"];
-  const randomCategory =
-    categories[Math.floor(Math.random() * categories.length)];
-
-  console.log(`📂 VU ${__VU} browsing "${randomCategory}" category...`);
-  const categoryResponse = http.get(
-    `${BASE_URL}/api/store/agents?category=${randomCategory}&page=1&page_size=15`,
-  );
-  logHttpError(categoryResponse, "/api/store/agents (category)", "GET");
-
-  marketplaceRequests.add(1);
-  const categorySuccess = check(categoryResponse, {
-    "Category agents endpoint returns 200": (r) => r.status === 200,
-    "Category agents response has data": (r) => {
-      try {
-        const json = r.json();
-        return json && json.agents && Array.isArray(json.agents);
-      } catch {
-        return false;
-      }
-    },
-    "Category agents responds within 60s": (r) =>
-      r.timings.duration < REQUEST_TIMEOUT,
-  });
-
-  if (categorySuccess) {
-    successfulRequests.add(1);
-  } else {
-    failedRequests.add(1);
-  }
-
-  // Step 5: Get specific agent details (simulate clicking on an agent)
-  if (allAgentsResponse.status === 200) {
-    try {
-      const allAgentsJson = allAgentsResponse.json();
-      if (allAgentsJson?.agents && allAgentsJson.agents.length > 0) {
-        const randomAgent =
-          allAgentsJson.agents[
-            Math.floor(Math.random() * allAgentsJson.agents.length)
-          ];
-
-        if (randomAgent?.creator_username && randomAgent?.slug) {
-          console.log(
-            `📄 VU ${__VU} viewing agent details for "${randomAgent.slug}"...`,
-          );
-          const agentDetailsResponse = http.get(
-            `${BASE_URL}/api/store/agents/${encodeURIComponent(randomAgent.creator_username)}/${encodeURIComponent(randomAgent.slug)}`,
-          );
-          logHttpError(
-            agentDetailsResponse,
-            "/api/store/agents/{creator}/{slug}",
-            "GET",
-          );
-
-          marketplaceRequests.add(1);
-          const agentDetailsSuccess = check(agentDetailsResponse, {
-            "Agent details endpoint returns 200": (r) => r.status === 200,
-            "Agent details response has data": (r) => {
-              try {
-                const json = r.json();
-                return json && json.id && json.name && json.description;
-              } catch {
-                return false;
-              }
-            },
-            "Agent details responds within 60s": (r) =>
-              r.timings.duration < REQUEST_TIMEOUT,
-          });
-
-          if (agentDetailsSuccess) {
-            successfulRequests.add(1);
-          } else {
-            failedRequests.add(1);
-          }
-        }
-      }
-    } catch (e) {
-      console.warn(
-        `⚠️ VU ${__VU} failed to parse agents data for details lookup: ${e}`,
-      );
-      failedRequests.add(1);
-    }
-  }
-
-  // Step 6: Browse creators
-  console.log(`👥 VU ${__VU} browsing creators...`);
-  const creatorsResponse = http.get(
-    `${BASE_URL}/api/store/creators?page=1&page_size=20`,
-  );
-  logHttpError(creatorsResponse, "/api/store/creators", "GET");
-
-  marketplaceRequests.add(1);
-  const creatorsSuccess = check(creatorsResponse, {
-    "Creators endpoint returns 200": (r) => r.status === 200,
-    "Creators response has data": (r) => {
-      try {
-        const json = r.json();
-        return json && json.creators && Array.isArray(json.creators);
-      } catch {
-        return false;
-      }
-    },
-    "Creators responds within 60s": (r) => r.timings.duration < REQUEST_TIMEOUT,
-  });
-
-  if (creatorsSuccess) {
-    successfulRequests.add(1);
-  } else {
-    failedRequests.add(1);
-  }
-
-  // Step 7: Get featured creators
-  console.log(`⭐ VU ${__VU} browsing featured creators...`);
-  const featuredCreatorsResponse = http.get(
-    `${BASE_URL}/api/store/creators?featured=true&page=1&page_size=10`,
-  );
-  logHttpError(
-    featuredCreatorsResponse,
-    "/api/store/creators?featured=true",
-    "GET",
-  );
-
-  marketplaceRequests.add(1);
-  const featuredCreatorsSuccess = check(featuredCreatorsResponse, {
-    "Featured creators endpoint returns 200": (r) => r.status === 200,
-    "Featured creators response has data": (r) => {
-      try {
-        const json = r.json();
-        return json && json.creators && Array.isArray(json.creators);
-      } catch {
-        return false;
-      }
-    },
-    "Featured creators responds within 60s": (r) =>
-      r.timings.duration < REQUEST_TIMEOUT,
-  });
-
-  if (featuredCreatorsSuccess) {
-    successfulRequests.add(1);
-  } else {
-    failedRequests.add(1);
-  }
-
-  // Step 8: Get specific creator details (simulate clicking on a creator)
-  if (creatorsResponse.status === 200) {
-    try {
-      const creatorsJson = creatorsResponse.json();
-      if (creatorsJson?.creators && creatorsJson.creators.length > 0) {
-        const randomCreator =
-          creatorsJson.creators[
-            Math.floor(Math.random() * creatorsJson.creators.length)
-          ];
-
-        if (randomCreator?.username) {
-          console.log(
-            `👤 VU ${__VU} viewing creator details for "${randomCreator.username}"...`,
-          );
-          const creatorDetailsResponse = http.get(
-            `${BASE_URL}/api/store/creator/${encodeURIComponent(randomCreator.username)}`,
-          );
-          logHttpError(
-            creatorDetailsResponse,
-            "/api/store/creator/{username}",
-            "GET",
-          );
-
-          marketplaceRequests.add(1);
-          const creatorDetailsSuccess = check(creatorDetailsResponse, {
-            "Creator details endpoint returns 200": (r) => r.status === 200,
-            "Creator details response has data": (r) => {
-              try {
-                const json = r.json();
-                return json && json.username && json.description !== undefined;
-              } catch {
-                return false;
-              }
-            },
-            "Creator details responds within 60s": (r) =>
-              r.timings.duration < REQUEST_TIMEOUT,
-          });
-
-          if (creatorDetailsSuccess) {
-            successfulRequests.add(1);
-          } else {
-            failedRequests.add(1);
-          }
-        }
-      }
-    } catch (e) {
-      console.warn(
-        `⚠️ VU ${__VU} failed to parse creators data for details lookup: ${e}`,
-      );
-      failedRequests.add(1);
-    }
-  }
-
-  const journeyDuration = Date.now() - journeyStart;
-  console.log(
-    `✅ VU ${__VU} completed marketplace browsing journey in ${journeyDuration}ms`,
-  );
-}
-
-export function handleSummary(data) {
-  const summary = {
-    test_type: "Marketplace Public Access Load Test",
-    environment: __ENV.K6_ENVIRONMENT || "DEV",
-    configuration: {
-      virtual_users: VUS,
-      duration: DURATION,
-      ramp_up: RAMP_UP,
-      ramp_down: RAMP_DOWN,
-    },
-    performance_metrics: {
-      total_requests: data.metrics.http_reqs?.count || 0,
-      failed_requests: data.metrics.http_req_failed?.values?.passes || 0,
-      avg_response_time: data.metrics.http_req_duration?.values?.avg || 0,
-      p95_response_time: data.metrics.http_req_duration?.values?.p95 || 0,
-      p99_response_time: data.metrics.http_req_duration?.values?.p99 || 0,
-    },
-    custom_metrics: {
-      marketplace_requests:
-        data.metrics.marketplace_requests_total?.values?.count || 0,
-      successful_requests:
-        data.metrics.successful_requests_total?.values?.count || 0,
-      failed_requests: data.metrics.failed_requests_total?.values?.count || 0,
-    },
-    thresholds_met: {
-      p95_threshold:
-        (data.metrics.http_req_duration?.values?.p95 || 0) < THRESHOLD_P95,
-      p99_threshold:
-        (data.metrics.http_req_duration?.values?.p99 || 0) < THRESHOLD_P99,
-      error_rate_threshold:
-        (data.metrics.http_req_failed?.values?.rate || 0) <
-        THRESHOLD_ERROR_RATE,
-      check_rate_threshold:
-        (data.metrics.checks?.values?.rate || 0) > THRESHOLD_CHECK_RATE,
-    },
-    user_journey_coverage: [
-      "Browse featured agents",
-      "Browse all agents with pagination",
-      "Search agents by keywords",
-      "Filter agents by category",
-      "View specific agent details",
-      "Browse creators directory",
-      "View featured creators",
-      "View specific creator details",
-    ],
-  };
-
-  console.log("\n📊 MARKETPLACE PUBLIC ACCESS TEST SUMMARY");
-  console.log("==========================================");
-  console.log(`Environment: ${summary.environment}`);
-  console.log(`Virtual Users: ${summary.configuration.virtual_users}`);
-  console.log(`Duration: ${summary.configuration.duration}`);
-  console.log(`Total Requests: ${summary.performance_metrics.total_requests}`);
-  console.log(
-    `Successful Requests: ${summary.custom_metrics.successful_requests}`,
-  );
-  console.log(`Failed Requests: ${summary.custom_metrics.failed_requests}`);
-  console.log(
-    `Average Response Time: ${Math.round(summary.performance_metrics.avg_response_time)}ms`,
-  );
-  console.log(
-    `95th Percentile: ${Math.round(summary.performance_metrics.p95_response_time)}ms`,
-  );
-  console.log(
-    `99th Percentile: ${Math.round(summary.performance_metrics.p99_response_time)}ms`,
-  );
-
-  console.log("\n🎯 Threshold Status:");
-  console.log(
-    `P95 < ${THRESHOLD_P95}ms: ${summary.thresholds_met.p95_threshold ? "✅" : "❌"}`,
-  );
-  console.log(
-    `P99 < ${THRESHOLD_P99}ms: ${summary.thresholds_met.p99_threshold ? "✅" : "❌"}`,
-  );
-  console.log(
-    `Error Rate < ${THRESHOLD_ERROR_RATE * 100}%: ${summary.thresholds_met.error_rate_threshold ? "✅" : "❌"}`,
-  );
-  console.log(
-    `Check Rate > ${THRESHOLD_CHECK_RATE * 100}%: ${summary.thresholds_met.check_rate_threshold ? "✅" : "❌"}`,
-  );
-
-  return {
-    stdout: JSON.stringify(summary, null, 2),
-  };
-}

autogpt_platform/backend/migrations/20250910161617_fix_store_materialized_views_refresh_job/migration.sql

@@ -1,66 +0,0 @@
--- Fixes the refresh function+job introduced in 20250604130249_optimise_store_agent_and_creator_views
--- by improving the function to accept a schema parameter and updating the cron job to use it.
--- This resolves the issue where pg_cron jobs fail because they run in 'public' schema
--- but the materialized views exist in 'platform' schema.
-
-
--- Create parameterized refresh function that accepts schema name
-CREATE OR REPLACE FUNCTION refresh_store_materialized_views()
-RETURNS void
-LANGUAGE plpgsql
-AS $$
-DECLARE
-    target_schema text := current_schema();  -- Use the current schema where the function is called
-BEGIN
-    -- Use CONCURRENTLY for better performance during refresh
-    REFRESH MATERIALIZED VIEW CONCURRENTLY "mv_agent_run_counts";
-    REFRESH MATERIALIZED VIEW CONCURRENTLY "mv_review_stats";
-    RAISE NOTICE 'Materialized views refreshed in schema % at %', target_schema, NOW();
-EXCEPTION
-    WHEN OTHERS THEN
-        -- Fallback to non-concurrent refresh if concurrent fails
-        REFRESH MATERIALIZED VIEW "mv_agent_run_counts";
-        REFRESH MATERIALIZED VIEW "mv_review_stats";
-        RAISE NOTICE 'Materialized views refreshed (non-concurrent) in schema % at %. Concurrent refresh failed due to: %', target_schema, NOW(), SQLERRM;
-END;
-$$;
-
--- Initial refresh + test of the function to ensure it works
-SELECT refresh_store_materialized_views();
-
--- Re-create the cron job to use the improved function
-DO $$
-DECLARE
-    has_pg_cron BOOLEAN;
-    current_schema_name text := current_schema();
-    old_job_name text;
-    job_name text;
-BEGIN
-    -- Check if pg_cron extension exists
-    SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_cron') INTO has_pg_cron;
-
-    IF has_pg_cron THEN
-        old_job_name := format('refresh-store-views-%s', current_schema_name);
-        job_name := format('refresh-store-views_%s', current_schema_name);
-
-        -- Try to unschedule existing job (ignore errors if it doesn't exist)
-        BEGIN
-            PERFORM cron.unschedule(old_job_name);
-        EXCEPTION WHEN OTHERS THEN
-            NULL;
-        END;
-
-        -- Schedule the new job with explicit schema parameter
-        PERFORM cron.schedule(
-            job_name,
-            '*/15 * * * *',
-            format('SET search_path TO %I; SELECT refresh_store_materialized_views();', current_schema_name)
-        );
-        RAISE NOTICE 'Scheduled job %; runs every 15 minutes for schema %', job_name, current_schema_name;
-    ELSE
-        RAISE WARNING '⚠️  Automatic refresh NOT configured - pg_cron is not available';
-        RAISE WARNING '⚠️  You must manually refresh views with: SELECT refresh_store_materialized_views();';
-        RAISE WARNING '⚠️  Or install pg_cron for automatic refresh in production';
-    END IF;
-END;
-$$;

autogpt_platform/backend/migrations/20250912164006_keep_credit_transactions_on_user_delete/migration.sql

@@ -1,3 +0,0 @@
--- Re-create foreign key CreditTransaction <- User with ON DELETE NO ACTION
-ALTER TABLE "CreditTransaction" DROP CONSTRAINT "CreditTransaction_userId_fkey";
-ALTER TABLE "CreditTransaction" ADD CONSTRAINT "CreditTransaction_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE NO ACTION ON UPDATE CASCADE;

autogpt_platform/backend/migrations/20250916191832_add_share_page/migration.sql

@@ -1,22 +0,0 @@
-/*
-  Warnings:
-
-  - A unique constraint covering the columns `[shareToken]` on the table `AgentGraphExecution` will be added. If there are existing duplicate values, this will fail.
-
-*/
--- AlterTable
-ALTER TABLE "AgentGraphExecution" ADD COLUMN     "isShared" BOOLEAN NOT NULL DEFAULT false,
-ADD COLUMN     "shareToken" TEXT,
-ADD COLUMN     "sharedAt" TIMESTAMP(3);
-
--- CreateIndex
-CREATE UNIQUE INDEX "AgentGraphExecution_shareToken_key" ON "AgentGraphExecution"("shareToken");
-
--- CreateIndex
-CREATE INDEX "AgentGraphExecution_shareToken_idx" ON "AgentGraphExecution"("shareToken");
-
--- RenameIndex
-ALTER INDEX "APIKey_key_key" RENAME TO "APIKey_hash_key";
-
--- RenameIndex
-ALTER INDEX "APIKey_prefix_name_idx" RENAME TO "APIKey_head_name_idx";

autogpt_platform/backend/migrations/20250916193100_add_instructions_field/migration.sql

@@ -1,53 +0,0 @@
--- Add instructions field to AgentGraph and StoreListingVersion tables and update StoreSubmission view
-
-BEGIN;
-
--- AddColumn
-ALTER TABLE "AgentGraph" ADD COLUMN     "instructions" TEXT;
-
--- AddColumn  
-ALTER TABLE "StoreListingVersion" ADD COLUMN     "instructions" TEXT;
-
--- Drop the existing view
-DROP VIEW IF EXISTS "StoreSubmission";
-
--- Recreate the view with the new instructions field
-CREATE VIEW "StoreSubmission" AS
-SELECT
-    sl.id AS listing_id,
-    sl."owningUserId" AS user_id,
-    slv."agentGraphId" AS agent_id,
-    slv.version AS agent_version,
-    sl.slug,
-    COALESCE(slv.name, '') AS name,
-    slv."subHeading" AS sub_heading,
-    slv.description,
-    slv.instructions,
-    slv."imageUrls" AS image_urls,
-    slv."submittedAt" AS date_submitted,
-    slv."submissionStatus" AS status,
-    COALESCE(ar.run_count, 0::bigint) AS runs,
-    COALESCE(avg(sr.score::numeric), 0.0)::double precision AS rating,
-    slv.id AS store_listing_version_id,
-    slv."reviewerId" AS reviewer_id,
-    slv."reviewComments" AS review_comments,
-    slv."internalComments" AS internal_comments,
-    slv."reviewedAt" AS reviewed_at,
-    slv."changesSummary" AS changes_summary,
-    slv."videoUrl" AS video_url,
-    slv.categories
-FROM "StoreListing" sl
-    JOIN "StoreListingVersion" slv ON slv."storeListingId" = sl.id
-    LEFT JOIN "StoreListingReview" sr ON sr."storeListingVersionId" = slv.id
-    LEFT JOIN (
-        SELECT "AgentGraphExecution"."agentGraphId", count(*) AS run_count
-        FROM "AgentGraphExecution"
-        GROUP BY "AgentGraphExecution"."agentGraphId"
-    ) ar ON ar."agentGraphId" = slv."agentGraphId"
-WHERE sl."isDeleted" = false
-GROUP BY sl.id, sl."owningUserId", slv.id, slv."agentGraphId", slv.version, sl.slug, slv.name,
-         slv."subHeading", slv.description, slv.instructions, slv."imageUrls", slv."submittedAt",
-         slv."submissionStatus", slv."reviewerId", slv."reviewComments", slv."internalComments",
-         slv."reviewedAt", slv."changesSummary", slv."videoUrl", slv.categories, ar.run_count;
-
-COMMIT;

autogpt_platform/backend/migrations/20250924230049_enhance_graph_and_execution_index/migration.sql

@@ -1,11 +0,0 @@
--- DropIndex
-DROP INDEX "AgentGraph_userId_isActive_idx";
-
--- DropIndex
-DROP INDEX "AgentGraphExecution_userId_idx";
-
--- CreateIndex
-CREATE INDEX "AgentGraph_userId_isActive_id_version_idx" ON "AgentGraph"("userId", "isActive", "id", "version");
-
--- CreateIndex
-CREATE INDEX "AgentGraphExecution_userId_isDeleted_createdAt_idx" ON "AgentGraphExecution"("userId", "isDeleted", "createdAt");

autogpt_platform/backend/poetry.lock

@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 2.1.4 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.1.1 and should not be changed by hand.
 
 [[package]]
 name = "aio-pika"
@@ -338,7 +338,7 @@ description = "LTS Port of Python audioop"
 optional = false
 python-versions = ">=3.13"
 groups = ["main"]
-markers = "python_version == \"3.13\""
+markers = "python_version >= \"3.13\""
 files = [
     {file = "audioop_lts-0.2.2-cp313-abi3-macosx_10_13_universal2.whl", hash = "sha256:fd3d4602dc64914d462924a08c1a9816435a2155d74f325853c1f1ac3b2d9800"},
     {file = "audioop_lts-0.2.2-cp313-abi3-macosx_10_13_x86_64.whl", hash = "sha256:550c114a8df0aafe9a05442a1162dfc8fec37e9af1d625ae6060fed6e756f303"},
@@ -438,7 +438,7 @@ description = "Backport of asyncio.Runner, a context manager that controls event
 optional = false
 python-versions = "<3.11,>=3.8"
 groups = ["main"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 files = [
     {file = "backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5"},
     {file = "backports_asyncio_runner-1.2.0.tar.gz", hash = "sha256:a5aa7b2b7d8f8bfcaa2b57313f70792df84e32a2a746f585213373f900b42162"},
@@ -451,7 +451,7 @@ description = "Backport of CPython tarfile module"
 optional = false
 python-versions = ">=3.8"
 groups = ["main"]
-markers = "python_version < \"3.12\""
+markers = "python_version <= \"3.11\""
 files = [
     {file = "backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34"},
     {file = "backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991"},
@@ -1215,7 +1215,7 @@ files = [
     {file = "exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10"},
     {file = "exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88"},
 ]
-markers = {dev = "python_version == \"3.10\""}
+markers = {dev = "python_version < \"3.11\""}
 
 [package.dependencies]
 typing-extensions = {version = ">=4.6.0", markers = "python_version < \"3.13\""}
@@ -1581,16 +1581,16 @@ files = [
 google-auth = ">=2.14.1,<3.0.0"
 googleapis-common-protos = ">=1.56.2,<2.0.0"
 grpcio = [
-    {version = ">=1.49.1,<2.0.0", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""},
     {version = ">=1.33.2,<2.0.0", optional = true, markers = "extra == \"grpc\""},
+    {version = ">=1.49.1,<2.0.0", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""},
 ]
 grpcio-status = [
-    {version = ">=1.49.1,<2.0.0", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""},
     {version = ">=1.33.2,<2.0.0", optional = true, markers = "extra == \"grpc\""},
+    {version = ">=1.49.1,<2.0.0", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""},
 ]
 proto-plus = [
-    {version = ">=1.25.0,<2.0.0", markers = "python_version >= \"3.13\""},
     {version = ">=1.22.3,<2.0.0"},
+    {version = ">=1.25.0,<2.0.0", markers = "python_version >= \"3.13\""},
 ]
 protobuf = ">=3.19.5,<3.20.0 || >3.20.0,<3.20.1 || >3.20.1,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<7.0.0"
 requests = ">=2.18.0,<3.0.0"
@@ -1698,8 +1698,8 @@ files = [
 google-api-core = {version = ">=1.34.1,<2.0.dev0 || >=2.11.dev0,<3.0.0", extras = ["grpc"]}
 google-auth = ">=2.14.1,<2.24.0 || >2.24.0,<2.25.0 || >2.25.0,<3.0.0"
 proto-plus = [
-    {version = ">=1.25.0,<2.0.0", markers = "python_version >= \"3.13\""},
     {version = ">=1.22.3,<2.0.0"},
+    {version = ">=1.25.0,<2.0.0", markers = "python_version >= \"3.13\""},
 ]
 protobuf = ">=3.20.2,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<7.0.0"
 
@@ -1759,9 +1759,9 @@ google-cloud-core = ">=2.0.0,<3.0.0"
 grpc-google-iam-v1 = ">=0.12.4,<1.0.0"
 opentelemetry-api = ">=1.9.0"
 proto-plus = [
+    {version = ">=1.22.0,<2.0.0"},
+    {version = ">=1.22.2,<2.0.0", markers = "python_version >= \"3.11\""},
     {version = ">=1.25.0,<2.0.0", markers = "python_version >= \"3.13\""},
-    {version = ">=1.22.2,<2.0.0", markers = "python_version >= \"3.11\" and python_version < \"3.13\""},
-    {version = ">=1.22.0,<2.0.0", markers = "python_version < \"3.11\""},
 ]
 protobuf = ">=3.20.2,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<7.0.0"
 
@@ -3253,7 +3253,7 @@ description = "Fundamental package for array computing in Python"
 optional = false
 python-versions = ">=3.10"
 groups = ["main"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 files = [
     {file = "numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb"},
     {file = "numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90"},
@@ -3451,99 +3451,6 @@ files = [
 importlib-metadata = ">=6.0,<8.8.0"
 typing-extensions = ">=4.5.0"
 
-[[package]]
-name = "orjson"
-version = "3.11.3"
-description = "Fast, correct Python JSON library supporting dataclasses, datetimes, and numpy"
-optional = false
-python-versions = ">=3.9"
-groups = ["main"]
-files = [
-    {file = "orjson-3.11.3-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:29cb1f1b008d936803e2da3d7cba726fc47232c45df531b29edf0b232dd737e7"},
-    {file = "orjson-3.11.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:97dceed87ed9139884a55db8722428e27bd8452817fbf1869c58b49fecab1120"},
-    {file = "orjson-3.11.3-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:58533f9e8266cb0ac298e259ed7b4d42ed3fa0b78ce76860626164de49e0d467"},
-    {file = "orjson-3.11.3-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0c212cfdd90512fe722fa9bd620de4d46cda691415be86b2e02243242ae81873"},
-    {file = "orjson-3.11.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ff835b5d3e67d9207343effb03760c00335f8b5285bfceefd4dc967b0e48f6a"},
-    {file = "orjson-3.11.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f5aa4682912a450c2db89cbd92d356fef47e115dffba07992555542f344d301b"},
-    {file = "orjson-3.11.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7d18dd34ea2e860553a579df02041845dee0af8985dff7f8661306f95504ddf"},
-    {file = "orjson-3.11.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d8b11701bc43be92ea42bd454910437b355dfb63696c06fe953ffb40b5f763b4"},
-    {file = "orjson-3.11.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:90368277087d4af32d38bd55f9da2ff466d25325bf6167c8f382d8ee40cb2bbc"},
-    {file = "orjson-3.11.3-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:fd7ff459fb393358d3a155d25b275c60b07a2c83dcd7ea962b1923f5a1134569"},
-    {file = "orjson-3.11.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f8d902867b699bcd09c176a280b1acdab57f924489033e53d0afe79817da37e6"},
-    {file = "orjson-3.11.3-cp310-cp310-win32.whl", hash = "sha256:bb93562146120bb51e6b154962d3dadc678ed0fce96513fa6bc06599bb6f6edc"},
-    {file = "orjson-3.11.3-cp310-cp310-win_amd64.whl", hash = "sha256:976c6f1975032cc327161c65d4194c549f2589d88b105a5e3499429a54479770"},
-    {file = "orjson-3.11.3-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9d2ae0cc6aeb669633e0124531f342a17d8e97ea999e42f12a5ad4adaa304c5f"},
-    {file = "orjson-3.11.3-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:ba21dbb2493e9c653eaffdc38819b004b7b1b246fb77bfc93dc016fe664eac91"},
-    {file = "orjson-3.11.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:00f1a271e56d511d1569937c0447d7dce5a99a33ea0dec76673706360a051904"},
-    {file = "orjson-3.11.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b67e71e47caa6680d1b6f075a396d04fa6ca8ca09aafb428731da9b3ea32a5a6"},
-    {file = "orjson-3.11.3-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d7d012ebddffcce8c85734a6d9e5f08180cd3857c5f5a3ac70185b43775d043d"},
-    {file = "orjson-3.11.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dd759f75d6b8d1b62012b7f5ef9461d03c804f94d539a5515b454ba3a6588038"},
-    {file = "orjson-3.11.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6890ace0809627b0dff19cfad92d69d0fa3f089d3e359a2a532507bb6ba34efb"},
-    {file = "orjson-3.11.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f9d4a5e041ae435b815e568537755773d05dac031fee6a57b4ba70897a44d9d2"},
-    {file = "orjson-3.11.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2d68bf97a771836687107abfca089743885fb664b90138d8761cce61d5625d55"},
-    {file = "orjson-3.11.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:bfc27516ec46f4520b18ef645864cee168d2a027dbf32c5537cb1f3e3c22dac1"},
-    {file = "orjson-3.11.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f66b001332a017d7945e177e282a40b6997056394e3ed7ddb41fb1813b83e824"},
-    {file = "orjson-3.11.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:212e67806525d2561efbfe9e799633b17eb668b8964abed6b5319b2f1cfbae1f"},
-    {file = "orjson-3.11.3-cp311-cp311-win32.whl", hash = "sha256:6e8e0c3b85575a32f2ffa59de455f85ce002b8bdc0662d6b9c2ed6d80ab5d204"},
-    {file = "orjson-3.11.3-cp311-cp311-win_amd64.whl", hash = "sha256:6be2f1b5d3dc99a5ce5ce162fc741c22ba9f3443d3dd586e6a1211b7bc87bc7b"},
-    {file = "orjson-3.11.3-cp311-cp311-win_arm64.whl", hash = "sha256:fafb1a99d740523d964b15c8db4eabbfc86ff29f84898262bf6e3e4c9e97e43e"},
-    {file = "orjson-3.11.3-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:8c752089db84333e36d754c4baf19c0e1437012242048439c7e80eb0e6426e3b"},
-    {file = "orjson-3.11.3-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:9b8761b6cf04a856eb544acdd82fc594b978f12ac3602d6374a7edb9d86fd2c2"},
-    {file = "orjson-3.11.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b13974dc8ac6ba22feaa867fc19135a3e01a134b4f7c9c28162fed4d615008a"},
-    {file = "orjson-3.11.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f83abab5bacb76d9c821fd5c07728ff224ed0e52d7a71b7b3de822f3df04e15c"},
-    {file = "orjson-3.11.3-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e6fbaf48a744b94091a56c62897b27c31ee2da93d826aa5b207131a1e13d4064"},
-    {file = "orjson-3.11.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bc779b4f4bba2847d0d2940081a7b6f7b5877e05408ffbb74fa1faf4a136c424"},
-    {file = "orjson-3.11.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd4b909ce4c50faa2192da6bb684d9848d4510b736b0611b6ab4020ea6fd2d23"},
-    {file = "orjson-3.11.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:524b765ad888dc5518bbce12c77c2e83dee1ed6b0992c1790cc5fb49bb4b6667"},
-    {file = "orjson-3.11.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:84fd82870b97ae3cdcea9d8746e592b6d40e1e4d4527835fc520c588d2ded04f"},
-    {file = "orjson-3.11.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:fbecb9709111be913ae6879b07bafd4b0785b44c1eb5cac8ac76da048b3885a1"},
-    {file = "orjson-3.11.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9dba358d55aee552bd868de348f4736ca5a4086d9a62e2bfbbeeb5629fe8b0cc"},
-    {file = "orjson-3.11.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eabcf2e84f1d7105f84580e03012270c7e97ecb1fb1618bda395061b2a84a049"},
-    {file = "orjson-3.11.3-cp312-cp312-win32.whl", hash = "sha256:3782d2c60b8116772aea8d9b7905221437fdf53e7277282e8d8b07c220f96cca"},
-    {file = "orjson-3.11.3-cp312-cp312-win_amd64.whl", hash = "sha256:79b44319268af2eaa3e315b92298de9a0067ade6e6003ddaef72f8e0bedb94f1"},
-    {file = "orjson-3.11.3-cp312-cp312-win_arm64.whl", hash = "sha256:0e92a4e83341ef79d835ca21b8bd13e27c859e4e9e4d7b63defc6e58462a3710"},
-    {file = "orjson-3.11.3-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:af40c6612fd2a4b00de648aa26d18186cd1322330bd3a3cc52f87c699e995810"},
-    {file = "orjson-3.11.3-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:9f1587f26c235894c09e8b5b7636a38091a9e6e7fe4531937534749c04face43"},
-    {file = "orjson-3.11.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:61dcdad16da5bb486d7227a37a2e789c429397793a6955227cedbd7252eb5a27"},
-    {file = "orjson-3.11.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:11c6d71478e2cbea0a709e8a06365fa63da81da6498a53e4c4f065881d21ae8f"},
-    {file = "orjson-3.11.3-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ff94112e0098470b665cb0ed06efb187154b63649403b8d5e9aedeb482b4548c"},
-    {file = "orjson-3.11.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae8b756575aaa2a855a75192f356bbda11a89169830e1439cfb1a3e1a6dde7be"},
-    {file = "orjson-3.11.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c9416cc19a349c167ef76135b2fe40d03cea93680428efee8771f3e9fb66079d"},
-    {file = "orjson-3.11.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b822caf5b9752bc6f246eb08124c3d12bf2175b66ab74bac2ef3bbf9221ce1b2"},
-    {file = "orjson-3.11.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:414f71e3bdd5573893bf5ecdf35c32b213ed20aa15536fe2f588f946c318824f"},
-    {file = "orjson-3.11.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:828e3149ad8815dc14468f36ab2a4b819237c155ee1370341b91ea4c8672d2ee"},
-    {file = "orjson-3.11.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ac9e05f25627ffc714c21f8dfe3a579445a5c392a9c8ae7ba1d0e9fb5333f56e"},
-    {file = "orjson-3.11.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e44fbe4000bd321d9f3b648ae46e0196d21577cf66ae684a96ff90b1f7c93633"},
-    {file = "orjson-3.11.3-cp313-cp313-win32.whl", hash = "sha256:2039b7847ba3eec1f5886e75e6763a16e18c68a63efc4b029ddf994821e2e66b"},
-    {file = "orjson-3.11.3-cp313-cp313-win_amd64.whl", hash = "sha256:29be5ac4164aa8bdcba5fa0700a3c9c316b411d8ed9d39ef8a882541bd452fae"},
-    {file = "orjson-3.11.3-cp313-cp313-win_arm64.whl", hash = "sha256:18bd1435cb1f2857ceb59cfb7de6f92593ef7b831ccd1b9bfb28ca530e539dce"},
-    {file = "orjson-3.11.3-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:cf4b81227ec86935568c7edd78352a92e97af8da7bd70bdfdaa0d2e0011a1ab4"},
-    {file = "orjson-3.11.3-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:bc8bc85b81b6ac9fc4dae393a8c159b817f4c2c9dee5d12b773bddb3b95fc07e"},
-    {file = "orjson-3.11.3-cp314-cp314-manylinux_2_34_aarch64.whl", hash = "sha256:88dcfc514cfd1b0de038443c7b3e6a9797ffb1b3674ef1fd14f701a13397f82d"},
-    {file = "orjson-3.11.3-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:d61cd543d69715d5fc0a690c7c6f8dcc307bc23abef9738957981885f5f38229"},
-    {file = "orjson-3.11.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2b7b153ed90ababadbef5c3eb39549f9476890d339cf47af563aea7e07db2451"},
-    {file = "orjson-3.11.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:7909ae2460f5f494fecbcd10613beafe40381fd0316e35d6acb5f3a05bfda167"},
-    {file = "orjson-3.11.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:2030c01cbf77bc67bee7eef1e7e31ecf28649353987775e3583062c752da0077"},
-    {file = "orjson-3.11.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a0169ebd1cbd94b26c7a7ad282cf5c2744fce054133f959e02eb5265deae1872"},
-    {file = "orjson-3.11.3-cp314-cp314-win32.whl", hash = "sha256:0c6d7328c200c349e3a4c6d8c83e0a5ad029bdc2d417f234152bf34842d0fc8d"},
-    {file = "orjson-3.11.3-cp314-cp314-win_amd64.whl", hash = "sha256:317bbe2c069bbc757b1a2e4105b64aacd3bc78279b66a6b9e51e846e4809f804"},
-    {file = "orjson-3.11.3-cp314-cp314-win_arm64.whl", hash = "sha256:e8f6a7a27d7b7bec81bd5924163e9af03d49bbb63013f107b48eb5d16db711bc"},
-    {file = "orjson-3.11.3-cp39-cp39-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:56afaf1e9b02302ba636151cfc49929c1bb66b98794291afd0e5f20fecaf757c"},
-    {file = "orjson-3.11.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:913f629adef31d2d350d41c051ce7e33cf0fd06a5d1cb28d49b1899b23b903aa"},
-    {file = "orjson-3.11.3-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e0a23b41f8f98b4e61150a03f83e4f0d566880fe53519d445a962929a4d21045"},
-    {file = "orjson-3.11.3-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3d721fee37380a44f9d9ce6c701b3960239f4fb3d5ceea7f31cbd43882edaa2f"},
-    {file = "orjson-3.11.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:73b92a5b69f31b1a58c0c7e31080aeaec49c6e01b9522e71ff38d08f15aa56de"},
-    {file = "orjson-3.11.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d2489b241c19582b3f1430cc5d732caefc1aaf378d97e7fb95b9e56bed11725f"},
-    {file = "orjson-3.11.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c5189a5dab8b0312eadaf9d58d3049b6a52c454256493a557405e77a3d67ab7f"},
-    {file = "orjson-3.11.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9d8787bdfbb65a85ea76d0e96a3b1bed7bf0fbcb16d40408dc1172ad784a49d2"},
-    {file = "orjson-3.11.3-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:8e531abd745f51f8035e207e75e049553a86823d189a51809c078412cefb399a"},
-    {file = "orjson-3.11.3-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:8ab962931015f170b97a3dd7bd933399c1bae8ed8ad0fb2a7151a5654b6941c7"},
-    {file = "orjson-3.11.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:124d5ba71fee9c9902c4a7baa9425e663f7f0aecf73d31d54fe3dd357d62c1a7"},
-    {file = "orjson-3.11.3-cp39-cp39-win32.whl", hash = "sha256:22724d80ee5a815a44fc76274bb7ba2e7464f5564aacb6ecddaa9970a83e3225"},
-    {file = "orjson-3.11.3-cp39-cp39-win_amd64.whl", hash = "sha256:215c595c792a87d4407cb72dd5e0f6ee8e694ceeb7f9102b533c5a9bf2a916bb"},
-    {file = "orjson-3.11.3.tar.gz", hash = "sha256:1c0603b1d2ffcd43a411d64797a19556ef76958aef1c182f22dc30860152a98a"},
-]
-
 [[package]]
 name = "packaging"
 version = "24.2"
@@ -3626,9 +3533,9 @@ files = [
 
 [package.dependencies]
 numpy = [
-    {version = ">=1.26.0", markers = "python_version >= \"3.12\""},
-    {version = ">=1.23.2", markers = "python_version == \"3.11\""},
     {version = ">=1.22.4", markers = "python_version < \"3.11\""},
+    {version = ">=1.23.2", markers = "python_version == \"3.11\""},
+    {version = ">=1.26.0", markers = "python_version >= \"3.12\""},
 ]
 python-dateutil = ">=2.8.2"
 pytz = ">=2020.1"
@@ -3865,8 +3772,8 @@ pinecone-plugin-interface = ">=0.0.7,<0.0.8"
 python-dateutil = ">=2.5.3"
 typing-extensions = ">=3.7.4"
 urllib3 = [
-    {version = ">=1.26.5", markers = "python_version >= \"3.12\" and python_version < \"4.0\""},
     {version = ">=1.26.0", markers = "python_version >= \"3.8\" and python_version < \"3.12\""},
+    {version = ">=1.26.5", markers = "python_version >= \"3.12\" and python_version < \"4.0\""},
 ]
 
 [package.extras]
@@ -4238,22 +4145,6 @@ files = [
 [package.extras]
 twisted = ["twisted"]
 
-[[package]]
-name = "prometheus-fastapi-instrumentator"
-version = "7.1.0"
-description = "Instrument your FastAPI app with Prometheus metrics"
-optional = false
-python-versions = ">=3.8"
-groups = ["main"]
-files = [
-    {file = "prometheus_fastapi_instrumentator-7.1.0-py3-none-any.whl", hash = "sha256:978130f3c0bb7b8ebcc90d35516a6fe13e02d2eb358c8f83887cdef7020c31e9"},
-    {file = "prometheus_fastapi_instrumentator-7.1.0.tar.gz", hash = "sha256:be7cd61eeea4e5912aeccb4261c6631b3f227d8924542d79eaf5af3f439cbe5e"},
-]
-
-[package.dependencies]
-prometheus-client = ">=0.8.0,<1.0.0"
-starlette = ">=0.30.0,<1.0.0"
-
 [[package]]
 name = "propcache"
 version = "0.3.2"
@@ -5201,8 +5092,8 @@ files = [
 grpcio = ">=1.41.0"
 httpx = {version = ">=0.20.0", extras = ["http2"]}
 numpy = [
-    {version = ">=2.1.0", markers = "python_version >= \"3.13\""},
     {version = ">=1.21", markers = "python_version >= \"3.10\" and python_version < \"3.12\""},
+    {version = ">=2.1.0", markers = "python_version >= \"3.13\""},
     {version = ">=1.26", markers = "python_version == \"3.12\""},
 ]
 portalocker = ">=2.7.0,<3.0.0"
@@ -6297,7 +6188,7 @@ description = "A lil' TOML parser"
 optional = false
 python-versions = ">=3.8"
 groups = ["main", "dev"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 files = [
     {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"},
     {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"},
@@ -7252,4 +7143,4 @@ cffi = ["cffi (>=1.11)"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.10,<3.14"
-content-hash = "b2363edeebb91f410039c8d4b563f683c1edb0cf4bda4f3e6c287040e93639bc"
+content-hash = "80d4dc2cbcd1ae33b2fa3920db5dcb1f82ad252d1e4a8bfeba8b2f2eebbdda0d"

autogpt_platform/backend/pyproject.toml

@@ -38,7 +38,6 @@ mem0ai = "^0.1.115"
 moviepy = "^2.1.2"
 ollama = "^0.5.1"
 openai = "^1.97.1"
-orjson = "^3.10.0"
 pika = "^1.3.2"
 pinecone = "^7.3.0"
 poetry = "2.1.1" # CHECK DEPENDABOT SUPPORT BEFORE UPGRADING
@@ -46,7 +45,6 @@ postmarker = "^1.0"
 praw = "~7.8.1"
 prisma = "^0.15.0"
 prometheus-client = "^0.22.1"
-prometheus-fastapi-instrumentator = "^7.0.0"
 psutil = "^7.0.0"
 psycopg2-binary = "^2.9.10"
 pydantic = { extras = ["email"], version = "^2.11.7" }

autogpt_platform/backend/schema.prisma

@@ -110,7 +110,6 @@ model AgentGraph {
 
   name        String?
   description String?
-  instructions String?
   recommendedScheduleCron String?
 
   isActive Boolean @default(true)
@@ -135,7 +134,7 @@ model AgentGraph {
   StoreListingVersions StoreListingVersion[]
 
   @@id(name: "graphVersionId", [id, version])
-  @@index([userId, isActive, id, version])
+  @@index([userId, isActive])
   @@index([forkedFromId, forkedFromVersion])
 }
 
@@ -371,16 +370,10 @@ model AgentGraphExecution {
 
   stats Json?
 
-  // Sharing fields
-  isShared    Boolean   @default(false)
-  shareToken  String?   @unique
-  sharedAt    DateTime?
-
   @@index([agentGraphId, agentGraphVersion])
-  @@index([userId, isDeleted, createdAt])
+  @@index([userId])
   @@index([createdAt])
   @@index([agentPresetId])
-  @@index([shareToken])
 }
 
 // This model describes the execution of an AgentNode.
@@ -535,7 +528,7 @@ model CreditTransaction {
   createdAt      DateTime @default(now())
 
   userId String
-  User   User?   @relation(fields: [userId], references: [id], onDelete: NoAction)
+  User   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
 
   amount Int
   type   CreditTransactionType
@@ -764,7 +757,6 @@ model StoreListingVersion {
   videoUrl    String?
   imageUrls   String[]
   description String
-  instructions String?
   categories  String[]
 
   isFeatured Boolean @default(false)

autogpt_platform/backend/snapshots/agt_details

@@ -11,7 +11,6 @@
   "creator_avatar": "avatar1.jpg",
   "sub_heading": "Test agent subheading",
   "description": "Test agent description",
-  "instructions": null,
   "categories": [
     "category1",
     "category2"

autogpt_platform/backend/snapshots/grph_single

@@ -1,5 +1,4 @@
 {
-  "created_at": "2025-09-04T13:37:00",
   "credentials_input_schema": {
     "properties": {},
     "title": "TestGraphCredentialsInputSchema",
@@ -15,7 +14,6 @@
     "required": [],
     "type": "object"
   },
-  "instructions": null,
   "is_active": true,
   "links": [],
   "name": "Test Graph",

autogpt_platform/backend/snapshots/grphs_all

@@ -15,7 +15,6 @@
       "required": [],
       "type": "object"
     },
-    "instructions": null,
     "is_active": true,
     "name": "Test Graph",
     "output_schema": {

autogpt_platform/backend/snapshots/lib_agts_search

@@ -11,7 +11,6 @@
       "updated_at": "2023-01-01T00:00:00",
       "name": "Test Agent 1",
       "description": "Test Description 1",
-      "instructions": null,
       "input_schema": {
         "type": "object",
         "properties": {}
@@ -29,7 +28,6 @@
       "new_output": false,
       "can_access_graph": true,
       "is_latest_version": true,
-      "is_favorite": false,
       "recommended_schedule_cron": null
     },
     {
@@ -43,7 +41,6 @@
       "updated_at": "2023-01-01T00:00:00",
       "name": "Test Agent 2",
       "description": "Test Description 2",
-      "instructions": null,
       "input_schema": {
         "type": "object",
         "properties": {}
@@ -61,7 +58,6 @@
       "new_output": false,
       "can_access_graph": false,
       "is_latest_version": true,
-      "is_favorite": false,
       "recommended_schedule_cron": null
     }
   ],

autogpt_platform/backend/snapshots/sub_success

@@ -7,7 +7,6 @@
       "sub_heading": "Test agent subheading",
       "slug": "test-agent",
       "description": "Test agent description",
-      "instructions": null,
       "image_urls": [
         "test.jpg"
       ],

autogpt_platform/backend/test/sdk/test_sdk_registry.py

@@ -146,23 +146,16 @@ class TestAutoRegistry:
         """Test API key environment variable registration."""
         import os
 
-        from backend.sdk.builder import ProviderBuilder
-
         # Set up a test environment variable
         os.environ["TEST_API_KEY"] = "test-api-key-value"
 
         try:
-            # Use ProviderBuilder which calls register_api_key and creates the credential
-            (
-                ProviderBuilder("test_provider")
-                .with_api_key("TEST_API_KEY", "Test API Key")
-                .build()
-            )
+            AutoRegistry.register_api_key("test_provider", "TEST_API_KEY")
 
             # Verify the mapping is stored
             assert AutoRegistry._api_key_mappings["test_provider"] == "TEST_API_KEY"
 
-            # Verify a credential was created through the provider
+            # Verify a credential was created
             all_creds = AutoRegistry.get_all_credentials()
             test_cred = next(
                 (c for c in all_creds if c.id == "test_provider-default"), None

autogpt_platform/docker-compose.platform.yml

@@ -37,7 +37,7 @@ services:
       context: ../
       dockerfile: autogpt_platform/backend/Dockerfile
       target: migrate
-    command: ["sh", "-c", "poetry run prisma generate && poetry run prisma migrate deploy"]
+    command: ["sh", "-c", "poetry run prisma migrate deploy"]
     develop:
       watch:
         - path: ./
@@ -65,6 +65,7 @@ services:
 
   redis:
     image: redis:latest
+    command: redis-server --requirepass password
     ports:
       - "6379:6379"
     networks: