feat(frontend): enhance UI components with animations and accessibility improvements

### Changes 🏗️ - Integrated `FadeIn` animations in `AgentsSection`, `FeaturedCreators`, `FeaturedSection`, `HeroSection`, and `BecomeACreator` components for improved visual appeal. - Replaced static elements with `StaggeredList` in `FeaturedCreators` and `AgentsSection` for a more dynamic layout. - Updated `SearchBar` to use `type="search"` and added `aria-label` for better accessibility. - Enhanced `StoreCard` with focus-visible styles and keyboard navigation support. - Refactored `FilterChips` to utilize `FilterChip` component for a more consistent design. ### Checklist 📋 - [x] Verified animations function correctly across components. - [x] Ensured accessibility improvements are in place and tested. - [x] Confirmed UI consistency with design specifications.
2026-01-21 04:57:58 -05:00 · 2026-01-20 20:12:33 +05:30
63 changed files with 1289 additions and 3958 deletions
--- a/autogpt_platform/backend/backend/api/features/admin/waitlist_admin_routes.py
+++ b/autogpt_platform/backend/backend/api/features/admin/waitlist_admin_routes.py
@@ -1,251 +0,0 @@
 import logging
 import autogpt_libs.auth
 import fastapi
 import fastapi.responses
 import backend.api.features.store.db as store_db
 import backend.api.features.store.model as store_model
 logger = logging.getLogger(__name__)
 router = fastapi.APIRouter(
    prefix="/admin/waitlist",
    tags=["store", "admin", "waitlist"],
    dependencies=[fastapi.Security(autogpt_libs.auth.requires_admin_user)],
 )
@router.post(
    "",
    summary="Create Waitlist",
    response_model=store_model.WaitlistAdminResponse,
 )
 async def create_waitlist(
    request: store_model.WaitlistCreateRequest,
    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
 ):
    """
    Create a new waitlist (admin only).
    Args:
        request: Waitlist creation details
        user_id: Authenticated admin user creating the waitlist
    Returns:
        WaitlistAdminResponse with the created waitlist details
    """
    try:
        waitlist = await store_db.create_waitlist_admin(
            admin_user_id=user_id,
            data=request,
        )
        return waitlist
    except Exception as e:
        logger.exception("Error creating waitlist: %s", e)
        return fastapi.responses.JSONResponse(
            status_code=500,
            content={"detail": "An error occurred while creating the waitlist"},
        )
@router.get(
    "",
    summary="List All Waitlists",
    response_model=store_model.WaitlistAdminListResponse,
 )
 async def list_waitlists():
    """
    Get all waitlists with admin details (admin only).
    Returns:
        WaitlistAdminListResponse with all waitlists
    """
    try:
        return await store_db.get_waitlists_admin()
    except Exception as e:
        logger.exception("Error listing waitlists: %s", e)
        return fastapi.responses.JSONResponse(
            status_code=500,
            content={"detail": "An error occurred while fetching waitlists"},
        )
@router.get(
    "/{waitlist_id}",
    summary="Get Waitlist Details",
    response_model=store_model.WaitlistAdminResponse,
 )
 async def get_waitlist(
    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
 ):
    """
    Get a single waitlist with admin details (admin only).
    Args:
        waitlist_id: ID of the waitlist to retrieve
    Returns:
        WaitlistAdminResponse with waitlist details
    """
    try:
        return await store_db.get_waitlist_admin(waitlist_id)
    except ValueError:
        logger.warning("Waitlist not found: %s", waitlist_id)
        return fastapi.responses.JSONResponse(
            status_code=404,
            content={"detail": "Waitlist not found"},
        )
    except Exception as e:
        logger.exception("Error fetching waitlist: %s", e)
        return fastapi.responses.JSONResponse(
            status_code=500,
            content={"detail": "An error occurred while fetching the waitlist"},
        )
@router.put(
    "/{waitlist_id}",
    summary="Update Waitlist",
    response_model=store_model.WaitlistAdminResponse,
 )
 async def update_waitlist(
    request: store_model.WaitlistUpdateRequest,
    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
 ):
    """
    Update a waitlist (admin only).
    Args:
        waitlist_id: ID of the waitlist to update
        request: Fields to update
    Returns:
        WaitlistAdminResponse with updated waitlist details
    """
    try:
        return await store_db.update_waitlist_admin(waitlist_id, request)
    except ValueError:
        logger.warning("Waitlist not found for update: %s", waitlist_id)
        return fastapi.responses.JSONResponse(
            status_code=404,
            content={"detail": "Waitlist not found"},
        )
    except Exception as e:
        logger.exception("Error updating waitlist: %s", e)
        return fastapi.responses.JSONResponse(
            status_code=500,
            content={"detail": "An error occurred while updating the waitlist"},
        )
@router.delete(
    "/{waitlist_id}",
    summary="Delete Waitlist",
 )
 async def delete_waitlist(
    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
 ):
    """
    Soft delete a waitlist (admin only).
    Args:
        waitlist_id: ID of the waitlist to delete
    Returns:
        Success message
    """
    try:
        await store_db.delete_waitlist_admin(waitlist_id)
        return {"message": "Waitlist deleted successfully"}
    except ValueError:
        logger.warning(f"Waitlist not found for deletion: {waitlist_id}")
        return fastapi.responses.JSONResponse(
            status_code=404,
            content={"detail": "Waitlist not found"},
        )
    except Exception as e:
        logger.exception("Error deleting waitlist: %s", e)
        return fastapi.responses.JSONResponse(
            status_code=500,
            content={"detail": "An error occurred while deleting the waitlist"},
        )
@router.get(
    "/{waitlist_id}/signups",
    summary="Get Waitlist Signups",
    response_model=store_model.WaitlistSignupListResponse,
 )
 async def get_waitlist_signups(
    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
 ):
    """
    Get all signups for a waitlist (admin only).
    Args:
        waitlist_id: ID of the waitlist
    Returns:
        WaitlistSignupListResponse with all signups
    """
    try:
        return await store_db.get_waitlist_signups_admin(waitlist_id)
    except ValueError:
        logger.warning("Waitlist not found for signups: %s", waitlist_id)
        return fastapi.responses.JSONResponse(
            status_code=404,
            content={"detail": "Waitlist not found"},
        )
    except Exception as e:
        logger.exception("Error fetching waitlist signups: %s", e)
        return fastapi.responses.JSONResponse(
            status_code=500,
            content={"detail": "An error occurred while fetching waitlist signups"},
        )
@router.post(
    "/{waitlist_id}/link",
    summary="Link Waitlist to Store Listing",
    response_model=store_model.WaitlistAdminResponse,
 )
 async def link_waitlist_to_listing(
    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
    store_listing_id: str = fastapi.Body(
        ..., embed=True, description="The ID of the store listing"
    ),
 ):
    """
    Link a waitlist to a store listing (admin only).
    When the linked store listing is approved/published, waitlist users
    will be automatically notified.
    Args:
        waitlist_id: ID of the waitlist
        store_listing_id: ID of the store listing to link
    Returns:
        WaitlistAdminResponse with updated waitlist details
    """
    try:
        return await store_db.link_waitlist_to_listing_admin(
            waitlist_id, store_listing_id
        )
    except ValueError:
        logger.warning(
            "Link failed - waitlist or listing not found: %s, %s",
            waitlist_id,
            store_listing_id,
        )
        return fastapi.responses.JSONResponse(
            status_code=404,
            content={"detail": "Waitlist or store listing not found"},
        )
    except Exception as e:
        logger.exception("Error linking waitlist to listing: %s", e)
        return fastapi.responses.JSONResponse(
            status_code=500,
            content={"detail": "An error occurred while linking the waitlist"},
        )
--- a/autogpt_platform/backend/backend/api/features/chat/tools/run_agent.py
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/run_agent.py
@@ -33,7 +33,7 @@ from .models import (
    UserReadiness,
 )
 from .utils import (
-    build_missing_credentials_from_graph,
+    check_user_has_required_credentials,
    extract_credentials_from_schema,
    fetch_graph_from_store_slug,
    get_or_create_library_agent,
@@ -237,13 +237,15 @@ class RunAgentTool(BaseTool):
                # Return credentials needed response with input data info
                # The UI handles credential setup automatically, so the message
                # focuses on asking about input data
-                requirements_creds_dict = build_missing_credentials_from_graph(
+                credentials = extract_credentials_from_schema(
-                    graph, None
+                    graph.credentials_input_schema
                )
-                missing_credentials_dict = build_missing_credentials_from_graph(
+                missing_creds_check = await check_user_has_required_credentials(
-                    graph, graph_credentials
+                    user_id, credentials
                )
-                requirements_creds_list = list(requirements_creds_dict.values())
+                missing_credentials_dict = {
                    c.id: c.model_dump() for c in missing_creds_check
                }
                return SetupRequirementsResponse(
                    message=self._build_inputs_message(graph, MSG_WHAT_VALUES_TO_USE),
@@ -257,7 +259,7 @@ class RunAgentTool(BaseTool):
                            ready_to_run=False,
                        ),
                        requirements={
-                            "credentials": requirements_creds_list,
+                            "credentials": [c.model_dump() for c in credentials],
                            "inputs": self._get_inputs_list(graph.input_schema),
                            "execution_modes": self._get_execution_modes(graph),
                        },
--- a/autogpt_platform/backend/backend/api/features/chat/tools/run_block.py
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/run_block.py
@@ -22,7 +22,6 @@ from .models import (
    ToolResponseBase,
    UserReadiness,
 )
 from .utils import build_missing_credentials_from_field_info
 logger = logging.getLogger(__name__)
@@ -190,11 +189,7 @@ class RunBlockTool(BaseTool):
        if missing_credentials:
            # Return setup requirements response with missing credentials
-            credentials_fields_info = block.input_schema.get_credentials_fields_info()
+            missing_creds_dict = {c.id: c.model_dump() for c in missing_credentials}
            missing_creds_dict = build_missing_credentials_from_field_info(
                credentials_fields_info, set(matched_credentials.keys())
            )
            missing_creds_list = list(missing_creds_dict.values())
            return SetupRequirementsResponse(
                message=(
@@ -211,7 +206,7 @@ class RunBlockTool(BaseTool):
                        ready_to_run=False,
                    ),
                    requirements={
-                        "credentials": missing_creds_list,
+                        "credentials": [c.model_dump() for c in missing_credentials],
                        "inputs": self._get_inputs_list(block),
                        "execution_modes": ["immediate"],
                    },
--- a/autogpt_platform/backend/backend/api/features/chat/tools/utils.py
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/utils.py
@@ -8,7 +8,7 @@ from backend.api.features.library import model as library_model
 from backend.api.features.store import db as store_db
 from backend.data import graph as graph_db
 from backend.data.graph import GraphModel
-from backend.data.model import CredentialsFieldInfo, CredentialsMetaInput
+from backend.data.model import CredentialsMetaInput
 from backend.integrations.creds_manager import IntegrationCredentialsManager
 from backend.util.exceptions import NotFoundError
@@ -89,59 +89,6 @@ def extract_credentials_from_schema(
    return credentials
 def _serialize_missing_credential(
    field_key: str, field_info: CredentialsFieldInfo
 ) -> dict[str, Any]:
    """
    Convert credential field info into a serializable dict that preserves all supported
    credential types (e.g., api_key + oauth2) so the UI can offer multiple options.
    """
    supported_types = sorted(field_info.supported_types)
    provider = next(iter(field_info.provider), "unknown")
    scopes = sorted(field_info.required_scopes or [])
    return {
        "id": field_key,
        "title": field_key.replace("_", " ").title(),
        "provider": provider,
        "provider_name": provider.replace("_", " ").title(),
        "type": supported_types[0] if supported_types else "api_key",
        "types": supported_types,
        "scopes": scopes,
    }
 def build_missing_credentials_from_graph(
    graph: GraphModel, matched_credentials: dict[str, CredentialsMetaInput] | None
 ) -> dict[str, Any]:
    """
    Build a missing_credentials mapping from a graph's aggregated credentials inputs,
    preserving all supported credential types for each field.
    """
    matched_keys = set(matched_credentials.keys()) if matched_credentials else set()
    aggregated_fields = graph.aggregate_credentials_inputs()
    return {
        field_key: _serialize_missing_credential(field_key, field_info)
        for field_key, (field_info, _node_fields) in aggregated_fields.items()
        if field_key not in matched_keys
    }
 def build_missing_credentials_from_field_info(
    credential_fields: dict[str, CredentialsFieldInfo],
    matched_keys: set[str],
 ) -> dict[str, Any]:
    """
    Build missing_credentials mapping from a simple credentials field info dictionary.
    """
    return {
        field_key: _serialize_missing_credential(field_key, field_info)
        for field_key, field_info in credential_fields.items()
        if field_key not in matched_keys
    }
 def extract_credentials_as_dict(
    credentials_input_schema: dict[str, Any] | None,
 ) -> dict[str, CredentialsMetaInput]:
--- a/autogpt_platform/backend/backend/api/features/store/db.py
+++ b/autogpt_platform/backend/backend/api/features/store/db.py
@@ -22,7 +22,6 @@ from backend.data.notifications import (
    AgentApprovalData,
    AgentRejectionData,
    NotificationEventModel,
    WaitlistLaunchData,
 )
 from backend.notifications.notifications import queue_notification_async
 from backend.util.exceptions import DatabaseError
@@ -1718,29 +1717,6 @@ async def review_store_submission(
                # Don't fail the review process if email sending fails
                pass
        # Notify waitlist users if this is an approval and has a linked waitlist
        if is_approved and submission.StoreListing:
            try:
                frontend_base_url = (
                    settings.config.frontend_base_url
                    or settings.config.platform_base_url
                )
                store_agent = (
                    await prisma.models.StoreAgent.prisma().find_first_or_raise(
                        where={"storeListingVersionId": submission.id}
                    )
                )
                creator_username = store_agent.creator_username or "unknown"
                store_url = f"{frontend_base_url}/marketplace/agent/{creator_username}/{store_agent.slug}"
                await notify_waitlist_users_on_launch(
                    store_listing_id=submission.StoreListing.id,
                    agent_name=submission.name,
                    store_url=store_url,
                )
            except Exception as e:
                logger.error(f"Failed to notify waitlist users on agent approval: {e}")
                # Don't fail the approval process
        # Convert to Pydantic model for consistency
        return store_model.StoreSubmission(
            listing_id=(submission.StoreListing.id if submission.StoreListing else ""),
@@ -1988,552 +1964,3 @@ async def get_agent_as_admin(
        )
    return graph
 def _waitlist_to_store_entry(
    waitlist: prisma.models.WaitlistEntry,
 ) -> store_model.StoreWaitlistEntry:
    """Convert a WaitlistEntry to StoreWaitlistEntry for public display."""
    return store_model.StoreWaitlistEntry(
        waitlistId=waitlist.id,
        slug=waitlist.slug,
        name=waitlist.name,
        subHeading=waitlist.subHeading,
        videoUrl=waitlist.videoUrl,
        agentOutputDemoUrl=waitlist.agentOutputDemoUrl,
        imageUrls=waitlist.imageUrls or [],
        description=waitlist.description,
        categories=waitlist.categories,
    )
 async def get_waitlist() -> list[store_model.StoreWaitlistEntry]:
    """Get all active waitlists for public display."""
    try:
        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
            where=prisma.types.WaitlistEntryWhereInput(isDeleted=False),
        )
        # Filter out closed/done waitlists and sort by votes (descending)
        excluded_statuses = {
            prisma.enums.WaitlistExternalStatus.CANCELED,
            prisma.enums.WaitlistExternalStatus.DONE,
        }
        active_waitlists = [w for w in waitlists if w.status not in excluded_statuses]
        sorted_list = sorted(active_waitlists, key=lambda x: x.votes, reverse=True)
        return [_waitlist_to_store_entry(w) for w in sorted_list]
    except Exception as e:
        logger.error(f"Error fetching waitlists: {e}")
        raise DatabaseError("Failed to fetch waitlists") from e
 async def get_user_waitlist_memberships(user_id: str) -> list[str]:
    """Get all waitlist IDs that a user has joined."""
    try:
        user = await prisma.models.User.prisma().find_unique(
            where={"id": user_id},
            include={"joinedWaitlists": True},
        )
        if not user or not user.joinedWaitlists:
            return []
        return [w.id for w in user.joinedWaitlists]
    except Exception as e:
        logger.error(f"Error fetching user waitlist memberships: {e}")
        raise DatabaseError("Failed to fetch waitlist memberships") from e
 async def add_user_to_waitlist(
    waitlist_id: str, user_id: str | None, email: str | None
 ) -> store_model.StoreWaitlistEntry:
    """
    Add a user to a waitlist.
    For logged-in users: connects via joinedUsers relation
    For anonymous users: adds email to unaffiliatedEmailUsers array
    """
    if not user_id and not email:
        raise ValueError("Either user_id or email must be provided")
    try:
        # Find the waitlist
        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
            where={"id": waitlist_id},
            include={"joinedUsers": True},
        )
        if not waitlist:
            raise ValueError(f"Waitlist {waitlist_id} not found")
        if waitlist.isDeleted:
            raise ValueError(f"Waitlist {waitlist_id} is no longer available")
        if waitlist.status in [
            prisma.enums.WaitlistExternalStatus.CANCELED,
            prisma.enums.WaitlistExternalStatus.DONE,
        ]:
            raise ValueError(f"Waitlist {waitlist_id} is closed")
        if user_id:
            # Check if user already joined
            joined_user_ids = [u.id for u in (waitlist.joinedUsers or [])]
            if user_id in joined_user_ids:
                # Already joined - return waitlist info
                logger.debug(f"User {user_id} already joined waitlist {waitlist_id}")
            else:
                # Connect user to waitlist
                await prisma.models.WaitlistEntry.prisma().update(
                    where={"id": waitlist_id},
                    data={"joinedUsers": {"connect": [{"id": user_id}]}},
                )
                logger.info(f"User {user_id} joined waitlist {waitlist_id}")
            # If user was previously in email list, remove them
            # Use transaction to prevent race conditions
            if email:
                async with transaction() as tx:
                    current_waitlist = await tx.waitlistentry.find_unique(
                        where={"id": waitlist_id}
                    )
                    if current_waitlist and email in (
                        current_waitlist.unaffiliatedEmailUsers or []
                    ):
                        updated_emails: list[str] = [
                            e
                            for e in (current_waitlist.unaffiliatedEmailUsers or [])
                            if e != email
                        ]
                        await tx.waitlistentry.update(
                            where={"id": waitlist_id},
                            data={"unaffiliatedEmailUsers": updated_emails},
                        )
        elif email:
            # Add email to unaffiliated list if not already present
            # Use transaction to prevent race conditions with concurrent signups
            async with transaction() as tx:
                # Re-fetch within transaction to get latest state
                current_waitlist = await tx.waitlistentry.find_unique(
                    where={"id": waitlist_id}
                )
                if current_waitlist:
                    current_emails: list[str] = list(
                        current_waitlist.unaffiliatedEmailUsers or []
                    )
                    if email not in current_emails:
                        current_emails.append(email)
                        await tx.waitlistentry.update(
                            where={"id": waitlist_id},
                            data={"unaffiliatedEmailUsers": current_emails},
                        )
                        logger.info(f"Email {email} added to waitlist {waitlist_id}")
                    else:
                        logger.debug(f"Email {email} already on waitlist {waitlist_id}")
        # Re-fetch to return updated data
        updated_waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
            where={"id": waitlist_id}
        )
        return _waitlist_to_store_entry(updated_waitlist or waitlist)
    except ValueError:
        raise
    except Exception as e:
        logger.error(f"Error adding user to waitlist: {e}")
        raise DatabaseError("Failed to add user to waitlist") from e
 # ============== Admin Waitlist Functions ==============
 def _waitlist_to_admin_response(
    waitlist: prisma.models.WaitlistEntry,
 ) -> store_model.WaitlistAdminResponse:
    """Convert a WaitlistEntry to WaitlistAdminResponse."""
    joined_count = len(waitlist.joinedUsers) if waitlist.joinedUsers else 0
    email_count = (
        len(waitlist.unaffiliatedEmailUsers) if waitlist.unaffiliatedEmailUsers else 0
    )
    return store_model.WaitlistAdminResponse(
        id=waitlist.id,
        createdAt=waitlist.createdAt.isoformat() if waitlist.createdAt else "",
        updatedAt=waitlist.updatedAt.isoformat() if waitlist.updatedAt else "",
        slug=waitlist.slug,
        name=waitlist.name,
        subHeading=waitlist.subHeading,
        description=waitlist.description,
        categories=waitlist.categories,
        imageUrls=waitlist.imageUrls or [],
        videoUrl=waitlist.videoUrl,
        agentOutputDemoUrl=waitlist.agentOutputDemoUrl,
        status=waitlist.status or prisma.enums.WaitlistExternalStatus.NOT_STARTED,
        votes=waitlist.votes,
        signupCount=joined_count + email_count,
        storeListingId=waitlist.storeListingId,
        owningUserId=waitlist.owningUserId,
    )
 async def create_waitlist_admin(
    admin_user_id: str,
    data: store_model.WaitlistCreateRequest,
 ) -> store_model.WaitlistAdminResponse:
    """Create a new waitlist (admin only)."""
    logger.info(f"Admin {admin_user_id} creating waitlist: {data.name}")
    try:
        waitlist = await prisma.models.WaitlistEntry.prisma().create(
            data=prisma.types.WaitlistEntryCreateInput(
                name=data.name,
                slug=data.slug,
                subHeading=data.subHeading,
                description=data.description,
                categories=data.categories,
                imageUrls=data.imageUrls,
                videoUrl=data.videoUrl,
                agentOutputDemoUrl=data.agentOutputDemoUrl,
                owningUserId=admin_user_id,
                status=prisma.enums.WaitlistExternalStatus.NOT_STARTED,
            ),
            include={"joinedUsers": True},
        )
        return _waitlist_to_admin_response(waitlist)
    except Exception as e:
        logger.error(f"Error creating waitlist: {e}")
        raise DatabaseError("Failed to create waitlist") from e
 async def get_waitlists_admin() -> store_model.WaitlistAdminListResponse:
    """Get all waitlists with admin details."""
    try:
        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
            where=prisma.types.WaitlistEntryWhereInput(isDeleted=False),
            include={"joinedUsers": True},
            order={"createdAt": "desc"},
        )
        return store_model.WaitlistAdminListResponse(
            waitlists=[_waitlist_to_admin_response(w) for w in waitlists],
            totalCount=len(waitlists),
        )
    except Exception as e:
        logger.error(f"Error fetching waitlists for admin: {e}")
        raise DatabaseError("Failed to fetch waitlists") from e
 async def get_waitlist_admin(
    waitlist_id: str,
 ) -> store_model.WaitlistAdminResponse:
    """Get a single waitlist with admin details."""
    try:
        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
            where={"id": waitlist_id},
            include={"joinedUsers": True},
        )
        if not waitlist:
            raise ValueError(f"Waitlist {waitlist_id} not found")
        if waitlist.isDeleted:
            raise ValueError(f"Waitlist {waitlist_id} has been deleted")
        return _waitlist_to_admin_response(waitlist)
    except ValueError:
        raise
    except Exception as e:
        logger.error(f"Error fetching waitlist {waitlist_id}: {e}")
        raise DatabaseError("Failed to fetch waitlist") from e
 async def update_waitlist_admin(
    waitlist_id: str,
    data: store_model.WaitlistUpdateRequest,
 ) -> store_model.WaitlistAdminResponse:
    """Update a waitlist (admin only)."""
    logger.info(f"Updating waitlist {waitlist_id}")
    try:
        # Check if waitlist exists first
        existing = await prisma.models.WaitlistEntry.prisma().find_unique(
            where={"id": waitlist_id}
        )
        if not existing:
            raise ValueError(f"Waitlist {waitlist_id} not found")
        if existing.isDeleted:
            raise ValueError(f"Waitlist {waitlist_id} has been deleted")
        # Build update data from explicitly provided fields
        # Use model_fields_set to allow clearing fields by setting them to None
        field_mappings = {
            "name": data.name,
            "slug": data.slug,
            "subHeading": data.subHeading,
            "description": data.description,
            "categories": data.categories,
            "imageUrls": data.imageUrls,
            "videoUrl": data.videoUrl,
            "agentOutputDemoUrl": data.agentOutputDemoUrl,
            "storeListingId": data.storeListingId,
        }
        update_data: dict[str, Any] = {
            k: v for k, v in field_mappings.items() if k in data.model_fields_set
        }
        # Add status if provided (already validated as enum by Pydantic)
        if "status" in data.model_fields_set and data.status is not None:
            update_data["status"] = data.status
        if not update_data:
            # No updates, just return current data
            return await get_waitlist_admin(waitlist_id)
        waitlist = await prisma.models.WaitlistEntry.prisma().update(
            where={"id": waitlist_id},
            data=prisma.types.WaitlistEntryUpdateInput(**update_data),
            include={"joinedUsers": True},
        )
        # We already verified existence above, so this should never be None
        assert waitlist is not None
        return _waitlist_to_admin_response(waitlist)
    except ValueError:
        raise
    except Exception as e:
        logger.error(f"Error updating waitlist {waitlist_id}: {e}")
        raise DatabaseError("Failed to update waitlist") from e
 async def delete_waitlist_admin(waitlist_id: str) -> None:
    """Soft delete a waitlist (admin only)."""
    logger.info(f"Soft deleting waitlist {waitlist_id}")
    try:
        # Check if waitlist exists first
        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
            where={"id": waitlist_id},
        )
        if not waitlist:
            raise ValueError(f"Waitlist {waitlist_id} not found")
        if waitlist.isDeleted:
            raise ValueError(f"Waitlist {waitlist_id} has already been deleted")
        await prisma.models.WaitlistEntry.prisma().update(
            where={"id": waitlist_id},
            data={"isDeleted": True},
        )
    except ValueError:
        raise
    except Exception as e:
        logger.error(f"Error deleting waitlist {waitlist_id}: {e}")
        raise DatabaseError("Failed to delete waitlist") from e
 async def get_waitlist_signups_admin(
    waitlist_id: str,
 ) -> store_model.WaitlistSignupListResponse:
    """Get all signups for a waitlist (admin only)."""
    try:
        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
            where={"id": waitlist_id},
            include={"joinedUsers": True},
        )
        if not waitlist:
            raise ValueError(f"Waitlist {waitlist_id} not found")
        signups: list[store_model.WaitlistSignup] = []
        # Add user signups
        for user in waitlist.joinedUsers or []:
            signups.append(
                store_model.WaitlistSignup(
                    type="user",
                    userId=user.id,
                    email=user.email,
                    username=user.name,
                )
            )
        # Add email signups
        for email in waitlist.unaffiliatedEmailUsers or []:
            signups.append(
                store_model.WaitlistSignup(
                    type="email",
                    email=email,
                )
            )
        return store_model.WaitlistSignupListResponse(
            waitlistId=waitlist_id,
            signups=signups,
            totalCount=len(signups),
        )
    except ValueError:
        raise
    except Exception as e:
        logger.error(f"Error fetching signups for waitlist {waitlist_id}: {e}")
        raise DatabaseError("Failed to fetch waitlist signups") from e
 async def link_waitlist_to_listing_admin(
    waitlist_id: str,
    store_listing_id: str,
 ) -> store_model.WaitlistAdminResponse:
    """Link a waitlist to a store listing (admin only)."""
    logger.info(f"Linking waitlist {waitlist_id} to listing {store_listing_id}")
    try:
        # Verify the waitlist exists
        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
            where={"id": waitlist_id}
        )
        if not waitlist:
            raise ValueError(f"Waitlist {waitlist_id} not found")
        if waitlist.isDeleted:
            raise ValueError(f"Waitlist {waitlist_id} has been deleted")
        # Verify the store listing exists
        listing = await prisma.models.StoreListing.prisma().find_unique(
            where={"id": store_listing_id}
        )
        if not listing:
            raise ValueError(f"Store listing {store_listing_id} not found")
        updated_waitlist = await prisma.models.WaitlistEntry.prisma().update(
            where={"id": waitlist_id},
            data={"StoreListing": {"connect": {"id": store_listing_id}}},
            include={"joinedUsers": True},
        )
        # We already verified existence above, so this should never be None
        assert updated_waitlist is not None
        return _waitlist_to_admin_response(updated_waitlist)
    except ValueError:
        raise
    except Exception as e:
        logger.error(f"Error linking waitlist to listing: {e}")
        raise DatabaseError("Failed to link waitlist to listing") from e
 async def notify_waitlist_users_on_launch(
    store_listing_id: str,
    agent_name: str,
    store_url: str,
 ) -> int:
    """
    Notify all users on waitlists linked to a store listing when the agent is launched.
    Args:
        store_listing_id: The ID of the store listing that was approved
        agent_name: The name of the approved agent
        store_url: The URL to the agent's store page
    Returns:
        The number of notifications sent
    """
    logger.info(f"Notifying waitlist users for store listing {store_listing_id}")
    try:
        # Find all active waitlists linked to this store listing
        # Exclude DONE and CANCELED to prevent duplicate notifications on re-approval
        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
            where={
                "storeListingId": store_listing_id,
                "isDeleted": False,
                "status": {
                    "not_in": [
                        prisma.enums.WaitlistExternalStatus.DONE,
                        prisma.enums.WaitlistExternalStatus.CANCELED,
                    ]
                },
            },
            include={"joinedUsers": True},
        )
        if not waitlists:
            logger.info(
                f"No active waitlists found for store listing {store_listing_id}"
            )
            return 0
        notification_count = 0
        launched_at = datetime.now(tz=timezone.utc)
        for waitlist in waitlists:
            # Track notification results for this waitlist
            users_to_notify = waitlist.joinedUsers or []
            failed_user_ids: list[str] = []
            # Notify registered users
            for user in users_to_notify:
                try:
                    notification_data = WaitlistLaunchData(
                        agent_name=agent_name,
                        waitlist_name=waitlist.name,
                        store_url=store_url,
                        launched_at=launched_at,
                    )
                    notification_event = NotificationEventModel[WaitlistLaunchData](
                        user_id=user.id,
                        type=prisma.enums.NotificationType.WAITLIST_LAUNCH,
                        data=notification_data,
                    )
                    await queue_notification_async(notification_event)
                    notification_count += 1
                except Exception as e:
                    logger.error(
                        f"Failed to send waitlist launch notification to user {user.id}: {e}"
                    )
                    failed_user_ids.append(user.id)
            # Note: For unaffiliated email users, you would need to send emails directly
            # since they don't have user IDs for the notification system.
            # This could be done via a separate email service.
            # For now, we log these for potential manual follow-up or future implementation.
            has_pending_email_users = bool(waitlist.unaffiliatedEmailUsers)
            if has_pending_email_users:
                logger.info(
                    f"Waitlist {waitlist.id} has {len(waitlist.unaffiliatedEmailUsers)} "
                    f"unaffiliated email users that need email notifications"
                )
            # Only mark waitlist as DONE if all registered user notifications succeeded
            # AND there are no unaffiliated email users still waiting for notifications
            if not failed_user_ids and not has_pending_email_users:
                await prisma.models.WaitlistEntry.prisma().update(
                    where={"id": waitlist.id},
                    data={"status": prisma.enums.WaitlistExternalStatus.DONE},
                )
                logger.info(f"Updated waitlist {waitlist.id} status to DONE")
            elif failed_user_ids:
                logger.warning(
                    f"Waitlist {waitlist.id} not marked as DONE due to "
                    f"{len(failed_user_ids)} failed notifications"
                )
            elif has_pending_email_users:
                logger.warning(
                    f"Waitlist {waitlist.id} not marked as DONE due to "
                    f"{len(waitlist.unaffiliatedEmailUsers)} pending email-only users"
                )
        logger.info(
            f"Sent {notification_count} waitlist launch notifications for store listing {store_listing_id}"
        )
        return notification_count
    except Exception as e:
        logger.error(
            f"Error notifying waitlist users for store listing {store_listing_id}: {e}"
        )
        # Don't raise - we don't want to fail the approval process
        return 0
--- a/autogpt_platform/backend/backend/api/features/store/embeddings.py
+++ b/autogpt_platform/backend/backend/api/features/store/embeddings.py
@@ -154,16 +154,15 @@ async def store_content_embedding(
        # Upsert the embedding
        # WHERE clause in DO UPDATE prevents PostgreSQL 15 bug with NULLS NOT DISTINCT
        # Use {pgvector_schema}.vector for explicit pgvector type qualification
        await execute_raw_with_schema(
            """
            INSERT INTO {schema_prefix}"UnifiedContentEmbedding" (
                "id", "contentType", "contentId", "userId", "embedding", "searchableText", "metadata", "createdAt", "updatedAt"
            )
-            VALUES (gen_random_uuid()::text, $1::{schema_prefix}"ContentType", $2, $3, $4::{pgvector_schema}.vector, $5, $6::jsonb, NOW(), NOW())
+            VALUES (gen_random_uuid()::text, $1::{schema_prefix}"ContentType", $2, $3, $4::vector, $5, $6::jsonb, NOW(), NOW())
            ON CONFLICT ("contentType", "contentId", "userId")
            DO UPDATE SET
-                "embedding" = $4::{pgvector_schema}.vector,
+                "embedding" = $4::vector,
                "searchableText" = $5,
                "metadata" = $6::jsonb,
                "updatedAt" = NOW()
@@ -178,6 +177,7 @@ async def store_content_embedding(
            searchable_text,
            metadata_json,
            client=client,
            set_public_search_path=True,
        )
        logger.info(f"Stored embedding for {content_type}:{content_id}")
@@ -236,6 +236,7 @@ async def get_content_embedding(
            content_type,
            content_id,
            user_id,
            set_public_search_path=True,
        )
        if result and len(result) > 0:
@@ -870,46 +871,31 @@ async def semantic_search(
        # Add content type parameters and build placeholders dynamically
        content_type_start_idx = len(params) + 1
        content_type_placeholders = ", ".join(
-            "$" + str(content_type_start_idx + i) + '::{schema_prefix}"ContentType"'
+            f'${content_type_start_idx + i}::{{{{schema_prefix}}}}"ContentType"'
            for i in range(len(content_types))
        )
        params.extend([ct.value for ct in content_types])
-        # Build min_similarity param index before appending
+        sql = f"""
        min_similarity_idx = len(params) + 1
        params.append(min_similarity)
        # Use regular string (not f-string) for template to preserve {schema_prefix} and {schema} placeholders
        # Use OPERATOR({pgvector_schema}.<=>) for explicit operator schema qualification
        sql = (
            """
            SELECT
                "contentId" as content_id,
                "contentType" as content_type,
                "searchableText" as searchable_text,
                metadata,
-                1 - (embedding OPERATOR({pgvector_schema}.<=>) '"""
+                1 - (embedding <=> '{embedding_str}'::vector) as similarity
-            + embedding_str
+            FROM {{{{schema_prefix}}}}"UnifiedContentEmbedding"
-            + """'::{pgvector_schema}.vector) as similarity
+            WHERE "contentType" IN ({content_type_placeholders})
-            FROM {schema_prefix}"UnifiedContentEmbedding"
+            {user_filter}
-            WHERE "contentType" IN ("""
+            AND 1 - (embedding <=> '{embedding_str}'::vector) >= ${len(params) + 1}
            + content_type_placeholders
            + """)
            """
            + user_filter
            + """
            AND 1 - (embedding OPERATOR({pgvector_schema}.<=>) '"""
            + embedding_str
            + """'::{pgvector_schema}.vector) >= $"""
            + str(min_similarity_idx)
            + """
            ORDER BY similarity DESC
            LIMIT $1
        """
-        )
+        params.append(min_similarity)
        try:
-            results = await query_raw_with_schema(sql, *params)
+            results = await query_raw_with_schema(
                sql, *params, set_public_search_path=True
            )
            return [
                {
                    "content_id": row["content_id"],
@@ -936,41 +922,31 @@ async def semantic_search(
    # Add content type parameters and build placeholders dynamically
    content_type_start_idx = len(params_lexical) + 1
    content_type_placeholders_lexical = ", ".join(
-        "$" + str(content_type_start_idx + i) + '::{schema_prefix}"ContentType"'
+        f'${content_type_start_idx + i}::{{{{schema_prefix}}}}"ContentType"'
        for i in range(len(content_types))
    )
    params_lexical.extend([ct.value for ct in content_types])
-    # Build query param index before appending
+    sql_lexical = f"""
    query_param_idx = len(params_lexical) + 1
    params_lexical.append(f"%{query}%")
    # Use regular string (not f-string) for template to preserve {schema_prefix} placeholders
    sql_lexical = (
        """
        SELECT
            "contentId" as content_id,
            "contentType" as content_type,
            "searchableText" as searchable_text,
            metadata,
            0.0 as similarity
-        FROM {schema_prefix}"UnifiedContentEmbedding"
+        FROM {{{{schema_prefix}}}}"UnifiedContentEmbedding"
-        WHERE "contentType" IN ("""
+        WHERE "contentType" IN ({content_type_placeholders_lexical})
-        + content_type_placeholders_lexical
+        {user_filter}
-        + """)
+        AND "searchableText" ILIKE ${len(params_lexical) + 1}
        """
        + user_filter
        + """
        AND "searchableText" ILIKE $"""
        + str(query_param_idx)
        + """
        ORDER BY "updatedAt" DESC
        LIMIT $1
    """
-    )
+    params_lexical.append(f"%{query}%")
    try:
-        results = await query_raw_with_schema(sql_lexical, *params_lexical)
+        results = await query_raw_with_schema(
            sql_lexical, *params_lexical, set_public_search_path=True
        )
        return [
            {
                "content_id": row["content_id"],
--- a/autogpt_platform/backend/backend/api/features/store/embeddings_test.py
+++ b/autogpt_platform/backend/backend/api/features/store/embeddings_test.py
@@ -155,14 +155,18 @@ async def test_store_embedding_success(mocker):
    )
    assert result is True
-    # execute_raw is called once for INSERT (no separate SET search_path needed)
+    # execute_raw is called twice: once for SET search_path, once for INSERT
-    assert mock_client.execute_raw.call_count == 1
+    assert mock_client.execute_raw.call_count == 2
-    # Verify the INSERT query with the actual data
+    # First call: SET search_path
-    call_args = mock_client.execute_raw.call_args_list[0][0]
+    first_call_args = mock_client.execute_raw.call_args_list[0][0]
-    assert "test-version-id" in call_args
+    assert "SET search_path" in first_call_args[0]
-    assert "[0.1,0.2,0.3]" in call_args
+
-    assert None in call_args  # userId should be None for store agents
+    # Second call: INSERT query with the actual data
    second_call_args = mock_client.execute_raw.call_args_list[1][0]
    assert "test-version-id" in second_call_args
    assert "[0.1,0.2,0.3]" in second_call_args
    assert None in second_call_args  # userId should be None for store agents
@pytest.mark.asyncio(loop_scope="session")
--- a/autogpt_platform/backend/backend/api/features/store/hybrid_search.py
+++ b/autogpt_platform/backend/backend/api/features/store/hybrid_search.py
@@ -12,7 +12,7 @@ from dataclasses import dataclass
 from typing import Any, Literal
 from prisma.enums import ContentType
-from rank_bm25 import BM25Okapi  # type: ignore[import-untyped]
+from rank_bm25 import BM25Okapi
 from backend.api.features.store.embeddings import (
    EMBEDDING_DIM,
@@ -295,7 +295,7 @@ async def unified_hybrid_search(
                FROM {{schema_prefix}}"UnifiedContentEmbedding" uce
                WHERE uce."contentType" = ANY({content_types_param}::{{schema_prefix}}"ContentType"[])
                {user_filter}
-                ORDER BY uce.embedding OPERATOR({{pgvector_schema}}.<=>)  {embedding_param}::{{pgvector_schema}}.vector
+                ORDER BY uce.embedding <=> {embedding_param}::vector
                LIMIT 200
            )
        ),
@@ -307,7 +307,7 @@ async def unified_hybrid_search(
                uce.metadata,
                uce."updatedAt" as updated_at,
                -- Semantic score: cosine similarity (1 - distance)
-                COALESCE(1 - (uce.embedding OPERATOR({{pgvector_schema}}.<=>)  {embedding_param}::{{pgvector_schema}}.vector), 0) as semantic_score,
+                COALESCE(1 - (uce.embedding <=> {embedding_param}::vector), 0) as semantic_score,
                -- Lexical score: ts_rank_cd
                COALESCE(ts_rank_cd(uce.search, plainto_tsquery('english', {query_param})), 0) as lexical_raw,
                -- Category match from metadata
@@ -363,7 +363,9 @@ async def unified_hybrid_search(
        LIMIT {limit_param} OFFSET {offset_param}
    """
-    results = await query_raw_with_schema(sql_query, *params)
+    results = await query_raw_with_schema(
        sql_query, *params, set_public_search_path=True
    )
    total = results[0]["total_count"] if results else 0
    # Apply BM25 reranking
@@ -583,7 +585,7 @@ async def hybrid_search(
                WHERE uce."contentType" = 'STORE_AGENT'::{{schema_prefix}}"ContentType"
                AND uce."userId" IS NULL
                AND {where_clause}
-                ORDER BY uce.embedding OPERATOR({{pgvector_schema}}.<=>)  {embedding_param}::{{pgvector_schema}}.vector
+                ORDER BY uce.embedding <=> {embedding_param}::vector
                LIMIT 200
            ) uce
        ),
@@ -605,7 +607,7 @@ async def hybrid_search(
                -- Searchable text for BM25 reranking
                COALESCE(sa.agent_name, '') || ' ' || COALESCE(sa.sub_heading, '') || ' ' || COALESCE(sa.description, '') as searchable_text,
                -- Semantic score
-                COALESCE(1 - (uce.embedding OPERATOR({{pgvector_schema}}.<=>)  {embedding_param}::{{pgvector_schema}}.vector), 0) as semantic_score,
+                COALESCE(1 - (uce.embedding <=> {embedding_param}::vector), 0) as semantic_score,
                -- Lexical score (raw, will normalize)
                COALESCE(ts_rank_cd(uce.search, plainto_tsquery('english', {query_param})), 0) as lexical_raw,
                -- Category match
@@ -686,7 +688,9 @@ async def hybrid_search(
        LIMIT {limit_param} OFFSET {offset_param}
    """
-    results = await query_raw_with_schema(sql_query, *params)
+    results = await query_raw_with_schema(
        sql_query, *params, set_public_search_path=True
    )
    total = results[0]["total_count"] if results else 0
--- a/autogpt_platform/backend/backend/api/features/store/model.py
+++ b/autogpt_platform/backend/backend/api/features/store/model.py
@@ -223,102 +223,6 @@ class ReviewSubmissionRequest(pydantic.BaseModel):
    internal_comments: str | None = None  # Private admin notes
 class StoreWaitlistEntry(pydantic.BaseModel):
    """Public waitlist entry - no PII fields exposed."""
    waitlistId: str
    slug: str
    # Content fields
    name: str
    subHeading: str
    videoUrl: str | None = None
    agentOutputDemoUrl: str | None = None
    imageUrls: list[str]
    description: str
    categories: list[str]
 class StoreWaitlistsAllResponse(pydantic.BaseModel):
    listings: list[StoreWaitlistEntry]
 # Admin Waitlist Models
 class WaitlistCreateRequest(pydantic.BaseModel):
    """Request model for creating a new waitlist."""
    name: str
    slug: str
    subHeading: str
    description: str
    categories: list[str] = []
    imageUrls: list[str] = []
    videoUrl: str | None = None
    agentOutputDemoUrl: str | None = None
 class WaitlistUpdateRequest(pydantic.BaseModel):
    """Request model for updating a waitlist."""
    name: str | None = None
    slug: str | None = None
    subHeading: str | None = None
    description: str | None = None
    categories: list[str] | None = None
    imageUrls: list[str] | None = None
    videoUrl: str | None = None
    agentOutputDemoUrl: str | None = None
    status: prisma.enums.WaitlistExternalStatus | None = None
    storeListingId: str | None = None  # Link to a store listing
 class WaitlistAdminResponse(pydantic.BaseModel):
    """Admin response model with full waitlist details including internal data."""
    id: str
    createdAt: str
    updatedAt: str
    slug: str
    name: str
    subHeading: str
    description: str
    categories: list[str]
    imageUrls: list[str]
    videoUrl: str | None = None
    agentOutputDemoUrl: str | None = None
    status: prisma.enums.WaitlistExternalStatus
    votes: int
    signupCount: int  # Total count of joinedUsers + unaffiliatedEmailUsers
    storeListingId: str | None = None
    owningUserId: str
 class WaitlistSignup(pydantic.BaseModel):
    """Individual signup entry for a waitlist."""
    type: str  # "user" or "email"
    userId: str | None = None
    email: str | None = None
    username: str | None = None  # For user signups
 class WaitlistSignupListResponse(pydantic.BaseModel):
    """Response model for listing waitlist signups."""
    waitlistId: str
    signups: list[WaitlistSignup]
    totalCount: int
 class WaitlistAdminListResponse(pydantic.BaseModel):
    """Response model for listing all waitlists (admin view)."""
    waitlists: list[WaitlistAdminResponse]
    totalCount: int
 class UnifiedSearchResult(pydantic.BaseModel):
    """A single result from unified hybrid search across all content types."""
--- a/autogpt_platform/backend/backend/api/features/store/routes.py
+++ b/autogpt_platform/backend/backend/api/features/store/routes.py
@@ -8,7 +8,6 @@ import autogpt_libs.auth
 import fastapi
 import fastapi.responses
 import prisma.enums
 from autogpt_libs.auth.dependencies import get_optional_user_id
 import backend.data.graph
 import backend.util.json
@@ -82,74 +81,6 @@ async def update_or_create_profile(
    return updated_profile
 ##############################################
 ############## Waitlist Endpoints ############
 ##############################################
@router.get(
    "/waitlist",
    summary="Get the agent waitlist",
    tags=["store", "public"],
    response_model=store_model.StoreWaitlistsAllResponse,
 )
 async def get_waitlist():
    """
    Get all active waitlists for public display.
    """
    waitlists = await store_db.get_waitlist()
    return store_model.StoreWaitlistsAllResponse(listings=waitlists)
@router.get(
    "/waitlist/my-memberships",
    summary="Get waitlist IDs the current user has joined",
    tags=["store", "private"],
 )
 async def get_my_waitlist_memberships(
    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
 ) -> list[str]:
    """Returns list of waitlist IDs the authenticated user has joined."""
    return await store_db.get_user_waitlist_memberships(user_id)
@router.post(
    path="/waitlist/{waitlist_id}/join",
    summary="Add self to the agent waitlist",
    tags=["store", "public"],
    response_model=store_model.StoreWaitlistEntry,
 )
 async def add_self_to_waitlist(
    user_id: str | None = fastapi.Security(get_optional_user_id),
    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist to join"),
    email: str | None = fastapi.Body(
        default=None, embed=True, description="Email address for unauthenticated users"
    ),
 ):
    """
    Add the current user to the agent waitlist.
    """
    if not user_id and not email:
        raise fastapi.HTTPException(
            status_code=400,
            detail="Either user authentication or email address is required",
        )
    try:
        waitlist_entry = await store_db.add_user_to_waitlist(
            waitlist_id=waitlist_id, user_id=user_id, email=email
        )
        return waitlist_entry
    except ValueError as e:
        error_msg = str(e)
        if "not found" in error_msg:
            raise fastapi.HTTPException(status_code=404, detail="Waitlist not found")
        # Waitlist exists but is closed or unavailable
        raise fastapi.HTTPException(status_code=400, detail=error_msg)
    except Exception:
        raise fastapi.HTTPException(
            status_code=500, detail="An error occurred while joining the waitlist"
        )
 ##############################################
 ############### Agent Endpoints ##############
 ##############################################
--- a/autogpt_platform/backend/backend/api/rest_api.py
+++ b/autogpt_platform/backend/backend/api/rest_api.py
@@ -19,7 +19,6 @@ from prisma.errors import PrismaError
 import backend.api.features.admin.credit_admin_routes
 import backend.api.features.admin.execution_analytics_routes
 import backend.api.features.admin.store_admin_routes
 import backend.api.features.admin.waitlist_admin_routes
 import backend.api.features.builder
 import backend.api.features.builder.routes
 import backend.api.features.chat.routes as chat_routes
@@ -284,11 +283,6 @@ app.include_router(
    tags=["v2", "admin"],
    prefix="/api/store",
 )
 app.include_router(
    backend.api.features.admin.waitlist_admin_routes.router,
    tags=["v2", "admin"],
    prefix="/api/store",
 )
 app.include_router(
    backend.api.features.admin.credit_admin_routes.router,
    tags=["v2", "admin"],
--- a/autogpt_platform/backend/backend/blocks/data_manipulation.py
+++ b/autogpt_platform/backend/backend/blocks/data_manipulation.py
@@ -680,58 +680,3 @@ class ListIsEmptyBlock(Block):
    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
        yield "is_empty", len(input_data.list) == 0
 class ConcatenateListsBlock(Block):
    class Input(BlockSchemaInput):
        lists: List[List[Any]] = SchemaField(
            description="A list of lists to concatenate together. All lists will be combined in order into a single list.",
            placeholder="e.g., [[1, 2], [3, 4], [5, 6]]",
        )
    class Output(BlockSchemaOutput):
        concatenated_list: List[Any] = SchemaField(
            description="The concatenated list containing all elements from all input lists in order."
        )
        error: str = SchemaField(
            description="Error message if concatenation failed due to invalid input types."
        )
    def __init__(self):
        super().__init__(
            id="3cf9298b-5817-4141-9d80-7c2cc5199c8e",
            description="Concatenates multiple lists into a single list. All elements from all input lists are combined in order.",
            categories={BlockCategory.BASIC},
            input_schema=ConcatenateListsBlock.Input,
            output_schema=ConcatenateListsBlock.Output,
            test_input=[
                {"lists": [[1, 2, 3], [4, 5, 6]]},
                {"lists": [["a", "b"], ["c"], ["d", "e", "f"]]},
                {"lists": [[1, 2], []]},
                {"lists": []},
            ],
            test_output=[
                ("concatenated_list", [1, 2, 3, 4, 5, 6]),
                ("concatenated_list", ["a", "b", "c", "d", "e", "f"]),
                ("concatenated_list", [1, 2]),
                ("concatenated_list", []),
            ],
        )
    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
        concatenated = []
        for idx, lst in enumerate(input_data.lists):
            if lst is None:
                # Skip None values to avoid errors
                continue
            if not isinstance(lst, list):
                # Type validation: each item must be a list
                # Strings are iterable and would cause extend() to iterate character-by-character
                # Non-iterable types would raise TypeError
                yield "error", (
                    f"Invalid input at index {idx}: expected a list, got {type(lst).__name__}. "
                    f"All items in 'lists' must be lists (e.g., [[1, 2], [3, 4]])."
                )
                return
            concatenated.extend(lst)
        yield "concatenated_list", concatenated
--- a/autogpt_platform/backend/backend/data/db.py
+++ b/autogpt_platform/backend/backend/data/db.py
@@ -38,6 +38,20 @@ POOL_TIMEOUT = os.getenv("DB_POOL_TIMEOUT")
 if POOL_TIMEOUT:
    DATABASE_URL = add_param(DATABASE_URL, "pool_timeout", POOL_TIMEOUT)
 # Add public schema to search_path for pgvector type access
 # The vector extension is in public schema, but search_path is determined by schema parameter
 # Extract the schema from DATABASE_URL or default to 'public' (matching get_database_schema())
 parsed_url = urlparse(DATABASE_URL)
 url_params = dict(parse_qsl(parsed_url.query))
 db_schema = url_params.get("schema", "public")
 # Build search_path, avoiding duplicates if db_schema is already 'public'
 search_path_schemas = list(
    dict.fromkeys([db_schema, "public"])
 )  # Preserves order, removes duplicates
 search_path = ",".join(search_path_schemas)
 # This allows using ::vector without schema qualification
 DATABASE_URL = add_param(DATABASE_URL, "options", f"-c search_path={search_path}")
 HTTP_TIMEOUT = int(POOL_TIMEOUT) if POOL_TIMEOUT else None
 prisma = Prisma(
@@ -113,48 +127,38 @@ async def _raw_with_schema(
    *args,
    execute: bool = False,
    client: Prisma | None = None,
    set_public_search_path: bool = False,
 ) -> list[dict] | int:
    """Internal: Execute raw SQL with proper schema handling.
    Use query_raw_with_schema() or execute_raw_with_schema() instead.
    Supports placeholders:
        - {schema_prefix}: Table/type prefix (e.g., "platform".)
        - {schema}: Raw schema name for application tables (e.g., platform)
        - {pgvector_schema}: Schema where pgvector is installed (defaults to "public")
    Args:
-        query_template: SQL query with {schema_prefix}, {schema}, and/or {pgvector_schema} placeholders
+        query_template: SQL query with {schema_prefix} placeholder
        *args: Query parameters
        execute: If False, executes SELECT query. If True, executes INSERT/UPDATE/DELETE.
        client: Optional Prisma client for transactions (only used when execute=True).
        set_public_search_path: If True, sets search_path to include public schema.
                                Needed for pgvector types and other public schema objects.
    Returns:
        - list[dict] if execute=False (query results)
        - int if execute=True (number of affected rows)
    Example with vector type:
        await execute_raw_with_schema(
            'INSERT INTO {schema_prefix}"Embedding" (vec) VALUES ($1::{pgvector_schema}.vector)',
            embedding_data
        )
    """
    schema = get_database_schema()
    schema_prefix = f'"{schema}".' if schema != "public" else ""
-    # pgvector extension is typically installed in "public" schema
+    formatted_query = query_template.format(schema_prefix=schema_prefix)
    # On Supabase it may be in "extensions" but "public" is the common default
    pgvector_schema = "public"
    formatted_query = query_template.format(
        schema_prefix=schema_prefix,
        schema=schema,
        pgvector_schema=pgvector_schema,
    )
    import prisma as prisma_module
    db_client = client if client else prisma_module.get_client()
    # Set search_path to include public schema if requested
    # Prisma doesn't support the 'options' connection parameter, so we set it per-session
    # This is idempotent and safe to call multiple times
    if set_public_search_path:
        await db_client.execute_raw(f"SET search_path = {schema}, public")  # type: ignore
    if execute:
        result = await db_client.execute_raw(formatted_query, *args)  # type: ignore
    else:
@@ -163,12 +167,16 @@ async def _raw_with_schema(
    return result
-async def query_raw_with_schema(query_template: str, *args) -> list[dict]:
+async def query_raw_with_schema(
    query_template: str, *args, set_public_search_path: bool = False
 ) -> list[dict]:
    """Execute raw SQL SELECT query with proper schema handling.
    Args:
-        query_template: SQL query with {schema_prefix} and/or {schema} placeholders
+        query_template: SQL query with {schema_prefix} placeholder
        *args: Query parameters
        set_public_search_path: If True, sets search_path to include public schema.
                                Needed for pgvector types and other public schema objects.
    Returns:
        List of result rows as dictionaries
@@ -179,20 +187,23 @@ async def query_raw_with_schema(query_template: str, *args) -> list[dict]:
            user_id
        )
    """
-    return await _raw_with_schema(query_template, *args, execute=False)  # type: ignore
+    return await _raw_with_schema(query_template, *args, execute=False, set_public_search_path=set_public_search_path)  # type: ignore
 async def execute_raw_with_schema(
    query_template: str,
    *args,
    client: Prisma | None = None,
    set_public_search_path: bool = False,
 ) -> int:
    """Execute raw SQL command (INSERT/UPDATE/DELETE) with proper schema handling.
    Args:
-        query_template: SQL query with {schema_prefix} and/or {schema} placeholders
+        query_template: SQL query with {schema_prefix} placeholder
        *args: Query parameters
        client: Optional Prisma client for transactions
        set_public_search_path: If True, sets search_path to include public schema.
                                Needed for pgvector types and other public schema objects.
    Returns:
        Number of affected rows
@@ -204,7 +215,7 @@ async def execute_raw_with_schema(
            client=tx  # Optional transaction client
        )
    """
-    return await _raw_with_schema(query_template, *args, execute=True, client=client)  # type: ignore
+    return await _raw_with_schema(query_template, *args, execute=True, client=client, set_public_search_path=set_public_search_path)  # type: ignore
 class BaseDbModel(BaseModel):
--- a/autogpt_platform/backend/backend/data/notifications.py
+++ b/autogpt_platform/backend/backend/data/notifications.py
@@ -211,22 +211,6 @@ class AgentRejectionData(BaseNotificationData):
        return value
 class WaitlistLaunchData(BaseNotificationData):
    """Notification data for when an agent from a waitlist is launched."""
    agent_name: str
    waitlist_name: str
    store_url: str
    launched_at: datetime
    @field_validator("launched_at")
    @classmethod
    def validate_timezone(cls, value: datetime):
        if value.tzinfo is None:
            raise ValueError("datetime must have timezone information")
        return value
 NotificationData = Annotated[
    Union[
        AgentRunData,
@@ -239,7 +223,6 @@ NotificationData = Annotated[
        DailySummaryData,
        RefundRequestData,
        BaseSummaryData,
        WaitlistLaunchData,
    ],
    Field(discriminator="type"),
 ]
@@ -290,7 +273,6 @@ def get_notif_data_type(
        NotificationType.REFUND_PROCESSED: RefundRequestData,
        NotificationType.AGENT_APPROVED: AgentApprovalData,
        NotificationType.AGENT_REJECTED: AgentRejectionData,
        NotificationType.WAITLIST_LAUNCH: WaitlistLaunchData,
    }[notification_type]
@@ -336,7 +318,6 @@ class NotificationTypeOverride:
            NotificationType.REFUND_PROCESSED: QueueType.ADMIN,
            NotificationType.AGENT_APPROVED: QueueType.IMMEDIATE,
            NotificationType.AGENT_REJECTED: QueueType.IMMEDIATE,
            NotificationType.WAITLIST_LAUNCH: QueueType.IMMEDIATE,
        }
        return BATCHING_RULES.get(self.notification_type, QueueType.IMMEDIATE)
@@ -356,7 +337,6 @@ class NotificationTypeOverride:
            NotificationType.REFUND_PROCESSED: "refund_processed.html",
            NotificationType.AGENT_APPROVED: "agent_approved.html",
            NotificationType.AGENT_REJECTED: "agent_rejected.html",
            NotificationType.WAITLIST_LAUNCH: "waitlist_launch.html",
        }[self.notification_type]
    @property
@@ -374,7 +354,6 @@ class NotificationTypeOverride:
            NotificationType.REFUND_PROCESSED: "Refund for ${{data.amount / 100}} to {{data.user_name}} has been processed",
            NotificationType.AGENT_APPROVED: "🎉 Your agent '{{data.agent_name}}' has been approved!",
            NotificationType.AGENT_REJECTED: "Your agent '{{data.agent_name}}' needs some updates",
            NotificationType.WAITLIST_LAUNCH: "🚀 {{data.agent_name}} is now available!",
        }[self.notification_type]
--- a/autogpt_platform/backend/backend/notifications/templates/waitlist_launch.html.jinja2
+++ b/autogpt_platform/backend/backend/notifications/templates/waitlist_launch.html.jinja2
@@ -1,59 +0,0 @@
 {# Waitlist Launch Notification Email Template #}
 {#
  Template variables:
  data.agent_name: the name of the launched agent
  data.waitlist_name: the name of the waitlist the user joined
  data.store_url: URL to view the agent in the store
  data.launched_at: when the agent was launched
  Subject: {{ data.agent_name }} is now available!
 #}
 {% block content %}
 <h1 style="color: #7c3aed; font-size: 32px; font-weight: 700; margin: 0 0 24px 0; text-align: center;">
  The wait is over!
 </h1>
 <p style="color: #586069; font-size: 18px; text-align: center; margin: 0 0 24px 0;">
  <strong>'{{ data.agent_name }}'</strong> is now live in the AutoGPT Store!
 </p>
 <div style="height: 32px; background: transparent;"></div>
 <div style="background: #f3e8ff; border: 1px solid #d8b4fe; border-radius: 8px; padding: 20px; margin: 0;">
  <h3 style="color: #6b21a8; font-size: 16px; font-weight: 600; margin: 0 0 12px 0;">
    You're one of the first to know!
  </h3>
  <p style="color: #6b21a8; margin: 0; font-size: 16px; line-height: 1.5;">
    You signed up for the <strong>{{ data.waitlist_name }}</strong> waitlist, and we're excited to let you know that this agent is now ready for you to use.
  </p>
 </div>
 <div style="height: 32px; background: transparent;"></div>
 <div style="text-align: center; margin: 24px 0;">
  <a href="{{ data.store_url }}" style="display: inline-block; background: linear-gradient(135deg, #7c3aed 0%, #5b21b6 100%); color: white; text-decoration: none; padding: 14px 28px; border-radius: 6px; font-weight: 600; font-size: 16px;">
    Get {{ data.agent_name }} Now
  </a>
 </div>
 <div style="height: 32px; background: transparent;"></div>
 <div style="background: #d1ecf1; border: 1px solid #bee5eb; border-radius: 8px; padding: 20px; margin: 0;">
  <h3 style="color: #0c5460; font-size: 16px; font-weight: 600; margin: 0 0 12px 0;">
    What can you do now?
  </h3>
  <ul style="color: #0c5460; margin: 0; padding-left: 18px; font-size: 16px; line-height: 1.6;">
    <li>Visit the store to learn more about what this agent can do</li>
    <li>Install and start using the agent right away</li>
    <li>Share it with others who might find it useful</li>
  </ul>
 </div>
 <div style="height: 32px; background: transparent;"></div>
 <p style="color: #6a737d; font-size: 14px; text-align: center; margin: 24px 0;">
  Thank you for helping us prioritize what to build! Your interest made this happen.
 </p>
 {% endblock %}
--- a/autogpt_platform/backend/migrations/20260108032037_add_waitlist_launch_notification/migration.sql
+++ b/autogpt_platform/backend/migrations/20260108032037_add_waitlist_launch_notification/migration.sql
@@ -1,53 +0,0 @@
 -- CreateEnum
 CREATE TYPE "WaitlistExternalStatus" AS ENUM ('DONE', 'NOT_STARTED', 'CANCELED', 'WORK_IN_PROGRESS');
 -- AlterEnum
 ALTER TYPE "NotificationType" ADD VALUE 'WAITLIST_LAUNCH';
 -- CreateTable
 CREATE TABLE "WaitlistEntry" (
    "id" TEXT NOT NULL,
    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    "updatedAt" TIMESTAMP(3) NOT NULL,
    "storeListingId" TEXT,
    "owningUserId" TEXT NOT NULL,
    "slug" TEXT NOT NULL,
    "search" tsvector DEFAULT ''::tsvector,
    "name" TEXT NOT NULL,
    "subHeading" TEXT NOT NULL,
    "videoUrl" TEXT,
    "agentOutputDemoUrl" TEXT,
    "imageUrls" TEXT[],
    "description" TEXT NOT NULL,
    "categories" TEXT[],
    "status" "WaitlistExternalStatus" NOT NULL DEFAULT 'NOT_STARTED',
    "votes" INTEGER NOT NULL DEFAULT 0,
    "unaffiliatedEmailUsers" TEXT[] DEFAULT ARRAY[]::TEXT[],
    "isDeleted" BOOLEAN NOT NULL DEFAULT false,
    CONSTRAINT "WaitlistEntry_pkey" PRIMARY KEY ("id")
 );
 -- CreateTable
 CREATE TABLE "_joinedWaitlists" (
    "A" TEXT NOT NULL,
    "B" TEXT NOT NULL
 );
 -- CreateIndex
 CREATE UNIQUE INDEX "_joinedWaitlists_AB_unique" ON "_joinedWaitlists"("A", "B");
 -- CreateIndex
 CREATE INDEX "_joinedWaitlists_B_index" ON "_joinedWaitlists"("B");
 -- AddForeignKey
 ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_storeListingId_fkey" FOREIGN KEY ("storeListingId") REFERENCES "StoreListing"("id") ON DELETE SET NULL ON UPDATE CASCADE;
 -- AddForeignKey
 ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_owningUserId_fkey" FOREIGN KEY ("owningUserId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
 -- AddForeignKey
 ALTER TABLE "_joinedWaitlists" ADD CONSTRAINT "_joinedWaitlists_A_fkey" FOREIGN KEY ("A") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
 -- AddForeignKey
 ALTER TABLE "_joinedWaitlists" ADD CONSTRAINT "_joinedWaitlists_B_fkey" FOREIGN KEY ("B") REFERENCES "WaitlistEntry"("id") ON DELETE CASCADE ON UPDATE CASCADE;
--- a/autogpt_platform/backend/schema.prisma
+++ b/autogpt_platform/backend/schema.prisma
@@ -69,10 +69,6 @@ model User {
  OAuthAuthorizationCodes OAuthAuthorizationCode[]
  OAuthAccessTokens       OAuthAccessToken[]
  OAuthRefreshTokens      OAuthRefreshToken[]
  // Waitlist relations
  waitlistEntries       WaitlistEntry[]
  joinedWaitlists       WaitlistEntry[] @relation("joinedWaitlists")
 }
 enum OnboardingStep {
@@ -299,7 +295,6 @@ enum NotificationType {
  REFUND_PROCESSED
  AGENT_APPROVED
  AGENT_REJECTED
  WAITLIST_LAUNCH
 }
 model NotificationEvent {
@@ -906,8 +901,7 @@ model StoreListing {
  OwningUser   User   @relation(fields: [owningUserId], references: [id])
  // Relations
-  Versions        StoreListingVersion[] @relation("ListingVersions")
+  Versions StoreListingVersion[] @relation("ListingVersions")
  waitlistEntries WaitlistEntry[]
  // Unique index on agentId to ensure only one listing per agent, regardless of number of versions the agent has.
  @@unique([agentGraphId])
@@ -1039,47 +1033,6 @@ model StoreListingReview {
  @@index([reviewByUserId])
 }
 enum WaitlistExternalStatus {
  DONE
  NOT_STARTED
  CANCELED
  WORK_IN_PROGRESS
 }
 model WaitlistEntry {
  id        String   @id @default(uuid())
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
  storeListingId String?
  StoreListing   StoreListing? @relation(fields: [storeListingId], references: [id], onDelete: SetNull)
  owningUserId String
  OwningUser   User   @relation(fields: [owningUserId], references: [id])
  slug   String
  search Unsupported("tsvector")? @default(dbgenerated("''::tsvector"))
  // Content fields
  name               String
  subHeading         String
  videoUrl           String?
  agentOutputDemoUrl String?
  imageUrls          String[]
  description        String
  categories         String[]
  //Waitlist specific fields
  status                 WaitlistExternalStatus @default(NOT_STARTED)
  votes                  Int                    @default(0) // Hide from frontend api
  joinedUsers            User[]                 @relation("joinedWaitlists")
  // NOTE: DO NOT DOUBLE SEND TO THESE USERS, IF THEY HAVE SIGNED UP SINCE THEY MAY HAVE ALREADY RECEIVED AN EMAIL
  // DOUBLE CHECK WHEN SENDING THAT THEY ARE NOT IN THE JOINED USERS LIST ALSO
  unaffiliatedEmailUsers String[]               @default([])
  isDeleted Boolean @default(false)
 }
 enum SubmissionStatus {
  DRAFT // Being prepared, not yet submitted
  PENDING // Submitted, awaiting review
--- a/autogpt_platform/frontend/src/app/(platform)/admin/layout.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/layout.tsx
@@ -1,5 +1,5 @@
 import { Sidebar } from "@/components/__legacy__/Sidebar";
-import { Users, DollarSign, UserSearch, FileText, Clock } from "lucide-react";
+import { Users, DollarSign, UserSearch, FileText } from "lucide-react";
 import { IconSliders } from "@/components/__legacy__/ui/icons";
@@ -11,11 +11,6 @@ const sidebarLinkGroups = [
        href: "/admin/marketplace",
        icon: <Users className="h-6 w-6" />,
      },
      {
        text: "Waitlist Management",
        href: "/admin/waitlist",
        icon: <Clock className="h-6 w-6" />,
      },
      {
        text: "User Spending",
        href: "/admin/spending",
--- a/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/CreateWaitlistButton.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/CreateWaitlistButton.tsx
@@ -1,217 +0,0 @@
 "use client";
 import { useState } from "react";
 import { useQueryClient } from "@tanstack/react-query";
 import { Button } from "@/components/atoms/Button/Button";
 import { Input } from "@/components/atoms/Input/Input";
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import {
  usePostV2CreateWaitlist,
  getGetV2ListAllWaitlistsQueryKey,
 } from "@/app/api/__generated__/endpoints/admin/admin";
 import { useToast } from "@/components/molecules/Toast/use-toast";
 import { Plus } from "@phosphor-icons/react";
 export function CreateWaitlistButton() {
  const [open, setOpen] = useState(false);
  const { toast } = useToast();
  const queryClient = useQueryClient();
  const createWaitlistMutation = usePostV2CreateWaitlist({
    mutation: {
      onSuccess: (response) => {
        if (response.status === 200) {
          toast({
            title: "Success",
            description: "Waitlist created successfully",
          });
          setOpen(false);
          setFormData({
            name: "",
            slug: "",
            subHeading: "",
            description: "",
            categories: "",
            imageUrls: "",
            videoUrl: "",
            agentOutputDemoUrl: "",
          });
          queryClient.invalidateQueries({
            queryKey: getGetV2ListAllWaitlistsQueryKey(),
          });
        } else {
          toast({
            variant: "destructive",
            title: "Error",
            description: "Failed to create waitlist",
          });
        }
      },
      onError: (error) => {
        console.error("Error creating waitlist:", error);
        toast({
          variant: "destructive",
          title: "Error",
          description: "Failed to create waitlist",
        });
      },
    },
  });
  const [formData, setFormData] = useState({
    name: "",
    slug: "",
    subHeading: "",
    description: "",
    categories: "",
    imageUrls: "",
    videoUrl: "",
    agentOutputDemoUrl: "",
  });
  function handleInputChange(id: string, value: string) {
    setFormData((prev) => ({
      ...prev,
      [id]: value,
    }));
  }
  function generateSlug(name: string) {
    return name
      .toLowerCase()
      .replace(/[^a-z0-9]+/g, "-")
      .replace(/^-|-$/g, "");
  }
  function handleSubmit(e: React.FormEvent) {
    e.preventDefault();
    createWaitlistMutation.mutate({
      data: {
        name: formData.name,
        slug: formData.slug || generateSlug(formData.name),
        subHeading: formData.subHeading,
        description: formData.description,
        categories: formData.categories
          ? formData.categories.split(",").map((c) => c.trim())
          : [],
        imageUrls: formData.imageUrls
          ? formData.imageUrls.split(",").map((u) => u.trim())
          : [],
        videoUrl: formData.videoUrl || null,
        agentOutputDemoUrl: formData.agentOutputDemoUrl || null,
      },
    });
  }
  return (
    <>
      <Button onClick={() => setOpen(true)}>
        <Plus size={16} className="mr-2" />
        Create Waitlist
      </Button>
      <Dialog
        title="Create New Waitlist"
        controlled={{
          isOpen: open,
          set: async (isOpen) => setOpen(isOpen),
        }}
        onClose={() => setOpen(false)}
        styling={{ maxWidth: "600px" }}
      >
        <Dialog.Content>
          <p className="mb-4 text-sm text-zinc-500">
            Create a new waitlist for an upcoming agent. Users can sign up to be
            notified when it launches.
          </p>
          <form onSubmit={handleSubmit} className="flex flex-col gap-2">
            <Input
              id="name"
              label="Name"
              value={formData.name}
              onChange={(e) => handleInputChange("name", e.target.value)}
              placeholder="SEO Analysis Agent"
              required
            />
            <Input
              id="slug"
              label="Slug"
              value={formData.slug}
              onChange={(e) => handleInputChange("slug", e.target.value)}
              placeholder="seo-analysis-agent (auto-generated if empty)"
            />
            <Input
              id="subHeading"
              label="Subheading"
              value={formData.subHeading}
              onChange={(e) => handleInputChange("subHeading", e.target.value)}
              placeholder="Analyze your website's SEO in minutes"
              required
            />
            <Input
              id="description"
              label="Description"
              type="textarea"
              value={formData.description}
              onChange={(e) => handleInputChange("description", e.target.value)}
              placeholder="Detailed description of what this agent does..."
              rows={4}
              required
            />
            <Input
              id="categories"
              label="Categories (comma-separated)"
              value={formData.categories}
              onChange={(e) => handleInputChange("categories", e.target.value)}
              placeholder="SEO, Marketing, Analysis"
            />
            <Input
              id="imageUrls"
              label="Image URLs (comma-separated)"
              value={formData.imageUrls}
              onChange={(e) => handleInputChange("imageUrls", e.target.value)}
              placeholder="https://example.com/image1.jpg, https://example.com/image2.jpg"
            />
            <Input
              id="videoUrl"
              label="Video URL (optional)"
              value={formData.videoUrl}
              onChange={(e) => handleInputChange("videoUrl", e.target.value)}
              placeholder="https://youtube.com/watch?v=..."
            />
            <Input
              id="agentOutputDemoUrl"
              label="Output Demo URL (optional)"
              value={formData.agentOutputDemoUrl}
              onChange={(e) =>
                handleInputChange("agentOutputDemoUrl", e.target.value)
              }
              placeholder="https://example.com/demo-output.mp4"
            />
            <Dialog.Footer>
              <Button
                type="button"
                variant="secondary"
                onClick={() => setOpen(false)}
              >
                Cancel
              </Button>
              <Button type="submit" loading={createWaitlistMutation.isPending}>
                Create Waitlist
              </Button>
            </Dialog.Footer>
          </form>
        </Dialog.Content>
      </Dialog>
    </>
  );
 }
--- a/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/EditWaitlistDialog.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/EditWaitlistDialog.tsx
@@ -1,221 +0,0 @@
 "use client";
 import { useState } from "react";
 import { Button } from "@/components/atoms/Button/Button";
 import { Input } from "@/components/atoms/Input/Input";
 import { Select } from "@/components/atoms/Select/Select";
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import { useToast } from "@/components/molecules/Toast/use-toast";
 import { usePutV2UpdateWaitlist } from "@/app/api/__generated__/endpoints/admin/admin";
 import type { WaitlistAdminResponse } from "@/app/api/__generated__/models/waitlistAdminResponse";
 import type { WaitlistUpdateRequest } from "@/app/api/__generated__/models/waitlistUpdateRequest";
 import { WaitlistExternalStatus } from "@/app/api/__generated__/models/waitlistExternalStatus";
 type EditWaitlistDialogProps = {
  waitlist: WaitlistAdminResponse;
  onClose: () => void;
  onSave: () => void;
 };
 const STATUS_OPTIONS = [
  { value: WaitlistExternalStatus.NOT_STARTED, label: "Not Started" },
  { value: WaitlistExternalStatus.WORK_IN_PROGRESS, label: "Work In Progress" },
  { value: WaitlistExternalStatus.DONE, label: "Done" },
  { value: WaitlistExternalStatus.CANCELED, label: "Canceled" },
 ];
 export function EditWaitlistDialog({
  waitlist,
  onClose,
  onSave,
 }: EditWaitlistDialogProps) {
  const { toast } = useToast();
  const updateWaitlistMutation = usePutV2UpdateWaitlist();
  const [formData, setFormData] = useState({
    name: waitlist.name,
    slug: waitlist.slug,
    subHeading: waitlist.subHeading,
    description: waitlist.description,
    categories: waitlist.categories.join(", "),
    imageUrls: waitlist.imageUrls.join(", "),
    videoUrl: waitlist.videoUrl || "",
    agentOutputDemoUrl: waitlist.agentOutputDemoUrl || "",
    status: waitlist.status,
    storeListingId: waitlist.storeListingId || "",
  });
  function handleInputChange(id: string, value: string) {
    setFormData((prev) => ({
      ...prev,
      [id]: value,
    }));
  }
  function handleStatusChange(value: string) {
    setFormData((prev) => ({
      ...prev,
      status: value as WaitlistExternalStatus,
    }));
  }
  async function handleSubmit(e: React.FormEvent) {
    e.preventDefault();
    const updateData: WaitlistUpdateRequest = {
      name: formData.name,
      slug: formData.slug,
      subHeading: formData.subHeading,
      description: formData.description,
      categories: formData.categories
        ? formData.categories.split(",").map((c) => c.trim())
        : [],
      imageUrls: formData.imageUrls
        ? formData.imageUrls.split(",").map((u) => u.trim())
        : [],
      videoUrl: formData.videoUrl || null,
      agentOutputDemoUrl: formData.agentOutputDemoUrl || null,
      status: formData.status,
      storeListingId: formData.storeListingId || null,
    };
    updateWaitlistMutation.mutate(
      { waitlistId: waitlist.id, data: updateData },
      {
        onSuccess: (response) => {
          if (response.status === 200) {
            toast({
              title: "Success",
              description: "Waitlist updated successfully",
            });
            onSave();
          } else {
            toast({
              variant: "destructive",
              title: "Error",
              description: "Failed to update waitlist",
            });
          }
        },
        onError: () => {
          toast({
            variant: "destructive",
            title: "Error",
            description: "Failed to update waitlist",
          });
        },
      },
    );
  }
  return (
    <Dialog
      title="Edit Waitlist"
      controlled={{
        isOpen: true,
        set: async (open) => {
          if (!open) onClose();
        },
      }}
      onClose={onClose}
      styling={{ maxWidth: "600px" }}
    >
      <Dialog.Content>
        <p className="mb-4 text-sm text-zinc-500">
          Update the waitlist details. Changes will be reflected immediately.
        </p>
        <form onSubmit={handleSubmit} className="flex flex-col gap-2">
          <Input
            id="name"
            label="Name"
            value={formData.name}
            onChange={(e) => handleInputChange("name", e.target.value)}
            required
          />
          <Input
            id="slug"
            label="Slug"
            value={formData.slug}
            onChange={(e) => handleInputChange("slug", e.target.value)}
          />
          <Input
            id="subHeading"
            label="Subheading"
            value={formData.subHeading}
            onChange={(e) => handleInputChange("subHeading", e.target.value)}
            required
          />
          <Input
            id="description"
            label="Description"
            type="textarea"
            value={formData.description}
            onChange={(e) => handleInputChange("description", e.target.value)}
            rows={4}
            required
          />
          <Select
            id="status"
            label="Status"
            value={formData.status}
            onValueChange={handleStatusChange}
            options={STATUS_OPTIONS}
          />
          <Input
            id="categories"
            label="Categories (comma-separated)"
            value={formData.categories}
            onChange={(e) => handleInputChange("categories", e.target.value)}
          />
          <Input
            id="imageUrls"
            label="Image URLs (comma-separated)"
            value={formData.imageUrls}
            onChange={(e) => handleInputChange("imageUrls", e.target.value)}
          />
          <Input
            id="videoUrl"
            label="Video URL"
            value={formData.videoUrl}
            onChange={(e) => handleInputChange("videoUrl", e.target.value)}
          />
          <Input
            id="agentOutputDemoUrl"
            label="Output Demo URL"
            value={formData.agentOutputDemoUrl}
            onChange={(e) =>
              handleInputChange("agentOutputDemoUrl", e.target.value)
            }
          />
          <Input
            id="storeListingId"
            label="Store Listing ID (for linking)"
            value={formData.storeListingId}
            onChange={(e) =>
              handleInputChange("storeListingId", e.target.value)
            }
            placeholder="Leave empty if not linked"
          />
          <Dialog.Footer>
            <Button type="button" variant="secondary" onClick={onClose}>
              Cancel
            </Button>
            <Button type="submit" loading={updateWaitlistMutation.isPending}>
              Save Changes
            </Button>
          </Dialog.Footer>
        </form>
      </Dialog.Content>
    </Dialog>
  );
 }
--- a/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/WaitlistSignupsDialog.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/WaitlistSignupsDialog.tsx
@@ -1,156 +0,0 @@
 "use client";
 import { Button } from "@/components/atoms/Button/Button";
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import { User, Envelope, DownloadSimple } from "@phosphor-icons/react";
 import { useGetV2GetWaitlistSignups } from "@/app/api/__generated__/endpoints/admin/admin";
 type WaitlistSignupsDialogProps = {
  waitlistId: string;
  onClose: () => void;
 };
 export function WaitlistSignupsDialog({
  waitlistId,
  onClose,
 }: WaitlistSignupsDialogProps) {
  const {
    data: signupsResponse,
    isLoading,
    isError,
  } = useGetV2GetWaitlistSignups(waitlistId);
  const signups = signupsResponse?.status === 200 ? signupsResponse.data : null;
  function exportToCSV() {
    if (!signups) return;
    const headers = ["Type", "Email", "User ID", "Username"];
    const rows = signups.signups.map((signup) => [
      signup.type,
      signup.email || "",
      signup.userId || "",
      signup.username || "",
    ]);
    const escapeCell = (cell: string) => `"${cell.replace(/"/g, '""')}"`;
    const csvContent = [
      headers.join(","),
      ...rows.map((row) => row.map(escapeCell).join(",")),
    ].join("\n");
    const blob = new Blob([csvContent], { type: "text/csv" });
    const url = window.URL.createObjectURL(blob);
    const a = document.createElement("a");
    a.href = url;
    a.download = `waitlist-${waitlistId}-signups.csv`;
    a.click();
    window.URL.revokeObjectURL(url);
  }
  function renderContent() {
    if (isLoading) {
      return <div className="py-10 text-center">Loading signups...</div>;
    }
    if (isError) {
      return (
        <div className="py-10 text-center text-red-500">
          Failed to load signups. Please try again.
        </div>
      );
    }
    if (!signups || signups.signups.length === 0) {
      return (
        <div className="py-10 text-center text-gray-500">
          No signups yet for this waitlist.
        </div>
      );
    }
    return (
      <>
        <div className="flex justify-end">
          <Button variant="secondary" size="small" onClick={exportToCSV}>
            <DownloadSimple className="mr-2 h-4 w-4" size={16} />
            Export CSV
          </Button>
        </div>
        <div className="max-h-[400px] overflow-y-auto rounded-md border">
          <table className="w-full">
            <thead className="bg-gray-50 dark:bg-gray-800">
              <tr>
                <th className="px-4 py-3 text-left text-sm font-medium">
                  Type
                </th>
                <th className="px-4 py-3 text-left text-sm font-medium">
                  Email / Username
                </th>
                <th className="px-4 py-3 text-left text-sm font-medium">
                  User ID
                </th>
              </tr>
            </thead>
            <tbody className="divide-y">
              {signups.signups.map((signup, index) => (
                <tr key={index}>
                  <td className="px-4 py-3">
                    {signup.type === "user" ? (
                      <span className="flex items-center gap-1 text-blue-600">
                        <User className="h-4 w-4" size={16} /> User
                      </span>
                    ) : (
                      <span className="flex items-center gap-1 text-gray-600">
                        <Envelope className="h-4 w-4" size={16} /> Email
                      </span>
                    )}
                  </td>
                  <td className="px-4 py-3">
                    {signup.type === "user"
                      ? signup.username || signup.email
                      : signup.email}
                  </td>
                  <td className="px-4 py-3 font-mono text-sm">
                    {signup.userId || "-"}
                  </td>
                </tr>
              ))}
            </tbody>
          </table>
        </div>
      </>
    );
  }
  return (
    <Dialog
      title="Waitlist Signups"
      controlled={{
        isOpen: true,
        set: async (open) => {
          if (!open) onClose();
        },
      }}
      onClose={onClose}
      styling={{ maxWidth: "700px" }}
    >
      <Dialog.Content>
        <p className="mb-4 text-sm text-zinc-500">
          {signups
            ? `${signups.totalCount} total signups`
            : "Loading signups..."}
        </p>
        {renderContent()}
        <Dialog.Footer>
          <Button variant="secondary" onClick={onClose}>
            Close
          </Button>
        </Dialog.Footer>
      </Dialog.Content>
    </Dialog>
  );
 }
--- a/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/WaitlistTable.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/WaitlistTable.tsx
@@ -1,206 +0,0 @@
 "use client";
 import { useState } from "react";
 import { useQueryClient } from "@tanstack/react-query";
 import {
  Table,
  TableBody,
  TableCell,
  TableHead,
  TableHeader,
  TableRow,
 } from "@/components/__legacy__/ui/table";
 import { Button } from "@/components/atoms/Button/Button";
 import {
  useGetV2ListAllWaitlists,
  useDeleteV2DeleteWaitlist,
  getGetV2ListAllWaitlistsQueryKey,
 } from "@/app/api/__generated__/endpoints/admin/admin";
 import type { WaitlistAdminResponse } from "@/app/api/__generated__/models/waitlistAdminResponse";
 import { EditWaitlistDialog } from "./EditWaitlistDialog";
 import { WaitlistSignupsDialog } from "./WaitlistSignupsDialog";
 import { Trash, PencilSimple, Users, Link } from "@phosphor-icons/react";
 import { useToast } from "@/components/molecules/Toast/use-toast";
 export function WaitlistTable() {
  const [editingWaitlist, setEditingWaitlist] =
    useState<WaitlistAdminResponse | null>(null);
  const [viewingSignups, setViewingSignups] = useState<string | null>(null);
  const { toast } = useToast();
  const queryClient = useQueryClient();
  const { data: response, isLoading, error } = useGetV2ListAllWaitlists();
  const deleteWaitlistMutation = useDeleteV2DeleteWaitlist({
    mutation: {
      onSuccess: () => {
        toast({
          title: "Success",
          description: "Waitlist deleted successfully",
        });
        queryClient.invalidateQueries({
          queryKey: getGetV2ListAllWaitlistsQueryKey(),
        });
      },
      onError: (error) => {
        console.error("Error deleting waitlist:", error);
        toast({
          variant: "destructive",
          title: "Error",
          description: "Failed to delete waitlist",
        });
      },
    },
  });
  function handleDelete(waitlistId: string) {
    if (!confirm("Are you sure you want to delete this waitlist?")) return;
    deleteWaitlistMutation.mutate({ waitlistId });
  }
  function handleWaitlistSaved() {
    setEditingWaitlist(null);
    queryClient.invalidateQueries({
      queryKey: getGetV2ListAllWaitlistsQueryKey(),
    });
  }
  function formatStatus(status: string) {
    const statusColors: Record<string, string> = {
      NOT_STARTED: "bg-gray-100 text-gray-800",
      WORK_IN_PROGRESS: "bg-blue-100 text-blue-800",
      DONE: "bg-green-100 text-green-800",
      CANCELED: "bg-red-100 text-red-800",
    };
    return (
      <span
        className={`rounded-full px-2 py-1 text-xs font-medium ${statusColors[status] || "bg-gray-100 text-gray-700"}`}
      >
        {status.replace(/_/g, " ")}
      </span>
    );
  }
  function formatDate(dateStr: string) {
    if (!dateStr) return "-";
    return new Intl.DateTimeFormat("en-US", {
      month: "short",
      day: "numeric",
      year: "numeric",
    }).format(new Date(dateStr));
  }
  if (isLoading) {
    return <div className="py-10 text-center">Loading waitlists...</div>;
  }
  if (error) {
    return (
      <div className="py-10 text-center text-red-500">
        Error loading waitlists. Please try again.
      </div>
    );
  }
  const waitlists = response?.status === 200 ? response.data.waitlists : [];
  if (waitlists.length === 0) {
    return (
      <div className="py-10 text-center text-gray-500">
        No waitlists found. Create one to get started!
      </div>
    );
  }
  return (
    <>
      <div className="rounded-md border bg-white">
        <Table>
          <TableHeader className="bg-gray-50">
            <TableRow>
              <TableHead className="font-medium">Name</TableHead>
              <TableHead className="font-medium">Status</TableHead>
              <TableHead className="font-medium">Signups</TableHead>
              <TableHead className="font-medium">Votes</TableHead>
              <TableHead className="font-medium">Created</TableHead>
              <TableHead className="font-medium">Linked Agent</TableHead>
              <TableHead className="font-medium">Actions</TableHead>
            </TableRow>
          </TableHeader>
          <TableBody>
            {waitlists.map((waitlist) => (
              <TableRow key={waitlist.id}>
                <TableCell>
                  <div>
                    <div className="font-medium">{waitlist.name}</div>
                    <div className="text-sm text-gray-500">
                      {waitlist.subHeading}
                    </div>
                  </div>
                </TableCell>
                <TableCell>{formatStatus(waitlist.status)}</TableCell>
                <TableCell>{waitlist.signupCount}</TableCell>
                <TableCell>{waitlist.votes}</TableCell>
                <TableCell>{formatDate(waitlist.createdAt)}</TableCell>
                <TableCell>
                  {waitlist.storeListingId ? (
                    <span className="text-green-600">
                      <Link size={16} className="inline" /> Linked
                    </span>
                  ) : (
                    <span className="text-gray-400">Not linked</span>
                  )}
                </TableCell>
                <TableCell>
                  <div className="flex gap-2">
                    <Button
                      variant="ghost"
                      size="small"
                      onClick={() => setViewingSignups(waitlist.id)}
                      title="View signups"
                    >
                      <Users size={16} />
                    </Button>
                    <Button
                      variant="ghost"
                      size="small"
                      onClick={() => setEditingWaitlist(waitlist)}
                      title="Edit"
                    >
                      <PencilSimple size={16} />
                    </Button>
                    <Button
                      variant="ghost"
                      size="small"
                      onClick={() => handleDelete(waitlist.id)}
                      title="Delete"
                      disabled={deleteWaitlistMutation.isPending}
                    >
                      <Trash size={16} className="text-red-500" />
                    </Button>
                  </div>
                </TableCell>
              </TableRow>
            ))}
          </TableBody>
        </Table>
      </div>
      {editingWaitlist && (
        <EditWaitlistDialog
          waitlist={editingWaitlist}
          onClose={() => setEditingWaitlist(null)}
          onSave={handleWaitlistSaved}
        />
      )}
      {viewingSignups && (
        <WaitlistSignupsDialog
          waitlistId={viewingSignups}
          onClose={() => setViewingSignups(null)}
        />
      )}
    </>
  );
 }
--- a/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/page.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/waitlist/page.tsx
@@ -1,52 +0,0 @@
 import { withRoleAccess } from "@/lib/withRoleAccess";
 import { Suspense } from "react";
 import { WaitlistTable } from "./components/WaitlistTable";
 import { CreateWaitlistButton } from "./components/CreateWaitlistButton";
 import { Warning } from "@phosphor-icons/react/dist/ssr";
 function WaitlistDashboard() {
  return (
    <div className="mx-auto p-6">
      <div className="flex flex-col gap-4">
        <div className="flex items-center justify-between">
          <div>
            <h1 className="text-3xl font-bold">Waitlist Management</h1>
            <p className="text-gray-500">
              Manage upcoming agent waitlists and track signups
            </p>
          </div>
          <CreateWaitlistButton />
        </div>
        <div className="flex items-start gap-3 rounded-lg border border-amber-300 bg-amber-50 p-4 dark:border-amber-700 dark:bg-amber-950">
          <Warning
            className="mt-0.5 h-5 w-5 flex-shrink-0 text-amber-600 dark:text-amber-400"
            weight="fill"
          />
          <div className="text-sm text-amber-800 dark:text-amber-200">
            <p className="font-medium">TODO: Email-only signup notifications</p>
            <p className="mt-1 text-amber-700 dark:text-amber-300">
              Notifications for email-only signups (users who weren&apos;t
              logged in) have not been implemented yet. Currently only
              registered users will receive launch emails.
            </p>
          </div>
        </div>
        <Suspense
          fallback={
            <div className="py-10 text-center">Loading waitlists...</div>
          }
        >
          <WaitlistTable />
        </Suspense>
      </div>
    </div>
  );
 }
 export default async function WaitlistDashboardPage() {
  const withAdminAccess = await withRoleAccess(["admin"]);
  const ProtectedWaitlistDashboard = await withAdminAccess(WaitlistDashboard);
  return <ProtectedWaitlistDashboard />;
 }
--- a/autogpt_platform/frontend/src/app/(platform)/build/components/BuilderActions/components/RunGraph/RunGraph.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/build/components/BuilderActions/components/RunGraph/RunGraph.tsx
@@ -5,11 +5,10 @@ import {
  TooltipContent,
  TooltipTrigger,
 } from "@/components/atoms/Tooltip/BaseTooltip";
-import { CircleNotchIcon, PlayIcon, StopIcon } from "@phosphor-icons/react";
+import { PlayIcon, StopIcon } from "@phosphor-icons/react";
 import { useShallow } from "zustand/react/shallow";
 import { RunInputDialog } from "../RunInputDialog/RunInputDialog";
 import { useRunGraph } from "./useRunGraph";
 import { cn } from "@/lib/utils";
 export const RunGraph = ({ flowID }: { flowID: string | null }) => {
  const {
@@ -25,31 +24,6 @@ export const RunGraph = ({ flowID }: { flowID: string | null }) => {
    useShallow((state) => state.isGraphRunning),
  );
  const isLoading = isExecutingGraph || isTerminatingGraph || isSaving;
  // Determine which icon to show with proper animation
  const renderIcon = () => {
    const iconClass = cn(
      "size-4 transition-transform duration-200 ease-out",
      !isLoading && "group-hover:scale-110",
    );
    if (isLoading) {
      return (
        <CircleNotchIcon
          className={cn(iconClass, "animate-spin")}
          weight="bold"
        />
      );
    }
    if (isGraphRunning) {
      return <StopIcon className={iconClass} weight="fill" />;
    }
    return <PlayIcon className={iconClass} weight="fill" />;
  };
  return (
    <>
      <Tooltip>
@@ -59,18 +33,18 @@ export const RunGraph = ({ flowID }: { flowID: string | null }) => {
            variant={isGraphRunning ? "destructive" : "primary"}
            data-id={isGraphRunning ? "stop-graph-button" : "run-graph-button"}
            onClick={isGraphRunning ? handleStopGraph : handleRunGraph}
-            disabled={!flowID || isLoading}
+            disabled={!flowID || isExecutingGraph || isTerminatingGraph}
-            className="group"
+            loading={isExecutingGraph || isTerminatingGraph || isSaving}
          >
-            {renderIcon()}
+            {!isGraphRunning ? (
              <PlayIcon className="size-4" />
            ) : (
              <StopIcon className="size-4" />
            )}
          </Button>
        </TooltipTrigger>
        <TooltipContent>
-          {isLoading
+          {isGraphRunning ? "Stop agent" : "Run agent"}
            ? "Processing..."
            : isGraphRunning
              ? "Stop agent"
              : "Run agent"}
        </TooltipContent>
      </Tooltip>
      <RunInputDialog
--- a/autogpt_platform/frontend/src/app/(platform)/build/components/BuilderActions/components/RunInputDialog/RunInputDialog.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/build/components/BuilderActions/components/RunInputDialog/RunInputDialog.tsx
@@ -61,67 +61,63 @@ export const RunInputDialog = ({
          isOpen,
          set: setIsOpen,
        }}
-        styling={{ maxWidth: "700px", minWidth: "700px" }}
+        styling={{ maxWidth: "600px", minWidth: "600px" }}
      >
        <Dialog.Content>
-          <div
+          <div className="space-y-6 p-1" data-id="run-input-dialog-content">
-            className="grid grid-cols-[1fr_auto] gap-10 p-1"
+            {/* Credentials Section */}
-            data-id="run-input-dialog-content"
+            {hasCredentials() && credentialFields.length > 0 && (
-          >
+              <div data-id="run-input-credentials-section">
-            <div className="space-y-6">
+                <div className="mb-4">
-              {/* Credentials Section */}
+                  <Text variant="h4" className="text-gray-900">
-              {hasCredentials() && credentialFields.length > 0 && (
+                    Credentials
-                <div data-id="run-input-credentials-section">
+                  </Text>
                  <div className="mb-4">
                    <Text variant="h4" className="text-gray-900">
                      Credentials
                    </Text>
                  </div>
                  <div className="px-2" data-id="run-input-credentials-form">
                    <CredentialsGroupedView
                      credentialFields={credentialFields}
                      requiredCredentials={requiredCredentials}
                      inputCredentials={credentialValues}
                      inputValues={inputValues}
                      onCredentialChange={handleCredentialFieldChange}
                    />
                  </div>
                </div>
-              )}
+                <div className="px-2" data-id="run-input-credentials-form">
-
+                  <CredentialsGroupedView
-              {/* Inputs Section */}
+                    credentialFields={credentialFields}
-              {hasInputs() && (
+                    requiredCredentials={requiredCredentials}
-                <div data-id="run-input-inputs-section">
+                    inputCredentials={credentialValues}
-                  <div className="mb-4">
+                    inputValues={inputValues}
-                    <Text variant="h4" className="text-gray-900">
+                    onCredentialChange={handleCredentialFieldChange}
-                      Inputs
+                  />
                    </Text>
                  </div>
                  <div data-id="run-input-inputs-form">
                    <FormRenderer
                      jsonSchema={inputSchema as RJSFSchema}
                      handleChange={(v) => handleInputChange(v.formData)}
                      uiSchema={uiSchema}
                      initialValues={{}}
                      formContext={{
                        showHandles: false,
                        size: "large",
                      }}
                    />
                  </div>
                </div>
-              )}
+              </div>
-            </div>
+            )}
            {/* Inputs Section */}
            {hasInputs() && (
              <div data-id="run-input-inputs-section">
                <div className="mb-4">
                  <Text variant="h4" className="text-gray-900">
                    Inputs
                  </Text>
                </div>
                <div data-id="run-input-inputs-form">
                  <FormRenderer
                    jsonSchema={inputSchema as RJSFSchema}
                    handleChange={(v) => handleInputChange(v.formData)}
                    uiSchema={uiSchema}
                    initialValues={{}}
                    formContext={{
                      showHandles: false,
                      size: "large",
                    }}
                  />
                </div>
              </div>
            )}
            {/* Action Button */}
            <div
-              className="flex flex-col items-end justify-start"
+              className="flex justify-end pt-2"
              data-id="run-input-actions-section"
            >
              {purpose === "run" && (
                <Button
                  variant="primary"
                  size="large"
-                  className="group h-fit min-w-0 gap-2 px-10"
+                  className="group h-fit min-w-0 gap-2"
                  onClick={handleManualRun}
                  loading={isExecutingGraph}
                  data-id="run-input-manual-run-button"
@@ -136,7 +132,7 @@ export const RunInputDialog = ({
                <Button
                  variant="primary"
                  size="large"
-                  className="group h-fit min-w-0 gap-2 px-10"
+                  className="group h-fit min-w-0 gap-2"
                  onClick={() => setOpenCronSchedulerDialog(true)}
                  data-id="run-input-schedule-button"
                >
--- a/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/Flow/components/CustomControl.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/Flow/components/CustomControl.tsx
@@ -53,14 +53,14 @@ export const CustomControls = memo(
    const controls = [
      {
        id: "zoom-in-button",
-        icon: <PlusIcon className="size-3.5 text-zinc-600" />,
+        icon: <PlusIcon className="size-4" />,
        label: "Zoom In",
        onClick: () => zoomIn(),
        className: "h-10 w-10 border-none",
      },
      {
        id: "zoom-out-button",
-        icon: <MinusIcon className="size-3.5 text-zinc-600" />,
+        icon: <MinusIcon className="size-4" />,
        label: "Zoom Out",
        onClick: () => zoomOut(),
        className: "h-10 w-10 border-none",
@@ -68,9 +68,9 @@ export const CustomControls = memo(
      {
        id: "tutorial-button",
        icon: isTutorialLoading ? (
-          <CircleNotchIcon className="size-3.5 animate-spin text-zinc-600" />
+          <CircleNotchIcon className="size-4 animate-spin" />
        ) : (
-          <ChalkboardIcon className="size-3.5 text-zinc-600" />
+          <ChalkboardIcon className="size-4" />
        ),
        label: isTutorialLoading ? "Loading Tutorial..." : "Start Tutorial",
        onClick: handleTutorialClick,
@@ -79,7 +79,7 @@ export const CustomControls = memo(
      },
      {
        id: "fit-view-button",
-        icon: <FrameCornersIcon className="size-3.5 text-zinc-600" />,
+        icon: <FrameCornersIcon className="size-4" />,
        label: "Fit View",
        onClick: () => fitView({ padding: 0.2, duration: 800, maxZoom: 1 }),
        className: "h-10 w-10 border-none",
@@ -87,9 +87,9 @@ export const CustomControls = memo(
      {
        id: "lock-button",
        icon: !isLocked ? (
-          <LockOpenIcon className="size-3.5 text-zinc-600" />
+          <LockOpenIcon className="size-4" />
        ) : (
-          <LockIcon className="size-3.5 text-zinc-600" />
+          <LockIcon className="size-4" />
        ),
        label: "Toggle Lock",
        onClick: () => setIsLocked(!isLocked),
--- a/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/edges/CustomEdge.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/edges/CustomEdge.tsx
@@ -19,8 +19,6 @@ export type CustomEdgeData = {
  beadUp?: number;
  beadDown?: number;
  beadData?: Map<string, NodeExecutionResult["status"]>;
  edgeColorClass?: string;
  edgeHexColor?: string;
 };
 export type CustomEdge = XYEdge<CustomEdgeData, "custom">;
@@ -38,6 +36,7 @@ const CustomEdge = ({
  selected,
 }: EdgeProps<CustomEdge>) => {
  const removeConnection = useEdgeStore((state) => state.removeEdge);
  // Subscribe to the brokenEdgeIDs map and check if this edge is broken across any node
  const isBroken = useNodeStore((state) => state.isEdgeBroken(id));
  const [isHovered, setIsHovered] = useState(false);
@@ -53,7 +52,6 @@ const CustomEdge = ({
  const isStatic = data?.isStatic ?? false;
  const beadUp = data?.beadUp ?? 0;
  const beadDown = data?.beadDown ?? 0;
  const edgeColorClass = data?.edgeColorClass;
  const handleRemoveEdge = () => {
    removeConnection(id);
@@ -72,9 +70,7 @@ const CustomEdge = ({
            ? "!stroke-red-500 !stroke-[2px] [stroke-dasharray:4]"
            : selected
              ? "stroke-zinc-800"
-              : edgeColorClass
+              : "stroke-zinc-500/50 hover:stroke-zinc-500",
                ? cn(edgeColorClass, "opacity-70 hover:opacity-100")
                : "stroke-zinc-500/50 hover:stroke-zinc-500",
        )}
      />
      <JSBeads
--- a/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/edges/useCustomEdge.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/edges/useCustomEdge.ts
@@ -8,7 +8,6 @@ import { useCallback } from "react";
 import { useNodeStore } from "../../../stores/nodeStore";
 import { useHistoryStore } from "../../../stores/historyStore";
 import { CustomEdge } from "./CustomEdge";
 import { getEdgeColorFromOutputType } from "../nodes/helpers";
 export const useCustomEdge = () => {
  const edges = useEdgeStore((s) => s.edges);
@@ -35,13 +34,8 @@ export const useCustomEdge = () => {
      if (exists) return;
      const nodes = useNodeStore.getState().nodes;
-      const sourceNode = nodes.find((n) => n.id === conn.source);
+      const isStatic = nodes.find((n) => n.id === conn.source)?.data
-      const isStatic = sourceNode?.data?.staticOutput;
+        ?.staticOutput;
      const { colorClass, hexColor } = getEdgeColorFromOutputType(
        sourceNode?.data?.outputSchema,
        conn.sourceHandle,
      );
      addEdge({
        source: conn.source,
@@ -50,8 +44,6 @@ export const useCustomEdge = () => {
        targetHandle: conn.targetHandle,
        data: {
          isStatic,
          edgeColorClass: colorClass,
          edgeHexColor: hexColor,
        },
      });
    },
--- a/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/helpers.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/helpers.ts
@@ -187,38 +187,3 @@ export const getTypeDisplayInfo = (schema: any) => {
    hexColor,
  };
 };
 export function getEdgeColorFromOutputType(
  outputSchema: RJSFSchema | undefined,
  sourceHandle: string,
 ): { colorClass: string; hexColor: string } {
  const defaultColor = {
    colorClass: "stroke-zinc-500/50",
    hexColor: "#6b7280",
  };
  if (!outputSchema?.properties) return defaultColor;
  const properties = outputSchema.properties as Record<string, unknown>;
  const handleParts = sourceHandle.split("_#_");
  let currentSchema: Record<string, unknown> = properties;
  for (let i = 0; i < handleParts.length; i++) {
    const part = handleParts[i];
    const fieldSchema = currentSchema[part] as Record<string, unknown>;
    if (!fieldSchema) return defaultColor;
    if (i === handleParts.length - 1) {
      const { hexColor, colorClass } = getTypeDisplayInfo(fieldSchema);
      return { colorClass: colorClass.replace("!text-", "stroke-"), hexColor };
    }
    if (fieldSchema.properties) {
      currentSchema = fieldSchema.properties as Record<string, unknown>;
    } else {
      return defaultColor;
    }
  }
  return defaultColor;
 }
--- a/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/tutorial/icons.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/tutorial/icons.ts
@@ -1,32 +1,7 @@
-type IconOptions = {
+// These are SVG Phosphor icons
  size?: number;
  color?: string;
 };
 const DEFAULT_SIZE = 16;
 const DEFAULT_COLOR = "#52525b"; // zinc-600
 const iconPaths = {
  ClickIcon: `M88,24V16a8,8,0,0,1,16,0v8a8,8,0,0,1-16,0ZM16,104h8a8,8,0,0,0,0-16H16a8,8,0,0,0,0,16ZM124.42,39.16a8,8,0,0,0,10.74-3.58l8-16a8,8,0,0,0-14.31-7.16l-8,16A8,8,0,0,0,124.42,39.16Zm-96,81.69-16,8a8,8,0,0,0,7.16,14.31l16-8a8,8,0,1,0-7.16-14.31ZM219.31,184a16,16,0,0,1,0,22.63l-12.68,12.68a16,16,0,0,1-22.63,0L132.7,168,115,214.09c0,.1-.08.21-.13.32a15.83,15.83,0,0,1-14.6,9.59l-.79,0a15.83,15.83,0,0,1-14.41-11L32.8,52.92A16,16,0,0,1,52.92,32.8L213,85.07a16,16,0,0,1,1.41,29.8l-.32.13L168,132.69ZM208,195.31,156.69,144h0a16,16,0,0,1,4.93-26l.32-.14,45.95-17.64L48,48l52.2,159.86,17.65-46c0-.11.08-.22.13-.33a16,16,0,0,1,11.69-9.34,16.72,16.72,0,0,1,3-.28,16,16,0,0,1,11.3,4.69L195.31,208Z`,
  Keyboard: `M224,48H32A16,16,0,0,0,16,64V192a16,16,0,0,0,16,16H224a16,16,0,0,0,16-16V64A16,16,0,0,0,224,48Zm0,144H32V64H224V192Zm-16-64a8,8,0,0,1-8,8H56a8,8,0,0,1,0-16H200A8,8,0,0,1,208,128Zm0-32a8,8,0,0,1-8,8H56a8,8,0,0,1,0-16H200A8,8,0,0,1,208,96ZM72,160a8,8,0,0,1-8,8H56a8,8,0,0,1,0-16h8A8,8,0,0,1,72,160Zm96,0a8,8,0,0,1-8,8H96a8,8,0,0,1,0-16h64A8,8,0,0,1,168,160Zm40,0a8,8,0,0,1-8,8h-8a8,8,0,0,1,0-16h8A8,8,0,0,1,208,160Z`,
  Drag: `M188,80a27.79,27.79,0,0,0-13.36,3.4,28,28,0,0,0-46.64-11A28,28,0,0,0,80,92v20H68a28,28,0,0,0-28,28v12a88,88,0,0,0,176,0V108A28,28,0,0,0,188,80Zm12,72a72,72,0,0,1-144,0V140a12,12,0,0,1,12-12H80v24a8,8,0,0,0,16,0V92a12,12,0,0,1,24,0v28a8,8,0,0,0,16,0V92a12,12,0,0,1,24,0v28a8,8,0,0,0,16,0V108a12,12,0,0,1,24,0Z`,
 };
 function createIcon(path: string, options: IconOptions = {}): string {
  const size = options.size ?? DEFAULT_SIZE;
  const color = options.color ?? DEFAULT_COLOR;
  return `<svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" fill="${color}" viewBox="0 0 256 256"><path d="${path}"></path></svg>`;
 }
 export const ICONS = {
-  ClickIcon: createIcon(iconPaths.ClickIcon),
+  ClickIcon: `<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" fill="#000000" viewBox="0 0 256 256"><path d="M88,24V16a8,8,0,0,1,16,0v8a8,8,0,0,1-16,0ZM16,104h8a8,8,0,0,0,0-16H16a8,8,0,0,0,0,16ZM124.42,39.16a8,8,0,0,0,10.74-3.58l8-16a8,8,0,0,0-14.31-7.16l-8,16A8,8,0,0,0,124.42,39.16Zm-96,81.69-16,8a8,8,0,0,0,7.16,14.31l16-8a8,8,0,1,0-7.16-14.31ZM219.31,184a16,16,0,0,1,0,22.63l-12.68,12.68a16,16,0,0,1-22.63,0L132.7,168,115,214.09c0,.1-.08.21-.13.32a15.83,15.83,0,0,1-14.6,9.59l-.79,0a15.83,15.83,0,0,1-14.41-11L32.8,52.92A16,16,0,0,1,52.92,32.8L213,85.07a16,16,0,0,1,1.41,29.8l-.32.13L168,132.69ZM208,195.31,156.69,144h0a16,16,0,0,1,4.93-26l.32-.14,45.95-17.64L48,48l52.2,159.86,17.65-46c0-.11.08-.22.13-.33a16,16,0,0,1,11.69-9.34,16.72,16.72,0,0,1,3-.28,16,16,0,0,1,11.3,4.69L195.31,208Z"></path></svg>`,
-  Keyboard: createIcon(iconPaths.Keyboard),
+  Keyboard: `<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" fill="#000000" viewBox="0 0 256 256"><path d="M224,48H32A16,16,0,0,0,16,64V192a16,16,0,0,0,16,16H224a16,16,0,0,0,16-16V64A16,16,0,0,0,224,48Zm0,144H32V64H224V192Zm-16-64a8,8,0,0,1-8,8H56a8,8,0,0,1,0-16H200A8,8,0,0,1,208,128Zm0-32a8,8,0,0,1-8,8H56a8,8,0,0,1,0-16H200A8,8,0,0,1,208,96ZM72,160a8,8,0,0,1-8,8H56a8,8,0,0,1,0-16h8A8,8,0,0,1,72,160Zm96,0a8,8,0,0,1-8,8H96a8,8,0,0,1,0-16h64A8,8,0,0,1,168,160Zm40,0a8,8,0,0,1-8,8h-8a8,8,0,0,1,0-16h8A8,8,0,0,1,208,160Z"></path></svg>`,
-  Drag: createIcon(iconPaths.Drag),
+  Drag: `<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" fill="#000000" viewBox="0 0 256 256"><path d="M188,80a27.79,27.79,0,0,0-13.36,3.4,28,28,0,0,0-46.64-11A28,28,0,0,0,80,92v20H68a28,28,0,0,0-28,28v12a88,88,0,0,0,176,0V108A28,28,0,0,0,188,80Zm12,72a72,72,0,0,1-144,0V140a12,12,0,0,1,12-12H80v24a8,8,0,0,0,16,0V92a12,12,0,0,1,24,0v28a8,8,0,0,0,16,0V92a12,12,0,0,1,24,0v28a8,8,0,0,0,16,0V108a12,12,0,0,1,24,0Z"></path></svg>`,
 };
 export function getIcon(
  name: keyof typeof iconPaths,
  options?: IconOptions,
 ): string {
  return createIcon(iconPaths[name], options);
 }
--- a/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/tutorial/index.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/tutorial/index.ts
@@ -11,7 +11,6 @@ import {
 } from "./helpers";
 import { useNodeStore } from "../../../stores/nodeStore";
 import { useEdgeStore } from "../../../stores/edgeStore";
 import { useTutorialStore } from "../../../stores/tutorialStore";
 let isTutorialLoading = false;
 let tutorialLoadingCallback: ((loading: boolean) => void) | null = null;
@@ -61,14 +60,12 @@ export const startTutorial = async () => {
    handleTutorialComplete();
    removeTutorialStyles();
    clearPrefetchedBlocks();
    useTutorialStore.getState().setIsTutorialRunning(false);
  });
  tour.on("cancel", () => {
    handleTutorialCancel(tour);
    removeTutorialStyles();
    clearPrefetchedBlocks();
    useTutorialStore.getState().setIsTutorialRunning(false);
  });
  for (const step of tour.steps) {
--- a/autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatContainer/helpers.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatContainer/helpers.ts
@@ -267,34 +267,23 @@ export function extractCredentialsNeeded(
      | undefined;
    if (missingCreds && Object.keys(missingCreds).length > 0) {
      const agentName = (setupInfo?.agent_name as string) || "this block";
-      const credentials = Object.values(missingCreds).map((credInfo) => {
+      const credentials = Object.values(missingCreds).map((credInfo) => ({
-        // Normalize to array at boundary - prefer 'types' array, fall back to single 'type'
+        provider: (credInfo.provider as string) || "unknown",
-        const typesArray = credInfo.types as
+        providerName:
-          | Array<"api_key" | "oauth2" | "user_password" | "host_scoped">
+          (credInfo.provider_name as string) ||
-          | undefined;
+          (credInfo.provider as string) ||
-        const singleType =
+          "Unknown Provider",
        credentialType:
          (credInfo.type as
            | "api_key"
            | "oauth2"
            | "user_password"
-            | "host_scoped"
+            | "host_scoped") || "api_key",
-            | undefined) || "api_key";
+        title:
-        const credentialTypes =
+          (credInfo.title as string) ||
-          typesArray && typesArray.length > 0 ? typesArray : [singleType];
+          `${(credInfo.provider_name as string) || (credInfo.provider as string)} credentials`,
-
+        scopes: credInfo.scopes as string[] | undefined,
-        return {
+      }));
          provider: (credInfo.provider as string) || "unknown",
          providerName:
            (credInfo.provider_name as string) ||
            (credInfo.provider as string) ||
            "Unknown Provider",
          credentialTypes,
          title:
            (credInfo.title as string) ||
            `${(credInfo.provider_name as string) || (credInfo.provider as string)} credentials`,
          scopes: credInfo.scopes as string[] | undefined,
        };
      });
      return {
        type: "credentials_needed",
        toolName,
@@ -369,14 +358,11 @@ export function extractInputsNeeded(
      credentials.forEach((cred) => {
        const id = cred.id as string;
        if (id) {
          const credentialTypes = Array.isArray(cred.types)
            ? cred.types
            : [(cred.type as string) || "api_key"];
          credentialsSchema[id] = {
            type: "object",
            properties: {},
            credentials_provider: [cred.provider as string],
-            credentials_types: credentialTypes,
+            credentials_types: [(cred.type as string) || "api_key"],
            credentials_scopes: cred.scopes as string[] | undefined,
          };
        }
--- a/autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatCredentialsSetup/ChatCredentialsSetup.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatCredentialsSetup/ChatCredentialsSetup.tsx
@@ -9,9 +9,7 @@ import { useChatCredentialsSetup } from "./useChatCredentialsSetup";
 export interface CredentialInfo {
  provider: string;
  providerName: string;
-  credentialTypes: Array<
+  credentialType: "api_key" | "oauth2" | "user_password" | "host_scoped";
    "api_key" | "oauth2" | "user_password" | "host_scoped"
  >;
  title: string;
  scopes?: string[];
 }
@@ -32,7 +30,7 @@ function createSchemaFromCredentialInfo(
    type: "object",
    properties: {},
    credentials_provider: [credential.provider],
-    credentials_types: credential.credentialTypes,
+    credentials_types: [credential.credentialType],
    credentials_scopes: credential.scopes,
    discriminator: undefined,
    discriminator_mapping: undefined,
--- a/autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatMessage/useChatMessage.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatMessage/useChatMessage.ts
@@ -41,9 +41,7 @@ export type ChatMessageData =
      credentials: Array<{
        provider: string;
        providerName: string;
-        credentialTypes: Array<
+        credentialType: "api_key" | "oauth2" | "user_password" | "host_scoped";
          "api_key" | "oauth2" | "user_password" | "host_scoped"
        >;
        title: string;
        scopes?: string[];
      }>;
--- a/autogpt_platform/frontend/src/app/(platform)/library/components/LibraryUploadAgentDialog/LibraryUploadAgentDialog.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/library/components/LibraryUploadAgentDialog/LibraryUploadAgentDialog.tsx
@@ -2,7 +2,6 @@
 import { Button } from "@/components/atoms/Button/Button";
 import { FileInput } from "@/components/atoms/FileInput/FileInput";
 import { Input } from "@/components/atoms/Input/Input";
 import { LoadingSpinner } from "@/components/atoms/LoadingSpinner/LoadingSpinner";
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import {
  Form,
@@ -121,7 +120,7 @@ export default function LibraryUploadAgentDialog() {
          >
            {isUploading ? (
              <div className="flex items-center gap-2">
-                <LoadingSpinner size="small" className="text-white" />
+                <div className="h-4 w-4 animate-spin rounded-full border-b-2 border-t-2 border-white"></div>
                <span>Uploading...</span>
              </div>
            ) : (
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/AgentsSection/AgentsSection.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/AgentsSection/AgentsSection.tsx
@@ -5,6 +5,8 @@ import {
  CarouselContent,
  CarouselItem,
 } from "@/components/__legacy__/ui/carousel";
 import { FadeIn } from "@/components/molecules/FadeIn/FadeIn";
 import { StaggeredList } from "@/components/molecules/StaggeredList/StaggeredList";
 import { useAgentsSection } from "./useAgentsSection";
 import { StoreAgent } from "@/app/api/__generated__/models/storeAgent";
 import { StoreCard } from "../StoreCard/StoreCard";
@@ -41,12 +43,14 @@ export const AgentsSection = ({
  return (
    <div className="flex flex-col items-center justify-center">
      <div className="w-full max-w-[1360px]">
-        <h2
+        <FadeIn direction="left" duration={0.5}>
-          style={{ marginBottom: margin }}
+          <h2
-          className="font-poppins text-lg font-semibold text-[#282828] dark:text-neutral-200"
+            style={{ marginBottom: margin }}
-        >
+            className="font-poppins text-lg font-semibold text-neutral-800 dark:text-neutral-200"
-          {sectionTitle}
+          >
-        </h2>
+            {sectionTitle}
          </h2>
        </FadeIn>
        {!displayedAgents || displayedAgents.length === 0 ? (
          <div className="text-center text-gray-500 dark:text-gray-400">
            No agents found
@@ -54,32 +58,38 @@ export const AgentsSection = ({
        ) : (
          <>
            {/* Mobile Carousel View */}
-            <Carousel
+            <FadeIn direction="up" className="md:hidden">
-              className="md:hidden"
+              <Carousel
-              opts={{
+                opts={{
-                loop: true,
+                  loop: true,
-              }}
+                }}
-            >
+              >
-              <CarouselContent>
+                <CarouselContent>
-                {displayedAgents.map((agent, index) => (
+                  {displayedAgents.map((agent, index) => (
-                  <CarouselItem key={index} className="min-w-64 max-w-71">
+                    <CarouselItem key={index} className="min-w-64 max-w-71">
-                    <StoreCard
+                      <StoreCard
-                      agentName={agent.agent_name}
+                        agentName={agent.agent_name}
-                      agentImage={agent.agent_image}
+                        agentImage={agent.agent_image}
-                      description={agent.description}
+                        description={agent.description}
-                      runs={agent.runs}
+                        runs={agent.runs}
-                      rating={agent.rating}
+                        rating={agent.rating}
-                      avatarSrc={agent.creator_avatar}
+                        avatarSrc={agent.creator_avatar}
-                      creatorName={agent.creator}
+                        creatorName={agent.creator}
-                      hideAvatar={hideAvatars}
+                        hideAvatar={hideAvatars}
-                      onClick={() => handleCardClick(agent.creator, agent.slug)}
+                        onClick={() => handleCardClick(agent.creator, agent.slug)}
-                    />
+                      />
-                  </CarouselItem>
+                    </CarouselItem>
-                ))}
+                  ))}
-              </CarouselContent>
+                </CarouselContent>
-            </Carousel>
+              </Carousel>
            </FadeIn>
-            <div className="hidden grid-cols-1 place-items-center gap-6 md:grid md:grid-cols-2 lg:grid-cols-3 2xl:grid-cols-4">
+            {/* Desktop Grid View with Staggered Animation */}
            <StaggeredList
              direction="up"
              staggerDelay={0.08}
              className="hidden grid-cols-1 place-items-center gap-6 md:grid md:grid-cols-2 lg:grid-cols-3 2xl:grid-cols-4"
            >
              {displayedAgents.map((agent, index) => (
                <StoreCard
                  key={index}
@@ -94,7 +104,7 @@ export const AgentsSection = ({
                  onClick={() => handleCardClick(agent.creator, agent.slug)}
                />
              ))}
-            </div>
+            </StaggeredList>
          </>
        )}
      </div>
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/BecomeACreator/BecomeACreator.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/BecomeACreator/BecomeACreator.tsx
@@ -38,7 +38,7 @@ export function BecomeACreator({
        <PublishAgentModal
          trigger={
-            <button className="inline-flex h-[48px] cursor-pointer items-center justify-center rounded-[38px] bg-neutral-800 px-8 py-3 transition-colors hover:bg-neutral-700 dark:bg-neutral-700 dark:hover:bg-neutral-600 md:h-[56px] md:px-10 md:py-4 lg:h-[68px] lg:px-12 lg:py-5">
+            <button className="inline-flex h-[48px] cursor-pointer items-center justify-center rounded-[38px] bg-neutral-800 px-8 py-3 transition-colors hover:bg-neutral-700 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-neutral-950 focus-visible:ring-offset-2 dark:bg-neutral-700 dark:hover:bg-neutral-600 dark:focus-visible:ring-neutral-50 md:h-[56px] md:px-10 md:py-4 lg:h-[68px] lg:px-12 lg:py-5">
              <span className="whitespace-nowrap font-poppins text-base font-medium leading-normal text-neutral-50 md:text-lg md:leading-relaxed lg:text-xl lg:leading-7">
                {buttonText}
              </span>
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/CreatorCard/CreatorCard.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/CreatorCard/CreatorCard.tsx
@@ -20,9 +20,18 @@ export const CreatorCard = ({
 }: CreatorCardProps) => {
  return (
    <div
-      className={`h-[264px] w-full px-[18px] pb-5 pt-6 ${backgroundColor(index)} inline-flex cursor-pointer flex-col items-start justify-start gap-3.5 rounded-[26px] transition-all duration-200 hover:brightness-95`}
+      className={`h-[264px] w-full px-[18px] pb-5 pt-6 ${backgroundColor(index)} inline-flex cursor-pointer flex-col items-start justify-start gap-3.5 rounded-[26px] transition-[filter] duration-200 hover:brightness-95 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-neutral-950 focus-visible:ring-offset-2 dark:focus-visible:ring-neutral-50`}
      onClick={onClick}
      onKeyDown={(e) => {
        if (e.key === "Enter" || e.key === " ") {
          e.preventDefault();
          onClick();
        }
      }}
      data-testid="creator-card"
      role="button"
      tabIndex={0}
      aria-label={`View ${creatorName}'s profile - ${agentsUploaded} agents`}
    >
      <div className="relative h-[64px] w-[64px]">
        <div className="absolute inset-0 overflow-hidden rounded-full">
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/FeaturedCreators/FeaturedCreators.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/FeaturedCreators/FeaturedCreators.tsx
@@ -1,5 +1,7 @@
 "use client";
 import { FadeIn } from "@/components/molecules/FadeIn/FadeIn";
 import { StaggeredList } from "@/components/molecules/StaggeredList/StaggeredList";
 import { CreatorCard } from "../CreatorCard/CreatorCard";
 import { useFeaturedCreators } from "./useFeaturedCreators";
 import { Creator } from "@/app/api/__generated__/models/creator";
@@ -19,11 +21,17 @@ export const FeaturedCreators = ({
  return (
    <div className="flex w-full flex-col items-center justify-center">
      <div className="w-full max-w-[1360px]">
-        <h2 className="mb-9 font-poppins text-lg font-semibold text-neutral-800 dark:text-neutral-200">
+        <FadeIn direction="left" duration={0.5}>
-          {title}
+          <h2 className="mb-9 font-poppins text-lg font-semibold text-neutral-800 dark:text-neutral-200">
-        </h2>
+            {title}
          </h2>
        </FadeIn>
-        <div className="grid grid-cols-1 gap-6 md:grid-cols-2 lg:grid-cols-4">
+        <StaggeredList
          direction="up"
          staggerDelay={0.1}
          className="grid grid-cols-1 gap-6 md:grid-cols-2 lg:grid-cols-4"
        >
          {displayedCreators.map((creator, index) => (
            <CreatorCard
              key={index}
@@ -35,7 +43,7 @@ export const FeaturedCreators = ({
              index={index}
            />
          ))}
-        </div>
+        </StaggeredList>
      </div>
    </div>
  );
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/FeaturedSection/FeaturedSection.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/FeaturedSection/FeaturedSection.tsx
@@ -8,6 +8,7 @@ import {
  CarouselNext,
  CarouselIndicator,
 } from "@/components/__legacy__/ui/carousel";
 import { FadeIn } from "@/components/molecules/FadeIn/FadeIn";
 import Link from "next/link";
 import { useFeaturedSection } from "./useFeaturedSection";
 import { StoreAgent } from "@/app/api/__generated__/models/storeAgent";
@@ -25,40 +26,44 @@ export const FeaturedSection = ({ featuredAgents }: FeaturedSectionProps) => {
  return (
    <section className="w-full">
-      <h2 className="mb-8 font-poppins text-2xl font-semibold leading-7 text-neutral-800 dark:text-neutral-200">
+      <FadeIn direction="left" duration={0.5}>
-        Featured agents
+        <h2 className="mb-8 font-poppins text-2xl font-semibold leading-7 text-neutral-800 dark:text-neutral-200">
-      </h2>
+          Featured agents
        </h2>
      </FadeIn>
-      <Carousel
+      <FadeIn direction="up" duration={0.6} delay={0.1}>
-        opts={{
+        <Carousel
-          align: "center",
+          opts={{
-          containScroll: "trimSnaps",
+            align: "center",
-        }}
+            containScroll: "trimSnaps",
-      >
+          }}
-        <CarouselContent>
+        >
-          {featuredAgents.map((agent, index) => (
+          <CarouselContent>
-            <CarouselItem
+            {featuredAgents.map((agent, index) => (
-              key={index}
+              <CarouselItem
-              className="h-[480px] md:basis-1/2 lg:basis-1/3"
+                key={index}
-            >
+                className="h-[480px] md:basis-1/2 lg:basis-1/3"
              <Link
                href={`/marketplace/agent/${encodeURIComponent(agent.creator)}/${encodeURIComponent(agent.slug)}`}
                className="block h-full"
              >
-                <FeaturedAgentCard
+                <Link
-                  agent={agent}
+                  href={`/marketplace/agent/${encodeURIComponent(agent.creator)}/${encodeURIComponent(agent.slug)}`}
-                  backgroundColor={getBackgroundColor(index)}
+                  className="block h-full"
-                />
+                >
-              </Link>
+                  <FeaturedAgentCard
-            </CarouselItem>
+                    agent={agent}
-          ))}
+                    backgroundColor={getBackgroundColor(index)}
-        </CarouselContent>
+                  />
-        <div className="relative mt-4">
+                </Link>
-          <CarouselIndicator />
+              </CarouselItem>
-          <CarouselPrevious afterClick={handlePrevSlide} />
+            ))}
-          <CarouselNext afterClick={handleNextSlide} />
+          </CarouselContent>
-        </div>
+          <div className="relative mt-4">
-      </Carousel>
+            <CarouselIndicator />
            <CarouselPrevious afterClick={handlePrevSlide} />
            <CarouselNext afterClick={handleNextSlide} />
          </div>
        </Carousel>
      </FadeIn>
    </section>
  );
 };
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/FilterChips/FilterChips.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/FilterChips/FilterChips.tsx
@@ -1,6 +1,6 @@
 "use client";
-import { Badge } from "@/components/__legacy__/ui/badge";
+import { FilterChip } from "@/components/atoms/FilterChip/FilterChip";
 import { useFilterChips } from "./useFilterChips";
 interface FilterChipsProps {
@@ -9,8 +9,6 @@ interface FilterChipsProps {
  multiSelect?: boolean;
 }
 // Some flaws in its logic
 // FRONTEND-TODO : This needs to be fixed
 export const FilterChips = ({
  badges,
  onFilterChange,
@@ -22,18 +20,20 @@ export const FilterChips = ({
  });
  return (
-    <div className="flex h-auto min-h-8 flex-wrap items-center justify-center gap-3 lg:min-h-14 lg:justify-start lg:gap-5">
+    <div
      className="flex h-auto min-h-8 flex-wrap items-center justify-center gap-3 lg:min-h-14 lg:justify-start lg:gap-5"
      role="group"
      aria-label="Filter options"
    >
      {badges.map((badge) => (
-        <Badge
+        <FilterChip
          key={badge}
-          variant={selectedFilters.includes(badge) ? "secondary" : "outline"}
+          label={badge}
-          className="mb-2 flex cursor-pointer items-center justify-center gap-2 rounded-full border border-black/50 px-3 py-1 dark:border-white/50 lg:mb-3 lg:gap-2.5 lg:px-6 lg:py-2"
+          selected={selectedFilters.includes(badge)}
          onClick={() => handleBadgeClick(badge)}
-        >
+          size="lg"
-          <div className="text-sm font-light tracking-tight text-[#474747] dark:text-[#e0e0e0] lg:text-xl lg:font-medium lg:leading-9">
+          className="mb-2 lg:mb-3"
-            {badge}
+        />
          </div>
        </Badge>
      ))}
    </div>
  );
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/HeroSection/HeroSection.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/HeroSection/HeroSection.tsx
@@ -1,5 +1,6 @@
 "use client";
 import { FadeIn } from "@/components/molecules/FadeIn/FadeIn";
 import { FilterChips } from "../FilterChips/FilterChips";
 import { SearchBar } from "../SearchBar/SearchBar";
 import { useHeroSection } from "./useHeroSection";
@@ -9,30 +10,36 @@ export const HeroSection = () => {
  return (
    <div className="mb-2 mt-8 flex flex-col items-center justify-center px-4 sm:mb-4 sm:mt-12 sm:px-6 md:mb-6 md:mt-16 lg:my-24 lg:px-8 xl:my-16">
      <div className="w-full max-w-3xl lg:max-w-4xl xl:max-w-5xl">
-        <div className="mb-4 text-center md:mb-8">
+        <FadeIn direction="down" duration={0.6} delay={0}>
-          <h1 className="text-center">
+          <div className="mb-4 text-center md:mb-8">
-            <span className="font-poppins text-[48px] font-semibold leading-[54px] text-neutral-950 dark:text-neutral-50">
+            <h1 className="text-center">
-              Explore AI agents built for{" "}
+              <span className="font-poppins text-[48px] font-semibold leading-[54px] text-neutral-950 dark:text-neutral-50">
-            </span>
+                Explore AI agents built for{" "}
-            <span className="font-poppins text-[48px] font-semibold leading-[54px] text-violet-600">
+              </span>
-              you
+              <span className="font-poppins text-[48px] font-semibold leading-[54px] text-violet-600">
-            </span>
+                you
-            <br />
+              </span>
-            <span className="font-poppins text-[48px] font-semibold leading-[54px] text-neutral-950 dark:text-neutral-50">
+              <br />
-              by the{" "}
+              <span className="font-poppins text-[48px] font-semibold leading-[54px] text-neutral-950 dark:text-neutral-50">
-            </span>
+                by the{" "}
-            <span className="font-poppins text-[48px] font-semibold leading-[54px] text-blue-500">
+              </span>
-              community
+              <span className="font-poppins text-[48px] font-semibold leading-[54px] text-blue-500">
-            </span>
+                community
-          </h1>
+              </span>
-        </div>
+            </h1>
-        <h3 className="mb:text-2xl mb-6 text-center font-sans text-xl font-normal leading-loose text-neutral-700 dark:text-neutral-300 md:mb-12">
+          </div>
-          Bringing you AI agents designed by thinkers from around the world
+        </FadeIn>
-        </h3>
+        <FadeIn direction="up" duration={0.6} delay={0.15}>
-        <div className="mb-4 flex justify-center sm:mb-5">
+          <h3 className="mb:text-2xl mb-6 text-center font-sans text-xl font-normal leading-loose text-neutral-700 dark:text-neutral-300 md:mb-12">
-          <SearchBar height="h-[74px]" />
+            Bringing you AI agents designed by thinkers from around the world
-        </div>
+          </h3>
-        <div>
+        </FadeIn>
        <FadeIn direction="up" duration={0.5} delay={0.3}>
          <div className="mb-4 flex justify-center sm:mb-5">
            <SearchBar height="h-[74px]" />
          </div>
        </FadeIn>
        <FadeIn direction="up" duration={0.5} delay={0.4}>
          <div className="flex justify-center">
            <FilterChips
              badges={searchTerms}
@@ -40,7 +47,7 @@ export const HeroSection = () => {
              multiSelect={false}
            />
          </div>
-        </div>
+        </FadeIn>
      </div>
    </div>
  );
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainMarketplacePage/MainMarketplacePage.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainMarketplacePage/MainMarketplacePage.tsx
@@ -1,5 +1,6 @@
 "use client";
-import { Separator } from "@/components/__legacy__/ui/separator";
+import { Separator } from "@/components/atoms/Separator/Separator";
 import { FadeIn } from "@/components/molecules/FadeIn/FadeIn";
 import { FeaturedSection } from "../FeaturedSection/FeaturedSection";
 import { BecomeACreator } from "../BecomeACreator/BecomeACreator";
 import { HeroSection } from "../HeroSection/HeroSection";
@@ -8,7 +9,6 @@ import { useMainMarketplacePage } from "./useMainMarketplacePage";
 import { FeaturedCreators } from "../FeaturedCreators/FeaturedCreators";
 import { MainMarketplacePageLoading } from "../MainMarketplacePageLoading";
 import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
 import { WaitlistSection } from "../WaitlistSection/WaitlistSection";
 export const MainMarkeplacePage = () => {
  const { featuredAgents, topAgents, featuredCreators, isLoading, hasError } =
@@ -47,10 +47,6 @@ export const MainMarkeplacePage = () => {
        {/* 100px margin because our featured sections button are placed 40px below the container */}
        <Separator className="mb-6 mt-24" />
        {/* Waitlist Section - "Help Shape What's Next" */}
        <WaitlistSection />
        <Separator className="mb-6 mt-12" />
        {topAgents && (
          <AgentsSection sectionTitle="Top Agents" agents={topAgents.agents} />
        )}
@@ -59,11 +55,13 @@ export const MainMarkeplacePage = () => {
          <FeaturedCreators featuredCreators={featuredCreators.creators} />
        )}
        <Separator className="mb-[25px] mt-[60px]" />
-        <BecomeACreator
+        <FadeIn direction="up" duration={0.6}>
-          title="Become a Creator"
+          <BecomeACreator
-          description="Join our ever-growing community of hackers and tinkerers"
+            title="Become a Creator"
-          buttonText="Become a Creator"
+            description="Join our ever-growing community of hackers and tinkerers"
-        />
+            buttonText="Become a Creator"
          />
        </FadeIn>
      </main>
    </div>
  );
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/SearchBar/SearchBar.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/SearchBar/SearchBar.tsx
@@ -16,9 +16,9 @@ interface SearchBarProps {
 export const SearchBar = ({
  placeholder = 'Search for tasks like "optimise SEO"',
  backgroundColor = "bg-neutral-100 dark:bg-neutral-800",
-  iconColor = "text-[#646464] dark:text-neutral-400",
+  iconColor = "text-neutral-500 dark:text-neutral-400",
-  textColor = "text-[#707070] dark:text-neutral-200",
+  textColor = "text-neutral-500 dark:text-neutral-200",
-  placeholderColor = "text-[#707070] dark:text-neutral-400",
+  placeholderColor = "text-neutral-500 dark:text-neutral-400",
  width = "w-9/10 lg:w-[56.25rem]",
  height = "h-[60px]",
 }: SearchBarProps) => {
@@ -32,10 +32,13 @@ export const SearchBar = ({
    >
      <MagnifyingGlassIcon className={`h-5 w-5 md:h-7 md:w-7 ${iconColor}`} />
      <input
-        type="text"
+        type="search"
        name="search"
        autoComplete="off"
        value={searchQuery}
        onChange={(e) => setSearchQuery(e.target.value)}
        placeholder={placeholder}
        aria-label="Search for AI agents"
        className={`flex-grow border-none bg-transparent ${textColor} font-sans text-lg font-normal leading-[2.25rem] tracking-tight md:text-xl placeholder:${placeholderColor} focus:outline-none`}
        data-testid="store-search-input"
      />
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/StoreCard/StoreCard.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/StoreCard/StoreCard.tsx
@@ -1,10 +1,25 @@
 import Image from "next/image";
-import { StarRatingIcons } from "@/components/__legacy__/ui/icons";
+import { Star } from "@phosphor-icons/react";
 import Avatar, {
  AvatarFallback,
  AvatarImage,
 } from "@/components/atoms/Avatar/Avatar";
 function StarRating({ rating }: { rating: number }) {
  const stars = [];
  const clampedRating = Math.max(0, Math.min(5, rating));
  for (let i = 1; i <= 5; i++) {
    stars.push(
      <Star
        key={i}
        weight={i <= clampedRating ? "fill" : "regular"}
        className="h-4 w-4 text-neutral-900 dark:text-yellow-500"
      />,
    );
  }
  return <>{stars}</>;
 }
 interface StoreCardProps {
  agentName: string;
  agentImage: string;
@@ -34,7 +49,7 @@ export const StoreCard: React.FC<StoreCardProps> = ({
  return (
    <div
-      className="flex h-[27rem] w-full max-w-md cursor-pointer flex-col items-start rounded-3xl bg-background transition-all duration-300 hover:shadow-lg dark:hover:shadow-gray-700"
+      className="flex h-[27rem] w-full max-w-md cursor-pointer flex-col items-start rounded-3xl bg-background transition-shadow duration-300 hover:shadow-lg focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-neutral-950 focus-visible:ring-offset-2 dark:hover:shadow-gray-700 dark:focus-visible:ring-neutral-50"
      onClick={handleClick}
      data-testid="store-card"
      role="button"
@@ -76,7 +91,7 @@ export const StoreCard: React.FC<StoreCardProps> = ({
      <div className="mt-3 flex w-full flex-1 flex-col px-4">
        {/* Second Section: Agent Name and Creator Name */}
        <div className="flex w-full flex-col">
-          <h3 className="line-clamp-2 font-poppins text-2xl font-semibold text-[#272727] dark:text-neutral-100">
+          <h3 className="line-clamp-2 font-poppins text-2xl font-semibold text-neutral-800 dark:text-neutral-100">
            {agentName}
          </h3>
          {!hideAvatar && creatorName && (
@@ -107,11 +122,11 @@ export const StoreCard: React.FC<StoreCardProps> = ({
                {rating.toFixed(1)}
              </span>
              <div
-                className="inline-flex items-center"
+                className="inline-flex items-center gap-0.5"
                role="img"
                aria-label={`Rating: ${rating.toFixed(1)} out of 5 stars`}
              >
-                {StarRatingIcons(rating)}
+                <StarRating rating={rating} />
              </div>
            </div>
          </div>
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistCard/WaitlistCard.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistCard/WaitlistCard.tsx
@@ -1,105 +0,0 @@
 "use client";
 import Image from "next/image";
 import { Button } from "@/components/atoms/Button/Button";
 import { Check } from "@phosphor-icons/react";
 interface WaitlistCardProps {
  name: string;
  subHeading: string;
  description: string;
  imageUrl: string | null;
  isMember?: boolean;
  onCardClick: () => void;
  onJoinClick: (e: React.MouseEvent) => void;
 }
 export function WaitlistCard({
  name,
  subHeading,
  description,
  imageUrl,
  isMember = false,
  onCardClick,
  onJoinClick,
 }: WaitlistCardProps) {
  function handleJoinClick(e: React.MouseEvent) {
    e.stopPropagation();
    onJoinClick(e);
  }
  return (
    <div
      className="flex h-[24rem] w-full max-w-md cursor-pointer flex-col items-start rounded-3xl bg-white transition-all duration-300 hover:shadow-lg dark:bg-zinc-900 dark:hover:shadow-gray-700"
      onClick={onCardClick}
      data-testid="waitlist-card"
      role="button"
      tabIndex={0}
      aria-label={`${name} waitlist card`}
      onKeyDown={(e) => {
        if (e.key === "Enter" || e.key === " ") {
          onCardClick();
        }
      }}
    >
      {/* Image Section */}
      <div className="relative aspect-[2/1.2] w-full overflow-hidden rounded-large md:aspect-[2.17/1]">
        {imageUrl ? (
          <Image
            src={imageUrl}
            alt={`${name} preview image`}
            fill
            className="object-cover"
          />
        ) : (
          <div className="flex h-full w-full items-center justify-center bg-gradient-to-br from-neutral-200 to-neutral-300 dark:from-neutral-700 dark:to-neutral-800">
            <span className="text-4xl font-bold text-neutral-400 dark:text-neutral-500">
              {name.charAt(0)}
            </span>
          </div>
        )}
      </div>
      <div className="mt-3 flex w-full flex-1 flex-col px-4">
        {/* Name and Subheading */}
        <div className="flex w-full flex-col">
          <h3 className="line-clamp-1 font-poppins text-xl font-semibold text-[#272727] dark:text-neutral-100">
            {name}
          </h3>
          <p className="mt-1 line-clamp-1 text-sm text-neutral-500 dark:text-neutral-400">
            {subHeading}
          </p>
        </div>
        {/* Description */}
        <div className="mt-2 flex w-full flex-col">
          <p className="line-clamp-5 text-sm font-normal leading-relaxed text-neutral-600 dark:text-neutral-400">
            {description}
          </p>
        </div>
        <div className="flex-grow" />
        {/* Join Waitlist Button */}
        <div className="mt-4 w-full pb-4">
          {isMember ? (
            <Button
              disabled
              className="w-full rounded-full bg-green-600 text-white hover:bg-green-600 dark:bg-green-700 dark:hover:bg-green-700"
            >
              <Check className="mr-2" size={16} weight="bold" />
              On the waitlist
            </Button>
          ) : (
            <Button
              onClick={handleJoinClick}
              className="w-full rounded-full bg-zinc-800 text-white hover:bg-zinc-700 dark:bg-zinc-700 dark:hover:bg-zinc-600"
            >
              Join waitlist
            </Button>
          )}
        </div>
      </div>
    </div>
  );
 }
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistDetailModal/WaitlistDetailModal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistDetailModal/WaitlistDetailModal.tsx
@@ -1,356 +0,0 @@
 "use client";
 import { useState } from "react";
 import Image from "next/image";
 import { Button } from "@/components/atoms/Button/Button";
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import { Input } from "@/components/atoms/Input/Input";
 import {
  Carousel,
  CarouselContent,
  CarouselItem,
  CarouselNext,
  CarouselPrevious,
 } from "@/components/__legacy__/ui/carousel";
 import type { StoreWaitlistEntry } from "@/app/api/__generated__/models/storeWaitlistEntry";
 import { Check, Play } from "@phosphor-icons/react";
 import { useSupabaseStore } from "@/lib/supabase/hooks/useSupabaseStore";
 import { useToast } from "@/components/molecules/Toast/use-toast";
 import { usePostV2AddSelfToTheAgentWaitlist } from "@/app/api/__generated__/endpoints/store/store";
 interface MediaItem {
  type: "image" | "video";
  url: string;
  label?: string;
 }
 // Extract YouTube video ID from various URL formats
 function getYouTubeVideoId(url: string): string | null {
  const regExp =
    /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#&?]*).*/;
  const match = url.match(regExp);
  return match && match[7].length === 11 ? match[7] : null;
 }
 // Validate video URL for security
 function isValidVideoUrl(url: string): boolean {
  if (url.startsWith("data:video")) {
    return true;
  }
  const videoExtensions = /\.(mp4|webm|ogg)$/i;
  const youtubeRegex = /^(https?:\/\/)?(www\.)?(youtube\.com|youtu\.?be)\/.+$/;
  const validUrl = /^(https?:\/\/)/i;
  const cleanedUrl = url.split("?")[0];
  return (
    (validUrl.test(url) && videoExtensions.test(cleanedUrl)) ||
    youtubeRegex.test(url)
  );
 }
 // Video player with YouTube embed support
 function VideoPlayer({
  url,
  autoPlay = false,
  className = "",
 }: {
  url: string;
  autoPlay?: boolean;
  className?: string;
 }) {
  const youtubeId = getYouTubeVideoId(url);
  if (youtubeId) {
    return (
      <iframe
        src={`https://www.youtube.com/embed/${youtubeId}${autoPlay ? "?autoplay=1" : ""}`}
        title="YouTube video player"
        className={className}
        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
        sandbox="allow-same-origin allow-scripts allow-presentation"
        allowFullScreen
      />
    );
  }
  if (!isValidVideoUrl(url)) {
    return (
      <div
        className={`flex items-center justify-center bg-zinc-800 ${className}`}
      >
        <span className="text-sm text-zinc-400">Invalid video URL</span>
      </div>
    );
  }
  return <video src={url} controls autoPlay={autoPlay} className={className} />;
 }
 function MediaCarousel({ waitlist }: { waitlist: StoreWaitlistEntry }) {
  const [activeVideo, setActiveVideo] = useState<string | null>(null);
  // Build media items array: videos first, then images
  const mediaItems: MediaItem[] = [
    ...(waitlist.videoUrl
      ? [{ type: "video" as const, url: waitlist.videoUrl, label: "Video" }]
      : []),
    ...(waitlist.agentOutputDemoUrl
      ? [
          {
            type: "video" as const,
            url: waitlist.agentOutputDemoUrl,
            label: "Demo",
          },
        ]
      : []),
    ...waitlist.imageUrls.map((url) => ({ type: "image" as const, url })),
  ];
  if (mediaItems.length === 0) return null;
  // Single item - no carousel needed
  if (mediaItems.length === 1) {
    const item = mediaItems[0];
    return (
      <div className="relative aspect-[350/196] w-full overflow-hidden rounded-large">
        {item.type === "image" ? (
          <Image
            src={item.url}
            alt={`${waitlist.name} preview`}
            fill
            className="object-cover"
          />
        ) : (
          <VideoPlayer url={item.url} className="h-full w-full object-cover" />
        )}
      </div>
    );
  }
  // Multiple items - use carousel
  return (
    <Carousel className="w-full">
      <CarouselContent>
        {mediaItems.map((item, index) => (
          <CarouselItem key={index}>
            <div className="relative aspect-[350/196] w-full overflow-hidden rounded-large">
              {item.type === "image" ? (
                <Image
                  src={item.url}
                  alt={`${waitlist.name} preview ${index + 1}`}
                  fill
                  className="object-cover"
                />
              ) : activeVideo === item.url ? (
                <VideoPlayer
                  url={item.url}
                  autoPlay
                  className="h-full w-full object-cover"
                />
              ) : (
                <button
                  onClick={() => setActiveVideo(item.url)}
                  className="group relative h-full w-full bg-zinc-900"
                >
                  <div className="absolute inset-0 flex items-center justify-center">
                    <div className="flex h-16 w-16 items-center justify-center rounded-full bg-white/90 transition-transform group-hover:scale-110">
                      <Play size={32} weight="fill" className="text-zinc-800" />
                    </div>
                  </div>
                  <span className="absolute bottom-3 left-3 text-sm text-white">
                    {item.label}
                  </span>
                </button>
              )}
            </div>
          </CarouselItem>
        ))}
      </CarouselContent>
      <CarouselPrevious className="left-2 top-1/2 -translate-y-1/2" />
      <CarouselNext className="right-2 top-1/2 -translate-y-1/2" />
    </Carousel>
  );
 }
 interface WaitlistDetailModalProps {
  waitlist: StoreWaitlistEntry;
  isMember?: boolean;
  onClose: () => void;
  onJoinSuccess?: (waitlistId: string) => void;
 }
 export function WaitlistDetailModal({
  waitlist,
  isMember = false,
  onClose,
  onJoinSuccess,
 }: WaitlistDetailModalProps) {
  const { user } = useSupabaseStore();
  const [email, setEmail] = useState("");
  const [success, setSuccess] = useState(false);
  const { toast } = useToast();
  const joinWaitlistMutation = usePostV2AddSelfToTheAgentWaitlist();
  function handleJoin() {
    joinWaitlistMutation.mutate(
      {
        waitlistId: waitlist.waitlistId,
        data: { email: user ? undefined : email },
      },
      {
        onSuccess: (response) => {
          if (response.status === 200) {
            setSuccess(true);
            toast({
              title: "You're on the waitlist!",
              description: `We'll notify you when ${waitlist.name} goes live.`,
            });
            onJoinSuccess?.(waitlist.waitlistId);
          } else {
            toast({
              variant: "destructive",
              title: "Error",
              description: "Failed to join waitlist. Please try again.",
            });
          }
        },
        onError: () => {
          toast({
            variant: "destructive",
            title: "Error",
            description: "Failed to join waitlist. Please try again.",
          });
        },
      },
    );
  }
  // Success state
  if (success) {
    return (
      <Dialog
        title=""
        controlled={{
          isOpen: true,
          set: async (open) => {
            if (!open) onClose();
          },
        }}
        onClose={onClose}
        styling={{ maxWidth: "500px" }}
      >
        <Dialog.Content>
          <div className="flex flex-col items-center justify-center py-4 text-center">
            {/* Party emoji */}
            <span className="mb-2 text-5xl">🎉</span>
            {/* Title */}
            <h2 className="mb-2 font-poppins text-[22px] font-medium leading-7 text-zinc-900 dark:text-zinc-100">
              You&apos;re on the waitlist
            </h2>
            {/* Subtitle */}
            <p className="text-base leading-[26px] text-zinc-600 dark:text-zinc-400">
              Thanks for helping us prioritize which agents to build next.
              We&apos;ll notify you when this agent goes live in the
              marketplace.
            </p>
          </div>
          {/* Close button */}
          <Dialog.Footer className="flex justify-center pb-2 pt-4">
            <Button
              variant="secondary"
              onClick={onClose}
              className="rounded-full border border-zinc-700 bg-white px-4 py-3 text-zinc-900 hover:bg-zinc-100 dark:border-zinc-500 dark:bg-zinc-800 dark:text-zinc-100 dark:hover:bg-zinc-700"
            >
              Close
            </Button>
          </Dialog.Footer>
        </Dialog.Content>
      </Dialog>
    );
  }
  // Main modal - handles both member and non-member states
  return (
    <Dialog
      title="Join the waitlist"
      controlled={{
        isOpen: true,
        set: async (open) => {
          if (!open) onClose();
        },
      }}
      onClose={onClose}
      styling={{ maxWidth: "500px" }}
    >
      <Dialog.Content>
        {/* Subtitle */}
        <p className="mb-6 text-center text-base text-zinc-600 dark:text-zinc-400">
          Help us decide what to build next — and get notified when this agent
          is ready
        </p>
        {/* Media Carousel */}
        <MediaCarousel waitlist={waitlist} />
        {/* Agent Name */}
        <h3 className="mt-4 font-poppins text-[22px] font-medium leading-7 text-zinc-800 dark:text-zinc-100">
          {waitlist.name}
        </h3>
        {/* Agent Description */}
        <p className="mt-2 line-clamp-5 text-sm leading-[22px] text-zinc-500 dark:text-zinc-400">
          {waitlist.description}
        </p>
        {/* Email input for non-logged-in users who haven't joined */}
        {!isMember && !user && (
          <div className="mt-4 pr-1">
            <Input
              id="email"
              label="Email address"
              type="email"
              placeholder="you@example.com"
              value={email}
              onChange={(e) => setEmail(e.target.value)}
              required
            />
          </div>
        )}
        {/* Footer buttons */}
        <Dialog.Footer className="sticky bottom-0 mt-6 flex justify-center gap-3 bg-white pb-2 pt-4 dark:bg-zinc-900">
          {isMember ? (
            <Button
              disabled
              className="rounded-full bg-green-600 px-4 py-3 text-white hover:bg-green-600 dark:bg-green-700 dark:hover:bg-green-700"
            >
              <Check size={16} className="mr-2" />
              You&apos;re on the waitlist
            </Button>
          ) : (
            <>
              <Button
                onClick={handleJoin}
                loading={joinWaitlistMutation.isPending}
                disabled={!user && !email}
                className="rounded-full bg-zinc-800 px-4 py-3 text-white hover:bg-zinc-700 dark:bg-zinc-700 dark:hover:bg-zinc-600"
              >
                Join waitlist
              </Button>
              <Button
                type="button"
                variant="secondary"
                onClick={onClose}
                className="rounded-full bg-zinc-200 px-4 py-3 text-zinc-900 hover:bg-zinc-300 dark:bg-zinc-700 dark:text-zinc-100 dark:hover:bg-zinc-600"
              >
                Not now
              </Button>
            </>
          )}
        </Dialog.Footer>
      </Dialog.Content>
    </Dialog>
  );
 }
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistSection/WaitlistSection.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistSection/WaitlistSection.tsx
@@ -1,102 +0,0 @@
 "use client";
 import { useState } from "react";
 import {
  Carousel,
  CarouselContent,
  CarouselItem,
 } from "@/components/__legacy__/ui/carousel";
 import { WaitlistCard } from "../WaitlistCard/WaitlistCard";
 import { WaitlistDetailModal } from "../WaitlistDetailModal/WaitlistDetailModal";
 import type { StoreWaitlistEntry } from "@/app/api/__generated__/models/storeWaitlistEntry";
 import { useWaitlistSection } from "./useWaitlistSection";
 export function WaitlistSection() {
  const { waitlists, joinedWaitlistIds, isLoading, hasError, markAsJoined } =
    useWaitlistSection();
  const [selectedWaitlist, setSelectedWaitlist] =
    useState<StoreWaitlistEntry | null>(null);
  function handleOpenModal(waitlist: StoreWaitlistEntry) {
    setSelectedWaitlist(waitlist);
  }
  function handleJoinSuccess(waitlistId: string) {
    markAsJoined(waitlistId);
  }
  // Don't render if loading, error, or no waitlists
  if (isLoading || hasError || !waitlists || waitlists.length === 0) {
    return null;
  }
  return (
    <div className="flex flex-col items-center justify-center">
      <div className="w-full max-w-[1360px]">
        {/* Section Header */}
        <div className="mb-6">
          <h2 className="font-poppins text-2xl font-semibold text-[#282828] dark:text-neutral-200">
            Help Shape What&apos;s Next
          </h2>
          <p className="mt-2 text-base text-neutral-600 dark:text-neutral-400">
            These agents are in development. Your interest helps us prioritize
            what gets built — and we&apos;ll notify you when they&apos;re ready.
          </p>
        </div>
        {/* Mobile Carousel View */}
        <Carousel
          className="md:hidden"
          opts={{
            loop: true,
          }}
        >
          <CarouselContent>
            {waitlists.map((waitlist) => (
              <CarouselItem
                key={waitlist.waitlistId}
                className="min-w-64 max-w-71"
              >
                <WaitlistCard
                  name={waitlist.name}
                  subHeading={waitlist.subHeading}
                  description={waitlist.description}
                  imageUrl={waitlist.imageUrls[0] || null}
                  isMember={joinedWaitlistIds.has(waitlist.waitlistId)}
                  onCardClick={() => handleOpenModal(waitlist)}
                  onJoinClick={() => handleOpenModal(waitlist)}
                />
              </CarouselItem>
            ))}
          </CarouselContent>
        </Carousel>
        {/* Desktop Grid View */}
        <div className="hidden grid-cols-1 place-items-center gap-6 md:grid md:grid-cols-2 lg:grid-cols-3">
          {waitlists.map((waitlist) => (
            <WaitlistCard
              key={waitlist.waitlistId}
              name={waitlist.name}
              subHeading={waitlist.subHeading}
              description={waitlist.description}
              imageUrl={waitlist.imageUrls[0] || null}
              isMember={joinedWaitlistIds.has(waitlist.waitlistId)}
              onCardClick={() => handleOpenModal(waitlist)}
              onJoinClick={() => handleOpenModal(waitlist)}
            />
          ))}
        </div>
      </div>
      {/* Single Modal for both viewing and joining */}
      {selectedWaitlist && (
        <WaitlistDetailModal
          waitlist={selectedWaitlist}
          isMember={joinedWaitlistIds.has(selectedWaitlist.waitlistId)}
          onClose={() => setSelectedWaitlist(null)}
          onJoinSuccess={handleJoinSuccess}
        />
      )}
    </div>
  );
 }
--- a/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistSection/useWaitlistSection.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistSection/useWaitlistSection.ts
@@ -1,58 +0,0 @@
 "use client";
 import { useMemo } from "react";
 import { useSupabaseStore } from "@/lib/supabase/hooks/useSupabaseStore";
 import {
  useGetV2GetTheAgentWaitlist,
  useGetV2GetWaitlistIdsTheCurrentUserHasJoined,
  getGetV2GetWaitlistIdsTheCurrentUserHasJoinedQueryKey,
 } from "@/app/api/__generated__/endpoints/store/store";
 import type { StoreWaitlistEntry } from "@/app/api/__generated__/models/storeWaitlistEntry";
 import { useQueryClient } from "@tanstack/react-query";
 export function useWaitlistSection() {
  const { user } = useSupabaseStore();
  const queryClient = useQueryClient();
  // Fetch waitlists
  const {
    data: waitlistsResponse,
    isLoading: waitlistsLoading,
    isError: waitlistsError,
  } = useGetV2GetTheAgentWaitlist();
  // Fetch memberships if logged in
  const { data: membershipsResponse, isLoading: membershipsLoading } =
    useGetV2GetWaitlistIdsTheCurrentUserHasJoined({
      query: {
        enabled: !!user,
      },
    });
  const waitlists: StoreWaitlistEntry[] = useMemo(() => {
    if (waitlistsResponse?.status === 200) {
      return waitlistsResponse.data.listings;
    }
    return [];
  }, [waitlistsResponse]);
  const joinedWaitlistIds: Set<string> = useMemo(() => {
    if (membershipsResponse?.status === 200) {
      return new Set(membershipsResponse.data);
    }
    return new Set();
  }, [membershipsResponse]);
  const isLoading = waitlistsLoading || (!!user && membershipsLoading);
  const hasError = waitlistsError;
  // Function to add a waitlist ID to joined set (called after successful join)
  function markAsJoined(_waitlistId: string) {
    // Invalidate the memberships query to refetch
    queryClient.invalidateQueries({
      queryKey: getGetV2GetWaitlistIdsTheCurrentUserHasJoinedQueryKey(),
    });
  }
  return { waitlists, joinedWaitlistIds, isLoading, hasError, markAsJoined };
 }
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -5082,301 +5082,6 @@
        }
      }
    },
    "/api/store/admin/waitlist": {
      "get": {
        "tags": ["v2", "admin", "store", "admin", "waitlist"],
        "summary": "List All Waitlists",
        "description": "Get all waitlists with admin details (admin only).\n\nReturns:\n    WaitlistAdminListResponse with all waitlists",
        "operationId": "getV2List all waitlists",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/WaitlistAdminListResponse"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
          }
        },
        "security": [{ "HTTPBearerJWT": [] }]
      },
      "post": {
        "tags": ["v2", "admin", "store", "admin", "waitlist"],
        "summary": "Create Waitlist",
        "description": "Create a new waitlist (admin only).\n\nArgs:\n    request: Waitlist creation details\n    user_id: Authenticated admin user creating the waitlist\n\nReturns:\n    WaitlistAdminResponse with the created waitlist details",
        "operationId": "postV2Create waitlist",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": { "$ref": "#/components/schemas/WaitlistCreateRequest" }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/WaitlistAdminResponse"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
              }
            }
          }
        },
        "security": [{ "HTTPBearerJWT": [] }]
      }
    },
    "/api/store/admin/waitlist/{waitlist_id}": {
      "delete": {
        "tags": ["v2", "admin", "store", "admin", "waitlist"],
        "summary": "Delete Waitlist",
        "description": "Soft delete a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to delete\n\nReturns:\n    Success message",
        "operationId": "deleteV2Delete waitlist",
        "security": [{ "HTTPBearerJWT": [] }],
        "parameters": [
          {
            "name": "waitlist_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "description": "The ID of the waitlist",
              "title": "Waitlist Id"
            },
            "description": "The ID of the waitlist"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": { "application/json": { "schema": {} } }
          },
          "401": {
            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
              }
            }
          }
        }
      },
      "get": {
        "tags": ["v2", "admin", "store", "admin", "waitlist"],
        "summary": "Get Waitlist Details",
        "description": "Get a single waitlist with admin details (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to retrieve\n\nReturns:\n    WaitlistAdminResponse with waitlist details",
        "operationId": "getV2Get waitlist details",
        "security": [{ "HTTPBearerJWT": [] }],
        "parameters": [
          {
            "name": "waitlist_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "description": "The ID of the waitlist",
              "title": "Waitlist Id"
            },
            "description": "The ID of the waitlist"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/WaitlistAdminResponse"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
              }
            }
          }
        }
      },
      "put": {
        "tags": ["v2", "admin", "store", "admin", "waitlist"],
        "summary": "Update Waitlist",
        "description": "Update a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to update\n    request: Fields to update\n\nReturns:\n    WaitlistAdminResponse with updated waitlist details",
        "operationId": "putV2Update waitlist",
        "security": [{ "HTTPBearerJWT": [] }],
        "parameters": [
          {
            "name": "waitlist_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "description": "The ID of the waitlist",
              "title": "Waitlist Id"
            },
            "description": "The ID of the waitlist"
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": { "$ref": "#/components/schemas/WaitlistUpdateRequest" }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/WaitlistAdminResponse"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
              }
            }
          }
        }
      }
    },
    "/api/store/admin/waitlist/{waitlist_id}/link": {
      "post": {
        "tags": ["v2", "admin", "store", "admin", "waitlist"],
        "summary": "Link Waitlist to Store Listing",
        "description": "Link a waitlist to a store listing (admin only).\n\nWhen the linked store listing is approved/published, waitlist users\nwill be automatically notified.\n\nArgs:\n    waitlist_id: ID of the waitlist\n    store_listing_id: ID of the store listing to link\n\nReturns:\n    WaitlistAdminResponse with updated waitlist details",
        "operationId": "postV2Link waitlist to store listing",
        "security": [{ "HTTPBearerJWT": [] }],
        "parameters": [
          {
            "name": "waitlist_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "description": "The ID of the waitlist",
              "title": "Waitlist Id"
            },
            "description": "The ID of the waitlist"
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Body_postV2Link_waitlist_to_store_listing"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/WaitlistAdminResponse"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
              }
            }
          }
        }
      }
    },
    "/api/store/admin/waitlist/{waitlist_id}/signups": {
      "get": {
        "tags": ["v2", "admin", "store", "admin", "waitlist"],
        "summary": "Get Waitlist Signups",
        "description": "Get all signups for a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist\n\nReturns:\n    WaitlistSignupListResponse with all signups",
        "operationId": "getV2Get waitlist signups",
        "security": [{ "HTTPBearerJWT": [] }],
        "parameters": [
          {
            "name": "waitlist_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "description": "The ID of the waitlist",
              "title": "Waitlist Id"
            },
            "description": "The ID of the waitlist"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/WaitlistSignupListResponse"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
              }
            }
          }
        }
      }
    },
    "/api/store/agents": {
      "get": {
        "tags": ["v2", "store", "public"],
@@ -6222,101 +5927,6 @@
        }
      }
    },
    "/api/store/waitlist": {
      "get": {
        "tags": ["v2", "store", "public"],
        "summary": "Get the agent waitlist",
        "description": "Get all active waitlists for public display.",
        "operationId": "getV2Get the agent waitlist",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/StoreWaitlistsAllResponse"
                }
              }
            }
          }
        }
      }
    },
    "/api/store/waitlist/my-memberships": {
      "get": {
        "tags": ["v2", "store", "private"],
        "summary": "Get waitlist IDs the current user has joined",
        "description": "Returns list of waitlist IDs the authenticated user has joined.",
        "operationId": "getV2Get waitlist ids the current user has joined",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "items": { "type": "string" },
                  "type": "array",
                  "title": "Response Getv2Get Waitlist Ids The Current User Has Joined"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
          }
        },
        "security": [{ "HTTPBearerJWT": [] }]
      }
    },
    "/api/store/waitlist/{waitlist_id}/join": {
      "post": {
        "tags": ["v2", "store", "public"],
        "summary": "Add self to the agent waitlist",
        "description": "Add the current user to the agent waitlist.",
        "operationId": "postV2Add self to the agent waitlist",
        "security": [{ "HTTPBearer": [] }],
        "parameters": [
          {
            "name": "waitlist_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "description": "The ID of the waitlist to join",
              "title": "Waitlist Id"
            },
            "description": "The ID of the waitlist to join"
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Body_postV2Add_self_to_the_agent_waitlist"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": { "$ref": "#/components/schemas/StoreWaitlistEntry" }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
              }
            }
          }
        }
      }
    },
    "/health": {
      "get": {
        "tags": ["health"],
@@ -7064,17 +6674,6 @@
        "required": ["store_listing_version_id"],
        "title": "Body_postV2Add marketplace agent"
      },
      "Body_postV2Add_self_to_the_agent_waitlist": {
        "properties": {
          "email": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Email",
            "description": "Email address for unauthenticated users"
          }
        },
        "type": "object",
        "title": "Body_postV2Add self to the agent waitlist"
      },
      "Body_postV2Execute_a_preset": {
        "properties": {
          "inputs": {
@@ -7093,18 +6692,6 @@
        "type": "object",
        "title": "Body_postV2Execute a preset"
      },
      "Body_postV2Link_waitlist_to_store_listing": {
        "properties": {
          "store_listing_id": {
            "type": "string",
            "title": "Store Listing Id",
            "description": "The ID of the store listing"
          }
        },
        "type": "object",
        "required": ["store_listing_id"],
        "title": "Body_postV2Link waitlist to store listing"
      },
      "Body_postV2Upload_submission_media": {
        "properties": {
          "file": { "type": "string", "format": "binary", "title": "File" }
@@ -8984,8 +8571,7 @@
          "REFUND_REQUEST",
          "REFUND_PROCESSED",
          "AGENT_APPROVED",
-          "AGENT_REJECTED",
+          "AGENT_REJECTED"
          "WAITLIST_LAUNCH"
        ],
        "title": "NotificationType"
      },
@@ -10548,57 +10134,6 @@
        "required": ["submissions", "pagination"],
        "title": "StoreSubmissionsResponse"
      },
      "StoreWaitlistEntry": {
        "properties": {
          "waitlistId": { "type": "string", "title": "Waitlistid" },
          "slug": { "type": "string", "title": "Slug" },
          "name": { "type": "string", "title": "Name" },
          "subHeading": { "type": "string", "title": "Subheading" },
          "videoUrl": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Videourl"
          },
          "agentOutputDemoUrl": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Agentoutputdemourl"
          },
          "imageUrls": {
            "items": { "type": "string" },
            "type": "array",
            "title": "Imageurls"
          },
          "description": { "type": "string", "title": "Description" },
          "categories": {
            "items": { "type": "string" },
            "type": "array",
            "title": "Categories"
          }
        },
        "type": "object",
        "required": [
          "waitlistId",
          "slug",
          "name",
          "subHeading",
          "imageUrls",
          "description",
          "categories"
        ],
        "title": "StoreWaitlistEntry",
        "description": "Public waitlist entry - no PII fields exposed."
      },
      "StoreWaitlistsAllResponse": {
        "properties": {
          "listings": {
            "items": { "$ref": "#/components/schemas/StoreWaitlistEntry" },
            "type": "array",
            "title": "Listings"
          }
        },
        "type": "object",
        "required": ["listings"],
        "title": "StoreWaitlistsAllResponse"
      },
      "StreamChatRequest": {
        "properties": {
          "message": { "type": "string", "title": "Message" },
@@ -12418,203 +11953,6 @@
        "required": ["loc", "msg", "type"],
        "title": "ValidationError"
      },
      "WaitlistAdminListResponse": {
        "properties": {
          "waitlists": {
            "items": { "$ref": "#/components/schemas/WaitlistAdminResponse" },
            "type": "array",
            "title": "Waitlists"
          },
          "totalCount": { "type": "integer", "title": "Totalcount" }
        },
        "type": "object",
        "required": ["waitlists", "totalCount"],
        "title": "WaitlistAdminListResponse",
        "description": "Response model for listing all waitlists (admin view)."
      },
      "WaitlistAdminResponse": {
        "properties": {
          "id": { "type": "string", "title": "Id" },
          "createdAt": { "type": "string", "title": "Createdat" },
          "updatedAt": { "type": "string", "title": "Updatedat" },
          "slug": { "type": "string", "title": "Slug" },
          "name": { "type": "string", "title": "Name" },
          "subHeading": { "type": "string", "title": "Subheading" },
          "description": { "type": "string", "title": "Description" },
          "categories": {
            "items": { "type": "string" },
            "type": "array",
            "title": "Categories"
          },
          "imageUrls": {
            "items": { "type": "string" },
            "type": "array",
            "title": "Imageurls"
          },
          "videoUrl": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Videourl"
          },
          "agentOutputDemoUrl": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Agentoutputdemourl"
          },
          "status": { "$ref": "#/components/schemas/WaitlistExternalStatus" },
          "votes": { "type": "integer", "title": "Votes" },
          "signupCount": { "type": "integer", "title": "Signupcount" },
          "storeListingId": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Storelistingid"
          },
          "owningUserId": { "type": "string", "title": "Owninguserid" }
        },
        "type": "object",
        "required": [
          "id",
          "createdAt",
          "updatedAt",
          "slug",
          "name",
          "subHeading",
          "description",
          "categories",
          "imageUrls",
          "status",
          "votes",
          "signupCount",
          "owningUserId"
        ],
        "title": "WaitlistAdminResponse",
        "description": "Admin response model with full waitlist details including internal data."
      },
      "WaitlistCreateRequest": {
        "properties": {
          "name": { "type": "string", "title": "Name" },
          "slug": { "type": "string", "title": "Slug" },
          "subHeading": { "type": "string", "title": "Subheading" },
          "description": { "type": "string", "title": "Description" },
          "categories": {
            "items": { "type": "string" },
            "type": "array",
            "title": "Categories",
            "default": []
          },
          "imageUrls": {
            "items": { "type": "string" },
            "type": "array",
            "title": "Imageurls",
            "default": []
          },
          "videoUrl": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Videourl"
          },
          "agentOutputDemoUrl": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Agentoutputdemourl"
          }
        },
        "type": "object",
        "required": ["name", "slug", "subHeading", "description"],
        "title": "WaitlistCreateRequest",
        "description": "Request model for creating a new waitlist."
      },
      "WaitlistExternalStatus": {
        "type": "string",
        "enum": ["DONE", "NOT_STARTED", "CANCELED", "WORK_IN_PROGRESS"],
        "title": "WaitlistExternalStatus"
      },
      "WaitlistSignup": {
        "properties": {
          "type": { "type": "string", "title": "Type" },
          "userId": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Userid"
          },
          "email": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Email"
          },
          "username": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Username"
          }
        },
        "type": "object",
        "required": ["type"],
        "title": "WaitlistSignup",
        "description": "Individual signup entry for a waitlist."
      },
      "WaitlistSignupListResponse": {
        "properties": {
          "waitlistId": { "type": "string", "title": "Waitlistid" },
          "signups": {
            "items": { "$ref": "#/components/schemas/WaitlistSignup" },
            "type": "array",
            "title": "Signups"
          },
          "totalCount": { "type": "integer", "title": "Totalcount" }
        },
        "type": "object",
        "required": ["waitlistId", "signups", "totalCount"],
        "title": "WaitlistSignupListResponse",
        "description": "Response model for listing waitlist signups."
      },
      "WaitlistUpdateRequest": {
        "properties": {
          "name": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Name"
          },
          "slug": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Slug"
          },
          "subHeading": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Subheading"
          },
          "description": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Description"
          },
          "categories": {
            "anyOf": [
              { "items": { "type": "string" }, "type": "array" },
              { "type": "null" }
            ],
            "title": "Categories"
          },
          "imageUrls": {
            "anyOf": [
              { "items": { "type": "string" }, "type": "array" },
              { "type": "null" }
            ],
            "title": "Imageurls"
          },
          "videoUrl": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Videourl"
          },
          "agentOutputDemoUrl": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Agentoutputdemourl"
          },
          "status": {
            "anyOf": [
              { "$ref": "#/components/schemas/WaitlistExternalStatus" },
              { "type": "null" }
            ]
          },
          "storeListingId": {
            "anyOf": [{ "type": "string" }, { "type": "null" }],
            "title": "Storelistingid"
          }
        },
        "type": "object",
        "title": "WaitlistUpdateRequest",
        "description": "Request model for updating a waitlist."
      },
      "Webhook": {
        "properties": {
          "id": { "type": "string", "title": "Id" },
--- a/autogpt_platform/frontend/src/components/atoms/FilterChip/FilterChip.stories.tsx
+++ b/autogpt_platform/frontend/src/components/atoms/FilterChip/FilterChip.stories.tsx
@@ -0,0 +1,151 @@
 import type { Meta, StoryObj } from "@storybook/react";
 import { useState } from "react";
 import { FilterChip } from "./FilterChip";
 const meta: Meta<typeof FilterChip> = {
  title: "Atoms/FilterChip",
  component: FilterChip,
  tags: ["autodocs"],
  parameters: {
    layout: "centered",
  },
  argTypes: {
    size: {
      control: "select",
      options: ["sm", "md", "lg"],
    },
  },
 };
 export default meta;
 type Story = StoryObj<typeof FilterChip>;
 export const Default: Story = {
  args: {
    label: "Marketing",
  },
 };
 export const Selected: Story = {
  args: {
    label: "Marketing",
    selected: true,
  },
 };
 export const Dismissible: Story = {
  args: {
    label: "Marketing",
    selected: true,
    dismissible: true,
  },
 };
 export const Sizes: Story = {
  render: () => (
    <div className="flex items-center gap-4">
      <FilterChip label="Small" size="sm" />
      <FilterChip label="Medium" size="md" />
      <FilterChip label="Large" size="lg" />
    </div>
  ),
 };
 export const Disabled: Story = {
  args: {
    label: "Disabled",
    disabled: true,
  },
 };
 function FilterChipGroupDemo() {
  const filters = [
    "Marketing",
    "Sales",
    "Development",
    "Design",
    "Research",
    "Analytics",
  ];
  const [selected, setSelected] = useState<string[]>(["Marketing"]);
  function handleToggle(filter: string) {
    setSelected((prev) =>
      prev.includes(filter)
        ? prev.filter((f) => f !== filter)
        : [...prev, filter],
    );
  }
  return (
    <div className="flex flex-wrap gap-3">
      {filters.map((filter) => (
        <FilterChip
          key={filter}
          label={filter}
          selected={selected.includes(filter)}
          onClick={() => handleToggle(filter)}
        />
      ))}
    </div>
  );
 }
 export const FilterGroup: Story = {
  render: () => <FilterChipGroupDemo />,
 };
 function SingleSelectDemo() {
  const filters = ["All", "Featured", "Popular", "New"];
  const [selected, setSelected] = useState("All");
  return (
    <div className="flex flex-wrap gap-3">
      {filters.map((filter) => (
        <FilterChip
          key={filter}
          label={filter}
          selected={selected === filter}
          onClick={() => setSelected(filter)}
        />
      ))}
    </div>
  );
 }
 export const SingleSelect: Story = {
  render: () => <SingleSelectDemo />,
 };
 function DismissibleDemo() {
  const [filters, setFilters] = useState([
    "Marketing",
    "Sales",
    "Development",
  ]);
  function handleDismiss(filter: string) {
    setFilters((prev) => prev.filter((f) => f !== filter));
  }
  return (
    <div className="flex flex-wrap gap-3">
      {filters.map((filter) => (
        <FilterChip
          key={filter}
          label={filter}
          selected
          dismissible
          onDismiss={() => handleDismiss(filter)}
        />
      ))}
      {filters.length === 0 && (
        <span className="text-neutral-500">No filters selected</span>
      )}
    </div>
  );
 }
 export const DismissibleGroup: Story = {
  render: () => <DismissibleDemo />,
 };
--- a/autogpt_platform/frontend/src/components/atoms/FilterChip/FilterChip.tsx
+++ b/autogpt_platform/frontend/src/components/atoms/FilterChip/FilterChip.tsx
@@ -0,0 +1,100 @@
 "use client";
 import { cn } from "@/lib/utils";
 import { X } from "@phosphor-icons/react";
 type FilterChipSize = "sm" | "md" | "lg";
 interface FilterChipProps {
  /** The label text displayed in the chip */
  label: string;
  /** Whether the chip is currently selected */
  selected?: boolean;
  /** Callback when the chip is clicked */
  onClick?: () => void;
  /** Whether to show a dismiss/remove button */
  dismissible?: boolean;
  /** Callback when the dismiss button is clicked */
  onDismiss?: () => void;
  /** Size variant of the chip */
  size?: FilterChipSize;
  /** Whether the chip is disabled */
  disabled?: boolean;
  /** Additional CSS classes */
  className?: string;
 }
 const sizeStyles: Record<FilterChipSize, string> = {
  sm: "px-3 py-1 text-sm gap-1.5",
  md: "px-4 py-1.5 text-base gap-2",
  lg: "px-6 py-2 text-lg gap-2.5 lg:text-xl lg:leading-9",
 };
 const iconSizes: Record<FilterChipSize, string> = {
  sm: "h-3 w-3",
  md: "h-4 w-4",
  lg: "h-5 w-5",
 };
 /**
 * A filter chip component for selecting/deselecting filter options.
 * Supports single and multi-select patterns with proper accessibility.
 */
 export function FilterChip({
  label,
  selected = false,
  onClick,
  dismissible = false,
  onDismiss,
  size = "md",
  disabled = false,
  className,
 }: FilterChipProps) {
  function handleDismiss(e: React.MouseEvent) {
    e.stopPropagation();
    onDismiss?.();
  }
  return (
    <button
      type="button"
      onClick={onClick}
      disabled={disabled}
      aria-pressed={selected}
      className={cn(
        // Base styles
        "inline-flex items-center justify-center rounded-full border font-medium transition-colors",
        // Focus styles
        "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-neutral-950 focus-visible:ring-offset-2 dark:focus-visible:ring-neutral-50",
        // Size styles
        sizeStyles[size],
        // State styles
        selected
          ? "border-neutral-900 bg-neutral-100 text-neutral-800 dark:border-neutral-100 dark:bg-neutral-800 dark:text-neutral-200"
          : "border-neutral-400 bg-transparent text-neutral-600 hover:bg-neutral-50 dark:border-neutral-500 dark:text-neutral-300 dark:hover:bg-neutral-800",
        // Disabled styles
        disabled && "pointer-events-none opacity-50",
        className,
      )}
    >
      <span>{label}</span>
      {dismissible && selected && (
        <span
          role="button"
          tabIndex={0}
          onClick={handleDismiss}
          onKeyDown={(e) => {
            if (e.key === "Enter" || e.key === " ") {
              e.preventDefault();
              handleDismiss(e as unknown as React.MouseEvent);
            }
          }}
          className="rounded-full p-0.5 hover:bg-neutral-200 dark:hover:bg-neutral-700"
          aria-label={`Remove ${label} filter`}
        >
          <X className={iconSizes[size]} weight="bold" />
        </span>
      )}
    </button>
  );
 }
--- a/autogpt_platform/frontend/src/components/atoms/Separator/Separator.stories.tsx
+++ b/autogpt_platform/frontend/src/components/atoms/Separator/Separator.stories.tsx
@@ -0,0 +1,72 @@
 import type { Meta, StoryObj } from "@storybook/react";
 import { Separator } from "./Separator";
 const meta: Meta<typeof Separator> = {
  title: "Atoms/Separator",
  component: Separator,
  tags: ["autodocs"],
  parameters: {
    layout: "padded",
  },
 };
 export default meta;
 type Story = StoryObj<typeof Separator>;
 export const Horizontal: Story = {
  render: () => (
    <div className="w-full max-w-md">
      <p className="mb-4 text-neutral-700 dark:text-neutral-300">
        Content above the separator
      </p>
      <Separator />
      <p className="mt-4 text-neutral-700 dark:text-neutral-300">
        Content below the separator
      </p>
    </div>
  ),
 };
 export const Vertical: Story = {
  render: () => (
    <div className="flex h-16 items-center gap-4">
      <span className="text-neutral-700 dark:text-neutral-300">Left</span>
      <Separator orientation="vertical" />
      <span className="text-neutral-700 dark:text-neutral-300">Right</span>
    </div>
  ),
 };
 export const WithCustomStyles: Story = {
  render: () => (
    <div className="w-full max-w-md space-y-4">
      <Separator className="bg-violet-500" />
      <Separator className="h-0.5 bg-gradient-to-r from-violet-500 to-blue-500" />
      <Separator className="bg-neutral-400 dark:bg-neutral-600" />
    </div>
  ),
 };
 export const InSection: Story = {
  render: () => (
    <div className="w-full max-w-md space-y-6">
      <section>
        <h2 className="mb-2 text-lg font-semibold text-neutral-900 dark:text-neutral-100">
          Featured Agents
        </h2>
        <p className="text-neutral-600 dark:text-neutral-400">
          Browse our collection of featured AI agents.
        </p>
      </section>
      <Separator className="my-6" />
      <section>
        <h2 className="mb-2 text-lg font-semibold text-neutral-900 dark:text-neutral-100">
          Top Creators
        </h2>
        <p className="text-neutral-600 dark:text-neutral-400">
          Meet the creators behind the most popular agents.
        </p>
      </section>
    </div>
  ),
 };
--- a/autogpt_platform/frontend/src/components/atoms/Separator/Separator.tsx
+++ b/autogpt_platform/frontend/src/components/atoms/Separator/Separator.tsx
@@ -0,0 +1,43 @@
 import { cn } from "@/lib/utils";
 type SeparatorOrientation = "horizontal" | "vertical";
 interface SeparatorProps {
  /** The orientation of the separator */
  orientation?: SeparatorOrientation;
  /** Whether the separator is purely decorative (true) or represents a semantic boundary (false) */
  decorative?: boolean;
  /** Additional CSS classes */
  className?: string;
 }
 /**
 * A visual separator that divides content.
 * Uses semantic `<hr>` for horizontal separators and a styled `<div>` for vertical.
 */
 export function Separator({
  orientation = "horizontal",
  decorative = true,
  className,
 }: SeparatorProps) {
  const baseStyles = "shrink-0 bg-neutral-200 dark:bg-neutral-800";
  if (orientation === "horizontal") {
    return (
      <hr
        className={cn(baseStyles, "h-px w-full border-0", className)}
        aria-hidden={decorative}
        role={decorative ? "none" : "separator"}
      />
    );
  }
  return (
    <div
      className={cn(baseStyles, "h-full w-px", className)}
      aria-hidden={decorative}
      role={decorative ? "none" : "separator"}
      aria-orientation="vertical"
    />
  );
 }
--- a/autogpt_platform/frontend/src/components/molecules/FadeIn/FadeIn.stories.tsx
+++ b/autogpt_platform/frontend/src/components/molecules/FadeIn/FadeIn.stories.tsx
@@ -0,0 +1,128 @@
 import type { Meta, StoryObj } from "@storybook/react";
 import { FadeIn } from "./FadeIn";
 const meta: Meta<typeof FadeIn> = {
  title: "Molecules/FadeIn",
  component: FadeIn,
  tags: ["autodocs"],
  parameters: {
    layout: "padded",
  },
  argTypes: {
    direction: {
      control: "select",
      options: ["up", "down", "left", "right", "none"],
    },
  },
 };
 export default meta;
 type Story = StoryObj<typeof FadeIn>;
 const DemoCard = ({ title }: { title: string }) => (
  <div className="rounded-xl bg-neutral-100 p-6 dark:bg-neutral-800">
    <h3 className="mb-2 text-lg font-semibold text-neutral-900 dark:text-neutral-100">
      {title}
    </h3>
    <p className="text-neutral-600 dark:text-neutral-400">
      This card fades in with a smooth animation.
    </p>
  </div>
 );
 export const Default: Story = {
  args: {
    direction: "up",
    children: <DemoCard title="Fade Up" />,
  },
 };
 export const FadeDown: Story = {
  args: {
    direction: "down",
    children: <DemoCard title="Fade Down" />,
  },
 };
 export const FadeLeft: Story = {
  args: {
    direction: "left",
    children: <DemoCard title="Fade Left" />,
  },
 };
 export const FadeRight: Story = {
  args: {
    direction: "right",
    children: <DemoCard title="Fade Right" />,
  },
 };
 export const FadeOnly: Story = {
  args: {
    direction: "none",
    children: <DemoCard title="Fade Only (No Direction)" />,
  },
 };
 export const WithDelay: Story = {
  args: {
    direction: "up",
    delay: 0.5,
    children: <DemoCard title="Delayed Fade (0.5s)" />,
  },
 };
 export const SlowAnimation: Story = {
  args: {
    direction: "up",
    duration: 1.5,
    children: <DemoCard title="Slow Animation (1.5s)" />,
  },
 };
 export const LargeDistance: Story = {
  args: {
    direction: "up",
    distance: 60,
    children: <DemoCard title="Large Distance (60px)" />,
  },
 };
 export const MultipleElements: Story = {
  render: () => (
    <div className="space-y-4">
      <FadeIn direction="up" delay={0}>
        <DemoCard title="First Card" />
      </FadeIn>
      <FadeIn direction="up" delay={0.1}>
        <DemoCard title="Second Card" />
      </FadeIn>
      <FadeIn direction="up" delay={0.2}>
        <DemoCard title="Third Card" />
      </FadeIn>
    </div>
  ),
 };
 export const HeroExample: Story = {
  render: () => (
    <div className="text-center">
      <FadeIn direction="down" delay={0}>
        <h1 className="mb-4 text-4xl font-bold text-neutral-900 dark:text-neutral-100">
          Welcome to the Marketplace
        </h1>
      </FadeIn>
      <FadeIn direction="up" delay={0.2}>
        <p className="mb-8 text-xl text-neutral-600 dark:text-neutral-400">
          Discover AI agents built by the community
        </p>
      </FadeIn>
      <FadeIn direction="up" delay={0.4}>
        <button className="rounded-full bg-violet-600 px-8 py-3 text-white hover:bg-violet-700">
          Get Started
        </button>
      </FadeIn>
    </div>
  ),
 };
--- a/autogpt_platform/frontend/src/components/molecules/FadeIn/FadeIn.tsx
+++ b/autogpt_platform/frontend/src/components/molecules/FadeIn/FadeIn.tsx
@@ -0,0 +1,109 @@
 "use client";
 import { cn } from "@/lib/utils";
 import { motion, useReducedMotion, type Variants } from "framer-motion";
 import { ReactNode } from "react";
 type FadeDirection = "up" | "down" | "left" | "right" | "none";
 interface FadeInProps {
  /** Content to animate */
  children: ReactNode;
  /** Direction the content fades in from */
  direction?: FadeDirection;
  /** Distance to travel in pixels (only applies when direction is not "none") */
  distance?: number;
  /** Animation duration in seconds */
  duration?: number;
  /** Delay before animation starts in seconds */
  delay?: number;
  /** Whether to trigger animation when element enters viewport */
  viewport?: boolean;
  /** How much of element must be visible to trigger (0-1) */
  viewportAmount?: number;
  /** Whether animation should only trigger once */
  once?: boolean;
  /** Additional CSS classes */
  className?: string;
  /** HTML element to render as */
  as?: keyof JSX.IntrinsicElements;
 }
 function getDirectionOffset(
  direction: FadeDirection,
  distance: number,
 ): { x: number; y: number } {
  switch (direction) {
    case "up":
      return { x: 0, y: distance };
    case "down":
      return { x: 0, y: -distance };
    case "left":
      return { x: distance, y: 0 };
    case "right":
      return { x: -distance, y: 0 };
    case "none":
    default:
      return { x: 0, y: 0 };
  }
 }
 /**
 * A fade-in animation wrapper component.
 * Animates children with a fade effect and optional directional slide.
 * Respects user's reduced motion preferences.
 */
 export function FadeIn({
  children,
  direction = "up",
  distance = 24,
  duration = 0.5,
  delay = 0,
  viewport = true,
  viewportAmount = 0.2,
  once = true,
  className,
  as = "div",
 }: FadeInProps) {
  const shouldReduceMotion = useReducedMotion();
  const offset = getDirectionOffset(direction, distance);
  // If user prefers reduced motion, render without animation
  if (shouldReduceMotion) {
    const Component = as as keyof JSX.IntrinsicElements;
    return <Component className={className}>{children}</Component>;
  }
  const variants: Variants = {
    hidden: {
      opacity: 0,
      x: offset.x,
      y: offset.y,
    },
    visible: {
      opacity: 1,
      x: 0,
      y: 0,
      transition: {
        duration,
        delay,
        ease: [0.25, 0.1, 0.25, 1], // Custom easing for smooth feel
      },
    },
  };
  const MotionComponent = motion[as as keyof typeof motion] as typeof motion.div;
  return (
    <MotionComponent
      className={cn(className)}
      initial="hidden"
      animate={viewport ? undefined : "visible"}
      whileInView={viewport ? "visible" : undefined}
      viewport={viewport ? { once, amount: viewportAmount } : undefined}
      variants={variants}
    >
      {children}
    </MotionComponent>
  );
 }
--- a/autogpt_platform/frontend/src/components/molecules/StaggeredList/StaggeredList.stories.tsx
+++ b/autogpt_platform/frontend/src/components/molecules/StaggeredList/StaggeredList.stories.tsx
@@ -0,0 +1,180 @@
 import type { Meta, StoryObj } from "@storybook/react";
 import { StaggeredList } from "./StaggeredList";
 const meta: Meta<typeof StaggeredList> = {
  title: "Molecules/StaggeredList",
  component: StaggeredList,
  tags: ["autodocs"],
  parameters: {
    layout: "padded",
  },
  argTypes: {
    direction: {
      control: "select",
      options: ["up", "down", "left", "right", "none"],
    },
  },
 };
 export default meta;
 type Story = StoryObj<typeof StaggeredList>;
 const DemoCard = ({ title, index }: { title: string; index: number }) => (
  <div className="rounded-xl bg-neutral-100 p-4 dark:bg-neutral-800">
    <h3 className="mb-1 font-semibold text-neutral-900 dark:text-neutral-100">
      {title}
    </h3>
    <p className="text-sm text-neutral-600 dark:text-neutral-400">
      Card #{index + 1} with staggered animation
    </p>
  </div>
 );
 const items = ["First Item", "Second Item", "Third Item", "Fourth Item"];
 export const Default: Story = {
  args: {
    direction: "up",
    className: "space-y-4",
    children: items.map((item, i) => <DemoCard key={i} title={item} index={i} />),
  },
 };
 export const FadeDown: Story = {
  args: {
    direction: "down",
    className: "space-y-4",
    children: items.map((item, i) => <DemoCard key={i} title={item} index={i} />),
  },
 };
 export const FadeLeft: Story = {
  args: {
    direction: "left",
    className: "flex gap-4",
    children: items.map((item, i) => <DemoCard key={i} title={item} index={i} />),
  },
 };
 export const FadeRight: Story = {
  args: {
    direction: "right",
    className: "flex gap-4",
    children: items.map((item, i) => <DemoCard key={i} title={item} index={i} />),
  },
 };
 export const FastStagger: Story = {
  args: {
    direction: "up",
    staggerDelay: 0.05,
    className: "space-y-4",
    children: items.map((item, i) => <DemoCard key={i} title={item} index={i} />),
  },
 };
 export const SlowStagger: Story = {
  args: {
    direction: "up",
    staggerDelay: 0.3,
    className: "space-y-4",
    children: items.map((item, i) => <DemoCard key={i} title={item} index={i} />),
  },
 };
 export const WithInitialDelay: Story = {
  args: {
    direction: "up",
    initialDelay: 0.5,
    className: "space-y-4",
    children: items.map((item, i) => <DemoCard key={i} title={item} index={i} />),
  },
 };
 export const GridLayout: Story = {
  args: {
    direction: "up",
    staggerDelay: 0.08,
    className: "grid grid-cols-2 gap-4 md:grid-cols-4",
    children: [
      ...items,
      "Fifth Item",
      "Sixth Item",
      "Seventh Item",
      "Eighth Item",
    ].map((item, i) => <DemoCard key={i} title={item} index={i} />),
  },
 };
 export const AgentCardsExample: Story = {
  render: () => {
    const agents = [
      { name: "SEO Optimizer", runs: 1234 },
      { name: "Content Writer", runs: 987 },
      { name: "Data Analyzer", runs: 756 },
      { name: "Code Reviewer", runs: 543 },
    ];
    return (
      <StaggeredList
        direction="up"
        staggerDelay={0.1}
        className="grid grid-cols-2 gap-6 md:grid-cols-4"
      >
        {agents.map((agent, i) => (
          <div
            key={i}
            className="rounded-2xl bg-white p-4 shadow-md dark:bg-neutral-900"
          >
            <div className="mb-3 aspect-video rounded-xl bg-gradient-to-br from-violet-500 to-blue-500" />
            <h3 className="mb-1 font-semibold text-neutral-900 dark:text-neutral-100">
              {agent.name}
            </h3>
            <p className="text-sm text-neutral-500">{agent.runs} runs</p>
          </div>
        ))}
      </StaggeredList>
    );
  },
 };
 export const CreatorCardsExample: Story = {
  render: () => {
    const creators = [
      { name: "Alice", agents: 12 },
      { name: "Bob", agents: 8 },
      { name: "Charlie", agents: 15 },
      { name: "Diana", agents: 6 },
    ];
    const colors = [
      "bg-violet-100 dark:bg-violet-900/30",
      "bg-blue-100 dark:bg-blue-900/30",
      "bg-green-100 dark:bg-green-900/30",
      "bg-orange-100 dark:bg-orange-900/30",
    ];
    return (
      <StaggeredList
        direction="up"
        staggerDelay={0.12}
        className="grid grid-cols-2 gap-6 md:grid-cols-4"
      >
        {creators.map((creator, i) => (
          <div
            key={i}
            className={`rounded-2xl p-5 ${colors[i % colors.length]}`}
          >
            <div className="mb-3 h-12 w-12 rounded-full bg-neutral-300 dark:bg-neutral-700" />
            <h3 className="mb-1 font-semibold text-neutral-900 dark:text-neutral-100">
              {creator.name}
            </h3>
            <p className="text-sm text-neutral-600 dark:text-neutral-400">
              {creator.agents} agents
            </p>
          </div>
        ))}
      </StaggeredList>
    );
  },
 };
--- a/autogpt_platform/frontend/src/components/molecules/StaggeredList/StaggeredList.tsx
+++ b/autogpt_platform/frontend/src/components/molecules/StaggeredList/StaggeredList.tsx
@@ -0,0 +1,130 @@
 "use client";
 import { cn } from "@/lib/utils";
 import { motion, useReducedMotion, type Variants } from "framer-motion";
 import { ReactNode } from "react";
 type StaggerDirection = "up" | "down" | "left" | "right" | "none";
 interface StaggeredListProps {
  /** Array of items to render with staggered animation */
  children: ReactNode[];
  /** Direction items animate from */
  direction?: StaggerDirection;
  /** Distance to travel in pixels */
  distance?: number;
  /** Base duration for each item's animation */
  duration?: number;
  /** Delay between each item's animation start */
  staggerDelay?: number;
  /** Initial delay before first item animates */
  initialDelay?: number;
  /** Whether to trigger animation when element enters viewport */
  viewport?: boolean;
  /** How much of container must be visible to trigger */
  viewportAmount?: number;
  /** Whether animation should only trigger once */
  once?: boolean;
  /** Additional CSS classes for the container */
  className?: string;
  /** Additional CSS classes for each item wrapper */
  itemClassName?: string;
 }
 function getDirectionOffset(
  direction: StaggerDirection,
  distance: number,
 ): { x: number; y: number } {
  switch (direction) {
    case "up":
      return { x: 0, y: distance };
    case "down":
      return { x: 0, y: -distance };
    case "left":
      return { x: distance, y: 0 };
    case "right":
      return { x: -distance, y: 0 };
    case "none":
    default:
      return { x: 0, y: 0 };
  }
 }
 /**
 * Animates a list of children with staggered fade-in effects.
 * Each child appears sequentially with a configurable delay.
 * Respects user's reduced motion preferences.
 */
 export function StaggeredList({
  children,
  direction = "up",
  distance = 20,
  duration = 0.4,
  staggerDelay = 0.1,
  initialDelay = 0,
  viewport = true,
  viewportAmount = 0.1,
  once = true,
  className,
  itemClassName,
 }: StaggeredListProps) {
  const shouldReduceMotion = useReducedMotion();
  const offset = getDirectionOffset(direction, distance);
  // If user prefers reduced motion, render without animation
  if (shouldReduceMotion) {
    return (
      <div className={className}>
        {children.map((child, index) => (
          <div key={index} className={itemClassName}>
            {child}
          </div>
        ))}
      </div>
    );
  }
  const containerVariants: Variants = {
    hidden: {},
    visible: {
      transition: {
        staggerChildren: staggerDelay,
        delayChildren: initialDelay,
      },
    },
  };
  const itemVariants: Variants = {
    hidden: {
      opacity: 0,
      x: offset.x,
      y: offset.y,
    },
    visible: {
      opacity: 1,
      x: 0,
      y: 0,
      transition: {
        duration,
        ease: [0.25, 0.1, 0.25, 1],
      },
    },
  };
  return (
    <motion.div
      className={cn(className)}
      initial="hidden"
      animate={viewport ? undefined : "visible"}
      whileInView={viewport ? "visible" : undefined}
      viewport={viewport ? { once, amount: viewportAmount } : undefined}
      variants={containerVariants}
    >
      {children.map((child, index) => (
        <motion.div key={index} className={itemClassName} variants={itemVariants}>
          {child}
        </motion.div>
      ))}
    </motion.div>
  );
 }
--- a/autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/CredentialField/components/CredentialFieldTitle.tsx
+++ b/autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/CredentialField/components/CredentialFieldTitle.tsx
@@ -35,13 +35,12 @@ export const CredentialFieldTitle = (props: {
    uiOptions,
  );
-  const provider = getCredentialProviderFromSchema(
+  const credentialProvider = toDisplayName(
-    useNodeStore.getState().getHardCodedValues(nodeId),
+    getCredentialProviderFromSchema(
-    schema as BlockIOCredentialsSubSchema,
+      useNodeStore.getState().getHardCodedValues(nodeId),
      schema as BlockIOCredentialsSubSchema,
    ) ?? "",
  );
  const credentialProvider = provider
    ? `${toDisplayName(provider)} credential`
    : "credential";
  const updatedUiSchema = updateUiOption(uiSchema, {
    showHandles: false,
--- a/autogpt_platform/frontend/src/lib/dexie/draft-utils.ts
+++ b/autogpt_platform/frontend/src/lib/dexie/draft-utils.ts
@@ -5,7 +5,7 @@ import isEqual from "lodash/isEqual";
 export function cleanNode(node: CustomNode) {
  return {
    id: node.id,
-    // Note: position is intentionally excluded to prevent draft saves when dragging nodes
+    position: node.position,
    data: {
      hardcodedValues: node.data.hardcodedValues,
      title: node.data.title,
--- a/docs/CLAUDE.md
+++ b/docs/CLAUDE.md
@@ -1,44 +0,0 @@
 # Documentation Guidelines
 ## Block Documentation Manual Sections
 When updating manual sections (`<!-- MANUAL: ... -->`) in block documentation files (e.g., `docs/integrations/basic.md`), follow these formats:
 ### How It Works Section
 Provide a technical explanation of how the block functions:
 - Describe the processing logic in 1-2 paragraphs
 - Mention any validation, error handling, or edge cases
 - Use code examples with backticks when helpful (e.g., `[[1, 2], [3, 4]]` becomes `[1, 2, 3, 4]`)
 Example:
 ```markdown
 <!-- MANUAL: how_it_works -->
 The block iterates through each list in the input and extends a result list with all elements from each one. It processes lists in order, so `[[1, 2], [3, 4]]` becomes `[1, 2, 3, 4]`.
 The block includes validation to ensure each item is actually a list. If a non-list value is encountered, the block outputs an error message instead of proceeding.
 <!-- END MANUAL -->
 ```
 ### Use Case Section
 Provide 3 practical use cases in this format:
 - **Bold Heading**: Short one-sentence description
 Example:
 ```markdown
 <!-- MANUAL: use_case -->
 **Paginated API Merging**: Combine results from multiple API pages into a single list for batch processing or display.
 **Parallel Task Aggregation**: Merge outputs from parallel workflow branches that each produce a list of results.
 **Multi-Source Data Collection**: Combine data collected from different sources (like multiple RSS feeds or API endpoints) into one unified list.
 <!-- END MANUAL -->
 ```
 ### Style Guidelines
 - Keep descriptions concise and action-oriented
 - Focus on practical, real-world scenarios
 - Use consistent terminology with other blocks
 - Avoid overly technical jargon unless necessary
--- a/docs/integrations/README.md
+++ b/docs/integrations/README.md
@@ -31,7 +31,6 @@ Below is a comprehensive list of all available blocks, categorized by their prim
 | [Agent Time Input](basic.md#agent-time-input) | Block for time input |
 | [Agent Toggle Input](basic.md#agent-toggle-input) | Block for boolean toggle input |
 | [Block Installation](basic.md#block-installation) | Given a code string, this block allows the verification and installation of a block code into the system |
 | [Concatenate Lists](basic.md#concatenate-lists) | Concatenates multiple lists into a single list |
 | [Dictionary Is Empty](basic.md#dictionary-is-empty) | Checks if a dictionary is empty |
 | [File Store](basic.md#file-store) | Stores the input file in the temporary directory |
 | [Find In Dictionary](basic.md#find-in-dictionary) | A block that looks up a value in a dictionary, list, or object by key or index and returns the corresponding value |
--- a/docs/integrations/basic.md
+++ b/docs/integrations/basic.md
@@ -634,42 +634,6 @@ This enables extensibility by allowing custom blocks to be added without modifyi
 ---
 ## Concatenate Lists
 ### What it is
 Concatenates multiple lists into a single list. All elements from all input lists are combined in order.
 ### How it works
 <!-- MANUAL: how_it_works -->
 The block iterates through each list in the input and extends a result list with all elements from each one. It processes lists in order, so `[[1, 2], [3, 4]]` becomes `[1, 2, 3, 4]`.
 The block includes validation to ensure each item is actually a list. If a non-list value (like a string or number) is encountered, the block outputs an error message instead of proceeding. None values are skipped automatically.
 <!-- END MANUAL -->
 ### Inputs
 | Input | Description | Type | Required |
 |-------|-------------|------|----------|
 | lists | A list of lists to concatenate together. All lists will be combined in order into a single list. | List[List[Any]] | Yes |
 ### Outputs
 | Output | Description | Type |
 |--------|-------------|------|
 | error | Error message if concatenation failed due to invalid input types. | str |
 | concatenated_list | The concatenated list containing all elements from all input lists in order. | List[Any] |
 ### Possible use case
 <!-- MANUAL: use_case -->
 **Paginated API Merging**: Combine results from multiple API pages into a single list for batch processing or display.
 **Parallel Task Aggregation**: Merge outputs from parallel workflow branches that each produce a list of results.
 **Multi-Source Data Collection**: Combine data collected from different sources (like multiple RSS feeds or API endpoints) into one unified list.
 <!-- END MANUAL -->
 ---
 ## Dictionary Is Empty
 ### What it is