Merge branch 'dev' into ntindle/waitlist

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

autogpt_platform/backend/backend/api/features/admin/waitlist_admin_routes.py

@@ -0,0 +1,251 @@
+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"},
+        )

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/core.py

@@ -218,7 +218,6 @@ async def save_agent_to_library(
     library_agents = await library_db.create_library_agent(
         graph=created_graph,
         user_id=user_id,
-        sensitive_action_safe_mode=True,
         create_library_agents_for_sub_graphs=False,
     )
 

autogpt_platform/backend/backend/api/features/executions/review/model.py

@@ -179,14 +179,6 @@ class ReviewRequest(BaseModel):
     reviews: List[ReviewItem] = Field(
         description="All reviews with their approval status, data, and messages"
     )
-    auto_approve_future_actions: bool = Field(
-        default=False,
-        description=(
-            "If true, future reviews from the same blocks (nodes) being approved "
-            "will be automatically approved for the remainder of this execution. "
-            "This only affects the current execution run."
-        ),
-    )
 
     @model_validator(mode="after")
     def validate_review_completeness(self):

autogpt_platform/backend/backend/api/features/executions/review/routes.py

@@ -4,9 +4,8 @@ from typing import List
 import autogpt_libs.auth as autogpt_auth_lib
 from fastapi import APIRouter, HTTPException, Query, Security, status
 from prisma.enums import ReviewStatus
-from prisma.models import AgentNodeExecution
 
-from backend.data.execution import ExecutionContext, get_graph_execution_meta
+from backend.data.execution import get_graph_execution_meta
 from backend.data.human_review import (
     get_pending_reviews_for_execution,
     get_pending_reviews_for_user,
@@ -129,20 +128,14 @@ async def process_review_action(
         )
 
     # Build review decisions map
-    # When auto_approve_future_actions is true, ignore any edited data
-    # (auto-approved reviews should use original data for consistency)
     review_decisions = {}
     for review in request.reviews:
         review_status = (
             ReviewStatus.APPROVED if review.approved else ReviewStatus.REJECTED
         )
-        # If auto-approving future actions, don't allow data modifications
-        reviewed_data = (
-            None if request.auto_approve_future_actions else review.reviewed_data
-        )
         review_decisions[review.node_exec_id] = (
             review_status,
-            reviewed_data,
+            review.reviewed_data,
             review.message,
         )
 
@@ -176,38 +169,10 @@ async def process_review_action(
         if not still_has_pending:
             # Resume execution
             try:
-                # If auto_approve_future_actions is set, create a context that will
-                # automatically approve future reviews from the approved nodes
-                execution_context = None
-                if request.auto_approve_future_actions:
-                    # Get node_ids for the approved node_exec_ids
-                    approved_node_exec_ids = [
-                        review.node_exec_id
-                        for review in request.reviews
-                        if review.approved
-                    ]
-                    if approved_node_exec_ids:
-                        # Look up the node_ids from the node executions
-                        node_executions = await AgentNodeExecution.prisma().find_many(
-                            where={"id": {"in": approved_node_exec_ids}},
-                        )
-                        auto_approved_node_ids = {
-                            ne.agentNodeId for ne in node_executions
-                        }
-                        if auto_approved_node_ids:
-                            execution_context = ExecutionContext(
-                                auto_approved_node_ids=auto_approved_node_ids,
-                            )
-                            logger.info(
-                                f"Auto-approving future reviews for nodes "
-                                f"{auto_approved_node_ids} in execution {graph_exec_id}"
-                            )
-
                 await add_graph_execution(
                     graph_id=first_review.graph_id,
                     user_id=user_id,
                     graph_exec_id=graph_exec_id,
-                    execution_context=execution_context,
                 )
                 logger.info(f"Resumed execution {graph_exec_id}")
             except Exception as e:

autogpt_platform/backend/backend/api/features/library/db.py

@@ -401,11 +401,27 @@ async def add_generated_agent_image(
     )
 
 
+def _initialize_graph_settings(graph: graph_db.GraphModel) -> GraphSettings:
+    """
+    Initialize GraphSettings based on graph content.
+
+    Args:
+        graph: The graph to analyze
+
+    Returns:
+        GraphSettings with appropriate human_in_the_loop_safe_mode value
+    """
+    if graph.has_human_in_the_loop:
+        # Graph has HITL blocks - set safe mode to True by default
+        return GraphSettings(human_in_the_loop_safe_mode=True)
+    else:
+        # Graph has no HITL blocks - keep None
+        return GraphSettings(human_in_the_loop_safe_mode=None)
+
+
 async def create_library_agent(
     graph: graph_db.GraphModel,
     user_id: str,
-    hitl_safe_mode: bool = True,
-    sensitive_action_safe_mode: bool = False,
     create_library_agents_for_sub_graphs: bool = True,
 ) -> list[library_model.LibraryAgent]:
     """
@@ -414,8 +430,6 @@ async def create_library_agent(
     Args:
         agent: The agent/Graph to add to the library.
         user_id: The user to whom the agent will be added.
-        hitl_safe_mode: Whether HITL blocks require manual review (default True).
-        sensitive_action_safe_mode: Whether sensitive action blocks require review.
         create_library_agents_for_sub_graphs: If True, creates LibraryAgent records for sub-graphs as well.
 
     Returns:
@@ -451,11 +465,7 @@ async def create_library_agent(
                             }
                         },
                         settings=SafeJson(
-                            GraphSettings.from_graph(
-                                graph_entry,
-                                hitl_safe_mode=hitl_safe_mode,
-                                sensitive_action_safe_mode=sensitive_action_safe_mode,
-                            ).model_dump()
+                            _initialize_graph_settings(graph_entry).model_dump()
                         ),
                     ),
                     include=library_agent_include(
@@ -617,6 +627,33 @@ async def update_library_agent(
         raise DatabaseError("Failed to update library agent") from e
 
 
+async def update_library_agent_settings(
+    user_id: str,
+    agent_id: str,
+    settings: GraphSettings,
+) -> library_model.LibraryAgent:
+    """
+    Updates the settings for a specific LibraryAgent.
+
+    Args:
+        user_id: The owner of the LibraryAgent.
+        agent_id: The ID of the LibraryAgent to update.
+        settings: New GraphSettings to apply.
+
+    Returns:
+        The updated LibraryAgent.
+
+    Raises:
+        NotFoundError: If the specified LibraryAgent does not exist.
+        DatabaseError: If there's an error in the update operation.
+    """
+    return await update_library_agent(
+        library_agent_id=agent_id,
+        user_id=user_id,
+        settings=settings,
+    )
+
+
 async def delete_library_agent(
     library_agent_id: str, user_id: str, soft_delete: bool = True
 ) -> None:
@@ -801,7 +838,7 @@ async def add_store_agent_to_library(
                 "isCreatedByUser": False,
                 "useGraphIsActiveVersion": False,
                 "settings": SafeJson(
-                    GraphSettings.from_graph(graph_model).model_dump()
+                    _initialize_graph_settings(graph_model).model_dump()
                 ),
             },
             include=library_agent_include(
@@ -1191,15 +1228,8 @@ async def fork_library_agent(
         )
         new_graph = await on_graph_activate(new_graph, user_id=user_id)
 
-        # Create a library agent for the new graph, preserving safe mode settings
-        return (
-            await create_library_agent(
-                new_graph,
-                user_id,
-                hitl_safe_mode=original_agent.settings.human_in_the_loop_safe_mode,
-                sensitive_action_safe_mode=original_agent.settings.sensitive_action_safe_mode,
-            )
-        )[0]
+        # Create a library agent for the new graph
+        return (await create_library_agent(new_graph, user_id))[0]
     except prisma.errors.PrismaError as e:
         logger.error(f"Database error cloning library agent: {e}")
         raise DatabaseError("Failed to fork library agent") from e

autogpt_platform/backend/backend/api/features/library/model.py

@@ -73,12 +73,6 @@ class LibraryAgent(pydantic.BaseModel):
     has_external_trigger: bool = pydantic.Field(
         description="Whether the agent has an external trigger (e.g. webhook) node"
     )
-    has_human_in_the_loop: bool = pydantic.Field(
-        description="Whether the agent has human-in-the-loop blocks"
-    )
-    has_sensitive_action: bool = pydantic.Field(
-        description="Whether the agent has sensitive action blocks"
-    )
     trigger_setup_info: Optional[GraphTriggerInfo] = None
 
     # Indicates whether there's a new output (based on recent runs)
@@ -186,8 +180,6 @@ class LibraryAgent(pydantic.BaseModel):
                 graph.credentials_input_schema if sub_graphs is not None else None
             ),
             has_external_trigger=graph.has_external_trigger,
-            has_human_in_the_loop=graph.has_human_in_the_loop,
-            has_sensitive_action=graph.has_sensitive_action,
             trigger_setup_info=graph.trigger_setup_info,
             new_output=new_output,
             can_access_graph=can_access_graph,

autogpt_platform/backend/backend/api/features/library/routes_test.py

@@ -52,8 +52,6 @@ async def test_get_library_agents_success(
                 output_schema={"type": "object", "properties": {}},
                 credentials_input_schema={"type": "object", "properties": {}},
                 has_external_trigger=False,
-                has_human_in_the_loop=False,
-                has_sensitive_action=False,
                 status=library_model.LibraryAgentStatus.COMPLETED,
                 recommended_schedule_cron=None,
                 new_output=False,
@@ -77,8 +75,6 @@ async def test_get_library_agents_success(
                 output_schema={"type": "object", "properties": {}},
                 credentials_input_schema={"type": "object", "properties": {}},
                 has_external_trigger=False,
-                has_human_in_the_loop=False,
-                has_sensitive_action=False,
                 status=library_model.LibraryAgentStatus.COMPLETED,
                 recommended_schedule_cron=None,
                 new_output=False,
@@ -154,8 +150,6 @@ async def test_get_favorite_library_agents_success(
                 output_schema={"type": "object", "properties": {}},
                 credentials_input_schema={"type": "object", "properties": {}},
                 has_external_trigger=False,
-                has_human_in_the_loop=False,
-                has_sensitive_action=False,
                 status=library_model.LibraryAgentStatus.COMPLETED,
                 recommended_schedule_cron=None,
                 new_output=False,
@@ -224,8 +218,6 @@ def test_add_agent_to_library_success(
         output_schema={"type": "object", "properties": {}},
         credentials_input_schema={"type": "object", "properties": {}},
         has_external_trigger=False,
-        has_human_in_the_loop=False,
-        has_sensitive_action=False,
         status=library_model.LibraryAgentStatus.COMPLETED,
         new_output=False,
         can_access_graph=True,

autogpt_platform/backend/backend/api/features/store/db.py

@@ -22,6 +22,7 @@ from backend.data.notifications import (
     AgentApprovalData,
     AgentRejectionData,
     NotificationEventModel,
+    WaitlistLaunchData,
 )
 from backend.notifications.notifications import queue_notification_async
 from backend.util.exceptions import DatabaseError
@@ -1717,6 +1718,29 @@ 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 ""),
@@ -1964,3 +1988,552 @@ 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

autogpt_platform/backend/backend/api/features/store/embeddings.py

@@ -154,16 +154,16 @@ async def store_content_embedding(
 
         # Upsert the embedding
         # WHERE clause in DO UPDATE prevents PostgreSQL 15 bug with NULLS NOT DISTINCT
-        # Use unqualified ::vector - pgvector is in search_path on all environments
+        # 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::vector, $5, $6::jsonb, NOW(), NOW())
+            VALUES (gen_random_uuid()::text, $1::{schema_prefix}"ContentType", $2, $3, $4::{pgvector_schema}.vector, $5, $6::jsonb, NOW(), NOW())
             ON CONFLICT ("contentType", "contentId", "userId")
             DO UPDATE SET
-                "embedding" = $4::vector,
+                "embedding" = $4::{pgvector_schema}.vector,
                 "searchableText" = $5,
                 "metadata" = $6::jsonb,
                 "updatedAt" = NOW()
@@ -879,7 +879,8 @@ async def semantic_search(
         min_similarity_idx = len(params) + 1
         params.append(min_similarity)
 
-        # Use unqualified ::vector and <=> operator - pgvector is in search_path on all environments
+        # 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
@@ -887,9 +888,9 @@ async def semantic_search(
                 "contentType" as content_type,
                 "searchableText" as searchable_text,
                 metadata,
-                1 - (embedding <=> '"""
+                1 - (embedding OPERATOR({pgvector_schema}.<=>) '"""
             + embedding_str
-            + """'::vector) as similarity
+            + """'::{pgvector_schema}.vector) as similarity
             FROM {schema_prefix}"UnifiedContentEmbedding"
             WHERE "contentType" IN ("""
             + content_type_placeholders
@@ -897,9 +898,9 @@ async def semantic_search(
             """
             + user_filter
             + """
-            AND 1 - (embedding <=> '"""
+            AND 1 - (embedding OPERATOR({pgvector_schema}.<=>) '"""
             + embedding_str
-            + """'::vector) >= $"""
+            + """'::{pgvector_schema}.vector) >= $"""
             + str(min_similarity_idx)
             + """
             ORDER BY similarity DESC

autogpt_platform/backend/backend/api/features/store/hybrid_search.py

@@ -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 <=> {embedding_param}::vector
+                ORDER BY uce.embedding OPERATOR({{pgvector_schema}}.<=>)  {embedding_param}::{{pgvector_schema}}.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 <=> {embedding_param}::vector), 0) as semantic_score,
+                COALESCE(1 - (uce.embedding OPERATOR({{pgvector_schema}}.<=>)  {embedding_param}::{{pgvector_schema}}.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
@@ -583,7 +583,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 <=> {embedding_param}::vector
+                ORDER BY uce.embedding OPERATOR({{pgvector_schema}}.<=>)  {embedding_param}::{{pgvector_schema}}.vector
                 LIMIT 200
             ) uce
         ),
@@ -605,7 +605,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 <=> {embedding_param}::vector), 0) as semantic_score,
+                COALESCE(1 - (uce.embedding OPERATOR({{pgvector_schema}}.<=>)  {embedding_param}::{{pgvector_schema}}.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

autogpt_platform/backend/backend/api/features/store/model.py

@@ -223,6 +223,102 @@ 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."""
 

autogpt_platform/backend/backend/api/features/store/routes.py

@@ -8,6 +8,7 @@ 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
@@ -81,6 +82,74 @@ 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 ##############
 ##############################################

autogpt_platform/backend/backend/api/features/v1.py

@@ -761,8 +761,10 @@ async def create_new_graph(
     graph.reassign_ids(user_id=user_id, reassign_graph_id=True)
     graph.validate_graph(for_run=False)
 
+    # The return value of the create graph & library function is intentionally not used here,
+    # as the graph already valid and no sub-graphs are returned back.
     await graph_db.create_graph(graph, user_id=user_id)
-    await library_db.create_library_agent(graph, user_id)
+    await library_db.create_library_agent(graph, user_id=user_id)
     activated_graph = await on_graph_activate(graph, user_id=user_id)
 
     if create_graph.source == "builder":
@@ -886,19 +888,21 @@ async def set_graph_active_version(
 async def _update_library_agent_version_and_settings(
     user_id: str, agent_graph: graph_db.GraphModel
 ) -> library_model.LibraryAgent:
+    # Keep the library agent up to date with the new active version
     library = await library_db.update_agent_version_in_library(
         user_id, agent_graph.id, agent_graph.version
     )
-    updated_settings = GraphSettings.from_graph(
-        graph=agent_graph,
-        hitl_safe_mode=library.settings.human_in_the_loop_safe_mode,
-        sensitive_action_safe_mode=library.settings.sensitive_action_safe_mode,
-    )
-    if updated_settings != library.settings:
-        library = await library_db.update_library_agent(
-            library_agent_id=library.id,
+    # If the graph has HITL node, initialize the setting if it's not already set.
+    if (
+        agent_graph.has_human_in_the_loop
+        and library.settings.human_in_the_loop_safe_mode is None
+    ):
+        await library_db.update_library_agent_settings(
             user_id=user_id,
-            settings=updated_settings,
+            agent_id=library.id,
+            settings=library.settings.model_copy(
+                update={"human_in_the_loop_safe_mode": True}
+            ),
         )
     return library
 
@@ -915,18 +919,21 @@ async def update_graph_settings(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> GraphSettings:
     """Update graph settings for the user's library agent."""
+    # Get the library agent for this graph
     library_agent = await library_db.get_library_agent_by_graph_id(
         graph_id=graph_id, user_id=user_id
     )
     if not library_agent:
         raise HTTPException(404, f"Graph #{graph_id} not found in user's library")
 
-    updated_agent = await library_db.update_library_agent(
-        library_agent_id=library_agent.id,
+    # Update the library agent settings
+    updated_agent = await library_db.update_library_agent_settings(
         user_id=user_id,
+        agent_id=library_agent.id,
         settings=settings,
     )
 
+    # Return the updated settings
     return GraphSettings.model_validate(updated_agent.settings)
 
 

autogpt_platform/backend/backend/api/rest_api.py

@@ -19,6 +19,7 @@ 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
@@ -283,6 +284,11 @@ 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"],

autogpt_platform/backend/backend/blocks/helpers/review.py

@@ -55,7 +55,6 @@ class HITLReviewHelper:
     async def _handle_review_request(
         input_data: Any,
         user_id: str,
-        node_id: str,
         node_exec_id: str,
         graph_exec_id: str,
         graph_id: str,
@@ -70,7 +69,6 @@ class HITLReviewHelper:
         Args:
             input_data: The input data to be reviewed
             user_id: ID of the user requesting the review
-            node_id: ID of the node in the graph definition
             node_exec_id: ID of the node execution
             graph_exec_id: ID of the graph execution
             graph_id: ID of the graph
@@ -86,7 +84,7 @@ class HITLReviewHelper:
             Exception: If review creation or status update fails
         """
         # Skip review if safe mode is disabled - return auto-approved result
-        if not execution_context.human_in_the_loop_safe_mode:
+        if not execution_context.safe_mode:
             logger.info(
                 f"Block {block_name} skipping review for node {node_exec_id} - safe mode disabled"
             )
@@ -98,20 +96,6 @@ class HITLReviewHelper:
                 node_exec_id=node_exec_id,
             )
 
-        # Skip review if this specific node has been auto-approved by the user
-        if node_id in execution_context.auto_approved_node_ids:
-            logger.info(
-                f"Block {block_name} skipping review for node {node_exec_id} - "
-                f"node {node_id} is auto-approved"
-            )
-            return ReviewResult(
-                data=input_data,
-                status=ReviewStatus.APPROVED,
-                message="Auto-approved (user approved all future actions for this block)",
-                processed=True,
-                node_exec_id=node_exec_id,
-            )
-
         result = await HITLReviewHelper.get_or_create_human_review(
             user_id=user_id,
             node_exec_id=node_exec_id,
@@ -145,7 +129,6 @@ class HITLReviewHelper:
     async def handle_review_decision(
         input_data: Any,
         user_id: str,
-        node_id: str,
         node_exec_id: str,
         graph_exec_id: str,
         graph_id: str,
@@ -160,7 +143,6 @@ class HITLReviewHelper:
         Args:
             input_data: The input data to be reviewed
             user_id: ID of the user requesting the review
-            node_id: ID of the node in the graph definition
             node_exec_id: ID of the node execution
             graph_exec_id: ID of the graph execution
             graph_id: ID of the graph
@@ -176,7 +158,6 @@ class HITLReviewHelper:
         review_result = await HITLReviewHelper._handle_review_request(
             input_data=input_data,
             user_id=user_id,
-            node_id=node_id,
             node_exec_id=node_exec_id,
             graph_exec_id=graph_exec_id,
             graph_id=graph_id,

autogpt_platform/backend/backend/blocks/human_in_the_loop.py

@@ -97,7 +97,6 @@ class HumanInTheLoopBlock(Block):
         input_data: Input,
         *,
         user_id: str,
-        node_id: str,
         node_exec_id: str,
         graph_exec_id: str,
         graph_id: str,
@@ -105,7 +104,7 @@ class HumanInTheLoopBlock(Block):
         execution_context: ExecutionContext,
         **_kwargs,
     ) -> BlockOutput:
-        if not execution_context.human_in_the_loop_safe_mode:
+        if not execution_context.safe_mode:
             logger.info(
                 f"HITL block skipping review for node {node_exec_id} - safe mode disabled"
             )
@@ -116,7 +115,6 @@ class HumanInTheLoopBlock(Block):
         decision = await self.handle_review_decision(
             input_data=input_data.data,
             user_id=user_id,
-            node_id=node_id,
             node_exec_id=node_exec_id,
             graph_exec_id=graph_exec_id,
             graph_id=graph_id,

autogpt_platform/backend/backend/blocks/llm.py

@@ -79,10 +79,6 @@ class ModelMetadata(NamedTuple):
     provider: str
     context_window: int
     max_output_tokens: int | None
-    display_name: str
-    provider_name: str
-    creator_name: str
-    price_tier: Literal[1, 2, 3]
 
 
 class LlmModelMeta(EnumMeta):
@@ -175,26 +171,6 @@ class LlmModel(str, Enum, metaclass=LlmModelMeta):
     V0_1_5_LG = "v0-1.5-lg"
     V0_1_0_MD = "v0-1.0-md"
 
-    @classmethod
-    def __get_pydantic_json_schema__(cls, schema, handler):
-        json_schema = handler(schema)
-        llm_model_metadata = {}
-        for model in cls:
-            model_name = model.value
-            metadata = model.metadata
-            llm_model_metadata[model_name] = {
-                "creator": metadata.creator_name,
-                "creator_name": metadata.creator_name,
-                "title": metadata.display_name,
-                "provider": metadata.provider,
-                "provider_name": metadata.provider_name,
-                "name": model_name,
-                "price_tier": metadata.price_tier,
-            }
-        json_schema["llm_model"] = True
-        json_schema["llm_model_metadata"] = llm_model_metadata
-        return json_schema
-
     @property
     def metadata(self) -> ModelMetadata:
         return MODEL_METADATA[self]
@@ -214,291 +190,119 @@ class LlmModel(str, Enum, metaclass=LlmModelMeta):
 
 MODEL_METADATA = {
     # https://platform.openai.com/docs/models
-    LlmModel.O3: ModelMetadata("openai", 200000, 100000, "O3", "OpenAI", "OpenAI", 2),
-    LlmModel.O3_MINI: ModelMetadata(
-        "openai", 200000, 100000, "O3 Mini", "OpenAI", "OpenAI", 1
-    ),  # o3-mini-2025-01-31
-    LlmModel.O1: ModelMetadata(
-        "openai", 200000, 100000, "O1", "OpenAI", "OpenAI", 3
-    ),  # o1-2024-12-17
-    LlmModel.O1_MINI: ModelMetadata(
-        "openai", 128000, 65536, "O1 Mini", "OpenAI", "OpenAI", 2
-    ),  # o1-mini-2024-09-12
+    LlmModel.O3: ModelMetadata("openai", 200000, 100000),
+    LlmModel.O3_MINI: ModelMetadata("openai", 200000, 100000),  # o3-mini-2025-01-31
+    LlmModel.O1: ModelMetadata("openai", 200000, 100000),  # o1-2024-12-17
+    LlmModel.O1_MINI: ModelMetadata("openai", 128000, 65536),  # o1-mini-2024-09-12
     # GPT-5 models
-    LlmModel.GPT5_2: ModelMetadata(
-        "openai", 400000, 128000, "GPT-5.2", "OpenAI", "OpenAI", 3
-    ),
-    LlmModel.GPT5_1: ModelMetadata(
-        "openai", 400000, 128000, "GPT-5.1", "OpenAI", "OpenAI", 2
-    ),
-    LlmModel.GPT5: ModelMetadata(
-        "openai", 400000, 128000, "GPT-5", "OpenAI", "OpenAI", 1
-    ),
-    LlmModel.GPT5_MINI: ModelMetadata(
-        "openai", 400000, 128000, "GPT-5 Mini", "OpenAI", "OpenAI", 1
-    ),
-    LlmModel.GPT5_NANO: ModelMetadata(
-        "openai", 400000, 128000, "GPT-5 Nano", "OpenAI", "OpenAI", 1
-    ),
-    LlmModel.GPT5_CHAT: ModelMetadata(
-        "openai", 400000, 16384, "GPT-5 Chat Latest", "OpenAI", "OpenAI", 2
-    ),
-    LlmModel.GPT41: ModelMetadata(
-        "openai", 1047576, 32768, "GPT-4.1", "OpenAI", "OpenAI", 1
-    ),
-    LlmModel.GPT41_MINI: ModelMetadata(
-        "openai", 1047576, 32768, "GPT-4.1 Mini", "OpenAI", "OpenAI", 1
-    ),
+    LlmModel.GPT5_2: ModelMetadata("openai", 400000, 128000),
+    LlmModel.GPT5_1: ModelMetadata("openai", 400000, 128000),
+    LlmModel.GPT5: ModelMetadata("openai", 400000, 128000),
+    LlmModel.GPT5_MINI: ModelMetadata("openai", 400000, 128000),
+    LlmModel.GPT5_NANO: ModelMetadata("openai", 400000, 128000),
+    LlmModel.GPT5_CHAT: ModelMetadata("openai", 400000, 16384),
+    LlmModel.GPT41: ModelMetadata("openai", 1047576, 32768),
+    LlmModel.GPT41_MINI: ModelMetadata("openai", 1047576, 32768),
     LlmModel.GPT4O_MINI: ModelMetadata(
-        "openai", 128000, 16384, "GPT-4o Mini", "OpenAI", "OpenAI", 1
+        "openai", 128000, 16384
     ),  # gpt-4o-mini-2024-07-18
-    LlmModel.GPT4O: ModelMetadata(
-        "openai", 128000, 16384, "GPT-4o", "OpenAI", "OpenAI", 2
-    ),  # gpt-4o-2024-08-06
+    LlmModel.GPT4O: ModelMetadata("openai", 128000, 16384),  # gpt-4o-2024-08-06
     LlmModel.GPT4_TURBO: ModelMetadata(
-        "openai", 128000, 4096, "GPT-4 Turbo", "OpenAI", "OpenAI", 3
+        "openai", 128000, 4096
     ),  # gpt-4-turbo-2024-04-09
-    LlmModel.GPT3_5_TURBO: ModelMetadata(
-        "openai", 16385, 4096, "GPT-3.5 Turbo", "OpenAI", "OpenAI", 1
-    ),  # gpt-3.5-turbo-0125
+    LlmModel.GPT3_5_TURBO: ModelMetadata("openai", 16385, 4096),  # gpt-3.5-turbo-0125
     # https://docs.anthropic.com/en/docs/about-claude/models
     LlmModel.CLAUDE_4_1_OPUS: ModelMetadata(
-        "anthropic", 200000, 32000, "Claude Opus 4.1", "Anthropic", "Anthropic", 3
+        "anthropic", 200000, 32000
     ),  # claude-opus-4-1-20250805
     LlmModel.CLAUDE_4_OPUS: ModelMetadata(
-        "anthropic", 200000, 32000, "Claude Opus 4", "Anthropic", "Anthropic", 3
+        "anthropic", 200000, 32000
     ),  # claude-4-opus-20250514
     LlmModel.CLAUDE_4_SONNET: ModelMetadata(
-        "anthropic", 200000, 64000, "Claude Sonnet 4", "Anthropic", "Anthropic", 2
+        "anthropic", 200000, 64000
     ),  # claude-4-sonnet-20250514
     LlmModel.CLAUDE_4_5_OPUS: ModelMetadata(
-        "anthropic", 200000, 64000, "Claude Opus 4.5", "Anthropic", "Anthropic", 3
+        "anthropic", 200000, 64000
     ),  # claude-opus-4-5-20251101
     LlmModel.CLAUDE_4_5_SONNET: ModelMetadata(
-        "anthropic", 200000, 64000, "Claude Sonnet 4.5", "Anthropic", "Anthropic", 3
+        "anthropic", 200000, 64000
     ),  # claude-sonnet-4-5-20250929
     LlmModel.CLAUDE_4_5_HAIKU: ModelMetadata(
-        "anthropic", 200000, 64000, "Claude Haiku 4.5", "Anthropic", "Anthropic", 2
+        "anthropic", 200000, 64000
     ),  # claude-haiku-4-5-20251001
     LlmModel.CLAUDE_3_7_SONNET: ModelMetadata(
-        "anthropic", 200000, 64000, "Claude 3.7 Sonnet", "Anthropic", "Anthropic", 2
+        "anthropic", 200000, 64000
     ),  # claude-3-7-sonnet-20250219
     LlmModel.CLAUDE_3_HAIKU: ModelMetadata(
-        "anthropic", 200000, 4096, "Claude 3 Haiku", "Anthropic", "Anthropic", 1
+        "anthropic", 200000, 4096
     ),  # claude-3-haiku-20240307
     # https://docs.aimlapi.com/api-overview/model-database/text-models
-    LlmModel.AIML_API_QWEN2_5_72B: ModelMetadata(
-        "aiml_api", 32000, 8000, "Qwen 2.5 72B Instruct Turbo", "AI/ML", "Qwen", 1
-    ),
-    LlmModel.AIML_API_LLAMA3_1_70B: ModelMetadata(
-        "aiml_api",
-        128000,
-        40000,
-        "Llama 3.1 Nemotron 70B Instruct",
-        "AI/ML",
-        "Nvidia",
-        1,
-    ),
-    LlmModel.AIML_API_LLAMA3_3_70B: ModelMetadata(
-        "aiml_api", 128000, None, "Llama 3.3 70B Instruct Turbo", "AI/ML", "Meta", 1
-    ),
-    LlmModel.AIML_API_META_LLAMA_3_1_70B: ModelMetadata(
-        "aiml_api", 131000, 2000, "Llama 3.1 70B Instruct Turbo", "AI/ML", "Meta", 1
-    ),
-    LlmModel.AIML_API_LLAMA_3_2_3B: ModelMetadata(
-        "aiml_api", 128000, None, "Llama 3.2 3B Instruct Turbo", "AI/ML", "Meta", 1
-    ),
+    LlmModel.AIML_API_QWEN2_5_72B: ModelMetadata("aiml_api", 32000, 8000),
+    LlmModel.AIML_API_LLAMA3_1_70B: ModelMetadata("aiml_api", 128000, 40000),
+    LlmModel.AIML_API_LLAMA3_3_70B: ModelMetadata("aiml_api", 128000, None),
+    LlmModel.AIML_API_META_LLAMA_3_1_70B: ModelMetadata("aiml_api", 131000, 2000),
+    LlmModel.AIML_API_LLAMA_3_2_3B: ModelMetadata("aiml_api", 128000, None),
     # https://console.groq.com/docs/models
-    LlmModel.LLAMA3_3_70B: ModelMetadata(
-        "groq", 128000, 32768, "Llama 3.3 70B Versatile", "Groq", "Meta", 1
-    ),
-    LlmModel.LLAMA3_1_8B: ModelMetadata(
-        "groq", 128000, 8192, "Llama 3.1 8B Instant", "Groq", "Meta", 1
-    ),
+    LlmModel.LLAMA3_3_70B: ModelMetadata("groq", 128000, 32768),
+    LlmModel.LLAMA3_1_8B: ModelMetadata("groq", 128000, 8192),
     # https://ollama.com/library
-    LlmModel.OLLAMA_LLAMA3_3: ModelMetadata(
-        "ollama", 8192, None, "Llama 3.3", "Ollama", "Meta", 1
-    ),
-    LlmModel.OLLAMA_LLAMA3_2: ModelMetadata(
-        "ollama", 8192, None, "Llama 3.2", "Ollama", "Meta", 1
-    ),
-    LlmModel.OLLAMA_LLAMA3_8B: ModelMetadata(
-        "ollama", 8192, None, "Llama 3", "Ollama", "Meta", 1
-    ),
-    LlmModel.OLLAMA_LLAMA3_405B: ModelMetadata(
-        "ollama", 8192, None, "Llama 3.1 405B", "Ollama", "Meta", 1
-    ),
-    LlmModel.OLLAMA_DOLPHIN: ModelMetadata(
-        "ollama", 32768, None, "Dolphin Mistral Latest", "Ollama", "Mistral AI", 1
-    ),
+    LlmModel.OLLAMA_LLAMA3_3: ModelMetadata("ollama", 8192, None),
+    LlmModel.OLLAMA_LLAMA3_2: ModelMetadata("ollama", 8192, None),
+    LlmModel.OLLAMA_LLAMA3_8B: ModelMetadata("ollama", 8192, None),
+    LlmModel.OLLAMA_LLAMA3_405B: ModelMetadata("ollama", 8192, None),
+    LlmModel.OLLAMA_DOLPHIN: ModelMetadata("ollama", 32768, None),
     # https://openrouter.ai/models
-    LlmModel.GEMINI_2_5_PRO: ModelMetadata(
-        "open_router",
-        1050000,
-        8192,
-        "Gemini 2.5 Pro Preview 03.25",
-        "OpenRouter",
-        "Google",
-        2,
-    ),
-    LlmModel.GEMINI_3_PRO_PREVIEW: ModelMetadata(
-        "open_router", 1048576, 65535, "Gemini 3 Pro Preview", "OpenRouter", "Google", 2
-    ),
-    LlmModel.GEMINI_2_5_FLASH: ModelMetadata(
-        "open_router", 1048576, 65535, "Gemini 2.5 Flash", "OpenRouter", "Google", 1
-    ),
-    LlmModel.GEMINI_2_0_FLASH: ModelMetadata(
-        "open_router", 1048576, 8192, "Gemini 2.0 Flash 001", "OpenRouter", "Google", 1
-    ),
+    LlmModel.GEMINI_2_5_PRO: ModelMetadata("open_router", 1050000, 8192),
+    LlmModel.GEMINI_3_PRO_PREVIEW: ModelMetadata("open_router", 1048576, 65535),
+    LlmModel.GEMINI_2_5_FLASH: ModelMetadata("open_router", 1048576, 65535),
+    LlmModel.GEMINI_2_0_FLASH: ModelMetadata("open_router", 1048576, 8192),
     LlmModel.GEMINI_2_5_FLASH_LITE_PREVIEW: ModelMetadata(
-        "open_router",
-        1048576,
-        65535,
-        "Gemini 2.5 Flash Lite Preview 06.17",
-        "OpenRouter",
-        "Google",
-        1,
-    ),
-    LlmModel.GEMINI_2_0_FLASH_LITE: ModelMetadata(
-        "open_router",
-        1048576,
-        8192,
-        "Gemini 2.0 Flash Lite 001",
-        "OpenRouter",
-        "Google",
-        1,
-    ),
-    LlmModel.MISTRAL_NEMO: ModelMetadata(
-        "open_router", 128000, 4096, "Mistral Nemo", "OpenRouter", "Mistral AI", 1
-    ),
-    LlmModel.COHERE_COMMAND_R_08_2024: ModelMetadata(
-        "open_router", 128000, 4096, "Command R 08.2024", "OpenRouter", "Cohere", 1
-    ),
-    LlmModel.COHERE_COMMAND_R_PLUS_08_2024: ModelMetadata(
-        "open_router", 128000, 4096, "Command R Plus 08.2024", "OpenRouter", "Cohere", 2
-    ),
-    LlmModel.DEEPSEEK_CHAT: ModelMetadata(
-        "open_router", 64000, 2048, "DeepSeek Chat", "OpenRouter", "DeepSeek", 1
-    ),
-    LlmModel.DEEPSEEK_R1_0528: ModelMetadata(
-        "open_router", 163840, 163840, "DeepSeek R1 0528", "OpenRouter", "DeepSeek", 1
-    ),
-    LlmModel.PERPLEXITY_SONAR: ModelMetadata(
-        "open_router", 127000, 8000, "Sonar", "OpenRouter", "Perplexity", 1
-    ),
-    LlmModel.PERPLEXITY_SONAR_PRO: ModelMetadata(
-        "open_router", 200000, 8000, "Sonar Pro", "OpenRouter", "Perplexity", 2
+        "open_router", 1048576, 65535
     ),
+    LlmModel.GEMINI_2_0_FLASH_LITE: ModelMetadata("open_router", 1048576, 8192),
+    LlmModel.MISTRAL_NEMO: ModelMetadata("open_router", 128000, 4096),
+    LlmModel.COHERE_COMMAND_R_08_2024: ModelMetadata("open_router", 128000, 4096),
+    LlmModel.COHERE_COMMAND_R_PLUS_08_2024: ModelMetadata("open_router", 128000, 4096),
+    LlmModel.DEEPSEEK_CHAT: ModelMetadata("open_router", 64000, 2048),
+    LlmModel.DEEPSEEK_R1_0528: ModelMetadata("open_router", 163840, 163840),
+    LlmModel.PERPLEXITY_SONAR: ModelMetadata("open_router", 127000, 8000),
+    LlmModel.PERPLEXITY_SONAR_PRO: ModelMetadata("open_router", 200000, 8000),
     LlmModel.PERPLEXITY_SONAR_DEEP_RESEARCH: ModelMetadata(
         "open_router",
         128000,
         16000,
-        "Sonar Deep Research",
-        "OpenRouter",
-        "Perplexity",
-        3,
     ),
     LlmModel.NOUSRESEARCH_HERMES_3_LLAMA_3_1_405B: ModelMetadata(
-        "open_router",
-        131000,
-        4096,
-        "Hermes 3 Llama 3.1 405B",
-        "OpenRouter",
-        "Nous Research",
-        1,
+        "open_router", 131000, 4096
     ),
     LlmModel.NOUSRESEARCH_HERMES_3_LLAMA_3_1_70B: ModelMetadata(
-        "open_router",
-        12288,
-        12288,
-        "Hermes 3 Llama 3.1 70B",
-        "OpenRouter",
-        "Nous Research",
-        1,
-    ),
-    LlmModel.OPENAI_GPT_OSS_120B: ModelMetadata(
-        "open_router", 131072, 131072, "GPT-OSS 120B", "OpenRouter", "OpenAI", 1
-    ),
-    LlmModel.OPENAI_GPT_OSS_20B: ModelMetadata(
-        "open_router", 131072, 32768, "GPT-OSS 20B", "OpenRouter", "OpenAI", 1
-    ),
-    LlmModel.AMAZON_NOVA_LITE_V1: ModelMetadata(
-        "open_router", 300000, 5120, "Nova Lite V1", "OpenRouter", "Amazon", 1
-    ),
-    LlmModel.AMAZON_NOVA_MICRO_V1: ModelMetadata(
-        "open_router", 128000, 5120, "Nova Micro V1", "OpenRouter", "Amazon", 1
-    ),
-    LlmModel.AMAZON_NOVA_PRO_V1: ModelMetadata(
-        "open_router", 300000, 5120, "Nova Pro V1", "OpenRouter", "Amazon", 1
-    ),
-    LlmModel.MICROSOFT_WIZARDLM_2_8X22B: ModelMetadata(
-        "open_router", 65536, 4096, "WizardLM 2 8x22B", "OpenRouter", "Microsoft", 1
-    ),
-    LlmModel.GRYPHE_MYTHOMAX_L2_13B: ModelMetadata(
-        "open_router", 4096, 4096, "MythoMax L2 13B", "OpenRouter", "Gryphe", 1
-    ),
-    LlmModel.META_LLAMA_4_SCOUT: ModelMetadata(
-        "open_router", 131072, 131072, "Llama 4 Scout", "OpenRouter", "Meta", 1
-    ),
-    LlmModel.META_LLAMA_4_MAVERICK: ModelMetadata(
-        "open_router", 1048576, 1000000, "Llama 4 Maverick", "OpenRouter", "Meta", 1
-    ),
-    LlmModel.GROK_4: ModelMetadata(
-        "open_router", 256000, 256000, "Grok 4", "OpenRouter", "xAI", 3
-    ),
-    LlmModel.GROK_4_FAST: ModelMetadata(
-        "open_router", 2000000, 30000, "Grok 4 Fast", "OpenRouter", "xAI", 1
-    ),
-    LlmModel.GROK_4_1_FAST: ModelMetadata(
-        "open_router", 2000000, 30000, "Grok 4.1 Fast", "OpenRouter", "xAI", 1
-    ),
-    LlmModel.GROK_CODE_FAST_1: ModelMetadata(
-        "open_router", 256000, 10000, "Grok Code Fast 1", "OpenRouter", "xAI", 1
-    ),
-    LlmModel.KIMI_K2: ModelMetadata(
-        "open_router", 131000, 131000, "Kimi K2", "OpenRouter", "Moonshot AI", 1
-    ),
-    LlmModel.QWEN3_235B_A22B_THINKING: ModelMetadata(
-        "open_router",
-        262144,
-        262144,
-        "Qwen 3 235B A22B Thinking 2507",
-        "OpenRouter",
-        "Qwen",
-        1,
-    ),
-    LlmModel.QWEN3_CODER: ModelMetadata(
-        "open_router", 262144, 262144, "Qwen 3 Coder", "OpenRouter", "Qwen", 3
+        "open_router", 12288, 12288
     ),
+    LlmModel.OPENAI_GPT_OSS_120B: ModelMetadata("open_router", 131072, 131072),
+    LlmModel.OPENAI_GPT_OSS_20B: ModelMetadata("open_router", 131072, 32768),
+    LlmModel.AMAZON_NOVA_LITE_V1: ModelMetadata("open_router", 300000, 5120),
+    LlmModel.AMAZON_NOVA_MICRO_V1: ModelMetadata("open_router", 128000, 5120),
+    LlmModel.AMAZON_NOVA_PRO_V1: ModelMetadata("open_router", 300000, 5120),
+    LlmModel.MICROSOFT_WIZARDLM_2_8X22B: ModelMetadata("open_router", 65536, 4096),
+    LlmModel.GRYPHE_MYTHOMAX_L2_13B: ModelMetadata("open_router", 4096, 4096),
+    LlmModel.META_LLAMA_4_SCOUT: ModelMetadata("open_router", 131072, 131072),
+    LlmModel.META_LLAMA_4_MAVERICK: ModelMetadata("open_router", 1048576, 1000000),
+    LlmModel.GROK_4: ModelMetadata("open_router", 256000, 256000),
+    LlmModel.GROK_4_FAST: ModelMetadata("open_router", 2000000, 30000),
+    LlmModel.GROK_4_1_FAST: ModelMetadata("open_router", 2000000, 30000),
+    LlmModel.GROK_CODE_FAST_1: ModelMetadata("open_router", 256000, 10000),
+    LlmModel.KIMI_K2: ModelMetadata("open_router", 131000, 131000),
+    LlmModel.QWEN3_235B_A22B_THINKING: ModelMetadata("open_router", 262144, 262144),
+    LlmModel.QWEN3_CODER: ModelMetadata("open_router", 262144, 262144),
     # Llama API models
-    LlmModel.LLAMA_API_LLAMA_4_SCOUT: ModelMetadata(
-        "llama_api",
-        128000,
-        4028,
-        "Llama 4 Scout 17B 16E Instruct FP8",
-        "Llama API",
-        "Meta",
-        1,
-    ),
-    LlmModel.LLAMA_API_LLAMA4_MAVERICK: ModelMetadata(
-        "llama_api",
-        128000,
-        4028,
-        "Llama 4 Maverick 17B 128E Instruct FP8",
-        "Llama API",
-        "Meta",
-        1,
-    ),
-    LlmModel.LLAMA_API_LLAMA3_3_8B: ModelMetadata(
-        "llama_api", 128000, 4028, "Llama 3.3 8B Instruct", "Llama API", "Meta", 1
-    ),
-    LlmModel.LLAMA_API_LLAMA3_3_70B: ModelMetadata(
-        "llama_api", 128000, 4028, "Llama 3.3 70B Instruct", "Llama API", "Meta", 1
-    ),
+    LlmModel.LLAMA_API_LLAMA_4_SCOUT: ModelMetadata("llama_api", 128000, 4028),
+    LlmModel.LLAMA_API_LLAMA4_MAVERICK: ModelMetadata("llama_api", 128000, 4028),
+    LlmModel.LLAMA_API_LLAMA3_3_8B: ModelMetadata("llama_api", 128000, 4028),
+    LlmModel.LLAMA_API_LLAMA3_3_70B: ModelMetadata("llama_api", 128000, 4028),
     # v0 by Vercel models
-    LlmModel.V0_1_5_MD: ModelMetadata("v0", 128000, 64000, "v0 1.5 MD", "V0", "V0", 1),
-    LlmModel.V0_1_5_LG: ModelMetadata("v0", 512000, 64000, "v0 1.5 LG", "V0", "V0", 1),
-    LlmModel.V0_1_0_MD: ModelMetadata("v0", 128000, 64000, "v0 1.0 MD", "V0", "V0", 1),
+    LlmModel.V0_1_5_MD: ModelMetadata("v0", 128000, 64000),
+    LlmModel.V0_1_5_LG: ModelMetadata("v0", 512000, 64000),
+    LlmModel.V0_1_0_MD: ModelMetadata("v0", 128000, 64000),
 }
 
 DEFAULT_LLM_MODEL = LlmModel.GPT5_2

autogpt_platform/backend/backend/blocks/test/test_smart_decision_maker.py

@@ -242,7 +242,7 @@ async def test_smart_decision_maker_tracks_llm_stats():
         outputs = {}
         # Create execution context
 
-        mock_execution_context = ExecutionContext(human_in_the_loop_safe_mode=False)
+        mock_execution_context = ExecutionContext(safe_mode=False)
 
         # Create a mock execution processor for tests
 
@@ -343,7 +343,7 @@ async def test_smart_decision_maker_parameter_validation():
 
         # Create execution context
 
-        mock_execution_context = ExecutionContext(human_in_the_loop_safe_mode=False)
+        mock_execution_context = ExecutionContext(safe_mode=False)
 
         # Create a mock execution processor for tests
 
@@ -409,7 +409,7 @@ async def test_smart_decision_maker_parameter_validation():
 
         # Create execution context
 
-        mock_execution_context = ExecutionContext(human_in_the_loop_safe_mode=False)
+        mock_execution_context = ExecutionContext(safe_mode=False)
 
         # Create a mock execution processor for tests
 
@@ -471,7 +471,7 @@ async def test_smart_decision_maker_parameter_validation():
         outputs = {}
         # Create execution context
 
-        mock_execution_context = ExecutionContext(human_in_the_loop_safe_mode=False)
+        mock_execution_context = ExecutionContext(safe_mode=False)
 
         # Create a mock execution processor for tests
 
@@ -535,7 +535,7 @@ async def test_smart_decision_maker_parameter_validation():
         outputs = {}
         # Create execution context
 
-        mock_execution_context = ExecutionContext(human_in_the_loop_safe_mode=False)
+        mock_execution_context = ExecutionContext(safe_mode=False)
 
         # Create a mock execution processor for tests
 
@@ -658,7 +658,7 @@ async def test_smart_decision_maker_raw_response_conversion():
         outputs = {}
         # Create execution context
 
-        mock_execution_context = ExecutionContext(human_in_the_loop_safe_mode=False)
+        mock_execution_context = ExecutionContext(safe_mode=False)
 
         # Create a mock execution processor for tests
 
@@ -730,7 +730,7 @@ async def test_smart_decision_maker_raw_response_conversion():
         outputs = {}
         # Create execution context
 
-        mock_execution_context = ExecutionContext(human_in_the_loop_safe_mode=False)
+        mock_execution_context = ExecutionContext(safe_mode=False)
 
         # Create a mock execution processor for tests
 
@@ -786,7 +786,7 @@ async def test_smart_decision_maker_raw_response_conversion():
         outputs = {}
         # Create execution context
 
-        mock_execution_context = ExecutionContext(human_in_the_loop_safe_mode=False)
+        mock_execution_context = ExecutionContext(safe_mode=False)
 
         # Create a mock execution processor for tests
 
@@ -905,7 +905,7 @@ async def test_smart_decision_maker_agent_mode():
         # Create a mock execution context
 
         mock_execution_context = ExecutionContext(
-            human_in_the_loop_safe_mode=False,
+            safe_mode=False,
         )
 
         # Create a mock execution processor for agent mode tests
@@ -1027,7 +1027,7 @@ async def test_smart_decision_maker_traditional_mode_default():
 
         # Create execution context
 
-        mock_execution_context = ExecutionContext(human_in_the_loop_safe_mode=False)
+        mock_execution_context = ExecutionContext(safe_mode=False)
 
         # Create a mock execution processor for tests
 

autogpt_platform/backend/backend/blocks/test/test_smart_decision_maker_dynamic_fields.py

@@ -386,7 +386,7 @@ async def test_output_yielding_with_dynamic_fields():
             outputs = {}
             from backend.data.execution import ExecutionContext
 
-            mock_execution_context = ExecutionContext(human_in_the_loop_safe_mode=False)
+            mock_execution_context = ExecutionContext(safe_mode=False)
             mock_execution_processor = MagicMock()
 
             async for output_name, output_value in block.run(
@@ -609,9 +609,7 @@ async def test_validation_errors_dont_pollute_conversation():
                 outputs = {}
                 from backend.data.execution import ExecutionContext
 
-                mock_execution_context = ExecutionContext(
-                    human_in_the_loop_safe_mode=False
-                )
+                mock_execution_context = ExecutionContext(safe_mode=False)
 
                 # Create a proper mock execution processor for agent mode
                 from collections import defaultdict

autogpt_platform/backend/backend/data/block.py

@@ -474,7 +474,7 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         self.block_type = block_type
         self.webhook_config = webhook_config
         self.execution_stats: NodeExecutionStats = NodeExecutionStats()
-        self.is_sensitive_action: bool = False
+        self.requires_human_review: bool = False
 
         if self.webhook_config:
             if isinstance(self.webhook_config, BlockWebhookConfig):
@@ -622,7 +622,6 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         input_data: BlockInput,
         *,
         user_id: str,
-        node_id: str,
         node_exec_id: str,
         graph_exec_id: str,
         graph_id: str,
@@ -638,9 +637,8 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
             - should_pause: True if execution should be paused for review
             - input_data_to_use: The input data to use (may be modified by reviewer)
         """
-        if not (
-            self.is_sensitive_action and execution_context.sensitive_action_safe_mode
-        ):
+        # Skip review if not required or safe mode is disabled
+        if not self.requires_human_review or not execution_context.safe_mode:
             return False, input_data
 
         from backend.blocks.helpers.review import HITLReviewHelper
@@ -649,7 +647,6 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         decision = await HITLReviewHelper.handle_review_decision(
             input_data=input_data,
             user_id=user_id,
-            node_id=node_id,
             node_exec_id=node_exec_id,
             graph_exec_id=graph_exec_id,
             graph_id=graph_id,

autogpt_platform/backend/backend/data/block_cost_config.py

@@ -99,15 +99,10 @@ MODEL_COST: dict[LlmModel, int] = {
     LlmModel.OPENAI_GPT_OSS_20B: 1,
     LlmModel.GEMINI_2_5_PRO: 4,
     LlmModel.GEMINI_3_PRO_PREVIEW: 5,
-    LlmModel.GEMINI_2_5_FLASH: 1,
-    LlmModel.GEMINI_2_0_FLASH: 1,
-    LlmModel.GEMINI_2_5_FLASH_LITE_PREVIEW: 1,
-    LlmModel.GEMINI_2_0_FLASH_LITE: 1,
     LlmModel.MISTRAL_NEMO: 1,
     LlmModel.COHERE_COMMAND_R_08_2024: 1,
     LlmModel.COHERE_COMMAND_R_PLUS_08_2024: 3,
     LlmModel.DEEPSEEK_CHAT: 2,
-    LlmModel.DEEPSEEK_R1_0528: 1,
     LlmModel.PERPLEXITY_SONAR: 1,
     LlmModel.PERPLEXITY_SONAR_PRO: 5,
     LlmModel.PERPLEXITY_SONAR_DEEP_RESEARCH: 10,
@@ -131,6 +126,11 @@ MODEL_COST: dict[LlmModel, int] = {
     LlmModel.KIMI_K2: 1,
     LlmModel.QWEN3_235B_A22B_THINKING: 1,
     LlmModel.QWEN3_CODER: 9,
+    LlmModel.GEMINI_2_5_FLASH: 1,
+    LlmModel.GEMINI_2_0_FLASH: 1,
+    LlmModel.GEMINI_2_5_FLASH_LITE_PREVIEW: 1,
+    LlmModel.GEMINI_2_0_FLASH_LITE: 1,
+    LlmModel.DEEPSEEK_R1_0528: 1,
     # v0 by Vercel models
     LlmModel.V0_1_5_MD: 1,
     LlmModel.V0_1_5_LG: 2,

autogpt_platform/backend/backend/data/db.py

@@ -121,14 +121,10 @@ async def _raw_with_schema(
     Supports placeholders:
         - {schema_prefix}: Table/type prefix (e.g., "platform".)
         - {schema}: Raw schema name for application tables (e.g., platform)
-
-    Note on pgvector types:
-        Use unqualified ::vector and <=> operator in queries. PostgreSQL resolves
-        these via search_path, which includes the schema where pgvector is installed
-        on all environments (local, CI, dev).
+        - {pgvector_schema}: Schema where pgvector is installed (defaults to "public")
 
     Args:
-        query_template: SQL query with {schema_prefix} and/or {schema} placeholders
+        query_template: SQL query with {schema_prefix}, {schema}, and/or {pgvector_schema} placeholders
         *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).
@@ -139,16 +135,20 @@ async def _raw_with_schema(
 
     Example with vector type:
         await execute_raw_with_schema(
-            'INSERT INTO {schema_prefix}"Embedding" (vec) VALUES ($1::vector)',
+            '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
+    # 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

autogpt_platform/backend/backend/data/event_bus.py

@@ -103,18 +103,8 @@ class RedisEventBus(BaseRedisEventBus[M], ABC):
         return redis.get_redis()
 
     def publish_event(self, event: M, channel_key: str):
-        """
-        Publish an event to Redis. Gracefully handles connection failures
-        by logging the error instead of raising exceptions.
-        """
-        try:
-            message, full_channel_name = self._serialize_message(event, channel_key)
-            self.connection.publish(full_channel_name, message)
-        except Exception:
-            logger.exception(
-                f"Failed to publish event to Redis channel {channel_key}. "
-                "Event bus operation will continue without Redis connectivity."
-            )
+        message, full_channel_name = self._serialize_message(event, channel_key)
+        self.connection.publish(full_channel_name, message)
 
     def listen_events(self, channel_key: str) -> Generator[M, None, None]:
         pubsub, full_channel_name = self._get_pubsub_channel(
@@ -138,19 +128,9 @@ class AsyncRedisEventBus(BaseRedisEventBus[M], ABC):
         return await redis.get_redis_async()
 
     async def publish_event(self, event: M, channel_key: str):
-        """
-        Publish an event to Redis. Gracefully handles connection failures
-        by logging the error instead of raising exceptions.
-        """
-        try:
-            message, full_channel_name = self._serialize_message(event, channel_key)
-            connection = await self.connection
-            await connection.publish(full_channel_name, message)
-        except Exception:
-            logger.exception(
-                f"Failed to publish event to Redis channel {channel_key}. "
-                "Event bus operation will continue without Redis connectivity."
-            )
+        message, full_channel_name = self._serialize_message(event, channel_key)
+        connection = await self.connection
+        await connection.publish(full_channel_name, message)
 
     async def listen_events(self, channel_key: str) -> AsyncGenerator[M, None]:
         pubsub, full_channel_name = self._get_pubsub_channel(

autogpt_platform/backend/backend/data/event_bus_test.py

@@ -1,56 +0,0 @@
-"""
-Tests for event_bus graceful degradation when Redis is unavailable.
-"""
-
-from unittest.mock import AsyncMock, patch
-
-import pytest
-from pydantic import BaseModel
-
-from backend.data.event_bus import AsyncRedisEventBus
-
-
-class TestEvent(BaseModel):
-    """Test event model."""
-
-    message: str
-
-
-class TestNotificationBus(AsyncRedisEventBus[TestEvent]):
-    """Test implementation of AsyncRedisEventBus."""
-
-    Model = TestEvent
-
-    @property
-    def event_bus_name(self) -> str:
-        return "test_event_bus"
-
-
-@pytest.mark.asyncio
-async def test_publish_event_handles_connection_failure_gracefully():
-    """Test that publish_event logs exception instead of raising when Redis is unavailable."""
-    bus = TestNotificationBus()
-    event = TestEvent(message="test message")
-
-    # Mock get_redis_async to raise connection error
-    with patch(
-        "backend.data.event_bus.redis.get_redis_async",
-        side_effect=ConnectionError("Authentication required."),
-    ):
-        # Should not raise exception
-        await bus.publish_event(event, "test_channel")
-
-
-@pytest.mark.asyncio
-async def test_publish_event_works_with_redis_available():
-    """Test that publish_event works normally when Redis is available."""
-    bus = TestNotificationBus()
-    event = TestEvent(message="test message")
-
-    # Mock successful Redis connection
-    mock_redis = AsyncMock()
-    mock_redis.publish = AsyncMock()
-
-    with patch("backend.data.event_bus.redis.get_redis_async", return_value=mock_redis):
-        await bus.publish_event(event, "test_channel")
-        mock_redis.publish.assert_called_once()

autogpt_platform/backend/backend/data/execution.py

@@ -81,14 +81,10 @@ class ExecutionContext(BaseModel):
     This includes information needed by blocks, sub-graphs, and execution management.
     """
 
-    model_config = {"extra": "ignore"}
-
-    human_in_the_loop_safe_mode: bool = True
-    sensitive_action_safe_mode: bool = False
+    safe_mode: bool = True
     user_timezone: str = "UTC"
     root_execution_id: Optional[str] = None
     parent_execution_id: Optional[str] = None
-    auto_approved_node_ids: set[str] = Field(default_factory=set)
 
 
 # -------------------------- Models -------------------------- #

autogpt_platform/backend/backend/data/graph.py

@@ -3,7 +3,7 @@ import logging
 import uuid
 from collections import defaultdict
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Annotated, Any, Literal, Optional, cast
+from typing import TYPE_CHECKING, Any, Literal, Optional, cast
 
 from prisma.enums import SubmissionStatus
 from prisma.models import (
@@ -20,7 +20,7 @@ from prisma.types import (
     AgentNodeLinkCreateInput,
     StoreListingVersionWhereInput,
 )
-from pydantic import BaseModel, BeforeValidator, Field, create_model
+from pydantic import BaseModel, Field, create_model
 from pydantic.fields import computed_field
 
 from backend.blocks.agent import AgentExecutorBlock
@@ -62,31 +62,7 @@ logger = logging.getLogger(__name__)
 
 
 class GraphSettings(BaseModel):
-    # Use Annotated with BeforeValidator to coerce None to default values.
-    # This handles cases where the database has null values for these fields.
-    model_config = {"extra": "ignore"}
-
-    human_in_the_loop_safe_mode: Annotated[
-        bool, BeforeValidator(lambda v: v if v is not None else True)
-    ] = True
-    sensitive_action_safe_mode: Annotated[
-        bool, BeforeValidator(lambda v: v if v is not None else False)
-    ] = False
-
-    @classmethod
-    def from_graph(
-        cls,
-        graph: "GraphModel",
-        hitl_safe_mode: bool | None = None,
-        sensitive_action_safe_mode: bool = False,
-    ) -> "GraphSettings":
-        # Default to True if not explicitly set
-        if hitl_safe_mode is None:
-            hitl_safe_mode = True
-        return cls(
-            human_in_the_loop_safe_mode=hitl_safe_mode,
-            sensitive_action_safe_mode=sensitive_action_safe_mode,
-        )
+    human_in_the_loop_safe_mode: bool | None = None
 
 
 class Link(BaseDbModel):
@@ -268,14 +244,10 @@ class BaseGraph(BaseDbModel):
         return any(
             node.block_id
             for node in self.nodes
-            if node.block.block_type == BlockType.HUMAN_IN_THE_LOOP
-        )
-
-    @computed_field
-    @property
-    def has_sensitive_action(self) -> bool:
-        return any(
-            node.block_id for node in self.nodes if node.block.is_sensitive_action
+            if (
+                node.block.block_type == BlockType.HUMAN_IN_THE_LOOP
+                or node.block.requires_human_review
+            )
         )
 
     @property

autogpt_platform/backend/backend/data/human_review_test.py

@@ -46,8 +46,8 @@ async def test_get_or_create_human_review_new(
     sample_db_review.status = ReviewStatus.WAITING
     sample_db_review.processed = False
 
-    mock_prisma = mocker.patch("backend.data.human_review.PendingHumanReview.prisma")
-    mock_prisma.return_value.upsert = AsyncMock(return_value=sample_db_review)
+    mock_upsert = mocker.patch("backend.data.human_review.PendingHumanReview.prisma")
+    mock_upsert.return_value.upsert = AsyncMock(return_value=sample_db_review)
 
     result = await get_or_create_human_review(
         user_id="test-user-123",
@@ -75,8 +75,8 @@ async def test_get_or_create_human_review_approved(
     sample_db_review.processed = False
     sample_db_review.reviewMessage = "Looks good"
 
-    mock_prisma = mocker.patch("backend.data.human_review.PendingHumanReview.prisma")
-    mock_prisma.return_value.upsert = AsyncMock(return_value=sample_db_review)
+    mock_upsert = mocker.patch("backend.data.human_review.PendingHumanReview.prisma")
+    mock_upsert.return_value.upsert = AsyncMock(return_value=sample_db_review)
 
     result = await get_or_create_human_review(
         user_id="test-user-123",

autogpt_platform/backend/backend/data/notifications.py

@@ -211,6 +211,22 @@ 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,
@@ -223,6 +239,7 @@ NotificationData = Annotated[
         DailySummaryData,
         RefundRequestData,
         BaseSummaryData,
+        WaitlistLaunchData,
     ],
     Field(discriminator="type"),
 ]
@@ -273,6 +290,7 @@ def get_notif_data_type(
         NotificationType.REFUND_PROCESSED: RefundRequestData,
         NotificationType.AGENT_APPROVED: AgentApprovalData,
         NotificationType.AGENT_REJECTED: AgentRejectionData,
+        NotificationType.WAITLIST_LAUNCH: WaitlistLaunchData,
     }[notification_type]
 
 
@@ -318,6 +336,7 @@ 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)
 
@@ -337,6 +356,7 @@ 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
@@ -354,6 +374,7 @@ 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]
 
 

autogpt_platform/backend/backend/executor/scheduler.py

@@ -309,7 +309,7 @@ def ensure_embeddings_coverage():
 
         # Process in batches until no more missing embeddings
         while True:
-            result = db_client.backfill_missing_embeddings(batch_size=100)
+            result = db_client.backfill_missing_embeddings(batch_size=10)
 
             total_processed += result["processed"]
             total_success += result["success"]

autogpt_platform/backend/backend/executor/utils.py

@@ -873,8 +873,11 @@ async def add_graph_execution(
         settings = await gdb.get_graph_settings(user_id=user_id, graph_id=graph_id)
 
         execution_context = ExecutionContext(
-            human_in_the_loop_safe_mode=settings.human_in_the_loop_safe_mode,
-            sensitive_action_safe_mode=settings.sensitive_action_safe_mode,
+            safe_mode=(
+                settings.human_in_the_loop_safe_mode
+                if settings.human_in_the_loop_safe_mode is not None
+                else True
+            ),
             user_timezone=(
                 user.timezone if user.timezone != USER_TIMEZONE_NOT_SET else "UTC"
             ),

autogpt_platform/backend/backend/executor/utils_test.py

@@ -386,7 +386,6 @@ async def test_add_graph_execution_is_repeatable(mocker: MockerFixture):
     mock_user.timezone = "UTC"
     mock_settings = mocker.MagicMock()
     mock_settings.human_in_the_loop_safe_mode = True
-    mock_settings.sensitive_action_safe_mode = False
 
     mock_udb.get_user_by_id = mocker.AsyncMock(return_value=mock_user)
     mock_gdb.get_graph_settings = mocker.AsyncMock(return_value=mock_settings)
@@ -652,7 +651,6 @@ async def test_add_graph_execution_with_nodes_to_skip(mocker: MockerFixture):
     mock_user.timezone = "UTC"
     mock_settings = mocker.MagicMock()
     mock_settings.human_in_the_loop_safe_mode = True
-    mock_settings.sensitive_action_safe_mode = False
 
     mock_udb.get_user_by_id = mocker.AsyncMock(return_value=mock_user)
     mock_gdb.get_graph_settings = mocker.AsyncMock(return_value=mock_settings)

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

@@ -0,0 +1,59 @@
+{# 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 %}

autogpt_platform/backend/migrations/20260108032037_add_waitlist_launch_notification/migration.sql

@@ -0,0 +1,53 @@
+-- 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;

autogpt_platform/backend/migrations/20260109181714_add_docs_embedding/migration.sql

@@ -1,10 +1,9 @@
 -- CreateExtension
 -- Supabase: pgvector must be enabled via Dashboard → Database → Extensions first
--- Creates extension in current schema (determined by search_path from DATABASE_URL ?schema= param)
--- This ensures vector type is in the same schema as tables, making ::vector work without explicit qualification
+-- Create in public schema so vector type is available across all schemas
 DO $$
 BEGIN
-    CREATE EXTENSION IF NOT EXISTS "vector";
+    CREATE EXTENSION IF NOT EXISTS "vector" WITH SCHEMA "public";
 EXCEPTION WHEN OTHERS THEN
     RAISE NOTICE 'vector extension not available or already exists, skipping';
 END $$;
@@ -20,7 +19,7 @@ CREATE TABLE "UnifiedContentEmbedding" (
     "contentType" "ContentType" NOT NULL,
     "contentId" TEXT NOT NULL,
     "userId" TEXT,
-    "embedding" vector(1536) NOT NULL,
+    "embedding" public.vector(1536) NOT NULL,
     "searchableText" TEXT NOT NULL,
     "metadata" JSONB NOT NULL DEFAULT '{}',
 
@@ -46,4 +45,4 @@ CREATE UNIQUE INDEX "UnifiedContentEmbedding_contentType_contentId_userId_key" O
 -- Uses cosine distance operator (<=>), which matches the query in hybrid_search.py
 -- Note: Drop first in case Prisma created a btree index (Prisma doesn't support HNSW)
 DROP INDEX IF EXISTS "UnifiedContentEmbedding_embedding_idx";
-CREATE INDEX "UnifiedContentEmbedding_embedding_idx" ON "UnifiedContentEmbedding" USING hnsw ("embedding" vector_cosine_ops);
+CREATE INDEX "UnifiedContentEmbedding_embedding_idx" ON "UnifiedContentEmbedding" USING hnsw ("embedding" public.vector_cosine_ops);

autogpt_platform/backend/migrations/20260121200000_remove_node_execution_fk_from_pending_human_review/migration.sql

@@ -1,7 +0,0 @@
--- Remove NodeExecution foreign key from PendingHumanReview
--- The nodeExecId column remains as the primary key, but we remove the FK constraint
--- to AgentNodeExecution since PendingHumanReview records can persist after node
--- execution records are deleted.
-
--- Drop foreign key constraint that linked PendingHumanReview.nodeExecId to AgentNodeExecution.id
-ALTER TABLE "platform"."PendingHumanReview" DROP CONSTRAINT IF EXISTS "PendingHumanReview_nodeExecId_fkey";

autogpt_platform/backend/schema.prisma

@@ -69,6 +69,10 @@ model User {
   OAuthAuthorizationCodes OAuthAuthorizationCode[]
   OAuthAccessTokens       OAuthAccessToken[]
   OAuthRefreshTokens      OAuthRefreshToken[]
+
+  // Waitlist relations
+  waitlistEntries       WaitlistEntry[]
+  joinedWaitlists       WaitlistEntry[] @relation("joinedWaitlists")
 }
 
 enum OnboardingStep {
@@ -295,6 +299,7 @@ enum NotificationType {
   REFUND_PROCESSED
   AGENT_APPROVED
   AGENT_REJECTED
+  WAITLIST_LAUNCH
 }
 
 model NotificationEvent {
@@ -517,6 +522,8 @@ model AgentNodeExecution {
 
   stats Json?
 
+  PendingHumanReview PendingHumanReview?
+
   @@index([agentGraphExecutionId, agentNodeId, executionStatus])
   @@index([agentNodeId, executionStatus])
   @@index([addedTime, queuedTime])
@@ -565,7 +572,6 @@ enum ReviewStatus {
 }
 
 // Pending human reviews for Human-in-the-loop blocks
-// Also stores auto-approval records with special nodeExecId patterns (e.g., "auto_approve_{graph_exec_id}_{node_id}")
 model PendingHumanReview {
   nodeExecId    String       @id
   userId        String
@@ -584,6 +590,7 @@ model PendingHumanReview {
   reviewedAt    DateTime?
 
   User           User                @relation(fields: [userId], references: [id], onDelete: Cascade)
+  NodeExecution  AgentNodeExecution  @relation(fields: [nodeExecId], references: [id], onDelete: Cascade)
   GraphExecution AgentGraphExecution @relation(fields: [graphExecId], references: [id], onDelete: Cascade)
 
   @@unique([nodeExecId]) // One pending review per node execution
@@ -899,7 +906,8 @@ 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])
@@ -1031,6 +1039,47 @@ 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

autogpt_platform/backend/scripts/generate_block_docs.py

@@ -366,12 +366,12 @@ def generate_block_markdown(
     lines.append("")
 
     # What it is (full description)
-    lines.append("### What it is")
+    lines.append(f"### What it is")
     lines.append(block.description or "No description available.")
     lines.append("")
 
     # How it works (manual section)
-    lines.append("### How it works")
+    lines.append(f"### How it works")
     how_it_works = manual_content.get(
         "how_it_works", "_Add technical explanation here._"
     )
@@ -383,7 +383,7 @@ def generate_block_markdown(
     # Inputs table (auto-generated)
     visible_inputs = [f for f in block.inputs if not f.hidden]
     if visible_inputs:
-        lines.append("### Inputs")
+        lines.append(f"### Inputs")
         lines.append("")
         lines.append("| Input | Description | Type | Required |")
         lines.append("|-------|-------------|------|----------|")
@@ -400,7 +400,7 @@ def generate_block_markdown(
     # Outputs table (auto-generated)
     visible_outputs = [f for f in block.outputs if not f.hidden]
     if visible_outputs:
-        lines.append("### Outputs")
+        lines.append(f"### Outputs")
         lines.append("")
         lines.append("| Output | Description | Type |")
         lines.append("|--------|-------------|------|")
@@ -414,7 +414,7 @@ def generate_block_markdown(
         lines.append("")
 
     # Possible use case (manual section)
-    lines.append("### Possible use case")
+    lines.append(f"### Possible use case")
     use_case = manual_content.get("use_case", "_Add practical use case examples here._")
     lines.append("<!-- MANUAL: use_case -->")
     lines.append(use_case)

autogpt_platform/backend/snapshots/grph_single

@@ -11,7 +11,6 @@
   "forked_from_version": null,
   "has_external_trigger": false,
   "has_human_in_the_loop": false,
-  "has_sensitive_action": false,
   "id": "graph-123",
   "input_schema": {
     "properties": {},

autogpt_platform/backend/snapshots/grphs_all

@@ -11,7 +11,6 @@
     "forked_from_version": null,
     "has_external_trigger": false,
     "has_human_in_the_loop": false,
-    "has_sensitive_action": false,
     "id": "graph-123",
     "input_schema": {
       "properties": {},

autogpt_platform/backend/snapshots/lib_agts_search

@@ -27,8 +27,6 @@
         "properties": {}
       },
       "has_external_trigger": false,
-      "has_human_in_the_loop": false,
-      "has_sensitive_action": false,
       "trigger_setup_info": null,
       "new_output": false,
       "can_access_graph": true,
@@ -36,8 +34,7 @@
       "is_favorite": false,
       "recommended_schedule_cron": null,
       "settings": {
-        "human_in_the_loop_safe_mode": true,
-        "sensitive_action_safe_mode": false
+        "human_in_the_loop_safe_mode": null
       },
       "marketplace_listing": null
     },
@@ -68,8 +65,6 @@
         "properties": {}
       },
       "has_external_trigger": false,
-      "has_human_in_the_loop": false,
-      "has_sensitive_action": false,
       "trigger_setup_info": null,
       "new_output": false,
       "can_access_graph": false,
@@ -77,8 +72,7 @@
       "is_favorite": false,
       "recommended_schedule_cron": null,
       "settings": {
-        "human_in_the_loop_safe_mode": true,
-        "sensitive_action_safe_mode": false
+        "human_in_the_loop_safe_mode": null
       },
       "marketplace_listing": null
     }

autogpt_platform/frontend/src/app/(platform)/admin/layout.tsx

@@ -1,5 +1,5 @@
 import { Sidebar } from "@/components/__legacy__/Sidebar";
-import { Users, DollarSign, UserSearch, FileText } from "lucide-react";
+import { Users, DollarSign, UserSearch, FileText, Clock } from "lucide-react";
 
 import { IconSliders } from "@/components/__legacy__/ui/icons";
 
@@ -11,6 +11,11 @@ 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",

autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/CreateWaitlistButton.tsx

@@ -0,0 +1,217 @@
+"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>
+    </>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/EditWaitlistDialog.tsx

@@ -0,0 +1,221 @@
+"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>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/WaitlistSignupsDialog.tsx

@@ -0,0 +1,156 @@
+"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>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/waitlist/components/WaitlistTable.tsx

@@ -0,0 +1,206 @@
+"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)}
+        />
+      )}
+    </>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/waitlist/page.tsx

@@ -0,0 +1,52 @@
+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 />;
+}

autogpt_platform/frontend/src/app/(platform)/build/components/FloatingSafeModeToogle.tsx

@@ -18,110 +18,69 @@ interface Props {
   fullWidth?: boolean;
 }
 
-interface SafeModeButtonProps {
-  isEnabled: boolean;
-  label: string;
-  tooltipEnabled: string;
-  tooltipDisabled: string;
-  onToggle: () => void;
-  isPending: boolean;
-  fullWidth?: boolean;
-}
-
-function SafeModeButton({
-  isEnabled,
-  label,
-  tooltipEnabled,
-  tooltipDisabled,
-  onToggle,
-  isPending,
-  fullWidth = false,
-}: SafeModeButtonProps) {
-  return (
-    <Tooltip delayDuration={100}>
-      <TooltipTrigger asChild>
-        <Button
-          variant={isEnabled ? "primary" : "outline"}
-          size="small"
-          onClick={onToggle}
-          disabled={isPending}
-          className={cn("justify-start", fullWidth ? "w-full" : "")}
-        >
-          {isEnabled ? (
-            <>
-              <ShieldCheckIcon weight="bold" size={16} />
-              <Text variant="body" className="text-zinc-200">
-                {label}: ON
-              </Text>
-            </>
-          ) : (
-            <>
-              <ShieldIcon weight="bold" size={16} />
-              <Text variant="body" className="text-zinc-600">
-                {label}: OFF
-              </Text>
-            </>
-          )}
-        </Button>
-      </TooltipTrigger>
-      <TooltipContent>
-        <div className="text-center">
-          <div className="font-medium">
-            {label}: {isEnabled ? "ON" : "OFF"}
-          </div>
-          <div className="mt-1 text-xs text-muted-foreground">
-            {isEnabled ? tooltipEnabled : tooltipDisabled}
-          </div>
-        </div>
-      </TooltipContent>
-    </Tooltip>
-  );
-}
-
 export function FloatingSafeModeToggle({
   graph,
   className,
   fullWidth = false,
 }: Props) {
   const {
-    currentHITLSafeMode,
-    showHITLToggle,
-    handleHITLToggle,
-    currentSensitiveActionSafeMode,
-    showSensitiveActionToggle,
-    handleSensitiveActionToggle,
+    currentSafeMode,
     isPending,
     shouldShowToggle,
+    isStateUndetermined,
+    handleToggle,
   } = useAgentSafeMode(graph);
 
-  if (!shouldShowToggle || isPending) {
+  if (!shouldShowToggle || isStateUndetermined || isPending) {
     return null;
   }
 
   return (
-    <div className={cn("fixed z-50 flex flex-col gap-2", className)}>
-      {showHITLToggle && (
-        <SafeModeButton
-          isEnabled={currentHITLSafeMode}
-          label="Human in the loop block approval"
-          tooltipEnabled="The agent will pause at human-in-the-loop blocks and wait for your approval"
-          tooltipDisabled="Human in the loop blocks will proceed automatically"
-          onToggle={handleHITLToggle}
-          isPending={isPending}
-          fullWidth={fullWidth}
-        />
-      )}
-      {showSensitiveActionToggle && (
-        <SafeModeButton
-          isEnabled={currentSensitiveActionSafeMode}
-          label="Sensitive actions blocks approval"
-          tooltipEnabled="The agent will pause at sensitive action blocks and wait for your approval"
-          tooltipDisabled="Sensitive action blocks will proceed automatically"
-          onToggle={handleSensitiveActionToggle}
-          isPending={isPending}
-          fullWidth={fullWidth}
-        />
-      )}
+    <div className={cn("fixed z-50", className)}>
+      <Tooltip delayDuration={100}>
+        <TooltipTrigger asChild>
+          <Button
+            variant={currentSafeMode! ? "primary" : "outline"}
+            key={graph.id}
+            size="small"
+            title={
+              currentSafeMode!
+                ? "Safe Mode: ON. Human in the loop blocks require manual review"
+                : "Safe Mode: OFF. Human in the loop blocks proceed automatically"
+            }
+            onClick={handleToggle}
+            className={cn(fullWidth ? "w-full" : "")}
+          >
+            {currentSafeMode! ? (
+              <>
+                <ShieldCheckIcon weight="bold" size={16} />
+                <Text variant="body" className="text-zinc-200">
+                  Safe Mode: ON
+                </Text>
+              </>
+            ) : (
+              <>
+                <ShieldIcon weight="bold" size={16} />
+                <Text variant="body" className="text-zinc-600">
+                  Safe Mode: OFF
+                </Text>
+              </>
+            )}
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>
+          <div className="text-center">
+            <div className="font-medium">
+              Safe Mode: {currentSafeMode! ? "ON" : "OFF"}
+            </div>
+            <div className="mt-1 text-xs text-muted-foreground">
+              {currentSafeMode!
+                ? "Human in the loop blocks require manual review"
+                : "Human in the loop blocks proceed automatically"}
+            </div>
+          </div>
+        </TooltipContent>
+      </Tooltip>
     </div>
   );
 }

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

@@ -31,18 +31,10 @@ export function AgentSettingsModal({
     }
   }
 
-  const {
-    currentHITLSafeMode,
-    showHITLToggle,
-    handleHITLToggle,
-    currentSensitiveActionSafeMode,
-    showSensitiveActionToggle,
-    handleSensitiveActionToggle,
-    isPending,
-    shouldShowToggle,
-  } = useAgentSafeMode(agent);
+  const { currentSafeMode, isPending, hasHITLBlocks, handleToggle } =
+    useAgentSafeMode(agent);
 
-  if (!shouldShowToggle) return null;
+  if (!hasHITLBlocks) return null;
 
   return (
     <Dialog
@@ -65,48 +57,23 @@ export function AgentSettingsModal({
       )}
       <Dialog.Content>
         <div className="space-y-6">
-          {showHITLToggle && (
-            <div className="flex w-full flex-col items-start gap-4 rounded-xl border border-zinc-100 bg-white p-6">
-              <div className="flex w-full items-start justify-between gap-4">
-                <div className="flex-1">
-                  <Text variant="large-semibold">
-                    Human-in-the-loop approval
-                  </Text>
-                  <Text variant="large" className="mt-1 text-zinc-900">
-                    The agent will pause at human-in-the-loop blocks and wait
-                    for your review before continuing
-                  </Text>
-                </div>
-                <Switch
-                  checked={currentHITLSafeMode || false}
-                  onCheckedChange={handleHITLToggle}
-                  disabled={isPending}
-                  className="mt-1"
-                />
+          <div className="flex w-full flex-col items-start gap-4 rounded-xl border border-zinc-100 bg-white p-6">
+            <div className="flex w-full items-start justify-between gap-4">
+              <div className="flex-1">
+                <Text variant="large-semibold">Require human approval</Text>
+                <Text variant="large" className="mt-1 text-zinc-900">
+                  The agent will pause and wait for your review before
+                  continuing
+                </Text>
               </div>
+              <Switch
+                checked={currentSafeMode || false}
+                onCheckedChange={handleToggle}
+                disabled={isPending}
+                className="mt-1"
+              />
             </div>
-          )}
-          {showSensitiveActionToggle && (
-            <div className="flex w-full flex-col items-start gap-4 rounded-xl border border-zinc-100 bg-white p-6">
-              <div className="flex w-full items-start justify-between gap-4">
-                <div className="flex-1">
-                  <Text variant="large-semibold">
-                    Sensitive action approval
-                  </Text>
-                  <Text variant="large" className="mt-1 text-zinc-900">
-                    The agent will pause at sensitive action blocks and wait for
-                    your review before continuing
-                  </Text>
-                </div>
-                <Switch
-                  checked={currentSensitiveActionSafeMode}
-                  onCheckedChange={handleSensitiveActionToggle}
-                  disabled={isPending}
-                  className="mt-1"
-                />
-              </div>
-            </div>
-          )}
+          </div>
         </div>
       </Dialog.Content>
     </Dialog>

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

@@ -14,10 +14,6 @@ import {
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import { useEffect, useRef, useState } from "react";
 import { ScheduleAgentModal } from "../ScheduleAgentModal/ScheduleAgentModal";
-import {
-  AIAgentSafetyPopup,
-  useAIAgentSafetyPopup,
-} from "./components/AIAgentSafetyPopup/AIAgentSafetyPopup";
 import { ModalHeader } from "./components/ModalHeader/ModalHeader";
 import { ModalRunSection } from "./components/ModalRunSection/ModalRunSection";
 import { RunActions } from "./components/RunActions/RunActions";
@@ -87,17 +83,8 @@ export function RunAgentModal({
 
   const [isScheduleModalOpen, setIsScheduleModalOpen] = useState(false);
   const [hasOverflow, setHasOverflow] = useState(false);
-  const [isSafetyPopupOpen, setIsSafetyPopupOpen] = useState(false);
-  const [pendingRunAction, setPendingRunAction] = useState<(() => void) | null>(
-    null,
-  );
   const contentRef = useRef<HTMLDivElement>(null);
 
-  const { shouldShowPopup, dismissPopup } = useAIAgentSafetyPopup(
-    agent.has_sensitive_action,
-    agent.has_human_in_the_loop,
-  );
-
   const hasAnySetupFields =
     Object.keys(agentInputFields || {}).length > 0 ||
     Object.keys(agentCredentialsInputFields || {}).length > 0;
@@ -178,24 +165,6 @@ export function RunAgentModal({
     onScheduleCreated?.(schedule);
   }
 
-  function handleRunWithSafetyCheck() {
-    if (shouldShowPopup) {
-      setPendingRunAction(() => handleRun);
-      setIsSafetyPopupOpen(true);
-    } else {
-      handleRun();
-    }
-  }
-
-  function handleSafetyPopupAcknowledge() {
-    setIsSafetyPopupOpen(false);
-    dismissPopup();
-    if (pendingRunAction) {
-      pendingRunAction();
-      setPendingRunAction(null);
-    }
-  }
-
   return (
     <>
       <Dialog
@@ -279,7 +248,7 @@ export function RunAgentModal({
                 )}
                 <RunActions
                   defaultRunType={defaultRunType}
-                  onRun={handleRunWithSafetyCheck}
+                  onRun={handleRun}
                   isExecuting={isExecuting}
                   isSettingUpTrigger={isSettingUpTrigger}
                   isRunReady={allRequiredInputsAreSet}
@@ -297,11 +266,6 @@ export function RunAgentModal({
           </div>
         </Dialog.Content>
       </Dialog>
-
-      <AIAgentSafetyPopup
-        isOpen={isSafetyPopupOpen}
-        onAcknowledge={handleSafetyPopupAcknowledge}
-      />
     </>
   );
 }

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

@@ -1,95 +0,0 @@
-"use client";
-
-import { Button } from "@/components/atoms/Button/Button";
-import { Text } from "@/components/atoms/Text/Text";
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import { Key, storage } from "@/services/storage/local-storage";
-import { ShieldCheckIcon } from "@phosphor-icons/react";
-import { useCallback, useEffect, useState } from "react";
-
-interface Props {
-  onAcknowledge: () => void;
-  isOpen: boolean;
-}
-
-export function AIAgentSafetyPopup({ onAcknowledge, isOpen }: Props) {
-  function handleAcknowledge() {
-    // Mark popup as shown so it won't appear again
-    storage.set(Key.AI_AGENT_SAFETY_POPUP_SHOWN, "true");
-    onAcknowledge();
-  }
-
-  if (!isOpen) return null;
-
-  return (
-    <Dialog
-      controlled={{ isOpen, set: () => {} }}
-      styling={{ maxWidth: "480px" }}
-    >
-      <Dialog.Content>
-        <div className="flex flex-col items-center p-6 text-center">
-          <div className="mb-6 flex h-16 w-16 items-center justify-center rounded-full bg-blue-50">
-            <ShieldCheckIcon
-              weight="fill"
-              size={32}
-              className="text-blue-600"
-            />
-          </div>
-
-          <Text variant="h3" className="mb-4">
-            Safety Checks Enabled
-          </Text>
-
-          <Text variant="body" className="mb-2 text-zinc-700">
-            AI-generated agents may take actions that affect your data or
-            external systems.
-          </Text>
-
-          <Text variant="body" className="mb-8 text-zinc-700">
-            AutoGPT includes safety checks so you&apos;ll always have the
-            opportunity to review and approve sensitive actions before they
-            happen.
-          </Text>
-
-          <Button
-            variant="primary"
-            size="large"
-            className="w-full"
-            onClick={handleAcknowledge}
-          >
-            Got it
-          </Button>
-        </div>
-      </Dialog.Content>
-    </Dialog>
-  );
-}
-
-export function useAIAgentSafetyPopup(
-  hasSensitiveAction: boolean,
-  hasHumanInTheLoop: boolean,
-) {
-  const [shouldShowPopup, setShouldShowPopup] = useState(false);
-  const [hasChecked, setHasChecked] = useState(false);
-
-  useEffect(() => {
-    // Only check once after mount (to avoid SSR issues)
-    if (hasChecked) return;
-
-    const hasSeenPopup =
-      storage.get(Key.AI_AGENT_SAFETY_POPUP_SHOWN) === "true";
-    const isRelevantAgent = hasSensitiveAction || hasHumanInTheLoop;
-
-    setShouldShowPopup(!hasSeenPopup && isRelevantAgent);
-    setHasChecked(true);
-  }, [hasSensitiveAction, hasHumanInTheLoop, hasChecked]);
-
-  const dismissPopup = useCallback(() => {
-    setShouldShowPopup(false);
-  }, []);
-
-  return {
-    shouldShowPopup,
-    dismissPopup,
-  };
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/SelectedRunView/components/SafeModeToggle.tsx

@@ -5,104 +5,48 @@ import { Graph } from "@/lib/autogpt-server-api/types";
 import { cn } from "@/lib/utils";
 import { ShieldCheckIcon, ShieldIcon } from "@phosphor-icons/react";
 import { useAgentSafeMode } from "@/hooks/useAgentSafeMode";
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipTrigger,
-} from "@/components/atoms/Tooltip/BaseTooltip";
 
 interface Props {
   graph: GraphModel | LibraryAgent | Graph;
   className?: string;
+  fullWidth?: boolean;
 }
 
-interface SafeModeIconButtonProps {
-  isEnabled: boolean;
-  label: string;
-  tooltipEnabled: string;
-  tooltipDisabled: string;
-  onToggle: () => void;
-  isPending: boolean;
-}
-
-function SafeModeIconButton({
-  isEnabled,
-  label,
-  tooltipEnabled,
-  tooltipDisabled,
-  onToggle,
-  isPending,
-}: SafeModeIconButtonProps) {
-  return (
-    <Tooltip delayDuration={100}>
-      <TooltipTrigger asChild>
-        <Button
-          variant="icon"
-          size="icon"
-          aria-label={`${label}: ${isEnabled ? "ON" : "OFF"}. ${isEnabled ? tooltipEnabled : tooltipDisabled}`}
-          onClick={onToggle}
-          disabled={isPending}
-          className={cn(isPending ? "opacity-0" : "opacity-100")}
-        >
-          {isEnabled ? (
-            <ShieldCheckIcon weight="bold" size={16} />
-          ) : (
-            <ShieldIcon weight="bold" size={16} />
-          )}
-        </Button>
-      </TooltipTrigger>
-      <TooltipContent>
-        <div className="text-center">
-          <div className="font-medium">
-            {label}: {isEnabled ? "ON" : "OFF"}
-          </div>
-          <div className="mt-1 text-xs text-muted-foreground">
-            {isEnabled ? tooltipEnabled : tooltipDisabled}
-          </div>
-        </div>
-      </TooltipContent>
-    </Tooltip>
-  );
-}
-
-export function SafeModeToggle({ graph, className }: Props) {
+export function SafeModeToggle({ graph }: Props) {
   const {
-    currentHITLSafeMode,
-    showHITLToggle,
-    handleHITLToggle,
-    currentSensitiveActionSafeMode,
-    showSensitiveActionToggle,
-    handleSensitiveActionToggle,
+    currentSafeMode,
     isPending,
     shouldShowToggle,
+    isStateUndetermined,
+    handleToggle,
   } = useAgentSafeMode(graph);
 
-  if (!shouldShowToggle) {
+  if (!shouldShowToggle || isStateUndetermined) {
     return null;
   }
 
   return (
-    <div className={cn("flex gap-1", className)}>
-      {showHITLToggle && (
-        <SafeModeIconButton
-          isEnabled={currentHITLSafeMode}
-          label="Human-in-the-loop"
-          tooltipEnabled="The agent will pause at human-in-the-loop blocks and wait for your approval"
-          tooltipDisabled="Human-in-the-loop blocks will proceed automatically"
-          onToggle={handleHITLToggle}
-          isPending={isPending}
-        />
+    <Button
+      variant="icon"
+      key={graph.id}
+      size="icon"
+      aria-label={
+        currentSafeMode!
+          ? "Safe Mode: ON. Human in the loop blocks require manual review"
+          : "Safe Mode: OFF. Human in the loop blocks proceed automatically"
+      }
+      onClick={handleToggle}
+      className={cn(isPending ? "opacity-0" : "opacity-100")}
+    >
+      {currentSafeMode! ? (
+        <>
+          <ShieldCheckIcon weight="bold" size={16} />
+        </>
+      ) : (
+        <>
+          <ShieldIcon weight="bold" size={16} />
+        </>
       )}
-      {showSensitiveActionToggle && (
-        <SafeModeIconButton
-          isEnabled={currentSensitiveActionSafeMode}
-          label="Sensitive actions"
-          tooltipEnabled="The agent will pause at sensitive action blocks and wait for your approval"
-          tooltipDisabled="Sensitive action blocks will proceed automatically"
-          onToggle={handleSensitiveActionToggle}
-          isPending={isPending}
-        />
-      )}
-    </div>
+    </Button>
   );
 }

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/SelectedSettingsView/SelectedSettingsView.tsx

@@ -13,16 +13,8 @@ interface Props {
 }
 
 export function SelectedSettingsView({ agent, onClearSelectedRun }: Props) {
-  const {
-    currentHITLSafeMode,
-    showHITLToggle,
-    handleHITLToggle,
-    currentSensitiveActionSafeMode,
-    showSensitiveActionToggle,
-    handleSensitiveActionToggle,
-    isPending,
-    shouldShowToggle,
-  } = useAgentSafeMode(agent);
+  const { currentSafeMode, isPending, hasHITLBlocks, handleToggle } =
+    useAgentSafeMode(agent);
 
   return (
     <SelectedViewLayout agent={agent}>
@@ -42,51 +34,24 @@ export function SelectedSettingsView({ agent, onClearSelectedRun }: Props) {
         </div>
 
         <div className={`${AGENT_LIBRARY_SECTION_PADDING_X} space-y-6`}>
-          {shouldShowToggle ? (
-            <>
-              {showHITLToggle && (
-                <div className="flex w-full max-w-2xl flex-col items-start gap-4 rounded-xl border border-zinc-100 bg-white p-6">
-                  <div className="flex w-full items-start justify-between gap-4">
-                    <div className="flex-1">
-                      <Text variant="large-semibold">
-                        Human-in-the-loop approval
-                      </Text>
-                      <Text variant="large" className="mt-1 text-zinc-900">
-                        The agent will pause at human-in-the-loop blocks and
-                        wait for your review before continuing
-                      </Text>
-                    </div>
-                    <Switch
-                      checked={currentHITLSafeMode || false}
-                      onCheckedChange={handleHITLToggle}
-                      disabled={isPending}
-                      className="mt-1"
-                    />
-                  </div>
+          {hasHITLBlocks ? (
+            <div className="flex w-full max-w-2xl flex-col items-start gap-4 rounded-xl border border-zinc-100 bg-white p-6">
+              <div className="flex w-full items-start justify-between gap-4">
+                <div className="flex-1">
+                  <Text variant="large-semibold">Require human approval</Text>
+                  <Text variant="large" className="mt-1 text-zinc-900">
+                    The agent will pause and wait for your review before
+                    continuing
+                  </Text>
                 </div>
-              )}
-              {showSensitiveActionToggle && (
-                <div className="flex w-full max-w-2xl flex-col items-start gap-4 rounded-xl border border-zinc-100 bg-white p-6">
-                  <div className="flex w-full items-start justify-between gap-4">
-                    <div className="flex-1">
-                      <Text variant="large-semibold">
-                        Sensitive action approval
-                      </Text>
-                      <Text variant="large" className="mt-1 text-zinc-900">
-                        The agent will pause at sensitive action blocks and wait
-                        for your review before continuing
-                      </Text>
-                    </div>
-                    <Switch
-                      checked={currentSensitiveActionSafeMode}
-                      onCheckedChange={handleSensitiveActionToggle}
-                      disabled={isPending}
-                      className="mt-1"
-                    />
-                  </div>
-                </div>
-              )}
-            </>
+                <Switch
+                  checked={currentSafeMode || false}
+                  onCheckedChange={handleToggle}
+                  disabled={isPending}
+                  className="mt-1"
+                />
+              </div>
+            </div>
           ) : (
             <div className="rounded-xl border border-zinc-100 bg-white p-6">
               <Text variant="body" className="text-muted-foreground">

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

@@ -1,15 +1,8 @@
 "use client";
-import React, {
-  useCallback,
-  useContext,
-  useEffect,
-  useMemo,
-  useState,
-} from "react";
+import React, { useCallback, useEffect, useMemo, useState } from "react";
 
 import {
   CredentialsMetaInput,
-  CredentialsType,
   GraphExecutionID,
   GraphMeta,
   LibraryAgentPreset,
@@ -36,11 +29,7 @@ import {
 } from "@/components/__legacy__/ui/icons";
 import { Input } from "@/components/__legacy__/ui/input";
 import { Button } from "@/components/atoms/Button/Button";
-import { CredentialsGroupedView } from "@/components/contextual/CredentialsInput/components/CredentialsGroupedView/CredentialsGroupedView";
-import {
-  findSavedCredentialByProviderAndType,
-  findSavedUserCredentialByProviderAndType,
-} from "@/components/contextual/CredentialsInput/components/CredentialsGroupedView/helpers";
+import { CredentialsInput } from "@/components/contextual/CredentialsInput/CredentialsInput";
 import { InformationTooltip } from "@/components/molecules/InformationTooltip/InformationTooltip";
 import {
   useToast,
@@ -48,7 +37,6 @@ import {
 } from "@/components/molecules/Toast/use-toast";
 import { humanizeCronExpression } from "@/lib/cron-expression-utils";
 import { cn, isEmpty } from "@/lib/utils";
-import { CredentialsProvidersContext } from "@/providers/agent-credentials/credentials-provider";
 import { ClockIcon, CopyIcon, InfoIcon } from "@phosphor-icons/react";
 import { CalendarClockIcon, Trash2Icon } from "lucide-react";
 
@@ -102,7 +90,6 @@ export function AgentRunDraftView({
   const api = useBackendAPI();
   const { toast } = useToast();
   const toastOnFail = useToastOnFail();
-  const allProviders = useContext(CredentialsProvidersContext);
 
   const [inputValues, setInputValues] = useState<Record<string, any>>({});
   const [inputCredentials, setInputCredentials] = useState<
@@ -141,77 +128,6 @@ export function AgentRunDraftView({
     () => graph.credentials_input_schema.properties,
     [graph],
   );
-  const credentialFields = useMemo(
-    function getCredentialFields() {
-      return Object.entries(agentCredentialsInputFields);
-    },
-    [agentCredentialsInputFields],
-  );
-  const requiredCredentials = useMemo(
-    function getRequiredCredentials() {
-      return new Set(
-        (graph.credentials_input_schema?.required as string[]) || [],
-      );
-    },
-    [graph.credentials_input_schema?.required],
-  );
-
-  useEffect(
-    function initializeDefaultCredentials() {
-      if (!allProviders) return;
-      if (!graph.credentials_input_schema?.properties) return;
-      if (requiredCredentials.size === 0) return;
-
-      setInputCredentials(function updateCredentials(currentCreds) {
-        const next = { ...currentCreds };
-        let didAdd = false;
-
-        for (const key of requiredCredentials) {
-          if (next[key]) continue;
-          const schema = graph.credentials_input_schema.properties[key];
-          if (!schema) continue;
-
-          const providerNames = schema.credentials_provider || [];
-          const credentialTypes = schema.credentials_types || [];
-          const requiredScopes = schema.credentials_scopes;
-
-          const userCredential = findSavedUserCredentialByProviderAndType(
-            providerNames,
-            credentialTypes,
-            requiredScopes,
-            allProviders,
-          );
-
-          const savedCredential =
-            userCredential ||
-            findSavedCredentialByProviderAndType(
-              providerNames,
-              credentialTypes,
-              requiredScopes,
-              allProviders,
-            );
-
-          if (!savedCredential) continue;
-
-          next[key] = {
-            id: savedCredential.id,
-            provider: savedCredential.provider,
-            type: savedCredential.type as CredentialsType,
-            title: savedCredential.title,
-          };
-          didAdd = true;
-        }
-
-        if (!didAdd) return currentCreds;
-        return next;
-      });
-    },
-    [
-      allProviders,
-      graph.credentials_input_schema?.properties,
-      requiredCredentials,
-    ],
-  );
 
   const [allRequiredInputsAreSet, missingInputs] = useMemo(() => {
     const nonEmptyInputs = new Set(
@@ -229,35 +145,18 @@ export function AgentRunDraftView({
     );
     return [isSuperset, difference];
   }, [agentInputSchema.required, inputValues]);
-  const [allCredentialsAreSet, missingCredentials] = useMemo(
-    function getCredentialStatus() {
-      const missing = Array.from(requiredCredentials).filter((key) => {
-        const cred = inputCredentials[key];
-        return !cred || !cred.id;
-      });
-      return [missing.length === 0, missing];
-    },
-    [requiredCredentials, inputCredentials],
-  );
-  function addChangedCredentials(prev: Set<keyof LibraryAgentPresetUpdatable>) {
-    const next = new Set(prev);
-    next.add("credentials");
-    return next;
-  }
-
-  function handleCredentialChange(key: string, value?: CredentialsMetaInput) {
-    setInputCredentials(function updateInputCredentials(currentCreds) {
-      const next = { ...currentCreds };
-      if (value === undefined) {
-        delete next[key];
-        return next;
-      }
-      next[key] = value;
-      return next;
-    });
-    setChangedPresetAttributes(addChangedCredentials);
-  }
-
+  const [allCredentialsAreSet, missingCredentials] = useMemo(() => {
+    const availableCredentials = new Set(Object.keys(inputCredentials));
+    const allCredentials = new Set(Object.keys(agentCredentialsInputFields));
+    // Backwards-compatible implementation of isSupersetOf and difference
+    const isSuperset = Array.from(allCredentials).every((item) =>
+      availableCredentials.has(item),
+    );
+    const difference = Array.from(allCredentials).filter(
+      (item) => !availableCredentials.has(item),
+    );
+    return [isSuperset, difference];
+  }, [agentCredentialsInputFields, inputCredentials]);
   const notifyMissingInputs = useCallback(
     (needPresetName: boolean = true) => {
       const allMissingFields = (
@@ -750,6 +649,35 @@ export function AgentRunDraftView({
               </>
             )}
 
+            {/* Credentials inputs */}
+            {Object.entries(agentCredentialsInputFields).map(
+              ([key, inputSubSchema]) => (
+                <CredentialsInput
+                  key={key}
+                  schema={{ ...inputSubSchema, discriminator: undefined }}
+                  selectedCredentials={
+                    inputCredentials[key] ?? inputSubSchema.default
+                  }
+                  onSelectCredentials={(value) => {
+                    setInputCredentials((obj) => {
+                      const newObj = { ...obj };
+                      if (value === undefined) {
+                        delete newObj[key];
+                        return newObj;
+                      }
+                      return {
+                        ...obj,
+                        [key]: value,
+                      };
+                    });
+                    setChangedPresetAttributes((prev) =>
+                      prev.add("credentials"),
+                    );
+                  }}
+                />
+              ),
+            )}
+
             {/* Regular inputs */}
             {Object.entries(agentInputFields).map(([key, inputSubSchema]) => (
               <RunAgentInputs
@@ -767,17 +695,6 @@ export function AgentRunDraftView({
                 data-testid={`agent-input-${key}`}
               />
             ))}
-
-            {/* Credentials inputs */}
-            {credentialFields.length > 0 && (
-              <CredentialsGroupedView
-                credentialFields={credentialFields}
-                requiredCredentials={requiredCredentials}
-                inputCredentials={inputCredentials}
-                inputValues={inputValues}
-                onCredentialChange={handleCredentialChange}
-              />
-            )}
           </CardContent>
         </Card>
       </div>

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

@@ -8,6 +8,7 @@ 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 } =
@@ -46,6 +47,10 @@ 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} />
         )}

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

@@ -0,0 +1,105 @@
+"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>
+  );
+}

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

@@ -0,0 +1,356 @@
+"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>
+  );
+}

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

@@ -0,0 +1,102 @@
+"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>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/marketplace/components/WaitlistSection/useWaitlistSection.ts

@@ -0,0 +1,58 @@
+"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 };
+}

autogpt_platform/frontend/src/app/api/openapi.json

@@ -5082,6 +5082,301 @@
         }
       }
     },
+    "/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"],
@@ -5927,6 +6222,101 @@
         }
       }
     },
+    "/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"],
@@ -6383,11 +6773,6 @@
             "title": "Has Human In The Loop",
             "readOnly": true
           },
-          "has_sensitive_action": {
-            "type": "boolean",
-            "title": "Has Sensitive Action",
-            "readOnly": true
-          },
           "trigger_setup_info": {
             "anyOf": [
               { "$ref": "#/components/schemas/GraphTriggerInfo" },
@@ -6404,7 +6789,6 @@
           "output_schema",
           "has_external_trigger",
           "has_human_in_the_loop",
-          "has_sensitive_action",
           "trigger_setup_info"
         ],
         "title": "BaseGraph"
@@ -6680,6 +7064,17 @@
         "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": {
@@ -6698,6 +7093,18 @@
         "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" }
@@ -7635,11 +8042,6 @@
             "title": "Has Human In The Loop",
             "readOnly": true
           },
-          "has_sensitive_action": {
-            "type": "boolean",
-            "title": "Has Sensitive Action",
-            "readOnly": true
-          },
           "trigger_setup_info": {
             "anyOf": [
               { "$ref": "#/components/schemas/GraphTriggerInfo" },
@@ -7663,7 +8065,6 @@
           "output_schema",
           "has_external_trigger",
           "has_human_in_the_loop",
-          "has_sensitive_action",
           "trigger_setup_info",
           "credentials_input_schema"
         ],
@@ -7742,11 +8143,6 @@
             "title": "Has Human In The Loop",
             "readOnly": true
           },
-          "has_sensitive_action": {
-            "type": "boolean",
-            "title": "Has Sensitive Action",
-            "readOnly": true
-          },
           "trigger_setup_info": {
             "anyOf": [
               { "$ref": "#/components/schemas/GraphTriggerInfo" },
@@ -7771,7 +8167,6 @@
           "output_schema",
           "has_external_trigger",
           "has_human_in_the_loop",
-          "has_sensitive_action",
           "trigger_setup_info",
           "credentials_input_schema"
         ],
@@ -7780,14 +8175,8 @@
       "GraphSettings": {
         "properties": {
           "human_in_the_loop_safe_mode": {
-            "type": "boolean",
-            "title": "Human In The Loop Safe Mode",
-            "default": true
-          },
-          "sensitive_action_safe_mode": {
-            "type": "boolean",
-            "title": "Sensitive Action Safe Mode",
-            "default": false
+            "anyOf": [{ "type": "boolean" }, { "type": "null" }],
+            "title": "Human In The Loop Safe Mode"
           }
         },
         "type": "object",
@@ -7945,16 +8334,6 @@
             "title": "Has External Trigger",
             "description": "Whether the agent has an external trigger (e.g. webhook) node"
           },
-          "has_human_in_the_loop": {
-            "type": "boolean",
-            "title": "Has Human In The Loop",
-            "description": "Whether the agent has human-in-the-loop blocks"
-          },
-          "has_sensitive_action": {
-            "type": "boolean",
-            "title": "Has Sensitive Action",
-            "description": "Whether the agent has sensitive action blocks"
-          },
           "trigger_setup_info": {
             "anyOf": [
               { "$ref": "#/components/schemas/GraphTriggerInfo" },
@@ -8001,8 +8380,6 @@
           "output_schema",
           "credentials_input_schema",
           "has_external_trigger",
-          "has_human_in_the_loop",
-          "has_sensitive_action",
           "new_output",
           "can_access_graph",
           "is_latest_version",
@@ -8607,7 +8984,8 @@
           "REFUND_REQUEST",
           "REFUND_PROCESSED",
           "AGENT_APPROVED",
-          "AGENT_REJECTED"
+          "AGENT_REJECTED",
+          "WAITLIST_LAUNCH"
         ],
         "title": "NotificationType"
       },
@@ -9425,12 +9803,6 @@
             "type": "array",
             "title": "Reviews",
             "description": "All reviews with their approval status, data, and messages"
-          },
-          "auto_approve_future_actions": {
-            "type": "boolean",
-            "title": "Auto Approve Future Actions",
-            "description": "If true, future reviews from the same blocks (nodes) being approved will be automatically approved for the remainder of this execution. This only affects the current execution run.",
-            "default": false
           }
         },
         "type": "object",
@@ -10176,6 +10548,57 @@
         "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" },
@@ -11995,6 +12418,203 @@
         "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" },

autogpt_platform/frontend/src/components/contextual/CredentialsInput/components/CredentialsGroupedView/helpers.ts

@@ -1,5 +1,5 @@
 import { CredentialsProvidersContextType } from "@/providers/agent-credentials/credentials-provider";
-import { filterSystemCredentials, getSystemCredentials } from "../../helpers";
+import { getSystemCredentials } from "../../helpers";
 
 export type CredentialField = [string, any];
 
@@ -208,42 +208,3 @@ export function findSavedCredentialByProviderAndType(
 
   return undefined;
 }
-
-export function findSavedUserCredentialByProviderAndType(
-  providerNames: string[],
-  credentialTypes: string[],
-  requiredScopes: string[] | undefined,
-  allProviders: CredentialsProvidersContextType | null,
-): SavedCredential | undefined {
-  for (const providerName of providerNames) {
-    const providerData = allProviders?.[providerName];
-    if (!providerData) continue;
-
-    const userCredentials = filterSystemCredentials(
-      providerData.savedCredentials ?? [],
-    );
-
-    const matchingCredentials: SavedCredential[] = [];
-
-    for (const credential of userCredentials) {
-      const typeMatches =
-        credentialTypes.length === 0 ||
-        credentialTypes.includes(credential.type);
-      const scopesMatch = hasRequiredScopes(credential, requiredScopes);
-
-      if (!typeMatches) continue;
-      if (!scopesMatch) continue;
-
-      matchingCredentials.push(credential as SavedCredential);
-    }
-
-    if (matchingCredentials.length === 1) {
-      return matchingCredentials[0];
-    }
-    if (matchingCredentials.length > 1) {
-      return undefined;
-    }
-  }
-
-  return undefined;
-}

autogpt_platform/frontend/src/components/contextual/CredentialsInput/useCredentialsInput.ts

@@ -98,20 +98,24 @@ export function useCredentialsInput({
 
   // Auto-select the first available credential on initial mount
   // Once a user has made a selection, we don't override it
-  useEffect(
-    function autoSelectCredential() {
-      if (readOnly) return;
-      if (!credentials || !("savedCredentials" in credentials)) return;
-      if (selectedCredential?.id) return;
+  useEffect(() => {
+    if (readOnly) return;
+    if (!credentials || !("savedCredentials" in credentials)) return;
 
-      const savedCreds = credentials.savedCredentials;
-      if (savedCreds.length === 0) return;
+    // If already selected, don't auto-select
+    if (selectedCredential?.id) return;
 
-      if (hasAttemptedAutoSelect.current) return;
-      hasAttemptedAutoSelect.current = true;
+    // Only attempt auto-selection once
+    if (hasAttemptedAutoSelect.current) return;
+    hasAttemptedAutoSelect.current = true;
 
-      if (isOptional) return;
+    // If optional, don't auto-select (user can choose "None")
+    if (isOptional) return;
 
+    const savedCreds = credentials.savedCredentials;
+
+    // Auto-select the first credential if any are available
+    if (savedCreds.length > 0) {
       const cred = savedCreds[0];
       onSelectCredential({
         id: cred.id,
@@ -119,15 +123,14 @@ export function useCredentialsInput({
         provider: credentials.provider,
         title: (cred as any).title,
       });
-    },
-    [
-      credentials,
-      selectedCredential?.id,
-      readOnly,
-      isOptional,
-      onSelectCredential,
-    ],
-  );
+    }
+  }, [
+    credentials,
+    selectedCredential?.id,
+    readOnly,
+    isOptional,
+    onSelectCredential,
+  ]);
 
   if (
     !credentials ||

autogpt_platform/frontend/src/components/molecules/Popover/Popover.tsx

@@ -1,33 +0,0 @@
-"use client";
-
-import * as PopoverPrimitive from "@radix-ui/react-popover";
-import * as React from "react";
-
-import { cn } from "@/lib/utils";
-
-const Popover = PopoverPrimitive.Root;
-
-const PopoverTrigger = PopoverPrimitive.Trigger;
-
-const PopoverAnchor = PopoverPrimitive.Anchor;
-
-const PopoverContent = React.forwardRef<
-  React.ElementRef<typeof PopoverPrimitive.Content>,
-  React.ComponentPropsWithoutRef<typeof PopoverPrimitive.Content>
->(({ className, align = "center", sideOffset = 4, ...props }, ref) => (
-  <PopoverPrimitive.Portal>
-    <PopoverPrimitive.Content
-      ref={ref}
-      align={align}
-      sideOffset={sideOffset}
-      className={cn(
-        "z-50 w-72 rounded-lg border border-zinc-200 bg-white p-4 text-zinc-900 shadow-md outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
-        className,
-      )}
-      {...props}
-    />
-  </PopoverPrimitive.Portal>
-));
-PopoverContent.displayName = PopoverPrimitive.Content.displayName;
-
-export { Popover, PopoverAnchor, PopoverContent, PopoverTrigger };

autogpt_platform/frontend/src/components/organisms/FloatingReviewsPanel/FloatingReviewsPanel.tsx

@@ -31,29 +31,6 @@ export function FloatingReviewsPanel({
       query: {
         enabled: !!(graphId && executionId),
         select: okData,
-        // Poll while execution is in progress to detect status changes
-        refetchInterval: (q) => {
-          // Note: refetchInterval callback receives raw data before select transform
-          const rawData = q.state.data as
-            | { status: number; data?: { status?: string } }
-            | undefined;
-          if (rawData?.status !== 200) return false;
-
-          const status = rawData?.data?.status;
-          if (!status) return false;
-
-          // Poll every 2 seconds while running or in review
-          if (
-            status === AgentExecutionStatus.RUNNING ||
-            status === AgentExecutionStatus.QUEUED ||
-            status === AgentExecutionStatus.INCOMPLETE ||
-            status === AgentExecutionStatus.REVIEW
-          ) {
-            return 2000;
-          }
-          return false;
-        },
-        refetchIntervalInBackground: true,
       },
     },
   );
@@ -63,27 +40,23 @@ export function FloatingReviewsPanel({
     useShallow((state) => state.graphExecutionStatus),
   );
 
-  // Determine if we should poll for pending reviews
-  const isInReviewStatus =
-    executionDetails?.status === AgentExecutionStatus.REVIEW ||
-    graphExecutionStatus === AgentExecutionStatus.REVIEW;
-
   const { pendingReviews, isLoading, refetch } = usePendingReviewsForExecution(
     executionId || "",
-    {
-      enabled: !!executionId,
-      // Poll every 2 seconds when in REVIEW status to catch new reviews
-      refetchInterval: isInReviewStatus ? 2000 : false,
-    },
   );
 
-  // Refetch pending reviews when execution status changes
   useEffect(() => {
-    if (executionId && executionDetails?.status) {
+    if (executionId) {
       refetch();
     }
   }, [executionDetails?.status, executionId, refetch]);
 
+  // Refetch when graph execution status changes to REVIEW
+  useEffect(() => {
+    if (graphExecutionStatus === AgentExecutionStatus.REVIEW && executionId) {
+      refetch();
+    }
+  }, [graphExecutionStatus, executionId, refetch]);
+
   if (
     !executionId ||
     (!isLoading &&

autogpt_platform/frontend/src/components/organisms/PendingReviewsList/PendingReviewsList.tsx

@@ -1,9 +1,8 @@
-import { useState, useCallback } from "react";
+import { useState } from "react";
 import { PendingHumanReviewModel } from "@/app/api/__generated__/models/pendingHumanReviewModel";
 import { PendingReviewCard } from "@/components/organisms/PendingReviewCard/PendingReviewCard";
 import { Text } from "@/components/atoms/Text/Text";
 import { Button } from "@/components/atoms/Button/Button";
-import { Switch } from "@/components/atoms/Switch/Switch";
 import { useToast } from "@/components/molecules/Toast/use-toast";
 import { ClockIcon, WarningIcon } from "@phosphor-icons/react";
 import { usePostV2ProcessReviewAction } from "@/app/api/__generated__/endpoints/executions/executions";
@@ -41,8 +40,6 @@ export function PendingReviewsList({
     "approve" | "reject" | null
   >(null);
 
-  const [autoApproveFuture, setAutoApproveFuture] = useState(false);
-
   const { toast } = useToast();
 
   const reviewActionMutation = usePostV2ProcessReviewAction({
@@ -95,26 +92,6 @@ export function PendingReviewsList({
     setReviewMessageMap((prev) => ({ ...prev, [nodeExecId]: message }));
   }
 
-  // Reset data to original values when toggling auto-approve
-  const handleAutoApproveFutureToggle = useCallback(
-    (enabled: boolean) => {
-      setAutoApproveFuture(enabled);
-      if (enabled) {
-        // Reset all data to original values
-        const originalData: Record<string, string> = {};
-        reviews.forEach((review) => {
-          originalData[review.node_exec_id] = JSON.stringify(
-            review.payload,
-            null,
-            2,
-          );
-        });
-        setReviewDataMap(originalData);
-      }
-    },
-    [reviews],
-  );
-
   function processReviews(approved: boolean) {
     if (reviews.length === 0) {
       toast({
@@ -132,31 +109,22 @@ export function PendingReviewsList({
       const reviewData = reviewDataMap[review.node_exec_id];
       const reviewMessage = reviewMessageMap[review.node_exec_id];
 
-      // When auto-approving future actions, send undefined (use original data)
-      // Otherwise, parse and send the edited data if available
-      let parsedData: any = undefined;
+      let parsedData: any = review.payload; // Default to original payload
 
-      if (!autoApproveFuture) {
-        // For regular approve/reject, use edited data if available
-        if (review.editable && reviewData) {
-          try {
-            parsedData = JSON.parse(reviewData);
-          } catch (error) {
-            toast({
-              title: "Invalid JSON",
-              description: `Please fix the JSON format in review for node ${review.node_exec_id}: ${error instanceof Error ? error.message : "Invalid syntax"}`,
-              variant: "destructive",
-            });
-            setPendingAction(null);
-            return;
-          }
-        } else {
-          // No edits, use original payload
-          parsedData = review.payload;
+      // Parse edited data if available and editable
+      if (review.editable && reviewData) {
+        try {
+          parsedData = JSON.parse(reviewData);
+        } catch (error) {
+          toast({
+            title: "Invalid JSON",
+            description: `Please fix the JSON format in review for node ${review.node_exec_id}: ${error instanceof Error ? error.message : "Invalid syntax"}`,
+            variant: "destructive",
+          });
+          setPendingAction(null);
+          return;
         }
       }
-      // When autoApproveFuture is true, parsedData stays undefined
-      // Backend will use the original payload stored in the database
 
       reviewItems.push({
         node_exec_id: review.node_exec_id,
@@ -169,7 +137,6 @@ export function PendingReviewsList({
     reviewActionMutation.mutate({
       data: {
         reviews: reviewItems,
-        auto_approve_future_actions: autoApproveFuture && approved,
       },
     });
   }
@@ -215,37 +182,21 @@ export function PendingReviewsList({
       <div className="space-y-7">
         {reviews.map((review) => (
           <PendingReviewCard
-            key={`${review.node_exec_id}-${autoApproveFuture}`}
+            key={review.node_exec_id}
             review={review}
             onReviewDataChange={handleReviewDataChange}
             onReviewMessageChange={handleReviewMessageChange}
             reviewMessage={reviewMessageMap[review.node_exec_id] || ""}
-            isDisabled={autoApproveFuture}
           />
         ))}
       </div>
 
-      <div className="space-y-4">
-        {/* Auto-approve toggle */}
-        <div className="flex items-center gap-3">
-          <Switch
-            checked={autoApproveFuture}
-            onCheckedChange={handleAutoApproveFutureToggle}
-            disabled={reviewActionMutation.isPending}
-          />
-          <Text variant="body" className="text-textBlack">
-            Auto-approve all future actions from these blocks
-          </Text>
-        </div>
+      <div className="space-y-7">
+        <Text variant="body" className="text-textGrey">
+          Note: Changes you make here apply only to this task
+        </Text>
 
-        {autoApproveFuture && (
-          <Text variant="small" className="text-amber-600">
-            Editing is disabled. Original data will be used for this and all
-            future reviews from these blocks.
-          </Text>
-        )}
-
-        <div className="flex flex-wrap gap-2">
+        <div className="flex gap-2">
           <Button
             onClick={() => processReviews(true)}
             disabled={reviewActionMutation.isPending || reviews.length === 0}
@@ -269,11 +220,6 @@ export function PendingReviewsList({
             Reject
           </Button>
         </div>
-
-        <Text variant="small" className="text-textGrey">
-          You can turn auto-approval on or off anytime in this agent&apos;s
-          settings.
-        </Text>
       </div>
     </div>
   );

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/LlmModelField/LlmModelField.tsx

@@ -1,92 +0,0 @@
-"use client";
-
-import {
-  descriptionId,
-  FieldProps,
-  getTemplate,
-  RJSFSchema,
-  titleId,
-} from "@rjsf/utils";
-import { useMemo } from "react";
-import { LlmModelPicker } from "./components/LlmModelPicker";
-import { LlmModelMetadataMap } from "./types";
-import { updateUiOption } from "../../helpers";
-
-type LlmModelSchema = RJSFSchema & {
-  llm_model_metadata?: LlmModelMetadataMap;
-};
-
-export function LlmModelField(props: FieldProps) {
-  const { schema, formData, onChange, disabled, readonly, fieldPathId } = props;
-
-  const metadata = useMemo(() => {
-    return (schema as LlmModelSchema)?.llm_model_metadata ?? {};
-  }, [schema]);
-
-  const models = useMemo(() => {
-    return Object.values(metadata);
-  }, [metadata]);
-
-  const selectedName =
-    typeof formData === "string"
-      ? formData
-      : typeof schema.default === "string"
-        ? schema.default
-        : "";
-
-  const selectedModel = selectedName
-    ? (metadata[selectedName] ??
-      models.find((model) => model.name === selectedName))
-    : undefined;
-
-  const recommendedName =
-    typeof schema.default === "string" ? schema.default : models[0]?.name;
-
-  const recommendedModel =
-    recommendedName && metadata[recommendedName]
-      ? metadata[recommendedName]
-      : undefined;
-
-  if (models.length === 0) {
-    return null;
-  }
-
-  const TitleFieldTemplate = getTemplate("TitleFieldTemplate", props.registry);
-  const DescriptionFieldTemplate = getTemplate(
-    "DescriptionFieldTemplate",
-    props.registry,
-  );
-
-  const updatedUiSchema = updateUiOption(props.uiSchema, {
-    showHandles: false,
-  });
-
-  return (
-    <>
-      <div className="flex items-center gap-2">
-        <TitleFieldTemplate
-          id={titleId(fieldPathId)}
-          title={schema.title || ""}
-          required={true}
-          schema={schema}
-          uiSchema={updatedUiSchema}
-          registry={props.registry}
-        />
-        <DescriptionFieldTemplate
-          id={descriptionId(fieldPathId)}
-          description={schema.description || ""}
-          schema={schema}
-          registry={props.registry}
-        />
-      </div>
-
-      <LlmModelPicker
-        models={models}
-        selectedModel={selectedModel}
-        recommendedModel={recommendedModel}
-        onSelect={(value) => onChange(value, fieldPathId?.path)}
-        disabled={disabled || readonly}
-      />
-    </>
-  );
-}

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/LlmModelField/components/LlmIcon.tsx

@@ -1,66 +0,0 @@
-"use client";
-
-import Image from "next/image";
-import { Text } from "@/components/atoms/Text/Text";
-
-const creatorIconMap: Record<string, string> = {
-  anthropic: "/integrations/anthropic-color.png",
-  openai: "/integrations/openai.png",
-  google: "/integrations/gemini.png",
-  nvidia: "/integrations/nvidia.png",
-  groq: "/integrations/groq.png",
-  ollama: "/integrations/ollama.png",
-  openrouter: "/integrations/open_router.png",
-  v0: "/integrations/v0.png",
-  xai: "/integrations/xai.webp",
-  meta: "/integrations/llama_api.png",
-  amazon: "/integrations/amazon.png",
-  cohere: "/integrations/cohere.png",
-  deepseek: "/integrations/deepseek.png",
-  gryphe: "/integrations/gryphe.png",
-  microsoft: "/integrations/microsoft.webp",
-  moonshotai: "/integrations/moonshot.png",
-  mistral: "/integrations/mistral.png",
-  mistralai: "/integrations/mistral.png",
-  nousresearch: "/integrations/nousresearch.avif",
-  perplexity: "/integrations/perplexity.webp",
-  qwen: "/integrations/qwen.png",
-};
-
-type Props = {
-  value: string;
-  size?: number;
-};
-
-export function LlmIcon({ value, size = 20 }: Props) {
-  const normalized = value.trim().toLowerCase().replace(/\s+/g, "");
-  const src = creatorIconMap[normalized];
-  if (src) {
-    return (
-      <div
-        className="flex items-center justify-center overflow-hidden rounded-xsmall"
-        style={{ width: size, height: size }}
-      >
-        <Image
-          src={src}
-          alt={value}
-          width={size}
-          height={size}
-          className="h-full w-full object-cover"
-        />
-      </div>
-    );
-  }
-
-  const fallback = value?.trim().slice(0, 1).toUpperCase() || "?";
-  return (
-    <div
-      className="flex items-center justify-center rounded-xsmall bg-zinc-100"
-      style={{ width: size, height: size }}
-    >
-      <Text variant="small" className="text-zinc-500">
-        {fallback}
-      </Text>
-    </div>
-  );
-}

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/LlmModelField/components/LlmMenuHeader.tsx

@@ -1,24 +0,0 @@
-"use client";
-
-import { ArrowLeftIcon } from "@phosphor-icons/react";
-import { Text } from "@/components/atoms/Text/Text";
-
-type Props = {
-  label: string;
-  onBack: () => void;
-};
-
-export function LlmMenuHeader({ label, onBack }: Props) {
-  return (
-    <button
-      type="button"
-      onClick={onBack}
-      className="flex w-full items-center gap-2 px-2 py-2 text-left hover:bg-zinc-100"
-    >
-      <ArrowLeftIcon className="h-4 w-4 text-zinc-800" weight="bold" />
-      <Text variant="body" className="text-zinc-900">
-        {label}
-      </Text>
-    </button>
-  );
-}

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/LlmModelField/components/LlmMenuItem.tsx

@@ -1,61 +0,0 @@
-"use client";
-
-import { CaretRightIcon, CheckIcon } from "@phosphor-icons/react";
-import { Text } from "@/components/atoms/Text/Text";
-import { cn } from "@/lib/utils";
-
-type Props = {
-  title: string;
-  subtitle?: string;
-  icon?: React.ReactNode;
-  showChevron?: boolean;
-  rightSlot?: React.ReactNode;
-  onClick: () => void;
-  isActive?: boolean;
-};
-
-export function LlmMenuItem({
-  title,
-  subtitle,
-  icon,
-  showChevron,
-  rightSlot,
-  onClick,
-  isActive,
-}: Props) {
-  const hasIcon = Boolean(icon);
-
-  return (
-    <button
-      type="button"
-      onClick={onClick}
-      className={cn("w-full py-1 pl-2 pr-4 text-left hover:bg-zinc-100")}
-    >
-      <div className="flex items-center justify-between gap-3">
-        <div className="flex items-center gap-2">
-          {icon}
-          <Text variant="body" className="text-zinc-900">
-            {title}
-          </Text>
-        </div>
-        <div className="flex items-center gap-2">
-          {isActive && (
-            <CheckIcon className="h-4 w-4 text-emerald-600" weight="bold" />
-          )}
-          {rightSlot}
-          {showChevron && (
-            <CaretRightIcon className="h-4 w-4 text-zinc-900" weight="bold" />
-          )}
-        </div>
-      </div>
-      {subtitle && (
-        <Text
-          variant="small"
-          className={cn("mb-1 text-zinc-500", hasIcon && "pl-0")}
-        >
-          {subtitle}
-        </Text>
-      )}
-    </button>
-  );
-}

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/LlmModelField/components/LlmModelPicker.tsx

@@ -1,235 +0,0 @@
-"use client";
-
-import { useCallback, useEffect, useMemo, useState } from "react";
-import { CaretDownIcon } from "@phosphor-icons/react";
-import {
-  Popover,
-  PopoverContent,
-  PopoverTrigger,
-} from "@/components/molecules/Popover/Popover";
-import { Text } from "@/components/atoms/Text/Text";
-import { cn } from "@/lib/utils";
-import {
-  getCreatorDisplayName,
-  getModelDisplayName,
-  getProviderDisplayName,
-  groupByCreator,
-  groupByTitle,
-} from "../helpers";
-import { LlmModelMetadata } from "../types";
-import { LlmIcon } from "./LlmIcon";
-import { LlmMenuHeader } from "./LlmMenuHeader";
-import { LlmMenuItem } from "./LlmMenuItem";
-import { LlmPriceTier } from "./LlmPriceTier";
-
-type MenuView = "creator" | "model" | "provider";
-
-type Props = {
-  models: LlmModelMetadata[];
-  selectedModel?: LlmModelMetadata;
-  recommendedModel?: LlmModelMetadata;
-  onSelect: (value: string) => void;
-  disabled?: boolean;
-};
-
-export function LlmModelPicker({
-  models,
-  selectedModel,
-  recommendedModel,
-  onSelect,
-  disabled,
-}: Props) {
-  const [open, setOpen] = useState(false);
-  const [view, setView] = useState<MenuView>("creator");
-  const [activeCreator, setActiveCreator] = useState<string | null>(null);
-  const [activeTitle, setActiveTitle] = useState<string | null>(null);
-
-  const modelsByCreator = useMemo(() => groupByCreator(models), [models]);
-
-  const creators = useMemo(() => {
-    return Array.from(modelsByCreator.keys()).sort((a, b) =>
-      a.localeCompare(b),
-    );
-  }, [modelsByCreator]);
-
-  const creatorIconValues = useMemo(() => {
-    const map = new Map<string, string>();
-    for (const [creator, entries] of modelsByCreator.entries()) {
-      map.set(creator, entries[0]?.creator ?? creator);
-    }
-    return map;
-  }, [modelsByCreator]);
-
-  useEffect(() => {
-    if (!open) {
-      return;
-    }
-    setView("creator");
-    setActiveCreator(
-      selectedModel
-        ? getCreatorDisplayName(selectedModel)
-        : (creators[0] ?? null),
-    );
-    setActiveTitle(selectedModel ? getModelDisplayName(selectedModel) : null);
-  }, [open, selectedModel, creators]);
-
-  const currentCreator = activeCreator ?? creators[0] ?? null;
-
-  const currentModels = useMemo(() => {
-    return currentCreator ? (modelsByCreator.get(currentCreator) ?? []) : [];
-  }, [currentCreator, modelsByCreator]);
-
-  const currentCreatorIcon = useMemo(() => {
-    return currentModels[0]?.creator ?? currentCreator;
-  }, [currentModels, currentCreator]);
-
-  const modelsByTitle = useMemo(
-    () => groupByTitle(currentModels),
-    [currentModels],
-  );
-
-  const modelEntries = useMemo(() => {
-    return Array.from(modelsByTitle.entries())
-      .map(([title, entries]) => {
-        const providers = new Set(entries.map((entry) => entry.provider));
-        return {
-          title,
-          entries,
-          providerCount: providers.size,
-        };
-      })
-      .sort((a, b) => a.title.localeCompare(b.title));
-  }, [modelsByTitle]);
-
-  const providerEntries = useMemo(() => {
-    if (!activeTitle) {
-      return [];
-    }
-    return modelsByTitle.get(activeTitle) ?? [];
-  }, [activeTitle, modelsByTitle]);
-
-  const handleSelectModel = useCallback(
-    (modelName: string) => {
-      onSelect(modelName);
-      setOpen(false);
-    },
-    [onSelect],
-  );
-
-  const triggerModel = selectedModel ?? recommendedModel ?? models[0];
-  const triggerTitle = triggerModel
-    ? getModelDisplayName(triggerModel)
-    : "Select model";
-  const triggerCreator = triggerModel?.creator ?? "";
-
-  return (
-    <Popover open={open} onOpenChange={setOpen}>
-      <PopoverTrigger asChild>
-        <button
-          type="button"
-          disabled={disabled}
-          className={cn(
-            "flex w-full min-w-[15rem] items-center rounded-lg border border-zinc-200 bg-white px-3 py-2 text-left",
-            "hover:border-zinc-300 focus:outline-none focus:ring-2 focus:ring-zinc-200",
-            disabled && "cursor-not-allowed opacity-60",
-          )}
-        >
-          <LlmIcon value={triggerCreator} />
-          <Text variant="body" className="ml-1 flex-1 text-zinc-900">
-            {triggerTitle}
-          </Text>
-          <CaretDownIcon className="h-3 w-3 text-zinc-900" weight="bold" />
-        </button>
-      </PopoverTrigger>
-      <PopoverContent
-        align="start"
-        sideOffset={4}
-        className="max-h-[45vh] w-[--radix-popover-trigger-width] min-w-[16rem] overflow-y-auto rounded-md border border-zinc-200 bg-white p-0 shadow-[0px_1px_4px_rgba(12,12,13,0.12)]"
-      >
-        {view === "creator" && (
-          <div className="flex flex-col">
-            {recommendedModel && (
-              <>
-                <LlmMenuItem
-                  title={getModelDisplayName(recommendedModel)}
-                  subtitle="Recommended"
-                  icon={<LlmIcon value={recommendedModel.creator} />}
-                  onClick={() => handleSelectModel(recommendedModel.name)}
-                />
-                <div className="border-b border-zinc-200" />
-              </>
-            )}
-            {creators.map((creator) => (
-              <LlmMenuItem
-                key={creator}
-                title={creator}
-                icon={
-                  <LlmIcon value={creatorIconValues.get(creator) ?? creator} />
-                }
-                showChevron={true}
-                isActive={
-                  selectedModel
-                    ? getCreatorDisplayName(selectedModel) === creator
-                    : false
-                }
-                onClick={() => {
-                  setActiveCreator(creator);
-                  setView("model");
-                }}
-              />
-            ))}
-          </div>
-        )}
-        {view === "model" && currentCreator && (
-          <div className="flex flex-col">
-            <LlmMenuHeader
-              label={currentCreator}
-              onBack={() => setView("creator")}
-            />
-            <div className="border-b border-zinc-200" />
-            {modelEntries.map((entry) => (
-              <LlmMenuItem
-                key={entry.title}
-                title={entry.title}
-                icon={<LlmIcon value={currentCreatorIcon} />}
-                rightSlot={<LlmPriceTier tier={entry.entries[0]?.price_tier} />}
-                showChevron={entry.providerCount > 1}
-                isActive={
-                  selectedModel
-                    ? getModelDisplayName(selectedModel) === entry.title
-                    : false
-                }
-                onClick={() => {
-                  if (entry.providerCount > 1) {
-                    setActiveTitle(entry.title);
-                    setView("provider");
-                    return;
-                  }
-                  handleSelectModel(entry.entries[0].name);
-                }}
-              />
-            ))}
-          </div>
-        )}
-        {view === "provider" && activeTitle && (
-          <div className="flex flex-col">
-            <LlmMenuHeader
-              label={activeTitle}
-              onBack={() => setView("model")}
-            />
-            <div className="border-b border-zinc-200" />
-            {providerEntries.map((entry) => (
-              <LlmMenuItem
-                key={`${entry.title}-${entry.provider}`}
-                title={getProviderDisplayName(entry)}
-                icon={<LlmIcon value={entry.provider} />}
-                isActive={selectedModel?.provider === entry.provider}
-                onClick={() => handleSelectModel(entry.name)}
-              />
-            ))}
-          </div>
-        )}
-      </PopoverContent>
-    </Popover>
-  );
-}

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/LlmModelField/components/LlmPriceTier.tsx

@@ -1,25 +0,0 @@
-"use client";
-
-import { CurrencyDollarSimpleIcon } from "@phosphor-icons/react";
-
-type Props = {
-  tier?: number;
-};
-
-export function LlmPriceTier({ tier }: Props) {
-  if (!tier || tier <= 0) {
-    return null;
-  }
-  const clamped = Math.min(3, Math.max(1, tier));
-  return (
-    <div className="flex items-center text-zinc-900">
-      {Array.from({ length: clamped }).map((_, index) => (
-        <CurrencyDollarSimpleIcon
-          key={`price-${index}`}
-          className="-mr-0.5 h-3 w-3"
-          weight="bold"
-        />
-      ))}
-    </div>
-  );
-}

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/LlmModelField/helpers.ts

@@ -1,35 +0,0 @@
-import { LlmModelMetadata } from "./types";
-
-export function groupByCreator(models: LlmModelMetadata[]) {
-  const map = new Map<string, LlmModelMetadata[]>();
-  for (const model of models) {
-    const key = getCreatorDisplayName(model);
-    const existing = map.get(key) ?? [];
-    existing.push(model);
-    map.set(key, existing);
-  }
-  return map;
-}
-
-export function groupByTitle(models: LlmModelMetadata[]) {
-  const map = new Map<string, LlmModelMetadata[]>();
-  for (const model of models) {
-    const displayName = getModelDisplayName(model);
-    const existing = map.get(displayName) ?? [];
-    existing.push(model);
-    map.set(displayName, existing);
-  }
-  return map;
-}
-
-export function getCreatorDisplayName(model: LlmModelMetadata): string {
-  return model.creator_name || model.creator || "";
-}
-
-export function getModelDisplayName(model: LlmModelMetadata): string {
-  return model.title || model.name || "";
-}
-
-export function getProviderDisplayName(model: LlmModelMetadata): string {
-  return model.provider_name || model.provider || "";
-}

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/LlmModelField/types.ts

@@ -1,11 +0,0 @@
-export type LlmModelMetadata = {
-  creator: string;
-  creator_name: string;
-  title: string;
-  provider: string;
-  provider_name: string;
-  name: string;
-  price_tier?: number;
-};
-
-export type LlmModelMetadataMap = Record<string, LlmModelMetadata>;

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/custom-registry.ts

@@ -8,7 +8,6 @@ import {
   isMultiSelectSchema,
 } from "../utils/schema-utils";
 import { TableField } from "./TableField/TableField";
-import { LlmModelField } from "./LlmModelField/LlmModelField";
 
 export interface CustomFieldDefinition {
   id: string;
@@ -58,15 +57,6 @@ export const CUSTOM_FIELDS: CustomFieldDefinition[] = [
     },
     component: TableField,
   },
-  {
-    id: "custom/llm_model_field",
-    matcher: (schema: any) => {
-      return (
-        typeof schema === "object" && schema !== null && "llm_model" in schema
-      );
-    },
-    component: LlmModelField,
-  },
 ];
 
 export function findCustomFieldId(schema: any): string | null {

autogpt_platform/frontend/src/hooks/useAgentSafeMode.ts

@@ -20,15 +20,11 @@ function hasHITLBlocks(graph: GraphModel | LibraryAgent | Graph): boolean {
   if ("has_human_in_the_loop" in graph) {
     return !!graph.has_human_in_the_loop;
   }
-  return false;
-}
 
-function hasSensitiveActionBlocks(
-  graph: GraphModel | LibraryAgent | Graph,
-): boolean {
-  if ("has_sensitive_action" in graph) {
-    return !!graph.has_sensitive_action;
+  if (isLibraryAgent(graph)) {
+    return graph.settings?.human_in_the_loop_safe_mode !== null;
   }
+
   return false;
 }
 
@@ -44,9 +40,7 @@ export function useAgentSafeMode(graph: GraphModel | LibraryAgent | Graph) {
 
   const graphId = getGraphId(graph);
   const isAgent = isLibraryAgent(graph);
-  const showHITLToggle = hasHITLBlocks(graph);
-  const showSensitiveActionToggle = hasSensitiveActionBlocks(graph);
-  const shouldShowToggle = showHITLToggle || showSensitiveActionToggle;
+  const shouldShowToggle = hasHITLBlocks(graph);
 
   const { mutateAsync: updateGraphSettings, isPending } =
     usePatchV1UpdateGraphSettings();
@@ -62,37 +56,27 @@ export function useAgentSafeMode(graph: GraphModel | LibraryAgent | Graph) {
     },
   );
 
-  const [localHITLSafeMode, setLocalHITLSafeMode] = useState<boolean>(true);
-  const [localSensitiveActionSafeMode, setLocalSensitiveActionSafeMode] =
-    useState<boolean>(false);
-  const [isLocalStateLoaded, setIsLocalStateLoaded] = useState<boolean>(false);
+  const [localSafeMode, setLocalSafeMode] = useState<boolean | null>(null);
 
   useEffect(() => {
     if (!isAgent && libraryAgent) {
-      setLocalHITLSafeMode(
-        libraryAgent.settings?.human_in_the_loop_safe_mode ?? true,
-      );
-      setLocalSensitiveActionSafeMode(
-        libraryAgent.settings?.sensitive_action_safe_mode ?? false,
-      );
-      setIsLocalStateLoaded(true);
+      const backendValue = libraryAgent.settings?.human_in_the_loop_safe_mode;
+      if (backendValue !== undefined) {
+        setLocalSafeMode(backendValue);
+      }
     }
   }, [isAgent, libraryAgent]);
 
-  const currentHITLSafeMode = isAgent
-    ? (graph.settings?.human_in_the_loop_safe_mode ?? true)
-    : localHITLSafeMode;
+  const currentSafeMode = isAgent
+    ? graph.settings?.human_in_the_loop_safe_mode
+    : localSafeMode;
 
-  const currentSensitiveActionSafeMode = isAgent
-    ? (graph.settings?.sensitive_action_safe_mode ?? false)
-    : localSensitiveActionSafeMode;
+  const isStateUndetermined = isAgent
+    ? graph.settings?.human_in_the_loop_safe_mode == null
+    : isLoading || localSafeMode === null;
 
-  const isHITLStateUndetermined = isAgent
-    ? false
-    : isLoading || !isLocalStateLoaded;
-
-  const handleHITLToggle = useCallback(async () => {
-    const newSafeMode = !currentHITLSafeMode;
+  const handleToggle = useCallback(async () => {
+    const newSafeMode = !currentSafeMode;
 
     try {
       await updateGraphSettings({
@@ -101,7 +85,7 @@ export function useAgentSafeMode(graph: GraphModel | LibraryAgent | Graph) {
       });
 
       if (!isAgent) {
-        setLocalHITLSafeMode(newSafeMode);
+        setLocalSafeMode(newSafeMode);
       }
 
       if (isAgent) {
@@ -117,62 +101,37 @@ export function useAgentSafeMode(graph: GraphModel | LibraryAgent | Graph) {
       queryClient.invalidateQueries({ queryKey: ["v2", "executions"] });
 
       toast({
-        title: `HITL safe mode ${newSafeMode ? "enabled" : "disabled"}`,
+        title: `Safe mode ${newSafeMode ? "enabled" : "disabled"}`,
         description: newSafeMode
           ? "Human-in-the-loop blocks will require manual review"
           : "Human-in-the-loop blocks will proceed automatically",
         duration: 2000,
       });
     } catch (error) {
-      handleToggleError(error, isAgent, toast);
-    }
-  }, [
-    currentHITLSafeMode,
-    graphId,
-    isAgent,
-    graph.id,
-    updateGraphSettings,
-    queryClient,
-    toast,
-  ]);
+      const isNotFoundError =
+        error instanceof Error &&
+        (error.message.includes("404") || error.message.includes("not found"));
 
-  const handleSensitiveActionToggle = useCallback(async () => {
-    const newSafeMode = !currentSensitiveActionSafeMode;
-
-    try {
-      await updateGraphSettings({
-        graphId,
-        data: { sensitive_action_safe_mode: newSafeMode },
-      });
-
-      if (!isAgent) {
-        setLocalSensitiveActionSafeMode(newSafeMode);
-      }
-
-      if (isAgent) {
-        queryClient.invalidateQueries({
-          queryKey: getGetV2GetLibraryAgentQueryOptions(graph.id.toString())
-            .queryKey,
+      if (!isAgent && isNotFoundError) {
+        toast({
+          title: "Safe mode not available",
+          description:
+            "To configure safe mode, please save this graph to your library first.",
+          variant: "destructive",
+        });
+      } else {
+        toast({
+          title: "Failed to update safe mode",
+          description:
+            error instanceof Error
+              ? error.message
+              : "An unexpected error occurred.",
+          variant: "destructive",
         });
       }
-
-      queryClient.invalidateQueries({
-        queryKey: ["v1", "graphs", graphId, "executions"],
-      });
-      queryClient.invalidateQueries({ queryKey: ["v2", "executions"] });
-
-      toast({
-        title: `Sensitive action safe mode ${newSafeMode ? "enabled" : "disabled"}`,
-        description: newSafeMode
-          ? "Sensitive action blocks will require manual review"
-          : "Sensitive action blocks will proceed automatically",
-        duration: 2000,
-      });
-    } catch (error) {
-      handleToggleError(error, isAgent, toast);
     }
   }, [
-    currentSensitiveActionSafeMode,
+    currentSafeMode,
     graphId,
     isAgent,
     graph.id,
@@ -182,53 +141,11 @@ export function useAgentSafeMode(graph: GraphModel | LibraryAgent | Graph) {
   ]);
 
   return {
-    // HITL safe mode
-    currentHITLSafeMode,
-    showHITLToggle,
-    isHITLStateUndetermined,
-    handleHITLToggle,
-
-    // Sensitive action safe mode
-    currentSensitiveActionSafeMode,
-    showSensitiveActionToggle,
-    handleSensitiveActionToggle,
-
-    // General
+    currentSafeMode,
     isPending,
     shouldShowToggle,
-
-    // Backwards compatibility
-    currentSafeMode: currentHITLSafeMode,
-    isStateUndetermined: isHITLStateUndetermined,
-    handleToggle: handleHITLToggle,
-    hasHITLBlocks: showHITLToggle,
+    isStateUndetermined,
+    handleToggle,
+    hasHITLBlocks: shouldShowToggle,
   };
 }
-
-function handleToggleError(
-  error: unknown,
-  isAgent: boolean,
-  toast: ReturnType<typeof useToast>["toast"],
-) {
-  const isNotFoundError =
-    error instanceof Error &&
-    (error.message.includes("404") || error.message.includes("not found"));
-
-  if (!isAgent && isNotFoundError) {
-    toast({
-      title: "Safe mode not available",
-      description:
-        "To configure safe mode, please save this graph to your library first.",
-      variant: "destructive",
-    });
-  } else {
-    toast({
-      title: "Failed to update safe mode",
-      description:
-        error instanceof Error
-          ? error.message
-          : "An unexpected error occurred.",
-      variant: "destructive",
-    });
-  }
-}

autogpt_platform/frontend/src/hooks/usePendingReviews.ts

@@ -15,22 +15,8 @@ export function usePendingReviews() {
   };
 }
 
-interface UsePendingReviewsForExecutionOptions {
-  enabled?: boolean;
-  refetchInterval?: number | false;
-}
-
-export function usePendingReviewsForExecution(
-  graphExecId: string,
-  options?: UsePendingReviewsForExecutionOptions,
-) {
-  const query = useGetV2GetPendingReviewsForExecution(graphExecId, {
-    query: {
-      enabled: options?.enabled ?? !!graphExecId,
-      refetchInterval: options?.refetchInterval,
-      refetchIntervalInBackground: !!options?.refetchInterval,
-    },
-  });
+export function usePendingReviewsForExecution(graphExecId: string) {
+  const query = useGetV2GetPendingReviewsForExecution(graphExecId);
 
   return {
     pendingReviews: okData(query.data) || [],

autogpt_platform/frontend/src/lib/timezone-utils.ts

@@ -106,14 +106,9 @@ export function getTimezoneDisplayName(timezone: string): string {
     const parts = timezone.split("/");
     const city = parts[parts.length - 1].replace(/_/g, " ");
     const abbr = getTimezoneAbbreviation(timezone);
-    if (abbr && abbr !== timezone) {
-      return `${city} (${abbr})`;
-    }
-    // If abbreviation is same as timezone or not found, show timezone with underscores replaced
-    const timezoneDisplay = timezone.replace(/_/g, " ");
-    return `${city} (${timezoneDisplay})`;
+    return abbr ? `${city} (${abbr})` : city;
   } catch {
-    return timezone.replace(/_/g, " ");
+    return timezone;
   }
 }
 

autogpt_platform/frontend/src/services/storage/local-storage.ts

@@ -10,7 +10,6 @@ export enum Key {
   LIBRARY_AGENTS_CACHE = "library-agents-cache",
   CHAT_SESSION_ID = "chat_session_id",
   COOKIE_CONSENT = "autogpt_cookie_consent",
-  AI_AGENT_SAFETY_POPUP_SHOWN = "ai-agent-safety-popup-shown",
 }
 
 function get(key: Key) {

autogpt_platform/frontend/src/tests/marketplace.spec.ts

@@ -4,7 +4,6 @@ import { LoginPage } from "./pages/login.page";
 import { MarketplacePage } from "./pages/marketplace.page";
 import { hasMinCount, hasUrl, isVisible, matchesUrl } from "./utils/assertion";
 
-// Marketplace tests for store agent search functionality
 test.describe("Marketplace – Basic Functionality", () => {
   test("User can access marketplace page when logged out", async ({ page }) => {
     const marketplacePage = new MarketplacePage(page);