fix(backend): sort imports alphabetically in run_agent.py

Co-authored-by: Nicholas Tindle <ntindle@users.noreply.github.com>

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

@@ -28,7 +28,6 @@ from backend.executor.manager import get_db_async_client
 from backend.util.settings import Settings
 
 logger = logging.getLogger(__name__)
-settings = Settings()
 
 
 class ExecutionAnalyticsRequest(BaseModel):
@@ -64,8 +63,6 @@ class ExecutionAnalyticsResult(BaseModel):
     score: Optional[float]
     status: str  # "success", "failed", "skipped"
     error_message: Optional[str] = None
-    started_at: Optional[datetime] = None
-    ended_at: Optional[datetime] = None
 
 
 class ExecutionAnalyticsResponse(BaseModel):
@@ -227,6 +224,11 @@ async def generate_execution_analytics(
     )
 
     try:
+        # Validate model configuration
+        settings = Settings()
+        if not settings.secrets.openai_internal_api_key:
+            raise HTTPException(status_code=500, detail="OpenAI API key not configured")
+
         # Get database client
         db_client = get_db_async_client()
 
@@ -318,8 +320,6 @@ async def generate_execution_analytics(
                     ),
                     status="skipped",
                     error_message=None,  # Not an error - just already processed
-                    started_at=execution.started_at,
-                    ended_at=execution.ended_at,
                 )
             )
 
@@ -349,9 +349,6 @@ async def _process_batch(
 ) -> list[ExecutionAnalyticsResult]:
     """Process a batch of executions concurrently."""
 
-    if not settings.secrets.openai_internal_api_key:
-        raise HTTPException(status_code=500, detail="OpenAI API key not configured")
-
     async def process_single_execution(execution) -> ExecutionAnalyticsResult:
         try:
             # Generate activity status and score using the specified model
@@ -390,8 +387,6 @@ async def _process_batch(
                     score=None,
                     status="skipped",
                     error_message="Activity generation returned None",
-                    started_at=execution.started_at,
-                    ended_at=execution.ended_at,
                 )
 
             # Update the execution stats
@@ -421,8 +416,6 @@ async def _process_batch(
                 summary_text=activity_response["activity_status"],
                 score=activity_response["correctness_score"],
                 status="success",
-                started_at=execution.started_at,
-                ended_at=execution.ended_at,
             )
 
         except Exception as e:
@@ -436,8 +429,6 @@ async def _process_batch(
                 score=None,
                 status="failed",
                 error_message=str(e),
-                started_at=execution.started_at,
-                ended_at=execution.ended_at,
             )
 
     # Process all executions in the batch concurrently

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

@@ -1,251 +0,0 @@
-import logging
-
-import autogpt_libs.auth
-import fastapi
-import fastapi.responses
-
-import backend.api.features.store.db as store_db
-import backend.api.features.store.model as store_model
-
-logger = logging.getLogger(__name__)
-
-router = fastapi.APIRouter(
-    prefix="/admin/waitlist",
-    tags=["store", "admin", "waitlist"],
-    dependencies=[fastapi.Security(autogpt_libs.auth.requires_admin_user)],
-)
-
-
-@router.post(
-    "",
-    summary="Create Waitlist",
-    response_model=store_model.WaitlistAdminResponse,
-)
-async def create_waitlist(
-    request: store_model.WaitlistCreateRequest,
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
-):
-    """
-    Create a new waitlist (admin only).
-
-    Args:
-        request: Waitlist creation details
-        user_id: Authenticated admin user creating the waitlist
-
-    Returns:
-        WaitlistAdminResponse with the created waitlist details
-    """
-    try:
-        waitlist = await store_db.create_waitlist_admin(
-            admin_user_id=user_id,
-            data=request,
-        )
-        return waitlist
-    except Exception as e:
-        logger.exception("Error creating waitlist: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while creating the waitlist"},
-        )
-
-
-@router.get(
-    "",
-    summary="List All Waitlists",
-    response_model=store_model.WaitlistAdminListResponse,
-)
-async def list_waitlists():
-    """
-    Get all waitlists with admin details (admin only).
-
-    Returns:
-        WaitlistAdminListResponse with all waitlists
-    """
-    try:
-        return await store_db.get_waitlists_admin()
-    except Exception as e:
-        logger.exception("Error listing waitlists: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while fetching waitlists"},
-        )
-
-
-@router.get(
-    "/{waitlist_id}",
-    summary="Get Waitlist Details",
-    response_model=store_model.WaitlistAdminResponse,
-)
-async def get_waitlist(
-    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
-):
-    """
-    Get a single waitlist with admin details (admin only).
-
-    Args:
-        waitlist_id: ID of the waitlist to retrieve
-
-    Returns:
-        WaitlistAdminResponse with waitlist details
-    """
-    try:
-        return await store_db.get_waitlist_admin(waitlist_id)
-    except ValueError:
-        logger.warning("Waitlist not found: %s", waitlist_id)
-        return fastapi.responses.JSONResponse(
-            status_code=404,
-            content={"detail": "Waitlist not found"},
-        )
-    except Exception as e:
-        logger.exception("Error fetching waitlist: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while fetching the waitlist"},
-        )
-
-
-@router.put(
-    "/{waitlist_id}",
-    summary="Update Waitlist",
-    response_model=store_model.WaitlistAdminResponse,
-)
-async def update_waitlist(
-    request: store_model.WaitlistUpdateRequest,
-    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
-):
-    """
-    Update a waitlist (admin only).
-
-    Args:
-        waitlist_id: ID of the waitlist to update
-        request: Fields to update
-
-    Returns:
-        WaitlistAdminResponse with updated waitlist details
-    """
-    try:
-        return await store_db.update_waitlist_admin(waitlist_id, request)
-    except ValueError:
-        logger.warning("Waitlist not found for update: %s", waitlist_id)
-        return fastapi.responses.JSONResponse(
-            status_code=404,
-            content={"detail": "Waitlist not found"},
-        )
-    except Exception as e:
-        logger.exception("Error updating waitlist: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while updating the waitlist"},
-        )
-
-
-@router.delete(
-    "/{waitlist_id}",
-    summary="Delete Waitlist",
-)
-async def delete_waitlist(
-    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
-):
-    """
-    Soft delete a waitlist (admin only).
-
-    Args:
-        waitlist_id: ID of the waitlist to delete
-
-    Returns:
-        Success message
-    """
-    try:
-        await store_db.delete_waitlist_admin(waitlist_id)
-        return {"message": "Waitlist deleted successfully"}
-    except ValueError:
-        logger.warning(f"Waitlist not found for deletion: {waitlist_id}")
-        return fastapi.responses.JSONResponse(
-            status_code=404,
-            content={"detail": "Waitlist not found"},
-        )
-    except Exception as e:
-        logger.exception("Error deleting waitlist: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while deleting the waitlist"},
-        )
-
-
-@router.get(
-    "/{waitlist_id}/signups",
-    summary="Get Waitlist Signups",
-    response_model=store_model.WaitlistSignupListResponse,
-)
-async def get_waitlist_signups(
-    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
-):
-    """
-    Get all signups for a waitlist (admin only).
-
-    Args:
-        waitlist_id: ID of the waitlist
-
-    Returns:
-        WaitlistSignupListResponse with all signups
-    """
-    try:
-        return await store_db.get_waitlist_signups_admin(waitlist_id)
-    except ValueError:
-        logger.warning("Waitlist not found for signups: %s", waitlist_id)
-        return fastapi.responses.JSONResponse(
-            status_code=404,
-            content={"detail": "Waitlist not found"},
-        )
-    except Exception as e:
-        logger.exception("Error fetching waitlist signups: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while fetching waitlist signups"},
-        )
-
-
-@router.post(
-    "/{waitlist_id}/link",
-    summary="Link Waitlist to Store Listing",
-    response_model=store_model.WaitlistAdminResponse,
-)
-async def link_waitlist_to_listing(
-    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist"),
-    store_listing_id: str = fastapi.Body(
-        ..., embed=True, description="The ID of the store listing"
-    ),
-):
-    """
-    Link a waitlist to a store listing (admin only).
-
-    When the linked store listing is approved/published, waitlist users
-    will be automatically notified.
-
-    Args:
-        waitlist_id: ID of the waitlist
-        store_listing_id: ID of the store listing to link
-
-    Returns:
-        WaitlistAdminResponse with updated waitlist details
-    """
-    try:
-        return await store_db.link_waitlist_to_listing_admin(
-            waitlist_id, store_listing_id
-        )
-    except ValueError:
-        logger.warning(
-            "Link failed - waitlist or listing not found: %s, %s",
-            waitlist_id,
-            store_listing_id,
-        )
-        return fastapi.responses.JSONResponse(
-            status_code=404,
-            content={"detail": "Waitlist or store listing not found"},
-        )
-    except Exception as e:
-        logger.exception("Error linking waitlist to listing: %s", e)
-        return fastapi.responses.JSONResponse(
-            status_code=500,
-            content={"detail": "An error occurred while linking the waitlist"},
-        )

autogpt_platform/backend/backend/api/features/chat/tools/run_agent.py

@@ -32,7 +32,7 @@ from .models import (
     UserReadiness,
 )
 from .utils import (
-    check_user_has_required_credentials,
+    build_missing_credentials_from_graph,
     extract_credentials_from_schema,
     fetch_graph_from_store_slug,
     get_or_create_library_agent,
@@ -235,15 +235,13 @@ class RunAgentTool(BaseTool):
                 # Return credentials needed response with input data info
                 # The UI handles credential setup automatically, so the message
                 # focuses on asking about input data
-                credentials = extract_credentials_from_schema(
-                    graph.credentials_input_schema
+                requirements_creds_dict = build_missing_credentials_from_graph(
+                    graph, None
                 )
-                missing_creds_check = await check_user_has_required_credentials(
-                    user_id, credentials
+                missing_credentials_dict = build_missing_credentials_from_graph(
+                    graph, graph_credentials
                 )
-                missing_credentials_dict = {
-                    c.id: c.model_dump() for c in missing_creds_check
-                }
+                requirements_creds_list = list(requirements_creds_dict.values())
 
                 return SetupRequirementsResponse(
                     message=self._build_inputs_message(graph, MSG_WHAT_VALUES_TO_USE),
@@ -257,7 +255,7 @@ class RunAgentTool(BaseTool):
                             ready_to_run=False,
                         ),
                         requirements={
-                            "credentials": [c.model_dump() for c in credentials],
+                            "credentials": requirements_creds_list,
                             "inputs": self._get_inputs_list(graph.input_schema),
                             "execution_modes": self._get_execution_modes(graph),
                         },

autogpt_platform/backend/backend/api/features/chat/tools/run_block.py

@@ -20,6 +20,7 @@ from .models import (
     ToolResponseBase,
     UserReadiness,
 )
+from .utils import build_missing_credentials_from_field_info
 
 logger = logging.getLogger(__name__)
 
@@ -186,7 +187,11 @@ class RunBlockTool(BaseTool):
 
         if missing_credentials:
             # Return setup requirements response with missing credentials
-            missing_creds_dict = {c.id: c.model_dump() for c in missing_credentials}
+            credentials_fields_info = block.input_schema.get_credentials_fields_info()
+            missing_creds_dict = build_missing_credentials_from_field_info(
+                credentials_fields_info, set(matched_credentials.keys())
+            )
+            missing_creds_list = list(missing_creds_dict.values())
 
             return SetupRequirementsResponse(
                 message=(
@@ -203,7 +208,7 @@ class RunBlockTool(BaseTool):
                         ready_to_run=False,
                     ),
                     requirements={
-                        "credentials": [c.model_dump() for c in missing_credentials],
+                        "credentials": missing_creds_list,
                         "inputs": self._get_inputs_list(block),
                         "execution_modes": ["immediate"],
                     },

autogpt_platform/backend/backend/api/features/chat/tools/utils.py

@@ -8,7 +8,7 @@ from backend.api.features.library import model as library_model
 from backend.api.features.store import db as store_db
 from backend.data import graph as graph_db
 from backend.data.graph import GraphModel
-from backend.data.model import CredentialsMetaInput
+from backend.data.model import CredentialsFieldInfo, CredentialsMetaInput
 from backend.integrations.creds_manager import IntegrationCredentialsManager
 from backend.util.exceptions import NotFoundError
 
@@ -89,6 +89,59 @@ def extract_credentials_from_schema(
     return credentials
 
 
+def _serialize_missing_credential(
+    field_key: str, field_info: CredentialsFieldInfo
+) -> dict[str, Any]:
+    """
+    Convert credential field info into a serializable dict that preserves all supported
+    credential types (e.g., api_key + oauth2) so the UI can offer multiple options.
+    """
+    supported_types = sorted(field_info.supported_types)
+    provider = next(iter(field_info.provider), "unknown")
+    scopes = sorted(field_info.required_scopes or [])
+
+    return {
+        "id": field_key,
+        "title": field_key.replace("_", " ").title(),
+        "provider": provider,
+        "provider_name": provider.replace("_", " ").title(),
+        "type": supported_types[0] if supported_types else "api_key",
+        "types": supported_types,
+        "scopes": scopes,
+    }
+
+
+def build_missing_credentials_from_graph(
+    graph: GraphModel, matched_credentials: dict[str, CredentialsMetaInput] | None
+) -> dict[str, Any]:
+    """
+    Build a missing_credentials mapping from a graph's aggregated credentials inputs,
+    preserving all supported credential types for each field.
+    """
+    matched_keys = set(matched_credentials.keys()) if matched_credentials else set()
+    aggregated_fields = graph.aggregate_credentials_inputs()
+
+    return {
+        field_key: _serialize_missing_credential(field_key, field_info)
+        for field_key, (field_info, _node_fields) in aggregated_fields.items()
+        if field_key not in matched_keys
+    }
+
+
+def build_missing_credentials_from_field_info(
+    credential_fields: dict[str, CredentialsFieldInfo],
+    matched_keys: set[str],
+) -> dict[str, Any]:
+    """
+    Build missing_credentials mapping from a simple credentials field info dictionary.
+    """
+    return {
+        field_key: _serialize_missing_credential(field_key, field_info)
+        for field_key, field_info in credential_fields.items()
+        if field_key not in matched_keys
+    }
+
+
 def extract_credentials_as_dict(
     credentials_input_schema: dict[str, Any] | None,
 ) -> dict[str, CredentialsMetaInput]:

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

@@ -22,7 +22,6 @@ from backend.data.notifications import (
     AgentApprovalData,
     AgentRejectionData,
     NotificationEventModel,
-    WaitlistLaunchData,
 )
 from backend.notifications.notifications import queue_notification_async
 from backend.util.exceptions import DatabaseError
@@ -1718,29 +1717,6 @@ async def review_store_submission(
                 # Don't fail the review process if email sending fails
                 pass
 
-        # Notify waitlist users if this is an approval and has a linked waitlist
-        if is_approved and submission.StoreListing:
-            try:
-                frontend_base_url = (
-                    settings.config.frontend_base_url
-                    or settings.config.platform_base_url
-                )
-                store_agent = (
-                    await prisma.models.StoreAgent.prisma().find_first_or_raise(
-                        where={"storeListingVersionId": submission.id}
-                    )
-                )
-                creator_username = store_agent.creator_username or "unknown"
-                store_url = f"{frontend_base_url}/marketplace/agent/{creator_username}/{store_agent.slug}"
-                await notify_waitlist_users_on_launch(
-                    store_listing_id=submission.StoreListing.id,
-                    agent_name=submission.name,
-                    store_url=store_url,
-                )
-            except Exception as e:
-                logger.error(f"Failed to notify waitlist users on agent approval: {e}")
-                # Don't fail the approval process
-
         # Convert to Pydantic model for consistency
         return store_model.StoreSubmission(
             listing_id=(submission.StoreListing.id if submission.StoreListing else ""),
@@ -1988,552 +1964,3 @@ async def get_agent_as_admin(
         )
 
     return graph
-
-
-def _waitlist_to_store_entry(
-    waitlist: prisma.models.WaitlistEntry,
-) -> store_model.StoreWaitlistEntry:
-    """Convert a WaitlistEntry to StoreWaitlistEntry for public display."""
-    return store_model.StoreWaitlistEntry(
-        waitlistId=waitlist.id,
-        slug=waitlist.slug,
-        name=waitlist.name,
-        subHeading=waitlist.subHeading,
-        videoUrl=waitlist.videoUrl,
-        agentOutputDemoUrl=waitlist.agentOutputDemoUrl,
-        imageUrls=waitlist.imageUrls or [],
-        description=waitlist.description,
-        categories=waitlist.categories,
-    )
-
-
-async def get_waitlist() -> list[store_model.StoreWaitlistEntry]:
-    """Get all active waitlists for public display."""
-    try:
-        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
-            where=prisma.types.WaitlistEntryWhereInput(isDeleted=False),
-        )
-
-        # Filter out closed/done waitlists and sort by votes (descending)
-        excluded_statuses = {
-            prisma.enums.WaitlistExternalStatus.CANCELED,
-            prisma.enums.WaitlistExternalStatus.DONE,
-        }
-        active_waitlists = [w for w in waitlists if w.status not in excluded_statuses]
-        sorted_list = sorted(active_waitlists, key=lambda x: x.votes, reverse=True)
-
-        return [_waitlist_to_store_entry(w) for w in sorted_list]
-    except Exception as e:
-        logger.error(f"Error fetching waitlists: {e}")
-        raise DatabaseError("Failed to fetch waitlists") from e
-
-
-async def get_user_waitlist_memberships(user_id: str) -> list[str]:
-    """Get all waitlist IDs that a user has joined."""
-    try:
-        user = await prisma.models.User.prisma().find_unique(
-            where={"id": user_id},
-            include={"joinedWaitlists": True},
-        )
-        if not user or not user.joinedWaitlists:
-            return []
-        return [w.id for w in user.joinedWaitlists]
-    except Exception as e:
-        logger.error(f"Error fetching user waitlist memberships: {e}")
-        raise DatabaseError("Failed to fetch waitlist memberships") from e
-
-
-async def add_user_to_waitlist(
-    waitlist_id: str, user_id: str | None, email: str | None
-) -> store_model.StoreWaitlistEntry:
-    """
-    Add a user to a waitlist.
-
-    For logged-in users: connects via joinedUsers relation
-    For anonymous users: adds email to unaffiliatedEmailUsers array
-    """
-    if not user_id and not email:
-        raise ValueError("Either user_id or email must be provided")
-
-    try:
-        # Find the waitlist
-        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id},
-            include={"joinedUsers": True},
-        )
-
-        if not waitlist:
-            raise ValueError(f"Waitlist {waitlist_id} not found")
-
-        if waitlist.isDeleted:
-            raise ValueError(f"Waitlist {waitlist_id} is no longer available")
-
-        if waitlist.status in [
-            prisma.enums.WaitlistExternalStatus.CANCELED,
-            prisma.enums.WaitlistExternalStatus.DONE,
-        ]:
-            raise ValueError(f"Waitlist {waitlist_id} is closed")
-
-        if user_id:
-            # Check if user already joined
-            joined_user_ids = [u.id for u in (waitlist.joinedUsers or [])]
-            if user_id in joined_user_ids:
-                # Already joined - return waitlist info
-                logger.debug(f"User {user_id} already joined waitlist {waitlist_id}")
-            else:
-                # Connect user to waitlist
-                await prisma.models.WaitlistEntry.prisma().update(
-                    where={"id": waitlist_id},
-                    data={"joinedUsers": {"connect": [{"id": user_id}]}},
-                )
-                logger.info(f"User {user_id} joined waitlist {waitlist_id}")
-
-            # If user was previously in email list, remove them
-            # Use transaction to prevent race conditions
-            if email:
-                async with transaction() as tx:
-                    current_waitlist = await tx.waitlistentry.find_unique(
-                        where={"id": waitlist_id}
-                    )
-                    if current_waitlist and email in (
-                        current_waitlist.unaffiliatedEmailUsers or []
-                    ):
-                        updated_emails: list[str] = [
-                            e
-                            for e in (current_waitlist.unaffiliatedEmailUsers or [])
-                            if e != email
-                        ]
-                        await tx.waitlistentry.update(
-                            where={"id": waitlist_id},
-                            data={"unaffiliatedEmailUsers": updated_emails},
-                        )
-        elif email:
-            # Add email to unaffiliated list if not already present
-            # Use transaction to prevent race conditions with concurrent signups
-            async with transaction() as tx:
-                # Re-fetch within transaction to get latest state
-                current_waitlist = await tx.waitlistentry.find_unique(
-                    where={"id": waitlist_id}
-                )
-                if current_waitlist:
-                    current_emails: list[str] = list(
-                        current_waitlist.unaffiliatedEmailUsers or []
-                    )
-                    if email not in current_emails:
-                        current_emails.append(email)
-                        await tx.waitlistentry.update(
-                            where={"id": waitlist_id},
-                            data={"unaffiliatedEmailUsers": current_emails},
-                        )
-                        logger.info(f"Email {email} added to waitlist {waitlist_id}")
-                    else:
-                        logger.debug(f"Email {email} already on waitlist {waitlist_id}")
-
-        # Re-fetch to return updated data
-        updated_waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id}
-        )
-        return _waitlist_to_store_entry(updated_waitlist or waitlist)
-
-    except ValueError:
-        raise
-    except Exception as e:
-        logger.error(f"Error adding user to waitlist: {e}")
-        raise DatabaseError("Failed to add user to waitlist") from e
-
-
-# ============== Admin Waitlist Functions ==============
-
-
-def _waitlist_to_admin_response(
-    waitlist: prisma.models.WaitlistEntry,
-) -> store_model.WaitlistAdminResponse:
-    """Convert a WaitlistEntry to WaitlistAdminResponse."""
-    joined_count = len(waitlist.joinedUsers) if waitlist.joinedUsers else 0
-    email_count = (
-        len(waitlist.unaffiliatedEmailUsers) if waitlist.unaffiliatedEmailUsers else 0
-    )
-
-    return store_model.WaitlistAdminResponse(
-        id=waitlist.id,
-        createdAt=waitlist.createdAt.isoformat() if waitlist.createdAt else "",
-        updatedAt=waitlist.updatedAt.isoformat() if waitlist.updatedAt else "",
-        slug=waitlist.slug,
-        name=waitlist.name,
-        subHeading=waitlist.subHeading,
-        description=waitlist.description,
-        categories=waitlist.categories,
-        imageUrls=waitlist.imageUrls or [],
-        videoUrl=waitlist.videoUrl,
-        agentOutputDemoUrl=waitlist.agentOutputDemoUrl,
-        status=waitlist.status or prisma.enums.WaitlistExternalStatus.NOT_STARTED,
-        votes=waitlist.votes,
-        signupCount=joined_count + email_count,
-        storeListingId=waitlist.storeListingId,
-        owningUserId=waitlist.owningUserId,
-    )
-
-
-async def create_waitlist_admin(
-    admin_user_id: str,
-    data: store_model.WaitlistCreateRequest,
-) -> store_model.WaitlistAdminResponse:
-    """Create a new waitlist (admin only)."""
-    logger.info(f"Admin {admin_user_id} creating waitlist: {data.name}")
-
-    try:
-        waitlist = await prisma.models.WaitlistEntry.prisma().create(
-            data=prisma.types.WaitlistEntryCreateInput(
-                name=data.name,
-                slug=data.slug,
-                subHeading=data.subHeading,
-                description=data.description,
-                categories=data.categories,
-                imageUrls=data.imageUrls,
-                videoUrl=data.videoUrl,
-                agentOutputDemoUrl=data.agentOutputDemoUrl,
-                owningUserId=admin_user_id,
-                status=prisma.enums.WaitlistExternalStatus.NOT_STARTED,
-            ),
-            include={"joinedUsers": True},
-        )
-
-        return _waitlist_to_admin_response(waitlist)
-    except Exception as e:
-        logger.error(f"Error creating waitlist: {e}")
-        raise DatabaseError("Failed to create waitlist") from e
-
-
-async def get_waitlists_admin() -> store_model.WaitlistAdminListResponse:
-    """Get all waitlists with admin details."""
-    try:
-        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
-            where=prisma.types.WaitlistEntryWhereInput(isDeleted=False),
-            include={"joinedUsers": True},
-            order={"createdAt": "desc"},
-        )
-
-        return store_model.WaitlistAdminListResponse(
-            waitlists=[_waitlist_to_admin_response(w) for w in waitlists],
-            totalCount=len(waitlists),
-        )
-    except Exception as e:
-        logger.error(f"Error fetching waitlists for admin: {e}")
-        raise DatabaseError("Failed to fetch waitlists") from e
-
-
-async def get_waitlist_admin(
-    waitlist_id: str,
-) -> store_model.WaitlistAdminResponse:
-    """Get a single waitlist with admin details."""
-    try:
-        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id},
-            include={"joinedUsers": True},
-        )
-
-        if not waitlist:
-            raise ValueError(f"Waitlist {waitlist_id} not found")
-
-        if waitlist.isDeleted:
-            raise ValueError(f"Waitlist {waitlist_id} has been deleted")
-
-        return _waitlist_to_admin_response(waitlist)
-    except ValueError:
-        raise
-    except Exception as e:
-        logger.error(f"Error fetching waitlist {waitlist_id}: {e}")
-        raise DatabaseError("Failed to fetch waitlist") from e
-
-
-async def update_waitlist_admin(
-    waitlist_id: str,
-    data: store_model.WaitlistUpdateRequest,
-) -> store_model.WaitlistAdminResponse:
-    """Update a waitlist (admin only)."""
-    logger.info(f"Updating waitlist {waitlist_id}")
-
-    try:
-        # Check if waitlist exists first
-        existing = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id}
-        )
-
-        if not existing:
-            raise ValueError(f"Waitlist {waitlist_id} not found")
-
-        if existing.isDeleted:
-            raise ValueError(f"Waitlist {waitlist_id} has been deleted")
-
-        # Build update data from explicitly provided fields
-        # Use model_fields_set to allow clearing fields by setting them to None
-        field_mappings = {
-            "name": data.name,
-            "slug": data.slug,
-            "subHeading": data.subHeading,
-            "description": data.description,
-            "categories": data.categories,
-            "imageUrls": data.imageUrls,
-            "videoUrl": data.videoUrl,
-            "agentOutputDemoUrl": data.agentOutputDemoUrl,
-            "storeListingId": data.storeListingId,
-        }
-        update_data: dict[str, Any] = {
-            k: v for k, v in field_mappings.items() if k in data.model_fields_set
-        }
-
-        # Add status if provided (already validated as enum by Pydantic)
-        if "status" in data.model_fields_set and data.status is not None:
-            update_data["status"] = data.status
-
-        if not update_data:
-            # No updates, just return current data
-            return await get_waitlist_admin(waitlist_id)
-
-        waitlist = await prisma.models.WaitlistEntry.prisma().update(
-            where={"id": waitlist_id},
-            data=prisma.types.WaitlistEntryUpdateInput(**update_data),
-            include={"joinedUsers": True},
-        )
-
-        # We already verified existence above, so this should never be None
-        assert waitlist is not None
-        return _waitlist_to_admin_response(waitlist)
-    except ValueError:
-        raise
-    except Exception as e:
-        logger.error(f"Error updating waitlist {waitlist_id}: {e}")
-        raise DatabaseError("Failed to update waitlist") from e
-
-
-async def delete_waitlist_admin(waitlist_id: str) -> None:
-    """Soft delete a waitlist (admin only)."""
-    logger.info(f"Soft deleting waitlist {waitlist_id}")
-
-    try:
-        # Check if waitlist exists first
-        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id},
-        )
-
-        if not waitlist:
-            raise ValueError(f"Waitlist {waitlist_id} not found")
-
-        if waitlist.isDeleted:
-            raise ValueError(f"Waitlist {waitlist_id} has already been deleted")
-
-        await prisma.models.WaitlistEntry.prisma().update(
-            where={"id": waitlist_id},
-            data={"isDeleted": True},
-        )
-    except ValueError:
-        raise
-    except Exception as e:
-        logger.error(f"Error deleting waitlist {waitlist_id}: {e}")
-        raise DatabaseError("Failed to delete waitlist") from e
-
-
-async def get_waitlist_signups_admin(
-    waitlist_id: str,
-) -> store_model.WaitlistSignupListResponse:
-    """Get all signups for a waitlist (admin only)."""
-    try:
-        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id},
-            include={"joinedUsers": True},
-        )
-
-        if not waitlist:
-            raise ValueError(f"Waitlist {waitlist_id} not found")
-
-        signups: list[store_model.WaitlistSignup] = []
-
-        # Add user signups
-        for user in waitlist.joinedUsers or []:
-            signups.append(
-                store_model.WaitlistSignup(
-                    type="user",
-                    userId=user.id,
-                    email=user.email,
-                    username=user.name,
-                )
-            )
-
-        # Add email signups
-        for email in waitlist.unaffiliatedEmailUsers or []:
-            signups.append(
-                store_model.WaitlistSignup(
-                    type="email",
-                    email=email,
-                )
-            )
-
-        return store_model.WaitlistSignupListResponse(
-            waitlistId=waitlist_id,
-            signups=signups,
-            totalCount=len(signups),
-        )
-    except ValueError:
-        raise
-    except Exception as e:
-        logger.error(f"Error fetching signups for waitlist {waitlist_id}: {e}")
-        raise DatabaseError("Failed to fetch waitlist signups") from e
-
-
-async def link_waitlist_to_listing_admin(
-    waitlist_id: str,
-    store_listing_id: str,
-) -> store_model.WaitlistAdminResponse:
-    """Link a waitlist to a store listing (admin only)."""
-    logger.info(f"Linking waitlist {waitlist_id} to listing {store_listing_id}")
-
-    try:
-        # Verify the waitlist exists
-        waitlist = await prisma.models.WaitlistEntry.prisma().find_unique(
-            where={"id": waitlist_id}
-        )
-
-        if not waitlist:
-            raise ValueError(f"Waitlist {waitlist_id} not found")
-
-        if waitlist.isDeleted:
-            raise ValueError(f"Waitlist {waitlist_id} has been deleted")
-
-        # Verify the store listing exists
-        listing = await prisma.models.StoreListing.prisma().find_unique(
-            where={"id": store_listing_id}
-        )
-
-        if not listing:
-            raise ValueError(f"Store listing {store_listing_id} not found")
-
-        updated_waitlist = await prisma.models.WaitlistEntry.prisma().update(
-            where={"id": waitlist_id},
-            data={"StoreListing": {"connect": {"id": store_listing_id}}},
-            include={"joinedUsers": True},
-        )
-
-        # We already verified existence above, so this should never be None
-        assert updated_waitlist is not None
-        return _waitlist_to_admin_response(updated_waitlist)
-    except ValueError:
-        raise
-    except Exception as e:
-        logger.error(f"Error linking waitlist to listing: {e}")
-        raise DatabaseError("Failed to link waitlist to listing") from e
-
-
-async def notify_waitlist_users_on_launch(
-    store_listing_id: str,
-    agent_name: str,
-    store_url: str,
-) -> int:
-    """
-    Notify all users on waitlists linked to a store listing when the agent is launched.
-
-    Args:
-        store_listing_id: The ID of the store listing that was approved
-        agent_name: The name of the approved agent
-        store_url: The URL to the agent's store page
-
-    Returns:
-        The number of notifications sent
-    """
-    logger.info(f"Notifying waitlist users for store listing {store_listing_id}")
-
-    try:
-        # Find all active waitlists linked to this store listing
-        # Exclude DONE and CANCELED to prevent duplicate notifications on re-approval
-        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
-            where={
-                "storeListingId": store_listing_id,
-                "isDeleted": False,
-                "status": {
-                    "not_in": [
-                        prisma.enums.WaitlistExternalStatus.DONE,
-                        prisma.enums.WaitlistExternalStatus.CANCELED,
-                    ]
-                },
-            },
-            include={"joinedUsers": True},
-        )
-
-        if not waitlists:
-            logger.info(
-                f"No active waitlists found for store listing {store_listing_id}"
-            )
-            return 0
-
-        notification_count = 0
-        launched_at = datetime.now(tz=timezone.utc)
-
-        for waitlist in waitlists:
-            # Track notification results for this waitlist
-            users_to_notify = waitlist.joinedUsers or []
-            failed_user_ids: list[str] = []
-
-            # Notify registered users
-            for user in users_to_notify:
-                try:
-                    notification_data = WaitlistLaunchData(
-                        agent_name=agent_name,
-                        waitlist_name=waitlist.name,
-                        store_url=store_url,
-                        launched_at=launched_at,
-                    )
-
-                    notification_event = NotificationEventModel[WaitlistLaunchData](
-                        user_id=user.id,
-                        type=prisma.enums.NotificationType.WAITLIST_LAUNCH,
-                        data=notification_data,
-                    )
-
-                    await queue_notification_async(notification_event)
-                    notification_count += 1
-                except Exception as e:
-                    logger.error(
-                        f"Failed to send waitlist launch notification to user {user.id}: {e}"
-                    )
-                    failed_user_ids.append(user.id)
-
-            # Note: For unaffiliated email users, you would need to send emails directly
-            # since they don't have user IDs for the notification system.
-            # This could be done via a separate email service.
-            # For now, we log these for potential manual follow-up or future implementation.
-            has_pending_email_users = bool(waitlist.unaffiliatedEmailUsers)
-            if has_pending_email_users:
-                logger.info(
-                    f"Waitlist {waitlist.id} has {len(waitlist.unaffiliatedEmailUsers)} "
-                    f"unaffiliated email users that need email notifications"
-                )
-
-            # Only mark waitlist as DONE if all registered user notifications succeeded
-            # AND there are no unaffiliated email users still waiting for notifications
-            if not failed_user_ids and not has_pending_email_users:
-                await prisma.models.WaitlistEntry.prisma().update(
-                    where={"id": waitlist.id},
-                    data={"status": prisma.enums.WaitlistExternalStatus.DONE},
-                )
-                logger.info(f"Updated waitlist {waitlist.id} status to DONE")
-            elif failed_user_ids:
-                logger.warning(
-                    f"Waitlist {waitlist.id} not marked as DONE due to "
-                    f"{len(failed_user_ids)} failed notifications"
-                )
-            elif has_pending_email_users:
-                logger.warning(
-                    f"Waitlist {waitlist.id} not marked as DONE due to "
-                    f"{len(waitlist.unaffiliatedEmailUsers)} pending email-only users"
-                )
-
-        logger.info(
-            f"Sent {notification_count} waitlist launch notifications for store listing {store_listing_id}"
-        )
-        return notification_count
-
-    except Exception as e:
-        logger.error(
-            f"Error notifying waitlist users for store listing {store_listing_id}: {e}"
-        )
-        # Don't raise - we don't want to fail the approval process
-        return 0

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

@@ -223,102 +223,6 @@ class ReviewSubmissionRequest(pydantic.BaseModel):
     internal_comments: str | None = None  # Private admin notes
 
 
-class StoreWaitlistEntry(pydantic.BaseModel):
-    """Public waitlist entry - no PII fields exposed."""
-
-    waitlistId: str
-    slug: str
-
-    # Content fields
-    name: str
-    subHeading: str
-    videoUrl: str | None = None
-    agentOutputDemoUrl: str | None = None
-    imageUrls: list[str]
-    description: str
-    categories: list[str]
-
-
-class StoreWaitlistsAllResponse(pydantic.BaseModel):
-    listings: list[StoreWaitlistEntry]
-
-
-# Admin Waitlist Models
-
-
-class WaitlistCreateRequest(pydantic.BaseModel):
-    """Request model for creating a new waitlist."""
-
-    name: str
-    slug: str
-    subHeading: str
-    description: str
-    categories: list[str] = []
-    imageUrls: list[str] = []
-    videoUrl: str | None = None
-    agentOutputDemoUrl: str | None = None
-
-
-class WaitlistUpdateRequest(pydantic.BaseModel):
-    """Request model for updating a waitlist."""
-
-    name: str | None = None
-    slug: str | None = None
-    subHeading: str | None = None
-    description: str | None = None
-    categories: list[str] | None = None
-    imageUrls: list[str] | None = None
-    videoUrl: str | None = None
-    agentOutputDemoUrl: str | None = None
-    status: prisma.enums.WaitlistExternalStatus | None = None
-    storeListingId: str | None = None  # Link to a store listing
-
-
-class WaitlistAdminResponse(pydantic.BaseModel):
-    """Admin response model with full waitlist details including internal data."""
-
-    id: str
-    createdAt: str
-    updatedAt: str
-    slug: str
-    name: str
-    subHeading: str
-    description: str
-    categories: list[str]
-    imageUrls: list[str]
-    videoUrl: str | None = None
-    agentOutputDemoUrl: str | None = None
-    status: prisma.enums.WaitlistExternalStatus
-    votes: int
-    signupCount: int  # Total count of joinedUsers + unaffiliatedEmailUsers
-    storeListingId: str | None = None
-    owningUserId: str
-
-
-class WaitlistSignup(pydantic.BaseModel):
-    """Individual signup entry for a waitlist."""
-
-    type: str  # "user" or "email"
-    userId: str | None = None
-    email: str | None = None
-    username: str | None = None  # For user signups
-
-
-class WaitlistSignupListResponse(pydantic.BaseModel):
-    """Response model for listing waitlist signups."""
-
-    waitlistId: str
-    signups: list[WaitlistSignup]
-    totalCount: int
-
-
-class WaitlistAdminListResponse(pydantic.BaseModel):
-    """Response model for listing all waitlists (admin view)."""
-
-    waitlists: list[WaitlistAdminResponse]
-    totalCount: int
-
-
 class UnifiedSearchResult(pydantic.BaseModel):
     """A single result from unified hybrid search across all content types."""
 

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

@@ -8,7 +8,6 @@ import autogpt_libs.auth
 import fastapi
 import fastapi.responses
 import prisma.enums
-from autogpt_libs.auth.dependencies import get_optional_user_id
 
 import backend.data.graph
 import backend.util.json
@@ -82,74 +81,6 @@ async def update_or_create_profile(
     return updated_profile
 
 
-##############################################
-############## Waitlist Endpoints ############
-##############################################
-@router.get(
-    "/waitlist",
-    summary="Get the agent waitlist",
-    tags=["store", "public"],
-    response_model=store_model.StoreWaitlistsAllResponse,
-)
-async def get_waitlist():
-    """
-    Get all active waitlists for public display.
-    """
-    waitlists = await store_db.get_waitlist()
-    return store_model.StoreWaitlistsAllResponse(listings=waitlists)
-
-
-@router.get(
-    "/waitlist/my-memberships",
-    summary="Get waitlist IDs the current user has joined",
-    tags=["store", "private"],
-)
-async def get_my_waitlist_memberships(
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
-) -> list[str]:
-    """Returns list of waitlist IDs the authenticated user has joined."""
-    return await store_db.get_user_waitlist_memberships(user_id)
-
-
-@router.post(
-    path="/waitlist/{waitlist_id}/join",
-    summary="Add self to the agent waitlist",
-    tags=["store", "public"],
-    response_model=store_model.StoreWaitlistEntry,
-)
-async def add_self_to_waitlist(
-    user_id: str | None = fastapi.Security(get_optional_user_id),
-    waitlist_id: str = fastapi.Path(..., description="The ID of the waitlist to join"),
-    email: str | None = fastapi.Body(
-        default=None, embed=True, description="Email address for unauthenticated users"
-    ),
-):
-    """
-    Add the current user to the agent waitlist.
-    """
-    if not user_id and not email:
-        raise fastapi.HTTPException(
-            status_code=400,
-            detail="Either user authentication or email address is required",
-        )
-
-    try:
-        waitlist_entry = await store_db.add_user_to_waitlist(
-            waitlist_id=waitlist_id, user_id=user_id, email=email
-        )
-        return waitlist_entry
-    except ValueError as e:
-        error_msg = str(e)
-        if "not found" in error_msg:
-            raise fastapi.HTTPException(status_code=404, detail="Waitlist not found")
-        # Waitlist exists but is closed or unavailable
-        raise fastapi.HTTPException(status_code=400, detail=error_msg)
-    except Exception:
-        raise fastapi.HTTPException(
-            status_code=500, detail="An error occurred while joining the waitlist"
-        )
-
-
 ##############################################
 ############### Agent Endpoints ##############
 ##############################################

autogpt_platform/backend/backend/api/rest_api.py

@@ -19,7 +19,6 @@ from prisma.errors import PrismaError
 import backend.api.features.admin.credit_admin_routes
 import backend.api.features.admin.execution_analytics_routes
 import backend.api.features.admin.store_admin_routes
-import backend.api.features.admin.waitlist_admin_routes
 import backend.api.features.builder
 import backend.api.features.builder.routes
 import backend.api.features.chat.routes as chat_routes
@@ -284,11 +283,6 @@ app.include_router(
     tags=["v2", "admin"],
     prefix="/api/store",
 )
-app.include_router(
-    backend.api.features.admin.waitlist_admin_routes.router,
-    tags=["v2", "admin"],
-    prefix="/api/store",
-)
 app.include_router(
     backend.api.features.admin.credit_admin_routes.router,
     tags=["v2", "admin"],

autogpt_platform/backend/backend/data/analytics.py

@@ -104,7 +104,7 @@ async def get_accuracy_trends_and_alerts(
             AND e."executionStatus" IN ('COMPLETED', 'FAILED', 'TERMINATED')
             {user_filter}
         GROUP BY DATE(e."createdAt")
-        HAVING COUNT(*) >= 1  -- Include all days with at least 1 execution
+        HAVING COUNT(*) >= 3  -- Need at least 3 executions per day
     ),
     trends AS (
         SELECT 

autogpt_platform/backend/backend/data/execution.py

@@ -153,14 +153,8 @@ class GraphExecutionMeta(BaseDbModel):
     nodes_input_masks: Optional[dict[str, BlockInput]]
     preset_id: Optional[str]
     status: ExecutionStatus
-    started_at: Optional[datetime] = Field(
-        None,
-        description="When execution started running. Null if not yet started (QUEUED).",
-    )
-    ended_at: Optional[datetime] = Field(
-        None,
-        description="When execution finished. Null if not yet completed (QUEUED, RUNNING, INCOMPLETE, REVIEW).",
-    )
+    started_at: datetime
+    ended_at: datetime
     is_shared: bool = False
     share_token: Optional[str] = None
 
@@ -235,8 +229,10 @@ class GraphExecutionMeta(BaseDbModel):
 
     @staticmethod
     def from_db(_graph_exec: AgentGraphExecution):
-        start_time = _graph_exec.startedAt
-        end_time = _graph_exec.endedAt
+        now = datetime.now(timezone.utc)
+        # TODO: make started_at and ended_at optional
+        start_time = _graph_exec.startedAt or _graph_exec.createdAt
+        end_time = _graph_exec.updatedAt or now
 
         try:
             stats = GraphExecutionStats.model_validate(_graph_exec.stats)
@@ -906,14 +902,6 @@ async def update_graph_execution_stats(
 
     if status:
         update_data["executionStatus"] = status
-        # Set endedAt when execution reaches a terminal status
-        terminal_statuses = [
-            ExecutionStatus.COMPLETED,
-            ExecutionStatus.FAILED,
-            ExecutionStatus.TERMINATED,
-        ]
-        if status in terminal_statuses:
-            update_data["endedAt"] = datetime.now(tz=timezone.utc)
 
     where_clause: AgentGraphExecutionWhereInput = {"id": graph_exec_id}
 

autogpt_platform/backend/backend/data/notifications.py

@@ -211,22 +211,6 @@ class AgentRejectionData(BaseNotificationData):
         return value
 
 
-class WaitlistLaunchData(BaseNotificationData):
-    """Notification data for when an agent from a waitlist is launched."""
-
-    agent_name: str
-    waitlist_name: str
-    store_url: str
-    launched_at: datetime
-
-    @field_validator("launched_at")
-    @classmethod
-    def validate_timezone(cls, value: datetime):
-        if value.tzinfo is None:
-            raise ValueError("datetime must have timezone information")
-        return value
-
-
 NotificationData = Annotated[
     Union[
         AgentRunData,
@@ -239,7 +223,6 @@ NotificationData = Annotated[
         DailySummaryData,
         RefundRequestData,
         BaseSummaryData,
-        WaitlistLaunchData,
     ],
     Field(discriminator="type"),
 ]
@@ -290,7 +273,6 @@ def get_notif_data_type(
         NotificationType.REFUND_PROCESSED: RefundRequestData,
         NotificationType.AGENT_APPROVED: AgentApprovalData,
         NotificationType.AGENT_REJECTED: AgentRejectionData,
-        NotificationType.WAITLIST_LAUNCH: WaitlistLaunchData,
     }[notification_type]
 
 
@@ -336,7 +318,6 @@ class NotificationTypeOverride:
             NotificationType.REFUND_PROCESSED: QueueType.ADMIN,
             NotificationType.AGENT_APPROVED: QueueType.IMMEDIATE,
             NotificationType.AGENT_REJECTED: QueueType.IMMEDIATE,
-            NotificationType.WAITLIST_LAUNCH: QueueType.IMMEDIATE,
         }
         return BATCHING_RULES.get(self.notification_type, QueueType.IMMEDIATE)
 
@@ -356,7 +337,6 @@ class NotificationTypeOverride:
             NotificationType.REFUND_PROCESSED: "refund_processed.html",
             NotificationType.AGENT_APPROVED: "agent_approved.html",
             NotificationType.AGENT_REJECTED: "agent_rejected.html",
-            NotificationType.WAITLIST_LAUNCH: "waitlist_launch.html",
         }[self.notification_type]
 
     @property
@@ -374,7 +354,6 @@ class NotificationTypeOverride:
             NotificationType.REFUND_PROCESSED: "Refund for ${{data.amount / 100}} to {{data.user_name}} has been processed",
             NotificationType.AGENT_APPROVED: "🎉 Your agent '{{data.agent_name}}' has been approved!",
             NotificationType.AGENT_REJECTED: "Your agent '{{data.agent_name}}' needs some updates",
-            NotificationType.WAITLIST_LAUNCH: "🚀 {{data.agent_name}} is now available!",
         }[self.notification_type]
 
 

autogpt_platform/backend/backend/integrations/credentials_store.py

@@ -96,9 +96,9 @@ jina_credentials = APIKeyCredentials(
 )
 unreal_credentials = APIKeyCredentials(
     id="66f20754-1b81-48e4-91d0-f4f0dd82145f",
-    provider="unreal_speech",
+    provider="unreal",
     api_key=SecretStr(settings.secrets.unreal_speech_api_key),
-    title="Use Credits for Unreal Speech",
+    title="Use Credits for Unreal",
     expires_at=None,
 )
 open_router_credentials = APIKeyCredentials(
@@ -216,14 +216,6 @@ webshare_proxy_credentials = UserPasswordCredentials(
     title="Use Credits for Webshare Proxy",
 )
 
-openweathermap_credentials = APIKeyCredentials(
-    id="8b3d4e5f-6a7b-8c9d-0e1f-2a3b4c5d6e7f",
-    provider="openweathermap",
-    api_key=SecretStr(settings.secrets.openweathermap_api_key),
-    title="Use Credits for OpenWeatherMap",
-    expires_at=None,
-)
-
 DEFAULT_CREDENTIALS = [
     ollama_credentials,
     revid_credentials,
@@ -251,7 +243,6 @@ DEFAULT_CREDENTIALS = [
     llama_api_credentials,
     v0_credentials,
     webshare_proxy_credentials,
-    openweathermap_credentials,
 ]
 
 SYSTEM_CREDENTIAL_IDS = {cred.id for cred in DEFAULT_CREDENTIALS}
@@ -355,17 +346,11 @@ class IntegrationCredentialsStore:
             all_credentials.append(zerobounce_credentials)
         if settings.secrets.google_maps_api_key:
             all_credentials.append(google_maps_credentials)
-        if settings.secrets.llama_api_key:
-            all_credentials.append(llama_api_credentials)
-        if settings.secrets.v0_api_key:
-            all_credentials.append(v0_credentials)
         if (
             settings.secrets.webshare_proxy_username
             and settings.secrets.webshare_proxy_password
         ):
             all_credentials.append(webshare_proxy_credentials)
-        if settings.secrets.openweathermap_api_key:
-            all_credentials.append(openweathermap_credentials)
         return all_credentials
 
     async def get_creds_by_id(

autogpt_platform/backend/backend/monitoring/late_execution_monitor.py

@@ -60,10 +60,8 @@ class LateExecutionMonitor:
         if not all_late_executions:
             return "No late executions detected."
 
-        # Sort by started time (oldest first), with None values (unstarted) first
-        all_late_executions.sort(
-            key=lambda x: x.started_at or datetime.min.replace(tzinfo=timezone.utc)
-        )
+        # Sort by created time (oldest first)
+        all_late_executions.sort(key=lambda x: x.started_at)
 
         num_total_late = len(all_late_executions)
         num_queued = len(queued_late_executions)
@@ -76,7 +74,7 @@ class LateExecutionMonitor:
         was_truncated = num_total_late > tuncate_size
 
         late_execution_details = [
-            f"* `Execution ID: {exec.id}, Graph ID: {exec.graph_id}v{exec.graph_version}, User ID: {exec.user_id}, Status: {exec.status}, Started At: {exec.started_at.isoformat() if exec.started_at else 'Not started'}`"
+            f"* `Execution ID: {exec.id}, Graph ID: {exec.graph_id}v{exec.graph_version}, User ID: {exec.user_id}, Status: {exec.status}, Created At: {exec.started_at.isoformat()}`"
             for exec in truncated_executions
         ]
 

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

@@ -1,59 +0,0 @@
-{# Waitlist Launch Notification Email Template #}
-{#
-  Template variables:
-  data.agent_name: the name of the launched agent
-  data.waitlist_name: the name of the waitlist the user joined
-  data.store_url: URL to view the agent in the store
-  data.launched_at: when the agent was launched
-
-  Subject: {{ data.agent_name }} is now available!
-#}
-
-{% block content %}
-<h1 style="color: #7c3aed; font-size: 32px; font-weight: 700; margin: 0 0 24px 0; text-align: center;">
-  The wait is over!
-</h1>
-
-<p style="color: #586069; font-size: 18px; text-align: center; margin: 0 0 24px 0;">
-  <strong>'{{ data.agent_name }}'</strong> is now live in the AutoGPT Store!
-</p>
-
-<div style="height: 32px; background: transparent;"></div>
-
-<div style="background: #f3e8ff; border: 1px solid #d8b4fe; border-radius: 8px; padding: 20px; margin: 0;">
-  <h3 style="color: #6b21a8; font-size: 16px; font-weight: 600; margin: 0 0 12px 0;">
-    You're one of the first to know!
-  </h3>
-  <p style="color: #6b21a8; margin: 0; font-size: 16px; line-height: 1.5;">
-    You signed up for the <strong>{{ data.waitlist_name }}</strong> waitlist, and we're excited to let you know that this agent is now ready for you to use.
-  </p>
-</div>
-
-<div style="height: 32px; background: transparent;"></div>
-
-<div style="text-align: center; margin: 24px 0;">
-  <a href="{{ data.store_url }}" style="display: inline-block; background: linear-gradient(135deg, #7c3aed 0%, #5b21b6 100%); color: white; text-decoration: none; padding: 14px 28px; border-radius: 6px; font-weight: 600; font-size: 16px;">
-    Get {{ data.agent_name }} Now
-  </a>
-</div>
-
-<div style="height: 32px; background: transparent;"></div>
-
-<div style="background: #d1ecf1; border: 1px solid #bee5eb; border-radius: 8px; padding: 20px; margin: 0;">
-  <h3 style="color: #0c5460; font-size: 16px; font-weight: 600; margin: 0 0 12px 0;">
-    What can you do now?
-  </h3>
-  <ul style="color: #0c5460; margin: 0; padding-left: 18px; font-size: 16px; line-height: 1.6;">
-    <li>Visit the store to learn more about what this agent can do</li>
-    <li>Install and start using the agent right away</li>
-    <li>Share it with others who might find it useful</li>
-  </ul>
-</div>
-
-<div style="height: 32px; background: transparent;"></div>
-
-<p style="color: #6a737d; font-size: 14px; text-align: center; margin: 24px 0;">
-  Thank you for helping us prioritize what to build! Your interest made this happen.
-</p>
-
-{% endblock %}

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

@@ -1,53 +0,0 @@
--- CreateEnum
-CREATE TYPE "WaitlistExternalStatus" AS ENUM ('DONE', 'NOT_STARTED', 'CANCELED', 'WORK_IN_PROGRESS');
-
--- AlterEnum
-ALTER TYPE "NotificationType" ADD VALUE 'WAITLIST_LAUNCH';
-
--- CreateTable
-CREATE TABLE "WaitlistEntry" (
-    "id" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-    "storeListingId" TEXT,
-    "owningUserId" TEXT NOT NULL,
-    "slug" TEXT NOT NULL,
-    "search" tsvector DEFAULT ''::tsvector,
-    "name" TEXT NOT NULL,
-    "subHeading" TEXT NOT NULL,
-    "videoUrl" TEXT,
-    "agentOutputDemoUrl" TEXT,
-    "imageUrls" TEXT[],
-    "description" TEXT NOT NULL,
-    "categories" TEXT[],
-    "status" "WaitlistExternalStatus" NOT NULL DEFAULT 'NOT_STARTED',
-    "votes" INTEGER NOT NULL DEFAULT 0,
-    "unaffiliatedEmailUsers" TEXT[] DEFAULT ARRAY[]::TEXT[],
-    "isDeleted" BOOLEAN NOT NULL DEFAULT false,
-
-    CONSTRAINT "WaitlistEntry_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "_joinedWaitlists" (
-    "A" TEXT NOT NULL,
-    "B" TEXT NOT NULL
-);
-
--- CreateIndex
-CREATE UNIQUE INDEX "_joinedWaitlists_AB_unique" ON "_joinedWaitlists"("A", "B");
-
--- CreateIndex
-CREATE INDEX "_joinedWaitlists_B_index" ON "_joinedWaitlists"("B");
-
--- AddForeignKey
-ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_storeListingId_fkey" FOREIGN KEY ("storeListingId") REFERENCES "StoreListing"("id") ON DELETE SET NULL ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_owningUserId_fkey" FOREIGN KEY ("owningUserId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "_joinedWaitlists" ADD CONSTRAINT "_joinedWaitlists_A_fkey" FOREIGN KEY ("A") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "_joinedWaitlists" ADD CONSTRAINT "_joinedWaitlists_B_fkey" FOREIGN KEY ("B") REFERENCES "WaitlistEntry"("id") ON DELETE CASCADE ON UPDATE CASCADE;

autogpt_platform/backend/migrations/20260113170839_add_ended_at_to_agent_graph_execution/migration.sql

@@ -1,8 +0,0 @@
--- AlterTable
-ALTER TABLE "AgentGraphExecution" ADD COLUMN "endedAt" TIMESTAMP(3);
-
--- Set endedAt to updatedAt for existing records with terminal status only
-UPDATE "AgentGraphExecution"
-SET "endedAt" = "updatedAt"
-WHERE "endedAt" IS NULL
-  AND "executionStatus" IN ('COMPLETED', 'FAILED', 'TERMINATED');

autogpt_platform/backend/schema.prisma

@@ -69,10 +69,6 @@ model User {
   OAuthAuthorizationCodes OAuthAuthorizationCode[]
   OAuthAccessTokens       OAuthAccessToken[]
   OAuthRefreshTokens      OAuthRefreshToken[]
-
-  // Waitlist relations
-  waitlistEntries       WaitlistEntry[]
-  joinedWaitlists       WaitlistEntry[] @relation("joinedWaitlists")
 }
 
 enum OnboardingStep {
@@ -299,7 +295,6 @@ enum NotificationType {
   REFUND_PROCESSED
   AGENT_APPROVED
   AGENT_REJECTED
-  WAITLIST_LAUNCH
 }
 
 model NotificationEvent {
@@ -455,7 +450,6 @@ model AgentGraphExecution {
   createdAt DateTime  @default(now())
   updatedAt DateTime? @updatedAt
   startedAt DateTime?
-  endedAt   DateTime?
 
   isDeleted Boolean @default(false)
 
@@ -906,8 +900,7 @@ model StoreListing {
   OwningUser   User   @relation(fields: [owningUserId], references: [id])
 
   // Relations
-  Versions        StoreListingVersion[] @relation("ListingVersions")
-  waitlistEntries WaitlistEntry[]
+  Versions StoreListingVersion[] @relation("ListingVersions")
 
   // Unique index on agentId to ensure only one listing per agent, regardless of number of versions the agent has.
   @@unique([agentGraphId])
@@ -1039,47 +1032,6 @@ model StoreListingReview {
   @@index([reviewByUserId])
 }
 
-enum WaitlistExternalStatus {
-  DONE
-  NOT_STARTED
-  CANCELED
-  WORK_IN_PROGRESS
-}
-
-model WaitlistEntry {
-  id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  storeListingId String?
-  StoreListing   StoreListing? @relation(fields: [storeListingId], references: [id], onDelete: SetNull)
-
-  owningUserId String
-  OwningUser   User   @relation(fields: [owningUserId], references: [id])
-
-  slug   String
-  search Unsupported("tsvector")? @default(dbgenerated("''::tsvector"))
-
-  // Content fields
-  name               String
-  subHeading         String
-  videoUrl           String?
-  agentOutputDemoUrl String?
-  imageUrls          String[]
-  description        String
-  categories         String[]
-
-  //Waitlist specific fields
-  status                 WaitlistExternalStatus @default(NOT_STARTED)
-  votes                  Int                    @default(0) // Hide from frontend api
-  joinedUsers            User[]                 @relation("joinedWaitlists")
-  // NOTE: DO NOT DOUBLE SEND TO THESE USERS, IF THEY HAVE SIGNED UP SINCE THEY MAY HAVE ALREADY RECEIVED AN EMAIL
-  // DOUBLE CHECK WHEN SENDING THAT THEY ARE NOT IN THE JOINED USERS LIST ALSO
-  unaffiliatedEmailUsers String[]               @default([])
-
-  isDeleted Boolean @default(false)
-}
-
 enum SubmissionStatus {
   DRAFT // Being prepared, not yet submitted
   PENDING // Submitted, awaiting review

autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/AnalyticsResultsTable.tsx

@@ -51,8 +51,6 @@ export function AnalyticsResultsTable({ results }: Props) {
       "Execution ID",
       "Status",
       "Score",
-      "Started At",
-      "Ended At",
       "Summary Text",
       "Error Message",
     ];
@@ -64,8 +62,6 @@ export function AnalyticsResultsTable({ results }: Props) {
       result.exec_id,
       result.status,
       result.score?.toString() || "",
-      result.started_at ? new Date(result.started_at).toLocaleString() : "",
-      result.ended_at ? new Date(result.ended_at).toLocaleString() : "",
       `"${(result.summary_text || "").replace(/"/g, '""')}"`, // Escape quotes in summary
       `"${(result.error_message || "").replace(/"/g, '""')}"`, // Escape quotes in error
     ]);
@@ -252,13 +248,15 @@ export function AnalyticsResultsTable({ results }: Props) {
                         )}
                       </td>
                       <td className="px-4 py-3">
-                        <Button
-                          variant="ghost"
-                          size="small"
-                          onClick={() => toggleRowExpansion(result.exec_id)}
-                        >
-                          <EyeIcon size={16} />
-                        </Button>
+                        {(result.summary_text || result.error_message) && (
+                          <Button
+                            variant="ghost"
+                            size="small"
+                            onClick={() => toggleRowExpansion(result.exec_id)}
+                          >
+                            <EyeIcon size={16} />
+                          </Button>
+                        )}
                       </td>
                     </tr>
 
@@ -266,44 +264,6 @@ export function AnalyticsResultsTable({ results }: Props) {
                       <tr>
                         <td colSpan={7} className="bg-gray-50 px-4 py-3">
                           <div className="space-y-3">
-                            {/* Timestamps section */}
-                            <div className="grid grid-cols-2 gap-4 border-b border-gray-200 pb-3">
-                              <div>
-                                <Text
-                                  variant="body"
-                                  className="text-xs font-medium text-gray-600"
-                                >
-                                  Started At:
-                                </Text>
-                                <Text
-                                  variant="body"
-                                  className="text-sm text-gray-700"
-                                >
-                                  {result.started_at
-                                    ? new Date(
-                                        result.started_at,
-                                      ).toLocaleString()
-                                    : "—"}
-                                </Text>
-                              </div>
-                              <div>
-                                <Text
-                                  variant="body"
-                                  className="text-xs font-medium text-gray-600"
-                                >
-                                  Ended At:
-                                </Text>
-                                <Text
-                                  variant="body"
-                                  className="text-sm text-gray-700"
-                                >
-                                  {result.ended_at
-                                    ? new Date(result.ended_at).toLocaleString()
-                                    : "—"}
-                                </Text>
-                              </div>
-                            </div>
-
                             {result.summary_text && (
                               <div>
                                 <Text

autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/ExecutionAnalyticsForm.tsx

@@ -541,19 +541,7 @@ export function ExecutionAnalyticsForm() {
       {/* Accuracy Trends Display */}
       {trendsData && (
         <div className="space-y-4">
-          <div className="flex items-start justify-between">
-            <h3 className="text-lg font-semibold">Execution Accuracy Trends</h3>
-            <div className="rounded-md bg-blue-50 px-3 py-2 text-xs text-blue-700">
-              <p className="font-medium">
-                Chart Filters (matches monitoring system):
-              </p>
-              <ul className="mt-1 list-inside list-disc space-y-1">
-                <li>Only days with ≥1 execution with correctness score</li>
-                <li>Last 30 days</li>
-                <li>Averages calculated from scored executions only</li>
-              </ul>
-            </div>
-          </div>
+          <h3 className="text-lg font-semibold">Execution Accuracy Trends</h3>
 
           {/* Alert Section */}
           {trendsData.alert && (

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

@@ -1,5 +1,5 @@
 import { Sidebar } from "@/components/__legacy__/Sidebar";
-import { Users, DollarSign, UserSearch, FileText, Clock } from "lucide-react";
+import { Users, DollarSign, UserSearch, FileText } from "lucide-react";
 
 import { IconSliders } from "@/components/__legacy__/ui/icons";
 
@@ -11,11 +11,6 @@ const sidebarLinkGroups = [
         href: "/admin/marketplace",
         icon: <Users className="h-6 w-6" />,
       },
-      {
-        text: "Waitlist Management",
-        href: "/admin/waitlist",
-        icon: <Clock className="h-6 w-6" />,
-      },
       {
         text: "User Spending",
         href: "/admin/spending",

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

@@ -1,217 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-import { Button } from "@/components/atoms/Button/Button";
-import { Input } from "@/components/atoms/Input/Input";
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import {
-  usePostV2CreateWaitlist,
-  getGetV2ListAllWaitlistsQueryKey,
-} from "@/app/api/__generated__/endpoints/admin/admin";
-import { useToast } from "@/components/molecules/Toast/use-toast";
-import { Plus } from "@phosphor-icons/react";
-
-export function CreateWaitlistButton() {
-  const [open, setOpen] = useState(false);
-  const { toast } = useToast();
-  const queryClient = useQueryClient();
-
-  const createWaitlistMutation = usePostV2CreateWaitlist({
-    mutation: {
-      onSuccess: (response) => {
-        if (response.status === 200) {
-          toast({
-            title: "Success",
-            description: "Waitlist created successfully",
-          });
-          setOpen(false);
-          setFormData({
-            name: "",
-            slug: "",
-            subHeading: "",
-            description: "",
-            categories: "",
-            imageUrls: "",
-            videoUrl: "",
-            agentOutputDemoUrl: "",
-          });
-          queryClient.invalidateQueries({
-            queryKey: getGetV2ListAllWaitlistsQueryKey(),
-          });
-        } else {
-          toast({
-            variant: "destructive",
-            title: "Error",
-            description: "Failed to create waitlist",
-          });
-        }
-      },
-      onError: (error) => {
-        console.error("Error creating waitlist:", error);
-        toast({
-          variant: "destructive",
-          title: "Error",
-          description: "Failed to create waitlist",
-        });
-      },
-    },
-  });
-
-  const [formData, setFormData] = useState({
-    name: "",
-    slug: "",
-    subHeading: "",
-    description: "",
-    categories: "",
-    imageUrls: "",
-    videoUrl: "",
-    agentOutputDemoUrl: "",
-  });
-
-  function handleInputChange(id: string, value: string) {
-    setFormData((prev) => ({
-      ...prev,
-      [id]: value,
-    }));
-  }
-
-  function generateSlug(name: string) {
-    return name
-      .toLowerCase()
-      .replace(/[^a-z0-9]+/g, "-")
-      .replace(/^-|-$/g, "");
-  }
-
-  function handleSubmit(e: React.FormEvent) {
-    e.preventDefault();
-
-    createWaitlistMutation.mutate({
-      data: {
-        name: formData.name,
-        slug: formData.slug || generateSlug(formData.name),
-        subHeading: formData.subHeading,
-        description: formData.description,
-        categories: formData.categories
-          ? formData.categories.split(",").map((c) => c.trim())
-          : [],
-        imageUrls: formData.imageUrls
-          ? formData.imageUrls.split(",").map((u) => u.trim())
-          : [],
-        videoUrl: formData.videoUrl || null,
-        agentOutputDemoUrl: formData.agentOutputDemoUrl || null,
-      },
-    });
-  }
-
-  return (
-    <>
-      <Button onClick={() => setOpen(true)}>
-        <Plus size={16} className="mr-2" />
-        Create Waitlist
-      </Button>
-
-      <Dialog
-        title="Create New Waitlist"
-        controlled={{
-          isOpen: open,
-          set: async (isOpen) => setOpen(isOpen),
-        }}
-        onClose={() => setOpen(false)}
-        styling={{ maxWidth: "600px" }}
-      >
-        <Dialog.Content>
-          <p className="mb-4 text-sm text-zinc-500">
-            Create a new waitlist for an upcoming agent. Users can sign up to be
-            notified when it launches.
-          </p>
-          <form onSubmit={handleSubmit} className="flex flex-col gap-2">
-            <Input
-              id="name"
-              label="Name"
-              value={formData.name}
-              onChange={(e) => handleInputChange("name", e.target.value)}
-              placeholder="SEO Analysis Agent"
-              required
-            />
-
-            <Input
-              id="slug"
-              label="Slug"
-              value={formData.slug}
-              onChange={(e) => handleInputChange("slug", e.target.value)}
-              placeholder="seo-analysis-agent (auto-generated if empty)"
-            />
-
-            <Input
-              id="subHeading"
-              label="Subheading"
-              value={formData.subHeading}
-              onChange={(e) => handleInputChange("subHeading", e.target.value)}
-              placeholder="Analyze your website's SEO in minutes"
-              required
-            />
-
-            <Input
-              id="description"
-              label="Description"
-              type="textarea"
-              value={formData.description}
-              onChange={(e) => handleInputChange("description", e.target.value)}
-              placeholder="Detailed description of what this agent does..."
-              rows={4}
-              required
-            />
-
-            <Input
-              id="categories"
-              label="Categories (comma-separated)"
-              value={formData.categories}
-              onChange={(e) => handleInputChange("categories", e.target.value)}
-              placeholder="SEO, Marketing, Analysis"
-            />
-
-            <Input
-              id="imageUrls"
-              label="Image URLs (comma-separated)"
-              value={formData.imageUrls}
-              onChange={(e) => handleInputChange("imageUrls", e.target.value)}
-              placeholder="https://example.com/image1.jpg, https://example.com/image2.jpg"
-            />
-
-            <Input
-              id="videoUrl"
-              label="Video URL (optional)"
-              value={formData.videoUrl}
-              onChange={(e) => handleInputChange("videoUrl", e.target.value)}
-              placeholder="https://youtube.com/watch?v=..."
-            />
-
-            <Input
-              id="agentOutputDemoUrl"
-              label="Output Demo URL (optional)"
-              value={formData.agentOutputDemoUrl}
-              onChange={(e) =>
-                handleInputChange("agentOutputDemoUrl", e.target.value)
-              }
-              placeholder="https://example.com/demo-output.mp4"
-            />
-
-            <Dialog.Footer>
-              <Button
-                type="button"
-                variant="secondary"
-                onClick={() => setOpen(false)}
-              >
-                Cancel
-              </Button>
-              <Button type="submit" loading={createWaitlistMutation.isPending}>
-                Create Waitlist
-              </Button>
-            </Dialog.Footer>
-          </form>
-        </Dialog.Content>
-      </Dialog>
-    </>
-  );
-}

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

@@ -1,221 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import { Button } from "@/components/atoms/Button/Button";
-import { Input } from "@/components/atoms/Input/Input";
-import { Select } from "@/components/atoms/Select/Select";
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import { useToast } from "@/components/molecules/Toast/use-toast";
-import { usePutV2UpdateWaitlist } from "@/app/api/__generated__/endpoints/admin/admin";
-import type { WaitlistAdminResponse } from "@/app/api/__generated__/models/waitlistAdminResponse";
-import type { WaitlistUpdateRequest } from "@/app/api/__generated__/models/waitlistUpdateRequest";
-import { WaitlistExternalStatus } from "@/app/api/__generated__/models/waitlistExternalStatus";
-
-type EditWaitlistDialogProps = {
-  waitlist: WaitlistAdminResponse;
-  onClose: () => void;
-  onSave: () => void;
-};
-
-const STATUS_OPTIONS = [
-  { value: WaitlistExternalStatus.NOT_STARTED, label: "Not Started" },
-  { value: WaitlistExternalStatus.WORK_IN_PROGRESS, label: "Work In Progress" },
-  { value: WaitlistExternalStatus.DONE, label: "Done" },
-  { value: WaitlistExternalStatus.CANCELED, label: "Canceled" },
-];
-
-export function EditWaitlistDialog({
-  waitlist,
-  onClose,
-  onSave,
-}: EditWaitlistDialogProps) {
-  const { toast } = useToast();
-  const updateWaitlistMutation = usePutV2UpdateWaitlist();
-
-  const [formData, setFormData] = useState({
-    name: waitlist.name,
-    slug: waitlist.slug,
-    subHeading: waitlist.subHeading,
-    description: waitlist.description,
-    categories: waitlist.categories.join(", "),
-    imageUrls: waitlist.imageUrls.join(", "),
-    videoUrl: waitlist.videoUrl || "",
-    agentOutputDemoUrl: waitlist.agentOutputDemoUrl || "",
-    status: waitlist.status,
-    storeListingId: waitlist.storeListingId || "",
-  });
-
-  function handleInputChange(id: string, value: string) {
-    setFormData((prev) => ({
-      ...prev,
-      [id]: value,
-    }));
-  }
-
-  function handleStatusChange(value: string) {
-    setFormData((prev) => ({
-      ...prev,
-      status: value as WaitlistExternalStatus,
-    }));
-  }
-
-  async function handleSubmit(e: React.FormEvent) {
-    e.preventDefault();
-
-    const updateData: WaitlistUpdateRequest = {
-      name: formData.name,
-      slug: formData.slug,
-      subHeading: formData.subHeading,
-      description: formData.description,
-      categories: formData.categories
-        ? formData.categories.split(",").map((c) => c.trim())
-        : [],
-      imageUrls: formData.imageUrls
-        ? formData.imageUrls.split(",").map((u) => u.trim())
-        : [],
-      videoUrl: formData.videoUrl || null,
-      agentOutputDemoUrl: formData.agentOutputDemoUrl || null,
-      status: formData.status,
-      storeListingId: formData.storeListingId || null,
-    };
-
-    updateWaitlistMutation.mutate(
-      { waitlistId: waitlist.id, data: updateData },
-      {
-        onSuccess: (response) => {
-          if (response.status === 200) {
-            toast({
-              title: "Success",
-              description: "Waitlist updated successfully",
-            });
-            onSave();
-          } else {
-            toast({
-              variant: "destructive",
-              title: "Error",
-              description: "Failed to update waitlist",
-            });
-          }
-        },
-        onError: () => {
-          toast({
-            variant: "destructive",
-            title: "Error",
-            description: "Failed to update waitlist",
-          });
-        },
-      },
-    );
-  }
-
-  return (
-    <Dialog
-      title="Edit Waitlist"
-      controlled={{
-        isOpen: true,
-        set: async (open) => {
-          if (!open) onClose();
-        },
-      }}
-      onClose={onClose}
-      styling={{ maxWidth: "600px" }}
-    >
-      <Dialog.Content>
-        <p className="mb-4 text-sm text-zinc-500">
-          Update the waitlist details. Changes will be reflected immediately.
-        </p>
-        <form onSubmit={handleSubmit} className="flex flex-col gap-2">
-          <Input
-            id="name"
-            label="Name"
-            value={formData.name}
-            onChange={(e) => handleInputChange("name", e.target.value)}
-            required
-          />
-
-          <Input
-            id="slug"
-            label="Slug"
-            value={formData.slug}
-            onChange={(e) => handleInputChange("slug", e.target.value)}
-          />
-
-          <Input
-            id="subHeading"
-            label="Subheading"
-            value={formData.subHeading}
-            onChange={(e) => handleInputChange("subHeading", e.target.value)}
-            required
-          />
-
-          <Input
-            id="description"
-            label="Description"
-            type="textarea"
-            value={formData.description}
-            onChange={(e) => handleInputChange("description", e.target.value)}
-            rows={4}
-            required
-          />
-
-          <Select
-            id="status"
-            label="Status"
-            value={formData.status}
-            onValueChange={handleStatusChange}
-            options={STATUS_OPTIONS}
-          />
-
-          <Input
-            id="categories"
-            label="Categories (comma-separated)"
-            value={formData.categories}
-            onChange={(e) => handleInputChange("categories", e.target.value)}
-          />
-
-          <Input
-            id="imageUrls"
-            label="Image URLs (comma-separated)"
-            value={formData.imageUrls}
-            onChange={(e) => handleInputChange("imageUrls", e.target.value)}
-          />
-
-          <Input
-            id="videoUrl"
-            label="Video URL"
-            value={formData.videoUrl}
-            onChange={(e) => handleInputChange("videoUrl", e.target.value)}
-          />
-
-          <Input
-            id="agentOutputDemoUrl"
-            label="Output Demo URL"
-            value={formData.agentOutputDemoUrl}
-            onChange={(e) =>
-              handleInputChange("agentOutputDemoUrl", e.target.value)
-            }
-          />
-
-          <Input
-            id="storeListingId"
-            label="Store Listing ID (for linking)"
-            value={formData.storeListingId}
-            onChange={(e) =>
-              handleInputChange("storeListingId", e.target.value)
-            }
-            placeholder="Leave empty if not linked"
-          />
-
-          <Dialog.Footer>
-            <Button type="button" variant="secondary" onClick={onClose}>
-              Cancel
-            </Button>
-            <Button type="submit" loading={updateWaitlistMutation.isPending}>
-              Save Changes
-            </Button>
-          </Dialog.Footer>
-        </form>
-      </Dialog.Content>
-    </Dialog>
-  );
-}

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

@@ -1,156 +0,0 @@
-"use client";
-
-import { Button } from "@/components/atoms/Button/Button";
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import { User, Envelope, DownloadSimple } from "@phosphor-icons/react";
-import { useGetV2GetWaitlistSignups } from "@/app/api/__generated__/endpoints/admin/admin";
-
-type WaitlistSignupsDialogProps = {
-  waitlistId: string;
-  onClose: () => void;
-};
-
-export function WaitlistSignupsDialog({
-  waitlistId,
-  onClose,
-}: WaitlistSignupsDialogProps) {
-  const {
-    data: signupsResponse,
-    isLoading,
-    isError,
-  } = useGetV2GetWaitlistSignups(waitlistId);
-
-  const signups = signupsResponse?.status === 200 ? signupsResponse.data : null;
-
-  function exportToCSV() {
-    if (!signups) return;
-
-    const headers = ["Type", "Email", "User ID", "Username"];
-    const rows = signups.signups.map((signup) => [
-      signup.type,
-      signup.email || "",
-      signup.userId || "",
-      signup.username || "",
-    ]);
-
-    const escapeCell = (cell: string) => `"${cell.replace(/"/g, '""')}"`;
-
-    const csvContent = [
-      headers.join(","),
-      ...rows.map((row) => row.map(escapeCell).join(",")),
-    ].join("\n");
-
-    const blob = new Blob([csvContent], { type: "text/csv" });
-    const url = window.URL.createObjectURL(blob);
-    const a = document.createElement("a");
-    a.href = url;
-    a.download = `waitlist-${waitlistId}-signups.csv`;
-    a.click();
-    window.URL.revokeObjectURL(url);
-  }
-
-  function renderContent() {
-    if (isLoading) {
-      return <div className="py-10 text-center">Loading signups...</div>;
-    }
-
-    if (isError) {
-      return (
-        <div className="py-10 text-center text-red-500">
-          Failed to load signups. Please try again.
-        </div>
-      );
-    }
-
-    if (!signups || signups.signups.length === 0) {
-      return (
-        <div className="py-10 text-center text-gray-500">
-          No signups yet for this waitlist.
-        </div>
-      );
-    }
-
-    return (
-      <>
-        <div className="flex justify-end">
-          <Button variant="secondary" size="small" onClick={exportToCSV}>
-            <DownloadSimple className="mr-2 h-4 w-4" size={16} />
-            Export CSV
-          </Button>
-        </div>
-        <div className="max-h-[400px] overflow-y-auto rounded-md border">
-          <table className="w-full">
-            <thead className="bg-gray-50 dark:bg-gray-800">
-              <tr>
-                <th className="px-4 py-3 text-left text-sm font-medium">
-                  Type
-                </th>
-                <th className="px-4 py-3 text-left text-sm font-medium">
-                  Email / Username
-                </th>
-                <th className="px-4 py-3 text-left text-sm font-medium">
-                  User ID
-                </th>
-              </tr>
-            </thead>
-            <tbody className="divide-y">
-              {signups.signups.map((signup, index) => (
-                <tr key={index}>
-                  <td className="px-4 py-3">
-                    {signup.type === "user" ? (
-                      <span className="flex items-center gap-1 text-blue-600">
-                        <User className="h-4 w-4" size={16} /> User
-                      </span>
-                    ) : (
-                      <span className="flex items-center gap-1 text-gray-600">
-                        <Envelope className="h-4 w-4" size={16} /> Email
-                      </span>
-                    )}
-                  </td>
-                  <td className="px-4 py-3">
-                    {signup.type === "user"
-                      ? signup.username || signup.email
-                      : signup.email}
-                  </td>
-                  <td className="px-4 py-3 font-mono text-sm">
-                    {signup.userId || "-"}
-                  </td>
-                </tr>
-              ))}
-            </tbody>
-          </table>
-        </div>
-      </>
-    );
-  }
-
-  return (
-    <Dialog
-      title="Waitlist Signups"
-      controlled={{
-        isOpen: true,
-        set: async (open) => {
-          if (!open) onClose();
-        },
-      }}
-      onClose={onClose}
-      styling={{ maxWidth: "700px" }}
-    >
-      <Dialog.Content>
-        <p className="mb-4 text-sm text-zinc-500">
-          {signups
-            ? `${signups.totalCount} total signups`
-            : "Loading signups..."}
-        </p>
-
-        {renderContent()}
-
-        <Dialog.Footer>
-          <Button variant="secondary" onClick={onClose}>
-            Close
-          </Button>
-        </Dialog.Footer>
-      </Dialog.Content>
-    </Dialog>
-  );
-}

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

@@ -1,206 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-import {
-  Table,
-  TableBody,
-  TableCell,
-  TableHead,
-  TableHeader,
-  TableRow,
-} from "@/components/__legacy__/ui/table";
-import { Button } from "@/components/atoms/Button/Button";
-import {
-  useGetV2ListAllWaitlists,
-  useDeleteV2DeleteWaitlist,
-  getGetV2ListAllWaitlistsQueryKey,
-} from "@/app/api/__generated__/endpoints/admin/admin";
-import type { WaitlistAdminResponse } from "@/app/api/__generated__/models/waitlistAdminResponse";
-import { EditWaitlistDialog } from "./EditWaitlistDialog";
-import { WaitlistSignupsDialog } from "./WaitlistSignupsDialog";
-import { Trash, PencilSimple, Users, Link } from "@phosphor-icons/react";
-import { useToast } from "@/components/molecules/Toast/use-toast";
-
-export function WaitlistTable() {
-  const [editingWaitlist, setEditingWaitlist] =
-    useState<WaitlistAdminResponse | null>(null);
-  const [viewingSignups, setViewingSignups] = useState<string | null>(null);
-  const { toast } = useToast();
-  const queryClient = useQueryClient();
-
-  const { data: response, isLoading, error } = useGetV2ListAllWaitlists();
-
-  const deleteWaitlistMutation = useDeleteV2DeleteWaitlist({
-    mutation: {
-      onSuccess: () => {
-        toast({
-          title: "Success",
-          description: "Waitlist deleted successfully",
-        });
-        queryClient.invalidateQueries({
-          queryKey: getGetV2ListAllWaitlistsQueryKey(),
-        });
-      },
-      onError: (error) => {
-        console.error("Error deleting waitlist:", error);
-        toast({
-          variant: "destructive",
-          title: "Error",
-          description: "Failed to delete waitlist",
-        });
-      },
-    },
-  });
-
-  function handleDelete(waitlistId: string) {
-    if (!confirm("Are you sure you want to delete this waitlist?")) return;
-    deleteWaitlistMutation.mutate({ waitlistId });
-  }
-
-  function handleWaitlistSaved() {
-    setEditingWaitlist(null);
-    queryClient.invalidateQueries({
-      queryKey: getGetV2ListAllWaitlistsQueryKey(),
-    });
-  }
-
-  function formatStatus(status: string) {
-    const statusColors: Record<string, string> = {
-      NOT_STARTED: "bg-gray-100 text-gray-800",
-      WORK_IN_PROGRESS: "bg-blue-100 text-blue-800",
-      DONE: "bg-green-100 text-green-800",
-      CANCELED: "bg-red-100 text-red-800",
-    };
-
-    return (
-      <span
-        className={`rounded-full px-2 py-1 text-xs font-medium ${statusColors[status] || "bg-gray-100 text-gray-700"}`}
-      >
-        {status.replace(/_/g, " ")}
-      </span>
-    );
-  }
-
-  function formatDate(dateStr: string) {
-    if (!dateStr) return "-";
-    return new Intl.DateTimeFormat("en-US", {
-      month: "short",
-      day: "numeric",
-      year: "numeric",
-    }).format(new Date(dateStr));
-  }
-
-  if (isLoading) {
-    return <div className="py-10 text-center">Loading waitlists...</div>;
-  }
-
-  if (error) {
-    return (
-      <div className="py-10 text-center text-red-500">
-        Error loading waitlists. Please try again.
-      </div>
-    );
-  }
-
-  const waitlists = response?.status === 200 ? response.data.waitlists : [];
-
-  if (waitlists.length === 0) {
-    return (
-      <div className="py-10 text-center text-gray-500">
-        No waitlists found. Create one to get started!
-      </div>
-    );
-  }
-
-  return (
-    <>
-      <div className="rounded-md border bg-white">
-        <Table>
-          <TableHeader className="bg-gray-50">
-            <TableRow>
-              <TableHead className="font-medium">Name</TableHead>
-              <TableHead className="font-medium">Status</TableHead>
-              <TableHead className="font-medium">Signups</TableHead>
-              <TableHead className="font-medium">Votes</TableHead>
-              <TableHead className="font-medium">Created</TableHead>
-              <TableHead className="font-medium">Linked Agent</TableHead>
-              <TableHead className="font-medium">Actions</TableHead>
-            </TableRow>
-          </TableHeader>
-          <TableBody>
-            {waitlists.map((waitlist) => (
-              <TableRow key={waitlist.id}>
-                <TableCell>
-                  <div>
-                    <div className="font-medium">{waitlist.name}</div>
-                    <div className="text-sm text-gray-500">
-                      {waitlist.subHeading}
-                    </div>
-                  </div>
-                </TableCell>
-                <TableCell>{formatStatus(waitlist.status)}</TableCell>
-                <TableCell>{waitlist.signupCount}</TableCell>
-                <TableCell>{waitlist.votes}</TableCell>
-                <TableCell>{formatDate(waitlist.createdAt)}</TableCell>
-                <TableCell>
-                  {waitlist.storeListingId ? (
-                    <span className="text-green-600">
-                      <Link size={16} className="inline" /> Linked
-                    </span>
-                  ) : (
-                    <span className="text-gray-400">Not linked</span>
-                  )}
-                </TableCell>
-                <TableCell>
-                  <div className="flex gap-2">
-                    <Button
-                      variant="ghost"
-                      size="small"
-                      onClick={() => setViewingSignups(waitlist.id)}
-                      title="View signups"
-                    >
-                      <Users size={16} />
-                    </Button>
-                    <Button
-                      variant="ghost"
-                      size="small"
-                      onClick={() => setEditingWaitlist(waitlist)}
-                      title="Edit"
-                    >
-                      <PencilSimple size={16} />
-                    </Button>
-                    <Button
-                      variant="ghost"
-                      size="small"
-                      onClick={() => handleDelete(waitlist.id)}
-                      title="Delete"
-                      disabled={deleteWaitlistMutation.isPending}
-                    >
-                      <Trash size={16} className="text-red-500" />
-                    </Button>
-                  </div>
-                </TableCell>
-              </TableRow>
-            ))}
-          </TableBody>
-        </Table>
-      </div>
-
-      {editingWaitlist && (
-        <EditWaitlistDialog
-          waitlist={editingWaitlist}
-          onClose={() => setEditingWaitlist(null)}
-          onSave={handleWaitlistSaved}
-        />
-      )}
-
-      {viewingSignups && (
-        <WaitlistSignupsDialog
-          waitlistId={viewingSignups}
-          onClose={() => setViewingSignups(null)}
-        />
-      )}
-    </>
-  );
-}

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

@@ -1,52 +0,0 @@
-import { withRoleAccess } from "@/lib/withRoleAccess";
-import { Suspense } from "react";
-import { WaitlistTable } from "./components/WaitlistTable";
-import { CreateWaitlistButton } from "./components/CreateWaitlistButton";
-import { Warning } from "@phosphor-icons/react/dist/ssr";
-
-function WaitlistDashboard() {
-  return (
-    <div className="mx-auto p-6">
-      <div className="flex flex-col gap-4">
-        <div className="flex items-center justify-between">
-          <div>
-            <h1 className="text-3xl font-bold">Waitlist Management</h1>
-            <p className="text-gray-500">
-              Manage upcoming agent waitlists and track signups
-            </p>
-          </div>
-          <CreateWaitlistButton />
-        </div>
-
-        <div className="flex items-start gap-3 rounded-lg border border-amber-300 bg-amber-50 p-4 dark:border-amber-700 dark:bg-amber-950">
-          <Warning
-            className="mt-0.5 h-5 w-5 flex-shrink-0 text-amber-600 dark:text-amber-400"
-            weight="fill"
-          />
-          <div className="text-sm text-amber-800 dark:text-amber-200">
-            <p className="font-medium">TODO: Email-only signup notifications</p>
-            <p className="mt-1 text-amber-700 dark:text-amber-300">
-              Notifications for email-only signups (users who weren&apos;t
-              logged in) have not been implemented yet. Currently only
-              registered users will receive launch emails.
-            </p>
-          </div>
-        </div>
-
-        <Suspense
-          fallback={
-            <div className="py-10 text-center">Loading waitlists...</div>
-          }
-        >
-          <WaitlistTable />
-        </Suspense>
-      </div>
-    </div>
-  );
-}
-
-export default async function WaitlistDashboardPage() {
-  const withAdminAccess = await withRoleAccess(["admin"]);
-  const ProtectedWaitlistDashboard = await withAdminAccess(WaitlistDashboard);
-  return <ProtectedWaitlistDashboard />;
-}

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatContainer/helpers.ts

@@ -267,23 +267,34 @@ export function extractCredentialsNeeded(
       | undefined;
     if (missingCreds && Object.keys(missingCreds).length > 0) {
       const agentName = (setupInfo?.agent_name as string) || "this block";
-      const credentials = Object.values(missingCreds).map((credInfo) => ({
-        provider: (credInfo.provider as string) || "unknown",
-        providerName:
-          (credInfo.provider_name as string) ||
-          (credInfo.provider as string) ||
-          "Unknown Provider",
-        credentialType:
+      const credentials = Object.values(missingCreds).map((credInfo) => {
+        // Normalize to array at boundary - prefer 'types' array, fall back to single 'type'
+        const typesArray = credInfo.types as
+          | Array<"api_key" | "oauth2" | "user_password" | "host_scoped">
+          | undefined;
+        const singleType =
           (credInfo.type as
             | "api_key"
             | "oauth2"
             | "user_password"
-            | "host_scoped") || "api_key",
-        title:
-          (credInfo.title as string) ||
-          `${(credInfo.provider_name as string) || (credInfo.provider as string)} credentials`,
-        scopes: credInfo.scopes as string[] | undefined,
-      }));
+            | "host_scoped"
+            | undefined) || "api_key";
+        const credentialTypes =
+          typesArray && typesArray.length > 0 ? typesArray : [singleType];
+
+        return {
+          provider: (credInfo.provider as string) || "unknown",
+          providerName:
+            (credInfo.provider_name as string) ||
+            (credInfo.provider as string) ||
+            "Unknown Provider",
+          credentialTypes,
+          title:
+            (credInfo.title as string) ||
+            `${(credInfo.provider_name as string) || (credInfo.provider as string)} credentials`,
+          scopes: credInfo.scopes as string[] | undefined,
+        };
+      });
       return {
         type: "credentials_needed",
         toolName,
@@ -358,11 +369,14 @@ export function extractInputsNeeded(
       credentials.forEach((cred) => {
         const id = cred.id as string;
         if (id) {
+          const credentialTypes = Array.isArray(cred.types)
+            ? cred.types
+            : [(cred.type as string) || "api_key"];
           credentialsSchema[id] = {
             type: "object",
             properties: {},
             credentials_provider: [cred.provider as string],
-            credentials_types: [(cred.type as string) || "api_key"],
+            credentials_types: credentialTypes,
             credentials_scopes: cred.scopes as string[] | undefined,
           };
         }

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatCredentialsSetup/ChatCredentialsSetup.tsx

@@ -9,7 +9,9 @@ import { useChatCredentialsSetup } from "./useChatCredentialsSetup";
 export interface CredentialInfo {
   provider: string;
   providerName: string;
-  credentialType: "api_key" | "oauth2" | "user_password" | "host_scoped";
+  credentialTypes: Array<
+    "api_key" | "oauth2" | "user_password" | "host_scoped"
+  >;
   title: string;
   scopes?: string[];
 }
@@ -30,7 +32,7 @@ function createSchemaFromCredentialInfo(
     type: "object",
     properties: {},
     credentials_provider: [credential.provider],
-    credentials_types: [credential.credentialType],
+    credentials_types: credential.credentialTypes,
     credentials_scopes: credential.scopes,
     discriminator: undefined,
     discriminator_mapping: undefined,

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatMessage/useChatMessage.ts

@@ -41,7 +41,9 @@ export type ChatMessageData =
       credentials: Array<{
         provider: string;
         providerName: string;
-        credentialType: "api_key" | "oauth2" | "user_password" | "host_scoped";
+        credentialTypes: Array<
+          "api_key" | "oauth2" | "user_password" | "host_scoped"
+        >;
         title: string;
         scopes?: string[];
       }>;

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

@@ -173,9 +173,8 @@ export function OldAgentLibraryView() {
     if (agentRuns.length > 0) {
       // select latest run
       const latestRun = agentRuns.reduce((latest, current) => {
-        if (!latest.started_at && !current.started_at) return latest;
-        if (!latest.started_at) return current;
-        if (!current.started_at) return latest;
+        if (latest.started_at && !current.started_at) return current;
+        else if (!latest.started_at) return latest;
         return latest.started_at > current.started_at ? latest : current;
       }, agentRuns[0]);
       selectRun(latestRun.id as GraphExecutionID);

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/agent-runs-selector-list.tsx

@@ -184,11 +184,9 @@ export function AgentRunsSelectorList({
                     ))}
                   {agentPresets.length > 0 && <Separator className="my-1" />}
                   {agentRuns
-                    .toSorted((a, b) => {
-                      const aTime = a.started_at?.getTime() ?? 0;
-                      const bTime = b.started_at?.getTime() ?? 0;
-                      return bTime - aTime;
-                    })
+                    .toSorted(
+                      (a, b) => b.started_at.getTime() - a.started_at.getTime(),
+                    )
                     .map((run) => (
                       <AgentRunSummaryCard
                         className={listItemClasses}
@@ -201,7 +199,7 @@ export function AgentRunsSelectorList({
                                 ?.name
                             : null) ?? agent.name
                         }
-                        timestamp={run.started_at ?? undefined}
+                        timestamp={run.started_at}
                         selected={selectedView.id === run.id}
                         onClick={() => onSelectRun(run.id)}
                         onDelete={() => doDeleteRun(run as GraphExecutionMeta)}

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

@@ -8,7 +8,6 @@ import { useMainMarketplacePage } from "./useMainMarketplacePage";
 import { FeaturedCreators } from "../FeaturedCreators/FeaturedCreators";
 import { MainMarketplacePageLoading } from "../MainMarketplacePageLoading";
 import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
-import { WaitlistSection } from "../WaitlistSection/WaitlistSection";
 
 export const MainMarkeplacePage = () => {
   const { featuredAgents, topAgents, featuredCreators, isLoading, hasError } =
@@ -47,10 +46,6 @@ export const MainMarkeplacePage = () => {
         {/* 100px margin because our featured sections button are placed 40px below the container */}
         <Separator className="mb-6 mt-24" />
 
-        {/* Waitlist Section - "Help Shape What's Next" */}
-        <WaitlistSection />
-        <Separator className="mb-6 mt-12" />
-
         {topAgents && (
           <AgentsSection sectionTitle="Top Agents" agents={topAgents.agents} />
         )}

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

@@ -1,105 +0,0 @@
-"use client";
-
-import Image from "next/image";
-import { Button } from "@/components/atoms/Button/Button";
-import { Check } from "@phosphor-icons/react";
-
-interface WaitlistCardProps {
-  name: string;
-  subHeading: string;
-  description: string;
-  imageUrl: string | null;
-  isMember?: boolean;
-  onCardClick: () => void;
-  onJoinClick: (e: React.MouseEvent) => void;
-}
-
-export function WaitlistCard({
-  name,
-  subHeading,
-  description,
-  imageUrl,
-  isMember = false,
-  onCardClick,
-  onJoinClick,
-}: WaitlistCardProps) {
-  function handleJoinClick(e: React.MouseEvent) {
-    e.stopPropagation();
-    onJoinClick(e);
-  }
-
-  return (
-    <div
-      className="flex h-[24rem] w-full max-w-md cursor-pointer flex-col items-start rounded-3xl bg-white transition-all duration-300 hover:shadow-lg dark:bg-zinc-900 dark:hover:shadow-gray-700"
-      onClick={onCardClick}
-      data-testid="waitlist-card"
-      role="button"
-      tabIndex={0}
-      aria-label={`${name} waitlist card`}
-      onKeyDown={(e) => {
-        if (e.key === "Enter" || e.key === " ") {
-          onCardClick();
-        }
-      }}
-    >
-      {/* Image Section */}
-      <div className="relative aspect-[2/1.2] w-full overflow-hidden rounded-large md:aspect-[2.17/1]">
-        {imageUrl ? (
-          <Image
-            src={imageUrl}
-            alt={`${name} preview image`}
-            fill
-            className="object-cover"
-          />
-        ) : (
-          <div className="flex h-full w-full items-center justify-center bg-gradient-to-br from-neutral-200 to-neutral-300 dark:from-neutral-700 dark:to-neutral-800">
-            <span className="text-4xl font-bold text-neutral-400 dark:text-neutral-500">
-              {name.charAt(0)}
-            </span>
-          </div>
-        )}
-      </div>
-
-      <div className="mt-3 flex w-full flex-1 flex-col px-4">
-        {/* Name and Subheading */}
-        <div className="flex w-full flex-col">
-          <h3 className="line-clamp-1 font-poppins text-xl font-semibold text-[#272727] dark:text-neutral-100">
-            {name}
-          </h3>
-          <p className="mt-1 line-clamp-1 text-sm text-neutral-500 dark:text-neutral-400">
-            {subHeading}
-          </p>
-        </div>
-
-        {/* Description */}
-        <div className="mt-2 flex w-full flex-col">
-          <p className="line-clamp-5 text-sm font-normal leading-relaxed text-neutral-600 dark:text-neutral-400">
-            {description}
-          </p>
-        </div>
-
-        <div className="flex-grow" />
-
-        {/* Join Waitlist Button */}
-        <div className="mt-4 w-full pb-4">
-          {isMember ? (
-            <Button
-              disabled
-              className="w-full rounded-full bg-green-600 text-white hover:bg-green-600 dark:bg-green-700 dark:hover:bg-green-700"
-            >
-              <Check className="mr-2" size={16} weight="bold" />
-              On the waitlist
-            </Button>
-          ) : (
-            <Button
-              onClick={handleJoinClick}
-              className="w-full rounded-full bg-zinc-800 text-white hover:bg-zinc-700 dark:bg-zinc-700 dark:hover:bg-zinc-600"
-            >
-              Join waitlist
-            </Button>
-          )}
-        </div>
-      </div>
-    </div>
-  );
-}

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

@@ -1,356 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import Image from "next/image";
-import { Button } from "@/components/atoms/Button/Button";
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import { Input } from "@/components/atoms/Input/Input";
-import {
-  Carousel,
-  CarouselContent,
-  CarouselItem,
-  CarouselNext,
-  CarouselPrevious,
-} from "@/components/__legacy__/ui/carousel";
-import type { StoreWaitlistEntry } from "@/app/api/__generated__/models/storeWaitlistEntry";
-import { Check, Play } from "@phosphor-icons/react";
-import { useSupabaseStore } from "@/lib/supabase/hooks/useSupabaseStore";
-import { useToast } from "@/components/molecules/Toast/use-toast";
-import { usePostV2AddSelfToTheAgentWaitlist } from "@/app/api/__generated__/endpoints/store/store";
-
-interface MediaItem {
-  type: "image" | "video";
-  url: string;
-  label?: string;
-}
-
-// Extract YouTube video ID from various URL formats
-function getYouTubeVideoId(url: string): string | null {
-  const regExp =
-    /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#&?]*).*/;
-  const match = url.match(regExp);
-  return match && match[7].length === 11 ? match[7] : null;
-}
-
-// Validate video URL for security
-function isValidVideoUrl(url: string): boolean {
-  if (url.startsWith("data:video")) {
-    return true;
-  }
-  const videoExtensions = /\.(mp4|webm|ogg)$/i;
-  const youtubeRegex = /^(https?:\/\/)?(www\.)?(youtube\.com|youtu\.?be)\/.+$/;
-  const validUrl = /^(https?:\/\/)/i;
-  const cleanedUrl = url.split("?")[0];
-  return (
-    (validUrl.test(url) && videoExtensions.test(cleanedUrl)) ||
-    youtubeRegex.test(url)
-  );
-}
-
-// Video player with YouTube embed support
-function VideoPlayer({
-  url,
-  autoPlay = false,
-  className = "",
-}: {
-  url: string;
-  autoPlay?: boolean;
-  className?: string;
-}) {
-  const youtubeId = getYouTubeVideoId(url);
-
-  if (youtubeId) {
-    return (
-      <iframe
-        src={`https://www.youtube.com/embed/${youtubeId}${autoPlay ? "?autoplay=1" : ""}`}
-        title="YouTube video player"
-        className={className}
-        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
-        sandbox="allow-same-origin allow-scripts allow-presentation"
-        allowFullScreen
-      />
-    );
-  }
-
-  if (!isValidVideoUrl(url)) {
-    return (
-      <div
-        className={`flex items-center justify-center bg-zinc-800 ${className}`}
-      >
-        <span className="text-sm text-zinc-400">Invalid video URL</span>
-      </div>
-    );
-  }
-
-  return <video src={url} controls autoPlay={autoPlay} className={className} />;
-}
-
-function MediaCarousel({ waitlist }: { waitlist: StoreWaitlistEntry }) {
-  const [activeVideo, setActiveVideo] = useState<string | null>(null);
-
-  // Build media items array: videos first, then images
-  const mediaItems: MediaItem[] = [
-    ...(waitlist.videoUrl
-      ? [{ type: "video" as const, url: waitlist.videoUrl, label: "Video" }]
-      : []),
-    ...(waitlist.agentOutputDemoUrl
-      ? [
-          {
-            type: "video" as const,
-            url: waitlist.agentOutputDemoUrl,
-            label: "Demo",
-          },
-        ]
-      : []),
-    ...waitlist.imageUrls.map((url) => ({ type: "image" as const, url })),
-  ];
-
-  if (mediaItems.length === 0) return null;
-
-  // Single item - no carousel needed
-  if (mediaItems.length === 1) {
-    const item = mediaItems[0];
-    return (
-      <div className="relative aspect-[350/196] w-full overflow-hidden rounded-large">
-        {item.type === "image" ? (
-          <Image
-            src={item.url}
-            alt={`${waitlist.name} preview`}
-            fill
-            className="object-cover"
-          />
-        ) : (
-          <VideoPlayer url={item.url} className="h-full w-full object-cover" />
-        )}
-      </div>
-    );
-  }
-
-  // Multiple items - use carousel
-  return (
-    <Carousel className="w-full">
-      <CarouselContent>
-        {mediaItems.map((item, index) => (
-          <CarouselItem key={index}>
-            <div className="relative aspect-[350/196] w-full overflow-hidden rounded-large">
-              {item.type === "image" ? (
-                <Image
-                  src={item.url}
-                  alt={`${waitlist.name} preview ${index + 1}`}
-                  fill
-                  className="object-cover"
-                />
-              ) : activeVideo === item.url ? (
-                <VideoPlayer
-                  url={item.url}
-                  autoPlay
-                  className="h-full w-full object-cover"
-                />
-              ) : (
-                <button
-                  onClick={() => setActiveVideo(item.url)}
-                  className="group relative h-full w-full bg-zinc-900"
-                >
-                  <div className="absolute inset-0 flex items-center justify-center">
-                    <div className="flex h-16 w-16 items-center justify-center rounded-full bg-white/90 transition-transform group-hover:scale-110">
-                      <Play size={32} weight="fill" className="text-zinc-800" />
-                    </div>
-                  </div>
-                  <span className="absolute bottom-3 left-3 text-sm text-white">
-                    {item.label}
-                  </span>
-                </button>
-              )}
-            </div>
-          </CarouselItem>
-        ))}
-      </CarouselContent>
-      <CarouselPrevious className="left-2 top-1/2 -translate-y-1/2" />
-      <CarouselNext className="right-2 top-1/2 -translate-y-1/2" />
-    </Carousel>
-  );
-}
-
-interface WaitlistDetailModalProps {
-  waitlist: StoreWaitlistEntry;
-  isMember?: boolean;
-  onClose: () => void;
-  onJoinSuccess?: (waitlistId: string) => void;
-}
-
-export function WaitlistDetailModal({
-  waitlist,
-  isMember = false,
-  onClose,
-  onJoinSuccess,
-}: WaitlistDetailModalProps) {
-  const { user } = useSupabaseStore();
-  const [email, setEmail] = useState("");
-  const [success, setSuccess] = useState(false);
-  const { toast } = useToast();
-  const joinWaitlistMutation = usePostV2AddSelfToTheAgentWaitlist();
-
-  function handleJoin() {
-    joinWaitlistMutation.mutate(
-      {
-        waitlistId: waitlist.waitlistId,
-        data: { email: user ? undefined : email },
-      },
-      {
-        onSuccess: (response) => {
-          if (response.status === 200) {
-            setSuccess(true);
-            toast({
-              title: "You're on the waitlist!",
-              description: `We'll notify you when ${waitlist.name} goes live.`,
-            });
-            onJoinSuccess?.(waitlist.waitlistId);
-          } else {
-            toast({
-              variant: "destructive",
-              title: "Error",
-              description: "Failed to join waitlist. Please try again.",
-            });
-          }
-        },
-        onError: () => {
-          toast({
-            variant: "destructive",
-            title: "Error",
-            description: "Failed to join waitlist. Please try again.",
-          });
-        },
-      },
-    );
-  }
-
-  // Success state
-  if (success) {
-    return (
-      <Dialog
-        title=""
-        controlled={{
-          isOpen: true,
-          set: async (open) => {
-            if (!open) onClose();
-          },
-        }}
-        onClose={onClose}
-        styling={{ maxWidth: "500px" }}
-      >
-        <Dialog.Content>
-          <div className="flex flex-col items-center justify-center py-4 text-center">
-            {/* Party emoji */}
-            <span className="mb-2 text-5xl">🎉</span>
-
-            {/* Title */}
-            <h2 className="mb-2 font-poppins text-[22px] font-medium leading-7 text-zinc-900 dark:text-zinc-100">
-              You&apos;re on the waitlist
-            </h2>
-
-            {/* Subtitle */}
-            <p className="text-base leading-[26px] text-zinc-600 dark:text-zinc-400">
-              Thanks for helping us prioritize which agents to build next.
-              We&apos;ll notify you when this agent goes live in the
-              marketplace.
-            </p>
-          </div>
-
-          {/* Close button */}
-          <Dialog.Footer className="flex justify-center pb-2 pt-4">
-            <Button
-              variant="secondary"
-              onClick={onClose}
-              className="rounded-full border border-zinc-700 bg-white px-4 py-3 text-zinc-900 hover:bg-zinc-100 dark:border-zinc-500 dark:bg-zinc-800 dark:text-zinc-100 dark:hover:bg-zinc-700"
-            >
-              Close
-            </Button>
-          </Dialog.Footer>
-        </Dialog.Content>
-      </Dialog>
-    );
-  }
-
-  // Main modal - handles both member and non-member states
-  return (
-    <Dialog
-      title="Join the waitlist"
-      controlled={{
-        isOpen: true,
-        set: async (open) => {
-          if (!open) onClose();
-        },
-      }}
-      onClose={onClose}
-      styling={{ maxWidth: "500px" }}
-    >
-      <Dialog.Content>
-        {/* Subtitle */}
-        <p className="mb-6 text-center text-base text-zinc-600 dark:text-zinc-400">
-          Help us decide what to build next — and get notified when this agent
-          is ready
-        </p>
-
-        {/* Media Carousel */}
-        <MediaCarousel waitlist={waitlist} />
-
-        {/* Agent Name */}
-        <h3 className="mt-4 font-poppins text-[22px] font-medium leading-7 text-zinc-800 dark:text-zinc-100">
-          {waitlist.name}
-        </h3>
-
-        {/* Agent Description */}
-        <p className="mt-2 line-clamp-5 text-sm leading-[22px] text-zinc-500 dark:text-zinc-400">
-          {waitlist.description}
-        </p>
-
-        {/* Email input for non-logged-in users who haven't joined */}
-        {!isMember && !user && (
-          <div className="mt-4 pr-1">
-            <Input
-              id="email"
-              label="Email address"
-              type="email"
-              placeholder="you@example.com"
-              value={email}
-              onChange={(e) => setEmail(e.target.value)}
-              required
-            />
-          </div>
-        )}
-
-        {/* Footer buttons */}
-        <Dialog.Footer className="sticky bottom-0 mt-6 flex justify-center gap-3 bg-white pb-2 pt-4 dark:bg-zinc-900">
-          {isMember ? (
-            <Button
-              disabled
-              className="rounded-full bg-green-600 px-4 py-3 text-white hover:bg-green-600 dark:bg-green-700 dark:hover:bg-green-700"
-            >
-              <Check size={16} className="mr-2" />
-              You&apos;re on the waitlist
-            </Button>
-          ) : (
-            <>
-              <Button
-                onClick={handleJoin}
-                loading={joinWaitlistMutation.isPending}
-                disabled={!user && !email}
-                className="rounded-full bg-zinc-800 px-4 py-3 text-white hover:bg-zinc-700 dark:bg-zinc-700 dark:hover:bg-zinc-600"
-              >
-                Join waitlist
-              </Button>
-              <Button
-                type="button"
-                variant="secondary"
-                onClick={onClose}
-                className="rounded-full bg-zinc-200 px-4 py-3 text-zinc-900 hover:bg-zinc-300 dark:bg-zinc-700 dark:text-zinc-100 dark:hover:bg-zinc-600"
-              >
-                Not now
-              </Button>
-            </>
-          )}
-        </Dialog.Footer>
-      </Dialog.Content>
-    </Dialog>
-  );
-}

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

@@ -1,102 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import {
-  Carousel,
-  CarouselContent,
-  CarouselItem,
-} from "@/components/__legacy__/ui/carousel";
-import { WaitlistCard } from "../WaitlistCard/WaitlistCard";
-import { WaitlistDetailModal } from "../WaitlistDetailModal/WaitlistDetailModal";
-import type { StoreWaitlistEntry } from "@/app/api/__generated__/models/storeWaitlistEntry";
-import { useWaitlistSection } from "./useWaitlistSection";
-
-export function WaitlistSection() {
-  const { waitlists, joinedWaitlistIds, isLoading, hasError, markAsJoined } =
-    useWaitlistSection();
-  const [selectedWaitlist, setSelectedWaitlist] =
-    useState<StoreWaitlistEntry | null>(null);
-
-  function handleOpenModal(waitlist: StoreWaitlistEntry) {
-    setSelectedWaitlist(waitlist);
-  }
-
-  function handleJoinSuccess(waitlistId: string) {
-    markAsJoined(waitlistId);
-  }
-
-  // Don't render if loading, error, or no waitlists
-  if (isLoading || hasError || !waitlists || waitlists.length === 0) {
-    return null;
-  }
-
-  return (
-    <div className="flex flex-col items-center justify-center">
-      <div className="w-full max-w-[1360px]">
-        {/* Section Header */}
-        <div className="mb-6">
-          <h2 className="font-poppins text-2xl font-semibold text-[#282828] dark:text-neutral-200">
-            Help Shape What&apos;s Next
-          </h2>
-          <p className="mt-2 text-base text-neutral-600 dark:text-neutral-400">
-            These agents are in development. Your interest helps us prioritize
-            what gets built — and we&apos;ll notify you when they&apos;re ready.
-          </p>
-        </div>
-
-        {/* Mobile Carousel View */}
-        <Carousel
-          className="md:hidden"
-          opts={{
-            loop: true,
-          }}
-        >
-          <CarouselContent>
-            {waitlists.map((waitlist) => (
-              <CarouselItem
-                key={waitlist.waitlistId}
-                className="min-w-64 max-w-71"
-              >
-                <WaitlistCard
-                  name={waitlist.name}
-                  subHeading={waitlist.subHeading}
-                  description={waitlist.description}
-                  imageUrl={waitlist.imageUrls[0] || null}
-                  isMember={joinedWaitlistIds.has(waitlist.waitlistId)}
-                  onCardClick={() => handleOpenModal(waitlist)}
-                  onJoinClick={() => handleOpenModal(waitlist)}
-                />
-              </CarouselItem>
-            ))}
-          </CarouselContent>
-        </Carousel>
-
-        {/* Desktop Grid View */}
-        <div className="hidden grid-cols-1 place-items-center gap-6 md:grid md:grid-cols-2 lg:grid-cols-3">
-          {waitlists.map((waitlist) => (
-            <WaitlistCard
-              key={waitlist.waitlistId}
-              name={waitlist.name}
-              subHeading={waitlist.subHeading}
-              description={waitlist.description}
-              imageUrl={waitlist.imageUrls[0] || null}
-              isMember={joinedWaitlistIds.has(waitlist.waitlistId)}
-              onCardClick={() => handleOpenModal(waitlist)}
-              onJoinClick={() => handleOpenModal(waitlist)}
-            />
-          ))}
-        </div>
-      </div>
-
-      {/* Single Modal for both viewing and joining */}
-      {selectedWaitlist && (
-        <WaitlistDetailModal
-          waitlist={selectedWaitlist}
-          isMember={joinedWaitlistIds.has(selectedWaitlist.waitlistId)}
-          onClose={() => setSelectedWaitlist(null)}
-          onJoinSuccess={handleJoinSuccess}
-        />
-      )}
-    </div>
-  );
-}

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

@@ -1,58 +0,0 @@
-"use client";
-
-import { useMemo } from "react";
-import { useSupabaseStore } from "@/lib/supabase/hooks/useSupabaseStore";
-import {
-  useGetV2GetTheAgentWaitlist,
-  useGetV2GetWaitlistIdsTheCurrentUserHasJoined,
-  getGetV2GetWaitlistIdsTheCurrentUserHasJoinedQueryKey,
-} from "@/app/api/__generated__/endpoints/store/store";
-import type { StoreWaitlistEntry } from "@/app/api/__generated__/models/storeWaitlistEntry";
-import { useQueryClient } from "@tanstack/react-query";
-
-export function useWaitlistSection() {
-  const { user } = useSupabaseStore();
-  const queryClient = useQueryClient();
-
-  // Fetch waitlists
-  const {
-    data: waitlistsResponse,
-    isLoading: waitlistsLoading,
-    isError: waitlistsError,
-  } = useGetV2GetTheAgentWaitlist();
-
-  // Fetch memberships if logged in
-  const { data: membershipsResponse, isLoading: membershipsLoading } =
-    useGetV2GetWaitlistIdsTheCurrentUserHasJoined({
-      query: {
-        enabled: !!user,
-      },
-    });
-
-  const waitlists: StoreWaitlistEntry[] = useMemo(() => {
-    if (waitlistsResponse?.status === 200) {
-      return waitlistsResponse.data.listings;
-    }
-    return [];
-  }, [waitlistsResponse]);
-
-  const joinedWaitlistIds: Set<string> = useMemo(() => {
-    if (membershipsResponse?.status === 200) {
-      return new Set(membershipsResponse.data);
-    }
-    return new Set();
-  }, [membershipsResponse]);
-
-  const isLoading = waitlistsLoading || (!!user && membershipsLoading);
-  const hasError = waitlistsError;
-
-  // Function to add a waitlist ID to joined set (called after successful join)
-  function markAsJoined(_waitlistId: string) {
-    // Invalidate the memberships query to refetch
-    queryClient.invalidateQueries({
-      queryKey: getGetV2GetWaitlistIdsTheCurrentUserHasJoinedQueryKey(),
-    });
-  }
-
-  return { waitlists, joinedWaitlistIds, isLoading, hasError, markAsJoined };
-}

autogpt_platform/frontend/src/app/(platform)/monitoring/components/AgentFlowList.tsx

@@ -120,11 +120,9 @@ export const AgentFlowList = ({
                   lastRun =
                     runCount == 0
                       ? null
-                      : _flowRuns.reduce((a, c) => {
-                          const aTime = a.started_at?.getTime() ?? 0;
-                          const cTime = c.started_at?.getTime() ?? 0;
-                          return aTime > cTime ? a : c;
-                        });
+                      : _flowRuns.reduce((a, c) =>
+                          a.started_at > c.started_at ? a : c,
+                        );
                 }
                 return { flow, runCount, lastRun };
               })
@@ -132,9 +130,10 @@ export const AgentFlowList = ({
                 if (!a.lastRun && !b.lastRun) return 0;
                 if (!a.lastRun) return 1;
                 if (!b.lastRun) return -1;
-                const bTime = b.lastRun.started_at?.getTime() ?? 0;
-                const aTime = a.lastRun.started_at?.getTime() ?? 0;
-                return bTime - aTime;
+                return (
+                  b.lastRun.started_at.getTime() -
+                  a.lastRun.started_at.getTime()
+                );
               })
               .map(({ flow, runCount, lastRun }) => (
                 <TableRow

autogpt_platform/frontend/src/app/(platform)/monitoring/components/FlowRunsStatus.tsx

@@ -29,10 +29,7 @@ export const FlowRunsStatus: React.FC<{
         : statsSince;
   const filteredFlowRuns =
     statsSinceTimestamp != null
-      ? executions.filter(
-          (fr) =>
-            fr.started_at && fr.started_at.getTime() > statsSinceTimestamp,
-        )
+      ? executions.filter((fr) => fr.started_at.getTime() > statsSinceTimestamp)
       : executions;
 
   return (

autogpt_platform/frontend/src/app/(platform)/monitoring/components/FlowRunsTimeline.tsx

@@ -98,43 +98,40 @@ export const FlowRunsTimeline = ({
         <Scatter
           key={flow.id}
           data={executions
-            .filter((e) => e.graph_id == flow.graph_id && e.started_at)
+            .filter((e) => e.graph_id == flow.graph_id)
             .map((e) => ({
               ...e,
               time:
-                (e.started_at?.getTime() ?? 0) +
-                (e.stats?.node_exec_time ?? 0) * 1000,
+                e.started_at.getTime() + (e.stats?.node_exec_time ?? 0) * 1000,
               _duration: e.stats?.node_exec_time ?? 0,
             }))}
           name={flow.name}
           fill={`hsl(${(hashString(flow.id) * 137.5) % 360}, 70%, 50%)`}
         />
       ))}
-      {executions
-        .filter((e) => e.started_at && e.ended_at)
-        .map((execution) => (
-          <Line
-            key={execution.id}
-            type="linear"
-            dataKey="_duration"
-            data={[
-              {
-                ...execution,
-                time: execution.started_at!.getTime(),
-                _duration: 0,
-              },
-              {
-                ...execution,
-                time: execution.ended_at!.getTime(),
-                _duration: execution.stats?.node_exec_time ?? 0,
-              },
-            ]}
-            stroke={`hsl(${(hashString(execution.graph_id) * 137.5) % 360}, 70%, 50%)`}
-            strokeWidth={2}
-            dot={false}
-            legendType="none"
-          />
-        ))}
+      {executions.map((execution) => (
+        <Line
+          key={execution.id}
+          type="linear"
+          dataKey="_duration"
+          data={[
+            {
+              ...execution,
+              time: execution.started_at.getTime(),
+              _duration: 0,
+            },
+            {
+              ...execution,
+              time: execution.ended_at.getTime(),
+              _duration: execution.stats?.node_exec_time ?? 0,
+            },
+          ]}
+          stroke={`hsl(${(hashString(execution.graph_id) * 137.5) % 360}, 70%, 50%)`}
+          strokeWidth={2}
+          dot={false}
+          legendType="none"
+        />
+      ))}
       <Legend
         content={<ScrollableLegend />}
         wrapperStyle={{

autogpt_platform/frontend/src/app/(platform)/monitoring/page.tsx

@@ -98,11 +98,7 @@ const Monitor = () => {
           ...(selectedFlow
             ? executions.filter((v) => v.graph_id == selectedFlow.graph_id)
             : executions),
-        ].sort((a, b) => {
-          const aTime = a.started_at?.getTime() ?? 0;
-          const bTime = b.started_at?.getTime() ?? 0;
-          return bTime - aTime;
-        })}
+        ].sort((a, b) => b.started_at.getTime() - a.started_at.getTime())}
         selectedRun={selectedRun}
         onSelectRun={(r) => setSelectedRun(r.id == selectedRun?.id ? null : r)}
       />

autogpt_platform/frontend/src/app/(platform)/profile/(user)/integrations/page.tsx

@@ -116,9 +116,6 @@ export default function UserIntegrationsPage() {
       "63a6e279-2dc2-448e-bf57-85776f7176dc", // ZeroBounce
       "9aa1bde0-4947-4a70-a20c-84daa3850d52", // Google Maps
       "d44045af-1c33-4833-9e19-752313214de2", // Llama API
-      "c4e6d1a0-3b5f-4789-a8e2-9b123456789f", // V0 by Vercel
-      "a5b3c7d9-2e4f-4a6b-8c1d-9e0f1a2b3c4d", // Webshare Proxy
-      "8b3d4e5f-6a7b-8c9d-0e1f-2a3b4c5d6e7f", // OpenWeatherMap
     ],
     [],
   );

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

@@ -5082,301 +5082,6 @@
         }
       }
     },
-    "/api/store/admin/waitlist": {
-      "get": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "List All Waitlists",
-        "description": "Get all waitlists with admin details (admin only).\n\nReturns:\n    WaitlistAdminListResponse with all waitlists",
-        "operationId": "getV2List all waitlists",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminListResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          }
-        },
-        "security": [{ "HTTPBearerJWT": [] }]
-      },
-      "post": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Create Waitlist",
-        "description": "Create a new waitlist (admin only).\n\nArgs:\n    request: Waitlist creation details\n    user_id: Authenticated admin user creating the waitlist\n\nReturns:\n    WaitlistAdminResponse with the created waitlist details",
-        "operationId": "postV2Create waitlist",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": { "$ref": "#/components/schemas/WaitlistCreateRequest" }
-            }
-          },
-          "required": true
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        },
-        "security": [{ "HTTPBearerJWT": [] }]
-      }
-    },
-    "/api/store/admin/waitlist/{waitlist_id}": {
-      "delete": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Delete Waitlist",
-        "description": "Soft delete a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to delete\n\nReturns:\n    Success message",
-        "operationId": "deleteV2Delete waitlist",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": { "application/json": { "schema": {} } }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      },
-      "get": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Get Waitlist Details",
-        "description": "Get a single waitlist with admin details (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to retrieve\n\nReturns:\n    WaitlistAdminResponse with waitlist details",
-        "operationId": "getV2Get waitlist details",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      },
-      "put": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Update Waitlist",
-        "description": "Update a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to update\n    request: Fields to update\n\nReturns:\n    WaitlistAdminResponse with updated waitlist details",
-        "operationId": "putV2Update waitlist",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": {
-              "schema": { "$ref": "#/components/schemas/WaitlistUpdateRequest" }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/store/admin/waitlist/{waitlist_id}/link": {
-      "post": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Link Waitlist to Store Listing",
-        "description": "Link a waitlist to a store listing (admin only).\n\nWhen the linked store listing is approved/published, waitlist users\nwill be automatically notified.\n\nArgs:\n    waitlist_id: ID of the waitlist\n    store_listing_id: ID of the store listing to link\n\nReturns:\n    WaitlistAdminResponse with updated waitlist details",
-        "operationId": "postV2Link waitlist to store listing",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/Body_postV2Link_waitlist_to_store_listing"
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/store/admin/waitlist/{waitlist_id}/signups": {
-      "get": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Get Waitlist Signups",
-        "description": "Get all signups for a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist\n\nReturns:\n    WaitlistSignupListResponse with all signups",
-        "operationId": "getV2Get waitlist signups",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistSignupListResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
     "/api/store/agents": {
       "get": {
         "tags": ["v2", "store", "public"],
@@ -6222,101 +5927,6 @@
         }
       }
     },
-    "/api/store/waitlist": {
-      "get": {
-        "tags": ["v2", "store", "public"],
-        "summary": "Get the agent waitlist",
-        "description": "Get all active waitlists for public display.",
-        "operationId": "getV2Get the agent waitlist",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/StoreWaitlistsAllResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/store/waitlist/my-memberships": {
-      "get": {
-        "tags": ["v2", "store", "private"],
-        "summary": "Get waitlist IDs the current user has joined",
-        "description": "Returns list of waitlist IDs the authenticated user has joined.",
-        "operationId": "getV2Get waitlist ids the current user has joined",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "items": { "type": "string" },
-                  "type": "array",
-                  "title": "Response Getv2Get Waitlist Ids The Current User Has Joined"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          }
-        },
-        "security": [{ "HTTPBearerJWT": [] }]
-      }
-    },
-    "/api/store/waitlist/{waitlist_id}/join": {
-      "post": {
-        "tags": ["v2", "store", "public"],
-        "summary": "Add self to the agent waitlist",
-        "description": "Add the current user to the agent waitlist.",
-        "operationId": "postV2Add self to the agent waitlist",
-        "security": [{ "HTTPBearer": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist to join",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist to join"
-          }
-        ],
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/Body_postV2Add_self_to_the_agent_waitlist"
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/StoreWaitlistEntry" }
-              }
-            }
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
     "/health": {
       "get": {
         "tags": ["health"],
@@ -7064,17 +6674,6 @@
         "required": ["store_listing_version_id"],
         "title": "Body_postV2Add marketplace agent"
       },
-      "Body_postV2Add_self_to_the_agent_waitlist": {
-        "properties": {
-          "email": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Email",
-            "description": "Email address for unauthenticated users"
-          }
-        },
-        "type": "object",
-        "title": "Body_postV2Add self to the agent waitlist"
-      },
       "Body_postV2Execute_a_preset": {
         "properties": {
           "inputs": {
@@ -7093,18 +6692,6 @@
         "type": "object",
         "title": "Body_postV2Execute a preset"
       },
-      "Body_postV2Link_waitlist_to_store_listing": {
-        "properties": {
-          "store_listing_id": {
-            "type": "string",
-            "title": "Store Listing Id",
-            "description": "The ID of the store listing"
-          }
-        },
-        "type": "object",
-        "required": ["store_listing_id"],
-        "title": "Body_postV2Link waitlist to store listing"
-      },
       "Body_postV2Upload_submission_media": {
         "properties": {
           "file": { "type": "string", "format": "binary", "title": "File" }
@@ -7561,20 +7148,6 @@
           "error_message": {
             "anyOf": [{ "type": "string" }, { "type": "null" }],
             "title": "Error Message"
-          },
-          "started_at": {
-            "anyOf": [
-              { "type": "string", "format": "date-time" },
-              { "type": "null" }
-            ],
-            "title": "Started At"
-          },
-          "ended_at": {
-            "anyOf": [
-              { "type": "string", "format": "date-time" },
-              { "type": "null" }
-            ],
-            "title": "Ended At"
           }
         },
         "type": "object",
@@ -7681,20 +7254,14 @@
           },
           "status": { "$ref": "#/components/schemas/AgentExecutionStatus" },
           "started_at": {
-            "anyOf": [
-              { "type": "string", "format": "date-time" },
-              { "type": "null" }
-            ],
-            "title": "Started At",
-            "description": "When execution started running. Null if not yet started (QUEUED)."
+            "type": "string",
+            "format": "date-time",
+            "title": "Started At"
           },
           "ended_at": {
-            "anyOf": [
-              { "type": "string", "format": "date-time" },
-              { "type": "null" }
-            ],
-            "title": "Ended At",
-            "description": "When execution finished. Null if not yet completed (QUEUED, RUNNING, INCOMPLETE, REVIEW)."
+            "type": "string",
+            "format": "date-time",
+            "title": "Ended At"
           },
           "is_shared": {
             "type": "boolean",
@@ -7728,6 +7295,8 @@
           "nodes_input_masks",
           "preset_id",
           "status",
+          "started_at",
+          "ended_at",
           "stats",
           "outputs"
         ],
@@ -7826,20 +7395,14 @@
           },
           "status": { "$ref": "#/components/schemas/AgentExecutionStatus" },
           "started_at": {
-            "anyOf": [
-              { "type": "string", "format": "date-time" },
-              { "type": "null" }
-            ],
-            "title": "Started At",
-            "description": "When execution started running. Null if not yet started (QUEUED)."
+            "type": "string",
+            "format": "date-time",
+            "title": "Started At"
           },
           "ended_at": {
-            "anyOf": [
-              { "type": "string", "format": "date-time" },
-              { "type": "null" }
-            ],
-            "title": "Ended At",
-            "description": "When execution finished. Null if not yet completed (QUEUED, RUNNING, INCOMPLETE, REVIEW)."
+            "type": "string",
+            "format": "date-time",
+            "title": "Ended At"
           },
           "is_shared": {
             "type": "boolean",
@@ -7868,6 +7431,8 @@
           "nodes_input_masks",
           "preset_id",
           "status",
+          "started_at",
+          "ended_at",
           "stats"
         ],
         "title": "GraphExecutionMeta"
@@ -7914,20 +7479,14 @@
           },
           "status": { "$ref": "#/components/schemas/AgentExecutionStatus" },
           "started_at": {
-            "anyOf": [
-              { "type": "string", "format": "date-time" },
-              { "type": "null" }
-            ],
-            "title": "Started At",
-            "description": "When execution started running. Null if not yet started (QUEUED)."
+            "type": "string",
+            "format": "date-time",
+            "title": "Started At"
           },
           "ended_at": {
-            "anyOf": [
-              { "type": "string", "format": "date-time" },
-              { "type": "null" }
-            ],
-            "title": "Ended At",
-            "description": "When execution finished. Null if not yet completed (QUEUED, RUNNING, INCOMPLETE, REVIEW)."
+            "type": "string",
+            "format": "date-time",
+            "title": "Ended At"
           },
           "is_shared": {
             "type": "boolean",
@@ -7966,6 +7525,8 @@
           "nodes_input_masks",
           "preset_id",
           "status",
+          "started_at",
+          "ended_at",
           "stats",
           "outputs",
           "node_executions"
@@ -8984,8 +8545,7 @@
           "REFUND_REQUEST",
           "REFUND_PROCESSED",
           "AGENT_APPROVED",
-          "AGENT_REJECTED",
-          "WAITLIST_LAUNCH"
+          "AGENT_REJECTED"
         ],
         "title": "NotificationType"
       },
@@ -10548,57 +10108,6 @@
         "required": ["submissions", "pagination"],
         "title": "StoreSubmissionsResponse"
       },
-      "StoreWaitlistEntry": {
-        "properties": {
-          "waitlistId": { "type": "string", "title": "Waitlistid" },
-          "slug": { "type": "string", "title": "Slug" },
-          "name": { "type": "string", "title": "Name" },
-          "subHeading": { "type": "string", "title": "Subheading" },
-          "videoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Videourl"
-          },
-          "agentOutputDemoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Agentoutputdemourl"
-          },
-          "imageUrls": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Imageurls"
-          },
-          "description": { "type": "string", "title": "Description" },
-          "categories": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Categories"
-          }
-        },
-        "type": "object",
-        "required": [
-          "waitlistId",
-          "slug",
-          "name",
-          "subHeading",
-          "imageUrls",
-          "description",
-          "categories"
-        ],
-        "title": "StoreWaitlistEntry",
-        "description": "Public waitlist entry - no PII fields exposed."
-      },
-      "StoreWaitlistsAllResponse": {
-        "properties": {
-          "listings": {
-            "items": { "$ref": "#/components/schemas/StoreWaitlistEntry" },
-            "type": "array",
-            "title": "Listings"
-          }
-        },
-        "type": "object",
-        "required": ["listings"],
-        "title": "StoreWaitlistsAllResponse"
-      },
       "StreamChatRequest": {
         "properties": {
           "message": { "type": "string", "title": "Message" },
@@ -12418,203 +11927,6 @@
         "required": ["loc", "msg", "type"],
         "title": "ValidationError"
       },
-      "WaitlistAdminListResponse": {
-        "properties": {
-          "waitlists": {
-            "items": { "$ref": "#/components/schemas/WaitlistAdminResponse" },
-            "type": "array",
-            "title": "Waitlists"
-          },
-          "totalCount": { "type": "integer", "title": "Totalcount" }
-        },
-        "type": "object",
-        "required": ["waitlists", "totalCount"],
-        "title": "WaitlistAdminListResponse",
-        "description": "Response model for listing all waitlists (admin view)."
-      },
-      "WaitlistAdminResponse": {
-        "properties": {
-          "id": { "type": "string", "title": "Id" },
-          "createdAt": { "type": "string", "title": "Createdat" },
-          "updatedAt": { "type": "string", "title": "Updatedat" },
-          "slug": { "type": "string", "title": "Slug" },
-          "name": { "type": "string", "title": "Name" },
-          "subHeading": { "type": "string", "title": "Subheading" },
-          "description": { "type": "string", "title": "Description" },
-          "categories": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Categories"
-          },
-          "imageUrls": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Imageurls"
-          },
-          "videoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Videourl"
-          },
-          "agentOutputDemoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Agentoutputdemourl"
-          },
-          "status": { "$ref": "#/components/schemas/WaitlistExternalStatus" },
-          "votes": { "type": "integer", "title": "Votes" },
-          "signupCount": { "type": "integer", "title": "Signupcount" },
-          "storeListingId": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Storelistingid"
-          },
-          "owningUserId": { "type": "string", "title": "Owninguserid" }
-        },
-        "type": "object",
-        "required": [
-          "id",
-          "createdAt",
-          "updatedAt",
-          "slug",
-          "name",
-          "subHeading",
-          "description",
-          "categories",
-          "imageUrls",
-          "status",
-          "votes",
-          "signupCount",
-          "owningUserId"
-        ],
-        "title": "WaitlistAdminResponse",
-        "description": "Admin response model with full waitlist details including internal data."
-      },
-      "WaitlistCreateRequest": {
-        "properties": {
-          "name": { "type": "string", "title": "Name" },
-          "slug": { "type": "string", "title": "Slug" },
-          "subHeading": { "type": "string", "title": "Subheading" },
-          "description": { "type": "string", "title": "Description" },
-          "categories": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Categories",
-            "default": []
-          },
-          "imageUrls": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Imageurls",
-            "default": []
-          },
-          "videoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Videourl"
-          },
-          "agentOutputDemoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Agentoutputdemourl"
-          }
-        },
-        "type": "object",
-        "required": ["name", "slug", "subHeading", "description"],
-        "title": "WaitlistCreateRequest",
-        "description": "Request model for creating a new waitlist."
-      },
-      "WaitlistExternalStatus": {
-        "type": "string",
-        "enum": ["DONE", "NOT_STARTED", "CANCELED", "WORK_IN_PROGRESS"],
-        "title": "WaitlistExternalStatus"
-      },
-      "WaitlistSignup": {
-        "properties": {
-          "type": { "type": "string", "title": "Type" },
-          "userId": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Userid"
-          },
-          "email": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Email"
-          },
-          "username": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Username"
-          }
-        },
-        "type": "object",
-        "required": ["type"],
-        "title": "WaitlistSignup",
-        "description": "Individual signup entry for a waitlist."
-      },
-      "WaitlistSignupListResponse": {
-        "properties": {
-          "waitlistId": { "type": "string", "title": "Waitlistid" },
-          "signups": {
-            "items": { "$ref": "#/components/schemas/WaitlistSignup" },
-            "type": "array",
-            "title": "Signups"
-          },
-          "totalCount": { "type": "integer", "title": "Totalcount" }
-        },
-        "type": "object",
-        "required": ["waitlistId", "signups", "totalCount"],
-        "title": "WaitlistSignupListResponse",
-        "description": "Response model for listing waitlist signups."
-      },
-      "WaitlistUpdateRequest": {
-        "properties": {
-          "name": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Name"
-          },
-          "slug": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Slug"
-          },
-          "subHeading": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Subheading"
-          },
-          "description": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Description"
-          },
-          "categories": {
-            "anyOf": [
-              { "items": { "type": "string" }, "type": "array" },
-              { "type": "null" }
-            ],
-            "title": "Categories"
-          },
-          "imageUrls": {
-            "anyOf": [
-              { "items": { "type": "string" }, "type": "array" },
-              { "type": "null" }
-            ],
-            "title": "Imageurls"
-          },
-          "videoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Videourl"
-          },
-          "agentOutputDemoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Agentoutputdemourl"
-          },
-          "status": {
-            "anyOf": [
-              { "$ref": "#/components/schemas/WaitlistExternalStatus" },
-              { "type": "null" }
-            ]
-          },
-          "storeListingId": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Storelistingid"
-          }
-        },
-        "type": "object",
-        "title": "WaitlistUpdateRequest",
-        "description": "Request model for updating a waitlist."
-      },
       "Webhook": {
         "properties": {
           "id": { "type": "string", "title": "Id" },

autogpt_platform/frontend/src/components/layout/Navbar/components/AgentActivityDropdown/components/ActivityItem.tsx

@@ -50,9 +50,7 @@ export function ActivityItem({ execution }: Props) {
       execution.status === AgentExecutionStatus.QUEUED;
 
     if (isActiveStatus) {
-      const timeAgo = execution.started_at
-        ? formatTimeAgo(execution.started_at.toString())
-        : "recently";
+      const timeAgo = formatTimeAgo(execution.started_at.toString());
       const statusText =
         execution.status === AgentExecutionStatus.QUEUED ? "queued" : "running";
       return [
@@ -63,9 +61,7 @@ export function ActivityItem({ execution }: Props) {
     // Handle all other statuses with time display
     const timeAgo = execution.ended_at
       ? formatTimeAgo(execution.ended_at.toString())
-      : execution.started_at
-        ? formatTimeAgo(execution.started_at.toString())
-        : "recently";
+      : formatTimeAgo(execution.started_at.toString());
 
     let statusText = "ended";
     switch (execution.status) {

autogpt_platform/frontend/src/lib/autogpt-server-api/types.ts

@@ -327,8 +327,8 @@ export type GraphExecutionMeta = {
     | "FAILED"
     | "INCOMPLETE"
     | "REVIEW";
-  started_at: Date | null;
-  ended_at: Date | null;
+  started_at: Date;
+  ended_at: Date;
   stats: {
     error: string | null;
     cost: number;

autogpt_platform/frontend/src/tests/agent-activity.spec.ts

@@ -39,9 +39,10 @@ test.beforeEach(async ({ page }) => {
   await page.waitForTimeout(1000);
 
   await page.goto("/library");
-  // Navigate to the specific agent we just created, not just the first one
-  await LibraryPage.navigateToAgentByName(page, "Test Agent");
+  await LibraryPage.clickFirstAgent(page);
   await LibraryPage.waitForAgentPageLoad(page);
+  const { getRole } = getSelectors(page);
+  await isVisible(getRole("heading", "Test Agent"), 8000);
 });
 
 test("shows badge with count when agent is running", async ({ page }) => {

autogpt_platform/frontend/src/tests/pages/library.page.ts

@@ -450,72 +450,45 @@ export async function navigateToAgentByName(
   agentName: string,
 ): Promise<void> {
   const agentCard = getAgentCards(page).filter({ hasText: agentName }).first();
-  // Wait for the agent card to be visible before clicking
-  // This handles async loading of agents after page navigation
-  await agentCard.waitFor({ state: "visible", timeout: 15000 });
   await agentCard.click();
 }
 
 export async function clickRunButton(page: Page): Promise<void> {
   const { getId } = getSelectors(page);
 
-  // Wait for page to stabilize and buttons to render
-  // The NewAgentLibraryView shows either "Setup your task" (empty state)
-  // or "New task" (with items) button
   const setupTaskButton = page.getByRole("button", {
     name: /Setup your task/i,
   });
-  const newTaskButton = page.getByRole("button", { name: /New task/i });
-  const runButton = getId("agent-run-button");
-  const runAgainButton = getId("run-again-button");
 
-  // Use Promise.race with waitFor to wait for any of the buttons to appear
-  // This handles the async rendering in CI environments
-  try {
-    await Promise.race([
-      setupTaskButton.waitFor({ state: "visible", timeout: 15000 }),
-      newTaskButton.waitFor({ state: "visible", timeout: 15000 }),
-      runButton.waitFor({ state: "visible", timeout: 15000 }),
-      runAgainButton.waitFor({ state: "visible", timeout: 15000 }),
-    ]);
-  } catch {
-    throw new Error(
-      "Could not find run/start task button - none of the expected buttons appeared",
-    );
-  }
-
-  // Now check which button is visible and click it
   if (await setupTaskButton.isVisible()) {
     await setupTaskButton.click();
     const startTaskButton = page
       .getByRole("button", { name: /Start Task/i })
       .first();
-    await startTaskButton.waitFor({ state: "visible", timeout: 10000 });
     await startTaskButton.click();
     return;
   }
 
+  const newTaskButton = page.getByRole("button", { name: /New task/i });
   if (await newTaskButton.isVisible()) {
     await newTaskButton.click();
     const startTaskButton = page
       .getByRole("button", { name: /Start Task/i })
       .first();
-    await startTaskButton.waitFor({ state: "visible", timeout: 10000 });
     await startTaskButton.click();
     return;
   }
 
+  const runButton = getId("agent-run-button");
+  const runAgainButton = getId("run-again-button");
+
   if (await runButton.isVisible()) {
     await runButton.click();
-    return;
-  }
-
-  if (await runAgainButton.isVisible()) {
+  } else if (await runAgainButton.isVisible()) {
     await runAgainButton.click();
-    return;
+  } else {
+    throw new Error("Could not find run/start task button");
   }
-
-  throw new Error("Could not find run/start task button");
 }
 
 export async function clickNewRunButton(page: Page): Promise<void> {

backend/blocks/video/__init__.py

@@ -1 +0,0 @@
-# Video editing blocks