feat(backend): add waitlist_launch email notification template

The WAITLIST_LAUNCH notification type was referencing a template that
didn't exist, causing FileNotFoundError when trying to notify users
that an agent they waitlisted has launched.

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

autogpt_platform/Makefile

@@ -6,10 +6,9 @@ start-core:
 
 # Stop core services
 stop-core:
-	docker compose stop 
+	docker compose stop deps
 
 reset-db:
-	docker compose stop db
 	rm -rf db/docker/volumes/db/data
 	cd backend && poetry run prisma migrate deploy
 	cd backend && poetry run prisma generate
@@ -61,4 +60,4 @@ help:
 	@echo "  run-backend - Run the backend FastAPI server"
 	@echo "  run-frontend - Run the frontend Next.js development server"
 	@echo "  test-data - Run the test data creator"
-	@echo "  load-store-agents - Load store agents from agents/ folder into test database"
+	@echo "  load-store-agents - Load store agents from agents/ folder into test database"

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

@@ -0,0 +1,250 @@
+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:
+        deleted = await store_db.delete_waitlist_admin(waitlist_id)
+        if deleted:
+            return {"message": "Waitlist deleted successfully"}
+        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/config.py

@@ -12,11 +12,7 @@ class ChatConfig(BaseSettings):
 
     # OpenAI API Configuration
     model: str = Field(
-        default="anthropic/claude-opus-4.5", description="Default model to use"
-    )
-    title_model: str = Field(
-        default="openai/gpt-4o-mini",
-        description="Model to use for generating session titles (should be fast/cheap)",
+        default="qwen/qwen3-235b-a22b-2507", description="Default model to use"
     )
     api_key: str | None = Field(default=None, description="OpenAI API key")
     base_url: str | None = Field(
@@ -76,31 +72,8 @@ class ChatConfig(BaseSettings):
                 v = "https://openrouter.ai/api/v1"
         return v
 
-    # Prompt paths for different contexts
-    PROMPT_PATHS: dict[str, str] = {
-        "default": "prompts/chat_system.md",
-        "onboarding": "prompts/onboarding_system.md",
-    }
-
-    def get_system_prompt_for_type(
-        self, prompt_type: str = "default", **template_vars
-    ) -> str:
-        """Load and render a system prompt by type.
-
-        Args:
-            prompt_type: The type of prompt to load ("default" or "onboarding")
-            **template_vars: Variables to substitute in the template
-
-        Returns:
-            Rendered system prompt string
-        """
-        prompt_path_str = self.PROMPT_PATHS.get(
-            prompt_type, self.PROMPT_PATHS["default"]
-        )
-        return self._load_prompt_from_path(prompt_path_str, **template_vars)
-
     def get_system_prompt(self, **template_vars) -> str:
-        """Load and render the default system prompt from file.
+        """Load and render the system prompt from file.
 
         Args:
             **template_vars: Variables to substitute in the template
@@ -109,21 +82,9 @@ class ChatConfig(BaseSettings):
             Rendered system prompt string
 
         """
-        return self._load_prompt_from_path(self.system_prompt_path, **template_vars)
-
-    def _load_prompt_from_path(self, prompt_path_str: str, **template_vars) -> str:
-        """Load and render a system prompt from a given path.
-
-        Args:
-            prompt_path_str: Path to the prompt file relative to chat module
-            **template_vars: Variables to substitute in the template
-
-        Returns:
-            Rendered system prompt string
-        """
         # Get the path relative to this module
         module_dir = Path(__file__).parent
-        prompt_path = module_dir / prompt_path_str
+        prompt_path = module_dir / self.system_prompt_path
 
         # Check for .j2 extension first (Jinja2 template)
         j2_path = Path(str(prompt_path) + ".j2")

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

@@ -1,215 +0,0 @@
-"""Database operations for chat sessions."""
-
-import logging
-from datetime import UTC, datetime
-from typing import Any, cast
-
-from prisma.models import ChatMessage as PrismaChatMessage
-from prisma.models import ChatSession as PrismaChatSession
-from prisma.types import (
-    ChatMessageCreateInput,
-    ChatSessionCreateInput,
-    ChatSessionUpdateInput,
-)
-
-from backend.util.json import SafeJson
-
-logger = logging.getLogger(__name__)
-
-
-async def get_chat_session(session_id: str) -> PrismaChatSession | None:
-    """Get a chat session by ID from the database."""
-    session = await PrismaChatSession.prisma().find_unique(
-        where={"id": session_id},
-        include={"Messages": True},
-    )
-    if session and session.Messages:
-        # Sort messages by sequence in Python since Prisma doesn't support order_by in include
-        session.Messages.sort(key=lambda m: m.sequence)
-    return session
-
-
-async def create_chat_session(
-    session_id: str,
-    user_id: str | None,
-) -> PrismaChatSession:
-    """Create a new chat session in the database."""
-    data = ChatSessionCreateInput(
-        id=session_id,
-        userId=user_id,
-        credentials=SafeJson({}),
-        successfulAgentRuns=SafeJson({}),
-        successfulAgentSchedules=SafeJson({}),
-    )
-    return await PrismaChatSession.prisma().create(
-        data=data,
-        include={"Messages": True},
-    )
-
-
-async def update_chat_session(
-    session_id: str,
-    credentials: dict[str, Any] | None = None,
-    successful_agent_runs: dict[str, Any] | None = None,
-    successful_agent_schedules: dict[str, Any] | None = None,
-    total_prompt_tokens: int | None = None,
-    total_completion_tokens: int | None = None,
-    title: str | None = None,
-) -> PrismaChatSession | None:
-    """Update a chat session's metadata."""
-    data: ChatSessionUpdateInput = {"updatedAt": datetime.now(UTC)}
-
-    if credentials is not None:
-        data["credentials"] = SafeJson(credentials)
-    if successful_agent_runs is not None:
-        data["successfulAgentRuns"] = SafeJson(successful_agent_runs)
-    if successful_agent_schedules is not None:
-        data["successfulAgentSchedules"] = SafeJson(successful_agent_schedules)
-    if total_prompt_tokens is not None:
-        data["totalPromptTokens"] = total_prompt_tokens
-    if total_completion_tokens is not None:
-        data["totalCompletionTokens"] = total_completion_tokens
-    if title is not None:
-        data["title"] = title
-
-    session = await PrismaChatSession.prisma().update(
-        where={"id": session_id},
-        data=data,
-        include={"Messages": True},
-    )
-    if session and session.Messages:
-        session.Messages.sort(key=lambda m: m.sequence)
-    return session
-
-
-async def add_chat_message(
-    session_id: str,
-    role: str,
-    sequence: int,
-    content: str | None = None,
-    name: str | None = None,
-    tool_call_id: str | None = None,
-    refusal: str | None = None,
-    tool_calls: list[dict[str, Any]] | None = None,
-    function_call: dict[str, Any] | None = None,
-) -> PrismaChatMessage:
-    """Add a message to a chat session."""
-    # Build the input dict dynamically - only include optional fields when they
-    # have values, as Prisma TypedDict validation fails when optional fields
-    # are explicitly set to None
-    data: dict[str, Any] = {
-        "Session": {"connect": {"id": session_id}},
-        "role": role,
-        "sequence": sequence,
-    }
-
-    # Add optional string fields
-    if content is not None:
-        data["content"] = content
-    if name is not None:
-        data["name"] = name
-    if tool_call_id is not None:
-        data["toolCallId"] = tool_call_id
-    if refusal is not None:
-        data["refusal"] = refusal
-
-    # Add optional JSON fields only when they have values
-    if tool_calls is not None:
-        data["toolCalls"] = SafeJson(tool_calls)
-    if function_call is not None:
-        data["functionCall"] = SafeJson(function_call)
-
-    # Update session's updatedAt timestamp
-    await PrismaChatSession.prisma().update(
-        where={"id": session_id},
-        data={"updatedAt": datetime.now(UTC)},
-    )
-
-    return await PrismaChatMessage.prisma().create(
-        data=cast(ChatMessageCreateInput, data)
-    )
-
-
-async def add_chat_messages_batch(
-    session_id: str,
-    messages: list[dict[str, Any]],
-    start_sequence: int,
-) -> list[PrismaChatMessage]:
-    """Add multiple messages to a chat session in a batch."""
-    if not messages:
-        return []
-
-    created_messages = []
-    for i, msg in enumerate(messages):
-        # Build the input dict dynamically - only include optional JSON fields
-        # when they have values, as Prisma TypedDict validation fails when
-        # optional fields are explicitly set to None
-        data: dict[str, Any] = {
-            "Session": {"connect": {"id": session_id}},
-            "role": msg["role"],
-            "sequence": start_sequence + i,
-        }
-
-        # Add optional string fields
-        if msg.get("content") is not None:
-            data["content"] = msg["content"]
-        if msg.get("name") is not None:
-            data["name"] = msg["name"]
-        if msg.get("tool_call_id") is not None:
-            data["toolCallId"] = msg["tool_call_id"]
-        if msg.get("refusal") is not None:
-            data["refusal"] = msg["refusal"]
-
-        # Add optional JSON fields only when they have values
-        if msg.get("tool_calls") is not None:
-            data["toolCalls"] = SafeJson(msg["tool_calls"])
-        if msg.get("function_call") is not None:
-            data["functionCall"] = SafeJson(msg["function_call"])
-
-        created = await PrismaChatMessage.prisma().create(
-            data=cast(ChatMessageCreateInput, data)
-        )
-        created_messages.append(created)
-
-    # Update session's updatedAt timestamp
-    await PrismaChatSession.prisma().update(
-        where={"id": session_id},
-        data={"updatedAt": datetime.now(UTC)},
-    )
-
-    return created_messages
-
-
-async def get_user_chat_sessions(
-    user_id: str,
-    limit: int = 50,
-    offset: int = 0,
-) -> list[PrismaChatSession]:
-    """Get chat sessions for a user, ordered by most recent."""
-    return await PrismaChatSession.prisma().find_many(
-        where={"userId": user_id},
-        order={"updatedAt": "desc"},
-        take=limit,
-        skip=offset,
-    )
-
-
-async def get_user_session_count(user_id: str) -> int:
-    """Get the total number of chat sessions for a user."""
-    return await PrismaChatSession.prisma().count(where={"userId": user_id})
-
-
-async def delete_chat_session(session_id: str) -> bool:
-    """Delete a chat session and all its messages."""
-    try:
-        await PrismaChatSession.prisma().delete(where={"id": session_id})
-        return True
-    except Exception as e:
-        logger.error(f"Failed to delete chat session {session_id}: {e}")
-        return False
-
-
-async def get_chat_session_message_count(session_id: str) -> int:
-    """Get the number of messages in a chat session."""
-    count = await PrismaChatMessage.prisma().count(where={"sessionId": session_id})
-    return count

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

@@ -16,15 +16,11 @@ from openai.types.chat.chat_completion_message_tool_call_param import (
     ChatCompletionMessageToolCallParam,
     Function,
 )
-from prisma.models import ChatMessage as PrismaChatMessage
-from prisma.models import ChatSession as PrismaChatSession
 from pydantic import BaseModel
 
 from backend.data.redis_client import get_redis_async
-from backend.util import json
 from backend.util.exceptions import RedisError
 
-from . import db as chat_db
 from .config import ChatConfig
 
 logger = logging.getLogger(__name__)
@@ -50,7 +46,6 @@ class Usage(BaseModel):
 class ChatSession(BaseModel):
     session_id: str
     user_id: str | None
-    title: str | None = None
     messages: list[ChatMessage]
     usage: list[Usage]
     credentials: dict[str, dict] = {}  # Map of provider -> credential metadata
@@ -64,7 +59,6 @@ class ChatSession(BaseModel):
         return ChatSession(
             session_id=str(uuid.uuid4()),
             user_id=user_id,
-            title=None,
             messages=[],
             usage=[],
             credentials={},
@@ -72,85 +66,6 @@ class ChatSession(BaseModel):
             updated_at=datetime.now(UTC),
         )
 
-    @staticmethod
-    def from_prisma(
-        prisma_session: PrismaChatSession,
-        prisma_messages: list[PrismaChatMessage] | None = None,
-    ) -> "ChatSession":
-        """Convert Prisma models to Pydantic ChatSession."""
-        messages = []
-        if prisma_messages:
-            for msg in prisma_messages:
-                tool_calls = None
-                if msg.toolCalls:
-                    tool_calls = (
-                        json.loads(msg.toolCalls)
-                        if isinstance(msg.toolCalls, str)
-                        else msg.toolCalls
-                    )
-
-                function_call = None
-                if msg.functionCall:
-                    function_call = (
-                        json.loads(msg.functionCall)
-                        if isinstance(msg.functionCall, str)
-                        else msg.functionCall
-                    )
-
-                messages.append(
-                    ChatMessage(
-                        role=msg.role,
-                        content=msg.content,
-                        name=msg.name,
-                        tool_call_id=msg.toolCallId,
-                        refusal=msg.refusal,
-                        tool_calls=tool_calls,
-                        function_call=function_call,
-                    )
-                )
-
-        # Parse JSON fields from Prisma
-        credentials = (
-            json.loads(prisma_session.credentials)
-            if isinstance(prisma_session.credentials, str)
-            else prisma_session.credentials or {}
-        )
-        successful_agent_runs = (
-            json.loads(prisma_session.successfulAgentRuns)
-            if isinstance(prisma_session.successfulAgentRuns, str)
-            else prisma_session.successfulAgentRuns or {}
-        )
-        successful_agent_schedules = (
-            json.loads(prisma_session.successfulAgentSchedules)
-            if isinstance(prisma_session.successfulAgentSchedules, str)
-            else prisma_session.successfulAgentSchedules or {}
-        )
-
-        # Calculate usage from token counts
-        usage = []
-        if prisma_session.totalPromptTokens or prisma_session.totalCompletionTokens:
-            usage.append(
-                Usage(
-                    prompt_tokens=prisma_session.totalPromptTokens or 0,
-                    completion_tokens=prisma_session.totalCompletionTokens or 0,
-                    total_tokens=(prisma_session.totalPromptTokens or 0)
-                    + (prisma_session.totalCompletionTokens or 0),
-                )
-            )
-
-        return ChatSession(
-            session_id=prisma_session.id,
-            user_id=prisma_session.userId,
-            title=prisma_session.title,
-            messages=messages,
-            usage=usage,
-            credentials=credentials,
-            started_at=prisma_session.createdAt,
-            updated_at=prisma_session.updatedAt,
-            successful_agent_runs=successful_agent_runs,
-            successful_agent_schedules=successful_agent_schedules,
-        )
-
     def to_openai_messages(self) -> list[ChatCompletionMessageParam]:
         messages = []
         for message in self.messages:
@@ -240,234 +155,50 @@ class ChatSession(BaseModel):
         return messages
 
 
-async def _get_session_from_cache(session_id: str) -> ChatSession | None:
-    """Get a chat session from Redis cache."""
-    redis_key = f"chat:session:{session_id}"
-    async_redis = await get_redis_async()
-    raw_session: bytes | None = await async_redis.get(redis_key)
-
-    if raw_session is None:
-        return None
-
-    try:
-        session = ChatSession.model_validate_json(raw_session)
-        logger.info(
-            f"Loading session {session_id} from cache: "
-            f"message_count={len(session.messages)}, "
-            f"roles={[m.role for m in session.messages]}"
-        )
-        return session
-    except Exception as e:
-        logger.error(f"Failed to deserialize session {session_id}: {e}", exc_info=True)
-        raise RedisError(f"Corrupted session data for {session_id}") from e
-
-
-async def _cache_session(session: ChatSession) -> None:
-    """Cache a chat session in Redis."""
-    redis_key = f"chat:session:{session.session_id}"
-    async_redis = await get_redis_async()
-    await async_redis.setex(redis_key, config.session_ttl, session.model_dump_json())
-
-
-async def _get_session_from_db(session_id: str) -> ChatSession | None:
-    """Get a chat session from the database."""
-    prisma_session = await chat_db.get_chat_session(session_id)
-    if not prisma_session:
-        return None
-
-    messages = prisma_session.Messages
-    logger.info(
-        f"Loading session {session_id} from DB: "
-        f"has_messages={messages is not None}, "
-        f"message_count={len(messages) if messages else 0}, "
-        f"roles={[m.role for m in messages] if messages else []}"
-    )
-
-    return ChatSession.from_prisma(prisma_session, messages)
-
-
-async def _save_session_to_db(
-    session: ChatSession, existing_message_count: int
-) -> None:
-    """Save or update a chat session in the database."""
-    # Check if session exists in DB
-    existing = await chat_db.get_chat_session(session.session_id)
-
-    if not existing:
-        # Create new session
-        await chat_db.create_chat_session(
-            session_id=session.session_id,
-            user_id=session.user_id,
-        )
-        existing_message_count = 0
-
-    # Calculate total tokens from usage
-    total_prompt = sum(u.prompt_tokens for u in session.usage)
-    total_completion = sum(u.completion_tokens for u in session.usage)
-
-    # Update session metadata
-    await chat_db.update_chat_session(
-        session_id=session.session_id,
-        credentials=session.credentials,
-        successful_agent_runs=session.successful_agent_runs,
-        successful_agent_schedules=session.successful_agent_schedules,
-        total_prompt_tokens=total_prompt,
-        total_completion_tokens=total_completion,
-    )
-
-    # Add new messages (only those after existing count)
-    new_messages = session.messages[existing_message_count:]
-    if new_messages:
-        messages_data = []
-        for msg in new_messages:
-            messages_data.append(
-                {
-                    "role": msg.role,
-                    "content": msg.content,
-                    "name": msg.name,
-                    "tool_call_id": msg.tool_call_id,
-                    "refusal": msg.refusal,
-                    "tool_calls": msg.tool_calls,
-                    "function_call": msg.function_call,
-                }
-            )
-        logger.info(
-            f"Saving {len(new_messages)} new messages to DB for session {session.session_id}: "
-            f"roles={[m['role'] for m in messages_data]}, "
-            f"start_sequence={existing_message_count}"
-        )
-        await chat_db.add_chat_messages_batch(
-            session_id=session.session_id,
-            messages=messages_data,
-            start_sequence=existing_message_count,
-        )
-
-
 async def get_chat_session(
     session_id: str,
     user_id: str | None,
 ) -> ChatSession | None:
-    """Get a chat session by ID.
+    """Get a chat session by ID."""
+    redis_key = f"chat:session:{session_id}"
+    async_redis = await get_redis_async()
 
-    Checks Redis cache first, falls back to database if not found.
-    Caches database results back to Redis.
-    """
-    # Try cache first
-    try:
-        session = await _get_session_from_cache(session_id)
-        if session:
-            # Verify user ownership
-            if session.user_id is not None and session.user_id != user_id:
-                logger.warning(
-                    f"Session {session_id} user id mismatch: {session.user_id} != {user_id}"
-                )
-                return None
-            return session
-    except RedisError:
-        logger.warning(f"Cache error for session {session_id}, trying database")
-    except Exception as e:
-        logger.warning(f"Unexpected cache error for session {session_id}: {e}")
+    raw_session: bytes | None = await async_redis.get(redis_key)
 
-    # Fall back to database
-    logger.info(f"Session {session_id} not in cache, checking database")
-    session = await _get_session_from_db(session_id)
-
-    if session is None:
-        logger.warning(f"Session {session_id} not found in cache or database")
+    if raw_session is None:
+        logger.warning(f"Session {session_id} not found in Redis")
         return None
 
-    # Verify user ownership
+    try:
+        session = ChatSession.model_validate_json(raw_session)
+    except Exception as e:
+        logger.error(f"Failed to deserialize session {session_id}: {e}", exc_info=True)
+        raise RedisError(f"Corrupted session data for {session_id}") from e
+
     if session.user_id is not None and session.user_id != user_id:
         logger.warning(
             f"Session {session_id} user id mismatch: {session.user_id} != {user_id}"
         )
         return None
 
-    # Cache the session from DB
-    try:
-        await _cache_session(session)
-        logger.info(f"Cached session {session_id} from database")
-    except Exception as e:
-        logger.warning(f"Failed to cache session {session_id}: {e}")
-
     return session
 
 
 async def upsert_chat_session(
     session: ChatSession,
 ) -> ChatSession:
-    """Update a chat session in both cache and database."""
-    # Get existing message count from DB for incremental saves
-    existing_message_count = await chat_db.get_chat_session_message_count(
-        session.session_id
+    """Update a chat session with the given messages."""
+
+    redis_key = f"chat:session:{session.session_id}"
+
+    async_redis = await get_redis_async()
+    resp = await async_redis.setex(
+        redis_key, config.session_ttl, session.model_dump_json()
     )
 
-    # Save to database
-    try:
-        await _save_session_to_db(session, existing_message_count)
-    except Exception as e:
-        logger.error(f"Failed to save session {session.session_id} to database: {e}")
-        # Continue to cache even if DB fails
-
-    # Save to cache
-    try:
-        await _cache_session(session)
-    except Exception as e:
+    if not resp:
         raise RedisError(
-            f"Failed to persist chat session {session.session_id} to Redis: {e}"
-        ) from e
-
-    return session
-
-
-async def create_chat_session(user_id: str | None) -> ChatSession:
-    """Create a new chat session and persist it."""
-    session = ChatSession.new(user_id)
-
-    # Create in database first
-    try:
-        await chat_db.create_chat_session(
-            session_id=session.session_id,
-            user_id=user_id,
+            f"Failed to persist chat session {session.session_id} to Redis: {resp}"
         )
-    except Exception as e:
-        logger.error(f"Failed to create session in database: {e}")
-        # Continue even if DB fails - cache will still work
-
-    # Cache the session
-    try:
-        await _cache_session(session)
-    except Exception as e:
-        logger.warning(f"Failed to cache new session: {e}")
 
     return session
-
-
-async def get_user_sessions(
-    user_id: str,
-    limit: int = 50,
-    offset: int = 0,
-) -> list[ChatSession]:
-    """Get all chat sessions for a user from the database."""
-    prisma_sessions = await chat_db.get_user_chat_sessions(user_id, limit, offset)
-
-    sessions = []
-    for prisma_session in prisma_sessions:
-        # Convert without messages for listing (lighter weight)
-        sessions.append(ChatSession.from_prisma(prisma_session, None))
-
-    return sessions
-
-
-async def delete_chat_session(session_id: str) -> bool:
-    """Delete a chat session from both cache and database."""
-    # Delete from cache
-    try:
-        redis_key = f"chat:session:{session_id}"
-        async_redis = await get_redis_async()
-        await async_redis.delete(redis_key)
-    except Exception as e:
-        logger.warning(f"Failed to delete session {session_id} from cache: {e}")
-
-    # Delete from database
-    return await chat_db.delete_chat_session(session_id)

autogpt_platform/backend/backend/api/features/chat/model_test.py

@@ -68,50 +68,3 @@ async def test_chatsession_redis_storage_user_id_mismatch():
     s2 = await get_chat_session(s.session_id, None)
 
     assert s2 is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_chatsession_db_storage():
-    """Test that messages are correctly saved to and loaded from DB (not cache)."""
-    from backend.data.redis_client import get_redis_async
-
-    # Create session with messages including assistant message
-    s = ChatSession.new(user_id=None)
-    s.messages = messages  # Contains user, assistant, and tool messages
-    assert s.session_id is not None, "Session id is not set"
-    # Upsert to save to both cache and DB
-    s = await upsert_chat_session(s)
-
-    # Clear the Redis cache to force DB load
-    redis_key = f"chat:session:{s.session_id}"
-    async_redis = await get_redis_async()
-    await async_redis.delete(redis_key)
-
-    # Load from DB (cache was cleared)
-    s2 = await get_chat_session(
-        session_id=s.session_id,
-        user_id=s.user_id,
-    )
-
-    assert s2 is not None, "Session not found after loading from DB"
-    assert len(s2.messages) == len(
-        s.messages
-    ), f"Message count mismatch: expected {len(s.messages)}, got {len(s2.messages)}"
-
-    # Verify all roles are present
-    roles = [m.role for m in s2.messages]
-    assert "user" in roles, f"User message missing. Roles found: {roles}"
-    assert "assistant" in roles, f"Assistant message missing. Roles found: {roles}"
-    assert "tool" in roles, f"Tool message missing. Roles found: {roles}"
-
-    # Verify message content
-    for orig, loaded in zip(s.messages, s2.messages):
-        assert orig.role == loaded.role, f"Role mismatch: {orig.role} != {loaded.role}"
-        assert (
-            orig.content == loaded.content
-        ), f"Content mismatch for {orig.role}: {orig.content} != {loaded.content}"
-        if orig.tool_calls:
-            assert (
-                loaded.tool_calls is not None
-            ), f"Tool calls missing for {orig.role} message"
-            assert len(orig.tool_calls) == len(loaded.tool_calls)

autogpt_platform/backend/backend/api/features/chat/prompts/chat_system.md

@@ -1,80 +1,12 @@
-You are Otto, an AI Co-Pilot and Forward Deployed Engineer for AutoGPT, an AI Business Automation tool. Your mission is to help users quickly find, create, and set up AutoGPT agents to solve their business problems.
+You are Otto, an AI Co-Pilot and Forward Deployed Engineer for AutoGPT, an AI Business Automation tool. Your mission is to help users quickly find and set up AutoGPT agents to solve their business problems.
 
 Here are the functions available to you:
 
 <functions>
-**Understanding & Discovery:**
-1. **add_understanding** - Save information about the user's business context (use this as you learn about them)
-2. **find_agent** - Search the marketplace for pre-built agents that solve the user's problem
-3. **find_library_agent** - Search the user's personal library of saved agents
-4. **find_block** - Search for individual blocks (building components for agents)
-5. **search_platform_docs** - Search AutoGPT documentation for help
-
-**Agent Creation & Editing:**
-6. **create_agent** - Create a new custom agent from scratch based on user requirements
-7. **edit_agent** - Modify an existing agent (add/remove blocks, change configuration)
-
-**Execution & Output:**
-8. **run_agent** - Run or schedule an agent (automatically handles setup)
-9. **run_block** - Run a single block directly without creating an agent
-10. **agent_output** - Get the output/results from a running or completed agent execution
+1. **find_agent** - Search for agents that solve the user's problem
+2. **run_agent** - Run or schedule an agent (automatically handles setup)
 </functions>
 
-## ALWAYS GET THE USER'S NAME
-
-**This is critical:** If you don't know the user's name, ask for it in your first response. Use a friendly, natural approach:
-- "Hi! I'm Otto. What's your name?"
-- "Hey there! Before we dive in, what should I call you?"
-
-Once you have their name, immediately save it with `add_understanding(user_name="...")` and use it throughout the conversation.
-
-## BUILDING USER UNDERSTANDING
-
-**If no User Business Context is provided below**, gather information naturally during conversation - don't interrogate them.
-
-**Key information to gather (in priority order):**
-1. Their name (ALWAYS first if unknown)
-2. Their job title and role
-3. Their business/company and industry
-4. Pain points and what they want to automate
-5. Tools they currently use
-
-**How to gather this information:**
-- Ask naturally as part of helping them (e.g., "What's your role?" or "What industry are you in?")
-- When they share information, immediately save it using `add_understanding`
-- Don't ask all questions at once - spread them across the conversation
-- Prioritize understanding their immediate problem first
-
-**Example:**
-```
-User: "I need help automating my social media"
-Otto: I can help with that! I'm Otto - what's your name?
-User: "I'm Sarah"
-Otto: [calls add_understanding with user_name="Sarah"]
-Nice to meet you, Sarah! What's your role - are you a social media manager or business owner?
-User: "I'm the marketing director at a fintech startup"
-Otto: [calls add_understanding with job_title="Marketing Director", industry="fintech", business_size="startup"]
-Great! Let me find social media automation agents for you.
-[calls find_agent with query="social media automation marketing"]
-```
-
-## WHEN TO USE WHICH TOOL
-
-**Finding existing agents:**
-- `find_agent` - Search the marketplace for pre-built agents others have created
-- `find_library_agent` - Search agents the user has already saved to their library
-
-**Creating/editing agents:**
-- `create_agent` - When user wants a custom agent that doesn't exist, or has specific requirements
-- `edit_agent` - When user wants to modify an existing agent (change inputs, add blocks, etc.)
-
-**Running agents:**
-- `run_agent` - To execute an agent (handles credentials and inputs automatically)
-- `agent_output` - To check the results of a running or completed agent execution
-
-**Direct execution:**
-- `run_block` - Run a single block directly without needing a full agent
-
 ## HOW run_agent WORKS
 
 The `run_agent` tool automatically handles the entire setup flow:
@@ -89,61 +21,49 @@ Parameters:
 - `use_defaults`: Set to `true` to run with default values (only after user confirms)
 - `schedule_name` + `cron`: For scheduled execution
 
-## HOW create_agent WORKS
-
-Use `create_agent` when the user wants to build a custom automation:
-- Describe what the agent should do
-- The tool will create the agent structure with appropriate blocks
-- Returns the agent ID for further editing or running
-
-## HOW agent_output WORKS
-
-Use `agent_output` to get results from agent executions:
-- Pass the execution_id from a run_agent response
-- Returns the current status and any outputs produced
-- Useful for checking if an agent has completed and what it produced
-
 ## WORKFLOW
 
-1. **Get their name** - If unknown, ask for it first
-2. **Understand context** - Ask 1-2 questions about their problem while helping
-3. **Find or create** - Use find_agent for existing solutions, create_agent for custom needs
-4. **Set up and run** - Use run_agent to execute, agent_output to get results
+1. **find_agent** - Search for agents that solve the user's problem
+2. **run_agent** (first call, no inputs) - Get available inputs for the agent
+3. **Ask user** what values they want to use OR if they want to use defaults
+4. **run_agent** (second call) - Either with `inputs={...}` or `use_defaults=true`
 
 ## YOUR APPROACH
 
-**Step 1: Greet and Identify**
-- If you don't know their name, ask for it
-- Be friendly and conversational
-
-**Step 2: Understand the Problem**
+**Step 1: Understand the Problem**
 - Ask maximum 1-2 targeted questions
 - Focus on: What business problem are they solving?
-- If they want to create/edit an agent, understand what it should do
+- Move quickly to searching for solutions
 
-**Step 3: Find or Create**
-- For existing solutions: Use `find_agent` with relevant keywords
-- For custom needs: Use `create_agent` with their requirements
-- For modifications: Use `edit_agent` on an existing agent
+**Step 2: Find Agents**
+- Use `find_agent` immediately with relevant keywords
+- Suggest the best option from search results
+- Explain briefly how it solves their problem
 
-**Step 4: Execute**
-- Call `run_agent` without inputs first to see what's available
-- Ask user what values they want or if defaults are okay
-- Call `run_agent` again with inputs or `use_defaults=true`
-- Use `agent_output` to check results when needed
+**Step 3: Get Agent Inputs**
+- Call `run_agent(username_agent_slug="creator/agent-name")` without inputs
+- This returns the available inputs (required and optional)
+- Present these to the user and ask what values they want
 
-## USING add_understanding
+**Step 4: Run with User's Choice**
+- If user provides values: `run_agent(username_agent_slug="...", inputs={...})`
+- If user says "use defaults": `run_agent(username_agent_slug="...", use_defaults=true)`
+- On success, share the agent link with the user
 
-Call `add_understanding` whenever you learn something about the user:
+**For Scheduled Execution:**
+- Add `schedule_name` and `cron` parameters
+- Example: `run_agent(username_agent_slug="...", inputs={...}, schedule_name="Daily Report", cron="0 9 * * *")`
 
-**User info:** `user_name`, `job_title`
-**Business:** `business_name`, `industry`, `business_size` (1-10, 11-50, 51-200, 201-1000, 1000+), `user_role` (decision maker, implementer, end user)
-**Processes:** `key_workflows` (array), `daily_activities` (array)
-**Pain points:** `pain_points` (array), `bottlenecks` (array), `manual_tasks` (array), `automation_goals` (array)
-**Tools:** `current_software` (array), `existing_automation` (array)
-**Other:** `additional_notes`
+## FUNCTION CALL FORMAT
 
-Example: `add_understanding(user_name="Sarah", job_title="Marketing Director", industry="fintech")`
+To call a function, use this exact format:
+`<function_call>function_name(parameter="value")</function_call>`
+
+Examples:
+- `<function_call>find_agent(query="social media automation")</function_call>`
+- `<function_call>run_agent(username_agent_slug="creator/agent-name")</function_call>` (get inputs)
+- `<function_call>run_agent(username_agent_slug="creator/agent-name", inputs={"topic": "AI news"})</function_call>`
+- `<function_call>run_agent(username_agent_slug="creator/agent-name", use_defaults=true)</function_call>`
 
 ## KEY RULES
 
@@ -153,12 +73,8 @@ Example: `add_understanding(user_name="Sarah", job_title="Marketing Director", i
 - Don't run agents without first showing available inputs to the user
 - Don't use `use_defaults=true` without user explicitly confirming
 - Don't write responses longer than 3 sentences
-- Don't interrogate users with many questions - gather info naturally
 
 **What You DO:**
-- ALWAYS ask for user's name if you don't have it
-- Save user information with `add_understanding` as you learn it
-- Use their name when addressing them
 - Always call run_agent first without inputs to see what's available
 - Ask user what values they want OR if they want to use defaults
 - Keep all responses to maximum 3 sentences
@@ -171,22 +87,18 @@ Example: `add_understanding(user_name="Sarah", job_title="Marketing Director", i
 ## RESPONSE STRUCTURE
 
 Before responding, wrap your analysis in <thinking> tags to systematically plan your approach:
-- Check if you know the user's name - if not, ask for it
-- Check if you have user context - if not, plan to gather some naturally
 - Extract the key business problem or request from the user's message
 - Determine what function call (if any) you need to make next
 - Plan your response to stay under the 3-sentence maximum
 
 Example interaction:
 ```
-User: "Hi, I want to build an agent that monitors my competitors"
-Otto: <thinking>I don't know this user's name. I should ask for it while acknowledging their request.</thinking>
-Hi! I'm Otto and I'd love to help you build a competitor monitoring agent. What's your name?
-User: "I'm Mike"
-Otto: [calls add_understanding with user_name="Mike"]
-<thinking>Now I know Mike wants competitor monitoring. I should search for existing agents first.</thinking>
-Great to meet you, Mike! Let me search for competitor monitoring agents.
-[calls find_agent with query="competitor monitoring analysis"]
+User: "Run the AI news agent for me"
+Otto: <function_call>run_agent(username_agent_slug="autogpt/ai-news")</function_call>
+[Tool returns: Agent accepts inputs - Required: topic. Optional: num_articles (default: 5)]
+Otto: The AI News agent needs a topic. What topic would you like news about, or should I use the defaults?
+User: "Use defaults"
+Otto: <function_call>run_agent(username_agent_slug="autogpt/ai-news", use_defaults=true)</function_call>
 ```
 
 KEEP ANSWERS TO 3 SENTENCES

autogpt_platform/backend/backend/api/features/chat/prompts/onboarding_system.md

@@ -1,155 +0,0 @@
-You are Otto, an AI Co-Pilot helping new users get started with AutoGPT, an AI Business Automation platform. Your mission is to welcome them, learn about their needs, and help them run their first successful agent.
-
-Here are the functions available to you:
-
-<functions>
-**Understanding & Discovery:**
-1. **add_understanding** - Save information about the user's business context (use this as you learn about them)
-2. **find_agent** - Search the marketplace for pre-built agents that solve the user's problem
-3. **find_library_agent** - Search the user's personal library of saved agents
-4. **find_block** - Search for individual blocks (building components for agents)
-5. **search_platform_docs** - Search AutoGPT documentation for help
-
-**Agent Creation & Editing:**
-6. **create_agent** - Create a new custom agent from scratch based on user requirements
-7. **edit_agent** - Modify an existing agent (add/remove blocks, change configuration)
-
-**Execution & Output:**
-8. **run_agent** - Run or schedule an agent (automatically handles setup)
-9. **run_block** - Run a single block directly without creating an agent
-10. **agent_output** - Get the output/results from a running or completed agent execution
-</functions>
-
-## YOUR ONBOARDING MISSION
-
-You are guiding a new user through their first experience with AutoGPT. Your goal is to:
-1. Welcome them warmly and get their name
-2. Learn about them and their business
-3. Find or create an agent that solves a real problem for them
-4. Get that agent running successfully
-5. Celebrate their success and point them to next steps
-
-## PHASE 1: WELCOME & INTRODUCTION
-
-**Start every conversation by:**
-- Giving a warm, friendly greeting
-- Introducing yourself as Otto, their AI assistant
-- Asking for their name immediately
-
-**Example opening:**
-```
-Hi! I'm Otto, your AI assistant. Welcome to AutoGPT! I'm here to help you set up your first automation. What's your name?
-```
-
-Once you have their name, save it immediately with `add_understanding(user_name="...")` and use it throughout.
-
-## PHASE 2: DISCOVERY
-
-**After getting their name, learn about them:**
-- What's their role/job title?
-- What industry/business are they in?
-- What's one thing they'd love to automate?
-
-**Keep it conversational - don't interrogate. Example:**
-```
-Nice to meet you, Sarah! What do you do for work, and what's one task you wish you could automate?
-```
-
-Save everything you learn with `add_understanding`.
-
-## PHASE 3: FIND OR CREATE AN AGENT
-
-**Once you understand their need:**
-- Search for existing agents with `find_agent`
-- Present the best match and explain how it helps them
-- If nothing fits, offer to create a custom agent with `create_agent`
-
-**Be enthusiastic about the solution:**
-```
-I found a great agent for you! The "Social Media Scheduler" can automatically post to your accounts on a schedule. Want to try it?
-```
-
-## PHASE 4: SETUP & RUN
-
-**Guide them through running the agent:**
-1. Call `run_agent` without inputs first to see what's needed
-2. Explain each input in simple terms
-3. Ask what values they want to use
-4. Run the agent with their inputs or defaults
-
-**Don't mention credentials** - the UI handles that automatically.
-
-## PHASE 5: CELEBRATE & HANDOFF
-
-**After successful execution:**
-- Congratulate them on their first automation!
-- Tell them where to find this agent (their Library)
-- Mention they can explore more agents in the Marketplace
-- Offer to help with anything else
-
-**Example:**
-```
-You did it! Your first agent is running. You can find it anytime in your Library. Ready to explore more automations?
-```
-
-## KEY RULES
-
-**What You DON'T Do:**
-- Don't help with login (frontend handles this)
-- Don't mention credentials (UI handles automatically)
-- Don't run agents without showing inputs first
-- Don't use `use_defaults=true` without explicit confirmation
-- Don't write responses longer than 3 sentences
-- Don't overwhelm with too many questions at once
-
-**What You DO:**
-- ALWAYS get the user's name first
-- Be warm, encouraging, and celebratory
-- Save info with `add_understanding` as you learn it
-- Use their name when addressing them
-- Keep responses to maximum 3 sentences
-- Make them feel successful at each step
-
-## USING add_understanding
-
-Save information as you learn it:
-
-**User info:** `user_name`, `job_title`
-**Business:** `business_name`, `industry`, `business_size`, `user_role`
-**Pain points:** `pain_points`, `manual_tasks`, `automation_goals`
-**Tools:** `current_software`
-
-Example: `add_understanding(user_name="Sarah", job_title="Marketing Manager", automation_goals=["social media scheduling"])`
-
-## HOW run_agent WORKS
-
-1. **First call** (no inputs) → Shows available inputs
-2. **Credentials** → UI handles automatically (don't mention)
-3. **Execution** → Run with `inputs={...}` or `use_defaults=true`
-
-## RESPONSE STRUCTURE
-
-Before responding, plan your approach in <thinking> tags:
-- What phase am I in? (Welcome/Discovery/Find/Setup/Celebrate)
-- Do I know their name? If not, ask for it
-- What's the next step to move them forward?
-- Keep response under 3 sentences
-
-**Example flow:**
-```
-User: "Hi"
-Otto: <thinking>Phase 1 - I need to welcome them and get their name.</thinking>
-Hi! I'm Otto, welcome to AutoGPT! I'm here to help you set up your first automation - what's your name?
-
-User: "I'm Alex"
-Otto: [calls add_understanding with user_name="Alex"]
-<thinking>Got their name. Phase 2 - learn about them.</thinking>
-Great to meet you, Alex! What do you do for work, and what's one task you'd love to automate?
-
-User: "I run an e-commerce store and spend hours on customer support emails"
-Otto: [calls add_understanding with industry="e-commerce", pain_points=["customer support emails"]]
-<thinking>Phase 3 - search for agents.</thinking>
-[calls find_agent with query="customer support email automation"]
-```
-
-KEEP ANSWERS TO 3 SENTENCES - Be warm, helpful, and focused on their success!

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

@@ -26,14 +26,6 @@ router = APIRouter(
 # ========== Request/Response Models ==========
 
 
-class StreamChatRequest(BaseModel):
-    """Request model for streaming chat with optional context."""
-
-    message: str
-    is_user_message: bool = True
-    context: dict[str, str] | None = None  # {url: str, content: str}
-
-
 class CreateSessionResponse(BaseModel):
     """Response model containing information on a newly created chat session."""
 
@@ -52,64 +44,9 @@ class SessionDetailResponse(BaseModel):
     messages: list[dict]
 
 
-class SessionSummaryResponse(BaseModel):
-    """Response model for a session summary (without messages)."""
-
-    id: str
-    created_at: str
-    updated_at: str
-    title: str | None = None
-
-
-class ListSessionsResponse(BaseModel):
-    """Response model for listing chat sessions."""
-
-    sessions: list[SessionSummaryResponse]
-    total: int
-
-
 # ========== Routes ==========
 
 
-@router.get(
-    "/sessions",
-    dependencies=[Security(auth.requires_user)],
-)
-async def list_sessions(
-    user_id: Annotated[str, Security(auth.get_user_id)],
-    limit: int = Query(default=50, ge=1, le=100),
-    offset: int = Query(default=0, ge=0),
-) -> ListSessionsResponse:
-    """
-    List chat sessions for the authenticated user.
-
-    Returns a paginated list of chat sessions belonging to the current user,
-    ordered by most recently updated.
-
-    Args:
-        user_id: The authenticated user's ID.
-        limit: Maximum number of sessions to return (1-100).
-        offset: Number of sessions to skip for pagination.
-
-    Returns:
-        ListSessionsResponse: List of session summaries and total count.
-    """
-    sessions = await chat_service.get_user_sessions(user_id, limit, offset)
-
-    return ListSessionsResponse(
-        sessions=[
-            SessionSummaryResponse(
-                id=session.session_id,
-                created_at=session.started_at.isoformat(),
-                updated_at=session.updated_at.isoformat(),
-                title=None,  # TODO: Add title support
-            )
-            for session in sessions
-        ],
-        total=len(sessions),
-    )
-
-
 @router.post(
     "/sessions",
 )
@@ -165,89 +102,26 @@ async def get_session(
     session = await chat_service.get_session(session_id, user_id)
     if not session:
         raise NotFoundError(f"Session {session_id} not found")
-
-    messages = [message.model_dump() for message in session.messages]
-    logger.info(
-        f"Returning session {session_id}: "
-        f"message_count={len(messages)}, "
-        f"roles={[m.get('role') for m in messages]}"
-    )
-
     return SessionDetailResponse(
         id=session.session_id,
         created_at=session.started_at.isoformat(),
         updated_at=session.updated_at.isoformat(),
         user_id=session.user_id or None,
-        messages=messages,
-    )
-
-
-@router.post(
-    "/sessions/{session_id}/stream",
-)
-async def stream_chat_post(
-    session_id: str,
-    request: StreamChatRequest,
-    user_id: str | None = Depends(auth.get_user_id),
-):
-    """
-    Stream chat responses for a session (POST with context support).
-
-    Streams the AI/completion responses in real time over Server-Sent Events (SSE), including:
-      - Text fragments as they are generated
-      - Tool call UI elements (if invoked)
-      - Tool execution results
-
-    Args:
-        session_id: The chat session identifier to associate with the streamed messages.
-        request: Request body containing message, is_user_message, and optional context.
-        user_id: Optional authenticated user ID.
-    Returns:
-        StreamingResponse: SSE-formatted response chunks.
-
-    """
-    # Validate session exists before starting the stream
-    # This prevents errors after the response has already started
-    session = await chat_service.get_session(session_id, user_id)
-
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found. ")
-    if session.user_id is None and user_id is not None:
-        session = await chat_service.assign_user_to_session(session_id, user_id)
-
-    async def event_generator() -> AsyncGenerator[str, None]:
-        async for chunk in chat_service.stream_chat_completion(
-            session_id,
-            request.message,
-            is_user_message=request.is_user_message,
-            user_id=user_id,
-            session=session,  # Pass pre-fetched session to avoid double-fetch
-            context=request.context,
-        ):
-            yield chunk.to_sse()
-
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",  # Disable nginx buffering
-        },
+        messages=[message.model_dump() for message in session.messages],
     )
 
 
 @router.get(
     "/sessions/{session_id}/stream",
 )
-async def stream_chat_get(
+async def stream_chat(
     session_id: str,
     message: Annotated[str, Query(min_length=1, max_length=10000)],
     user_id: str | None = Depends(auth.get_user_id),
     is_user_message: bool = Query(default=True),
 ):
     """
-    Stream chat responses for a session (GET - legacy endpoint).
+    Stream chat responses for a session.
 
     Streams the AI/completion responses in real time over Server-Sent Events (SSE), including:
       - Text fragments as they are generated
@@ -319,133 +193,6 @@ async def session_assign_user(
     return {"status": "ok"}
 
 
-# ========== Onboarding Routes ==========
-# These routes use a specialized onboarding system prompt
-
-
-@router.post(
-    "/onboarding/sessions",
-)
-async def create_onboarding_session(
-    user_id: Annotated[str | None, Depends(auth.get_user_id)],
-) -> CreateSessionResponse:
-    """
-    Create a new onboarding chat session.
-
-    Initiates a new chat session specifically for user onboarding,
-    using a specialized prompt that guides users through their first
-    experience with AutoGPT.
-
-    Args:
-        user_id: The optional authenticated user ID parsed from the JWT.
-
-    Returns:
-        CreateSessionResponse: Details of the created onboarding session.
-    """
-    logger.info(
-        f"Creating onboarding session with user_id: "
-        f"...{user_id[-8:] if user_id and len(user_id) > 8 else '<redacted>'}"
-    )
-
-    session = await chat_service.create_chat_session(user_id)
-
-    return CreateSessionResponse(
-        id=session.session_id,
-        created_at=session.started_at.isoformat(),
-        user_id=session.user_id or None,
-    )
-
-
-@router.get(
-    "/onboarding/sessions/{session_id}",
-)
-async def get_onboarding_session(
-    session_id: str,
-    user_id: Annotated[str | None, Depends(auth.get_user_id)],
-) -> SessionDetailResponse:
-    """
-    Retrieve the details of an onboarding chat session.
-
-    Args:
-        session_id: The unique identifier for the onboarding session.
-        user_id: The optional authenticated user ID.
-
-    Returns:
-        SessionDetailResponse: Details for the requested session.
-    """
-    session = await chat_service.get_session(session_id, user_id)
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found")
-
-    messages = [message.model_dump() for message in session.messages]
-    logger.info(
-        f"Returning onboarding session {session_id}: "
-        f"message_count={len(messages)}, "
-        f"roles={[m.get('role') for m in messages]}"
-    )
-
-    return SessionDetailResponse(
-        id=session.session_id,
-        created_at=session.started_at.isoformat(),
-        updated_at=session.updated_at.isoformat(),
-        user_id=session.user_id or None,
-        messages=messages,
-    )
-
-
-@router.post(
-    "/onboarding/sessions/{session_id}/stream",
-)
-async def stream_onboarding_chat(
-    session_id: str,
-    request: StreamChatRequest,
-    user_id: str | None = Depends(auth.get_user_id),
-):
-    """
-    Stream onboarding chat responses for a session.
-
-    Uses the specialized onboarding system prompt to guide new users
-    through their first experience with AutoGPT. Streams AI responses
-    in real time over Server-Sent Events (SSE).
-
-    Args:
-        session_id: The onboarding session identifier.
-        request: Request body containing message and optional context.
-        user_id: Optional authenticated user ID.
-
-    Returns:
-        StreamingResponse: SSE-formatted response chunks.
-    """
-    session = await chat_service.get_session(session_id, user_id)
-
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found.")
-    if session.user_id is None and user_id is not None:
-        session = await chat_service.assign_user_to_session(session_id, user_id)
-
-    async def event_generator() -> AsyncGenerator[str, None]:
-        async for chunk in chat_service.stream_chat_completion(
-            session_id,
-            request.message,
-            is_user_message=request.is_user_message,
-            user_id=user_id,
-            session=session,
-            context=request.context,
-            prompt_type="onboarding",  # Use onboarding system prompt
-        ):
-            yield chunk.to_sse()
-
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",
-        },
-    )
-
-
 # ========== Health Check ==========
 
 

autogpt_platform/backend/backend/api/features/chat/service.py

@@ -7,17 +7,16 @@ import orjson
 from openai import AsyncOpenAI
 from openai.types.chat import ChatCompletionChunk, ChatCompletionToolParam
 
-from backend.data.understanding import (
-    format_understanding_for_prompt,
-    get_business_understanding,
-)
 from backend.util.exceptions import NotFoundError
 
-from . import db as chat_db
 from .config import ChatConfig
-from .model import ChatMessage, ChatSession, Usage
-from .model import create_chat_session as model_create_chat_session
-from .model import get_chat_session, upsert_chat_session
+from .model import (
+    ChatMessage,
+    ChatSession,
+    Usage,
+    get_chat_session,
+    upsert_chat_session,
+)
 from .response_model import (
     StreamBaseResponse,
     StreamEnd,
@@ -37,109 +36,15 @@ config = ChatConfig()
 client = AsyncOpenAI(api_key=config.api_key, base_url=config.base_url)
 
 
-async def _is_first_session(user_id: str) -> bool:
-    """Check if this is the user's first chat session.
-
-    Returns True if the user has 1 or fewer sessions (meaning this is their first).
-    """
-    try:
-        session_count = await chat_db.get_user_session_count(user_id)
-        return session_count <= 1
-    except Exception as e:
-        logger.warning(f"Failed to check session count for user {user_id}: {e}")
-        return False  # Default to non-onboarding if we can't check
-
-
-async def _build_system_prompt(
-    user_id: str | None, prompt_type: str = "default"
-) -> str:
-    """Build the full system prompt including business understanding if available.
-
-    Args:
-        user_id: The user ID for fetching business understanding
-        prompt_type: The type of prompt to load ("default" or "onboarding")
-                     If "default" and this is the user's first session, will use "onboarding" instead.
-
-    Returns:
-        The full system prompt with business understanding context if available
-    """
-    # Auto-detect: if using default prompt and this is user's first session, use onboarding
-    effective_prompt_type = prompt_type
-    if prompt_type == "default" and user_id:
-        if await _is_first_session(user_id):
-            logger.info("First session detected for user, using onboarding prompt")
-            effective_prompt_type = "onboarding"
-
-    # Start with the base system prompt for the specified type
-    base_prompt = config.get_system_prompt_for_type(effective_prompt_type)
-
-    # If user is authenticated, try to fetch their business understanding
-    if user_id:
-        try:
-            understanding = await get_business_understanding(user_id)
-            if understanding:
-                context = format_understanding_for_prompt(understanding)
-                if context:
-                    return (
-                        f"{base_prompt}\n\n---\n\n"
-                        f"{context}\n\n"
-                        "Use this context to provide more personalized recommendations "
-                        "and to better understand the user's business needs when "
-                        "suggesting agents and automations."
-                    )
-        except Exception as e:
-            logger.warning(f"Failed to fetch business understanding: {e}")
-
-    return base_prompt
-
-
-async def _generate_session_title(message: str) -> str | None:
-    """Generate a concise title for a chat session based on the first message.
-
-    Args:
-        message: The first user message in the session
-
-    Returns:
-        A short title (3-6 words) or None if generation fails
-    """
-    try:
-        response = await client.chat.completions.create(
-            model=config.title_model,
-            messages=[
-                {
-                    "role": "system",
-                    "content": (
-                        "Generate a very short title (3-6 words) for a chat conversation "
-                        "based on the user's first message. The title should capture the "
-                        "main topic or intent. Return ONLY the title, no quotes or punctuation."
-                    ),
-                },
-                {"role": "user", "content": message[:500]},  # Limit input length
-            ],
-            max_tokens=20,
-            temperature=0.7,
-        )
-        title = response.choices[0].message.content
-        if title:
-            # Clean up the title
-            title = title.strip().strip("\"'")
-            # Limit length
-            if len(title) > 50:
-                title = title[:47] + "..."
-            return title
-        return None
-    except Exception as e:
-        logger.warning(f"Failed to generate session title: {e}")
-        return None
-
-
 async def create_chat_session(
     user_id: str | None = None,
 ) -> ChatSession:
     """
     Create a new chat session and persist it to the database.
     """
-    return await model_create_chat_session(user_id)
+    session = ChatSession.new(user_id)
+    # Persist the session immediately so it can be used for streaming
+    return await upsert_chat_session(session)
 
 
 async def get_session(
@@ -152,19 +57,6 @@ async def get_session(
     return await get_chat_session(session_id, user_id)
 
 
-async def get_user_sessions(
-    user_id: str,
-    limit: int = 50,
-    offset: int = 0,
-) -> list[ChatSession]:
-    """
-    Get all chat sessions for a user.
-    """
-    from .model import get_user_sessions as model_get_user_sessions
-
-    return await model_get_user_sessions(user_id, limit, offset)
-
-
 async def assign_user_to_session(
     session_id: str,
     user_id: str,
@@ -186,8 +78,6 @@ async def stream_chat_completion(
     user_id: str | None = None,
     retry_count: int = 0,
     session: ChatSession | None = None,
-    context: dict[str, str] | None = None,  # {url: str, content: str}
-    prompt_type: str = "default",
 ) -> AsyncGenerator[StreamBaseResponse, None]:
     """Main entry point for streaming chat completions with database handling.
 
@@ -199,7 +89,6 @@ async def stream_chat_completion(
         user_message: User's input message
         user_id: User ID for authentication (None for anonymous)
         session: Optional pre-loaded session object (for recursive calls to avoid Redis refetch)
-        prompt_type: The type of prompt to use ("default" or "onboarding")
 
     Yields:
         StreamBaseResponse objects formatted as SSE
@@ -232,18 +121,9 @@ async def stream_chat_completion(
         )
 
     if message:
-        # Build message content with context if provided
-        message_content = message
-        if context and context.get("url") and context.get("content"):
-            context_text = f"Page URL: {context['url']}\n\nPage Content:\n{context['content']}\n\n---\n\nUser Message: {message}"
-            message_content = context_text
-            logger.info(
-                f"Including page context: URL={context['url']}, content_length={len(context['content'])}"
-            )
-
         session.messages.append(
             ChatMessage(
-                role="user" if is_user_message else "assistant", content=message_content
+                role="user" if is_user_message else "assistant", content=message
             )
         )
         logger.info(
@@ -261,32 +141,6 @@ async def stream_chat_completion(
     session = await upsert_chat_session(session)
     assert session, "Session not found"
 
-    # Generate title for new sessions on first user message (non-blocking)
-    # Check: is_user_message, no title yet, and this is the first user message
-    if is_user_message and message and not session.title:
-        user_messages = [m for m in session.messages if m.role == "user"]
-        if len(user_messages) == 1:
-            # First user message - generate title in background
-            import asyncio
-
-            async def _update_title():
-                try:
-                    title = await _generate_session_title(message)
-                    if title:
-                        session.title = title
-                        await upsert_chat_session(session)
-                        logger.info(
-                            f"Generated title for session {session_id}: {title}"
-                        )
-                except Exception as e:
-                    logger.warning(f"Failed to update session title: {e}")
-
-            # Fire and forget - don't block the chat response
-            asyncio.create_task(_update_title())
-
-    # Build system prompt with business understanding
-    system_prompt = await _build_system_prompt(user_id, prompt_type)
-
     assistant_response = ChatMessage(
         role="assistant",
         content="",
@@ -305,7 +159,6 @@ async def stream_chat_completion(
         async for chunk in _stream_chat_chunks(
             session=session,
             tools=tools,
-            system_prompt=system_prompt,
         ):
 
             if isinstance(chunk, StreamTextChunk):
@@ -426,7 +279,6 @@ async def stream_chat_completion(
             user_id=user_id,
             retry_count=retry_count + 1,
             session=session,
-            prompt_type=prompt_type,
         ):
             yield chunk
         return  # Exit after retry to avoid double-saving in finally block
@@ -472,7 +324,6 @@ async def stream_chat_completion(
             session_id=session.session_id,
             user_id=user_id,
             session=session,  # Pass session object to avoid Redis refetch
-            prompt_type=prompt_type,
         ):
             yield chunk
 
@@ -480,7 +331,6 @@ async def stream_chat_completion(
 async def _stream_chat_chunks(
     session: ChatSession,
     tools: list[ChatCompletionToolParam],
-    system_prompt: str | None = None,
 ) -> AsyncGenerator[StreamBaseResponse, None]:
     """
     Pure streaming function for OpenAI chat completions with tool calling.
@@ -488,9 +338,9 @@ async def _stream_chat_chunks(
     This function is database-agnostic and focuses only on streaming logic.
 
     Args:
-        session: Chat session with conversation history
-        tools: Available tools for the model
-        system_prompt: System prompt to prepend to messages
+        messages: Conversation context as ChatCompletionMessageParam list
+        session_id: Session ID
+        user_id: User ID for tool execution
 
     Yields:
         SSE formatted JSON response objects
@@ -500,17 +350,6 @@ async def _stream_chat_chunks(
 
     logger.info("Starting pure chat stream")
 
-    # Build messages with system prompt prepended
-    messages = session.to_openai_messages()
-    if system_prompt:
-        from openai.types.chat import ChatCompletionSystemMessageParam
-
-        system_message = ChatCompletionSystemMessageParam(
-            role="system",
-            content=system_prompt,
-        )
-        messages = [system_message] + messages
-
     # Loop to handle tool calls and continue conversation
     while True:
         try:
@@ -519,7 +358,7 @@ async def _stream_chat_chunks(
             # Create the stream with proper types
             stream = await client.chat.completions.create(
                 model=model,
-                messages=messages,
+                messages=session.to_openai_messages(),
                 tools=tools,
                 tool_choice="auto",
                 stream=True,
@@ -663,12 +502,8 @@ async def _yield_tool_call(
     """
     logger.info(f"Yielding tool call: {tool_calls[yield_idx]}")
 
-    # Parse tool call arguments - handle empty arguments gracefully
-    raw_arguments = tool_calls[yield_idx]["function"]["arguments"]
-    if raw_arguments:
-        arguments = orjson.loads(raw_arguments)
-    else:
-        arguments = {}
+    # Parse tool call arguments - exceptions will propagate to caller
+    arguments = orjson.loads(tool_calls[yield_idx]["function"]["arguments"])
 
     yield StreamToolCall(
         tool_id=tool_calls[yield_idx]["id"],

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

@@ -4,30 +4,21 @@ from openai.types.chat import ChatCompletionToolParam
 
 from backend.api.features.chat.model import ChatSession
 
-from .add_understanding import AddUnderstandingTool
-from .agent_output import AgentOutputTool
 from .base import BaseTool
 from .find_agent import FindAgentTool
-from .find_library_agent import FindLibraryAgentTool
 from .run_agent import RunAgentTool
 
 if TYPE_CHECKING:
     from backend.api.features.chat.response_model import StreamToolExecutionResult
 
 # Initialize tool instances
-add_understanding_tool = AddUnderstandingTool()
 find_agent_tool = FindAgentTool()
-find_library_agent_tool = FindLibraryAgentTool()
 run_agent_tool = RunAgentTool()
-agent_output_tool = AgentOutputTool()
 
 # Export tools as OpenAI format
 tools: list[ChatCompletionToolParam] = [
-    add_understanding_tool.as_openai_tool(),
     find_agent_tool.as_openai_tool(),
-    find_library_agent_tool.as_openai_tool(),
     run_agent_tool.as_openai_tool(),
-    agent_output_tool.as_openai_tool(),
 ]
 
 
@@ -40,11 +31,8 @@ async def execute_tool(
 ) -> "StreamToolExecutionResult":
 
     tool_map: dict[str, BaseTool] = {
-        "add_understanding": add_understanding_tool,
         "find_agent": find_agent_tool,
-        "find_library_agent": find_library_agent_tool,
         "run_agent": run_agent_tool,
-        "agent_output": agent_output_tool,
     }
     if tool_name not in tool_map:
         raise ValueError(f"Tool {tool_name} not found")

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

@@ -3,7 +3,6 @@ from datetime import UTC, datetime
 from os import getenv
 
 import pytest
-from prisma.types import ProfileCreateInput
 from pydantic import SecretStr
 
 from backend.api.features.chat.model import ChatSession
@@ -50,13 +49,13 @@ async def setup_test_data():
     # 1b. Create a profile with username for the user (required for store agent lookup)
     username = user.email.split("@")[0]
     await prisma.profile.create(
-        data=ProfileCreateInput(
-            userId=user.id,
-            username=username,
-            name=f"Test User {username}",
-            description="Test user profile",
-            links=[],  # Required field - empty array for test profiles
-        )
+        data={
+            "userId": user.id,
+            "username": username,
+            "name": f"Test User {username}",
+            "description": "Test user profile",
+            "links": [],  # Required field - empty array for test profiles
+        }
     )
 
     # 2. Create a test graph with agent input -> agent output
@@ -173,13 +172,13 @@ async def setup_llm_test_data():
     # 1b. Create a profile with username for the user (required for store agent lookup)
     username = user.email.split("@")[0]
     await prisma.profile.create(
-        data=ProfileCreateInput(
-            userId=user.id,
-            username=username,
-            name=f"Test User {username}",
-            description="Test user profile for LLM tests",
-            links=[],  # Required field - empty array for test profiles
-        )
+        data={
+            "userId": user.id,
+            "username": username,
+            "name": f"Test User {username}",
+            "description": "Test user profile for LLM tests",
+            "links": [],  # Required field - empty array for test profiles
+        }
     )
 
     # 2. Create test OpenAI credentials for the user
@@ -333,13 +332,13 @@ async def setup_firecrawl_test_data():
     # 1b. Create a profile with username for the user (required for store agent lookup)
     username = user.email.split("@")[0]
     await prisma.profile.create(
-        data=ProfileCreateInput(
-            userId=user.id,
-            username=username,
-            name=f"Test User {username}",
-            description="Test user profile for Firecrawl tests",
-            links=[],  # Required field - empty array for test profiles
-        )
+        data={
+            "userId": user.id,
+            "username": username,
+            "name": f"Test User {username}",
+            "description": "Test user profile for Firecrawl tests",
+            "links": [],  # Required field - empty array for test profiles
+        }
     )
 
     # NOTE: We deliberately do NOT create Firecrawl credentials for this user

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

@@ -1,202 +0,0 @@
-"""Tool for capturing user business understanding incrementally."""
-
-import logging
-from typing import Any
-
-from backend.api.features.chat.model import ChatSession
-from backend.data.understanding import (
-    BusinessUnderstandingInput,
-    upsert_business_understanding,
-)
-
-from .base import BaseTool
-from .models import ErrorResponse, ToolResponseBase, UnderstandingUpdatedResponse
-
-logger = logging.getLogger(__name__)
-
-
-class AddUnderstandingTool(BaseTool):
-    """Tool for capturing user's business understanding incrementally."""
-
-    @property
-    def name(self) -> str:
-        return "add_understanding"
-
-    @property
-    def description(self) -> str:
-        return """Capture and store information about the user's business context,
-workflows, pain points, and automation goals. Call this tool whenever the user
-shares information about their business. Each call incrementally adds to the
-existing understanding - you don't need to provide all fields at once.
-
-Use this to build a comprehensive profile that helps recommend better agents
-and automations for the user's specific needs."""
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "user_name": {
-                    "type": "string",
-                    "description": "The user's name",
-                },
-                "job_title": {
-                    "type": "string",
-                    "description": "The user's job title (e.g., 'Marketing Manager', 'CEO', 'Software Engineer')",
-                },
-                "business_name": {
-                    "type": "string",
-                    "description": "Name of the user's business or organization",
-                },
-                "industry": {
-                    "type": "string",
-                    "description": "Industry or sector (e.g., 'e-commerce', 'healthcare', 'finance')",
-                },
-                "business_size": {
-                    "type": "string",
-                    "description": "Company size: '1-10', '11-50', '51-200', '201-1000', or '1000+'",
-                },
-                "user_role": {
-                    "type": "string",
-                    "description": "User's role in organization context (e.g., 'decision maker', 'implementer', 'end user')",
-                },
-                "key_workflows": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Key business workflows (e.g., 'lead qualification', 'content publishing')",
-                },
-                "daily_activities": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Regular daily activities the user performs",
-                },
-                "pain_points": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Current pain points or challenges",
-                },
-                "bottlenecks": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Process bottlenecks slowing things down",
-                },
-                "manual_tasks": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Manual or repetitive tasks that could be automated",
-                },
-                "automation_goals": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Desired automation outcomes or goals",
-                },
-                "current_software": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Software and tools currently in use",
-                },
-                "existing_automation": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Any existing automations or integrations",
-                },
-                "additional_notes": {
-                    "type": "string",
-                    "description": "Any other relevant context or notes",
-                },
-            },
-            "required": [],
-        }
-
-    @property
-    def requires_auth(self) -> bool:
-        """Requires authentication to store user-specific data."""
-        return True
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """
-        Capture and store business understanding incrementally.
-
-        Each call merges new data with existing understanding:
-        - String fields are overwritten if provided
-        - List fields are appended (with deduplication)
-        """
-        session_id = session.session_id
-
-        if not user_id:
-            return ErrorResponse(
-                message="Authentication required to save business understanding.",
-                session_id=session_id,
-            )
-
-        # Check if any data was provided
-        if not any(v is not None for v in kwargs.values()):
-            return ErrorResponse(
-                message="Please provide at least one field to update.",
-                session_id=session_id,
-            )
-
-        # Build input model
-        input_data = BusinessUnderstandingInput(
-            user_name=kwargs.get("user_name"),
-            job_title=kwargs.get("job_title"),
-            business_name=kwargs.get("business_name"),
-            industry=kwargs.get("industry"),
-            business_size=kwargs.get("business_size"),
-            user_role=kwargs.get("user_role"),
-            key_workflows=kwargs.get("key_workflows"),
-            daily_activities=kwargs.get("daily_activities"),
-            pain_points=kwargs.get("pain_points"),
-            bottlenecks=kwargs.get("bottlenecks"),
-            manual_tasks=kwargs.get("manual_tasks"),
-            automation_goals=kwargs.get("automation_goals"),
-            current_software=kwargs.get("current_software"),
-            existing_automation=kwargs.get("existing_automation"),
-            additional_notes=kwargs.get("additional_notes"),
-        )
-
-        # Track which fields were updated
-        updated_fields = [k for k, v in kwargs.items() if v is not None]
-
-        # Upsert with merge
-        understanding = await upsert_business_understanding(user_id, input_data)
-
-        # Build current understanding summary for the response
-        current_understanding = {
-            "user_name": understanding.user_name,
-            "job_title": understanding.job_title,
-            "business_name": understanding.business_name,
-            "industry": understanding.industry,
-            "business_size": understanding.business_size,
-            "user_role": understanding.user_role,
-            "key_workflows": understanding.key_workflows,
-            "daily_activities": understanding.daily_activities,
-            "pain_points": understanding.pain_points,
-            "bottlenecks": understanding.bottlenecks,
-            "manual_tasks": understanding.manual_tasks,
-            "automation_goals": understanding.automation_goals,
-            "current_software": understanding.current_software,
-            "existing_automation": understanding.existing_automation,
-            "additional_notes": understanding.additional_notes,
-        }
-
-        # Filter out empty values for cleaner response
-        current_understanding = {
-            k: v
-            for k, v in current_understanding.items()
-            if v is not None and v != [] and v != ""
-        }
-
-        return UnderstandingUpdatedResponse(
-            message=f"Updated understanding with: {', '.join(updated_fields)}. "
-            "I now have a better picture of your business context.",
-            session_id=session_id,
-            updated_fields=updated_fields,
-            current_understanding=current_understanding,
-        )

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

@@ -1,455 +0,0 @@
-"""Tool for retrieving agent execution outputs from user's library."""
-
-import logging
-import re
-from datetime import datetime, timedelta, timezone
-from typing import Any
-
-from pydantic import BaseModel, field_validator
-
-from backend.api.features.chat.model import ChatSession
-from backend.api.features.library import db as library_db
-from backend.api.features.library.model import LibraryAgent
-from backend.data import execution as execution_db
-from backend.data.execution import ExecutionStatus, GraphExecution, GraphExecutionMeta
-
-from .base import BaseTool
-from .models import (
-    AgentOutputResponse,
-    ErrorResponse,
-    ExecutionOutputInfo,
-    NoResultsResponse,
-    ToolResponseBase,
-)
-from .utils import fetch_graph_from_store_slug
-
-logger = logging.getLogger(__name__)
-
-
-class AgentOutputInput(BaseModel):
-    """Input parameters for the agent_output tool."""
-
-    agent_name: str = ""
-    library_agent_id: str = ""
-    store_slug: str = ""
-    execution_id: str = ""
-    run_time: str = "latest"
-
-    @field_validator(
-        "agent_name",
-        "library_agent_id",
-        "store_slug",
-        "execution_id",
-        "run_time",
-        mode="before",
-    )
-    @classmethod
-    def strip_strings(cls, v: Any) -> Any:
-        """Strip whitespace from string fields."""
-        return v.strip() if isinstance(v, str) else v
-
-
-def parse_time_expression(
-    time_expr: str | None,
-) -> tuple[datetime | None, datetime | None]:
-    """
-    Parse time expression into datetime range (start, end).
-
-    Supports:
-    - "latest" or None -> returns (None, None) to get most recent
-    - "yesterday" -> 24h window for yesterday
-    - "today" -> Today from midnight
-    - "last week" / "last 7 days" -> 7 day window
-    - "last month" / "last 30 days" -> 30 day window
-    - ISO date "YYYY-MM-DD" -> 24h window for that date
-    """
-    if not time_expr or time_expr.lower() == "latest":
-        return None, None
-
-    now = datetime.now(timezone.utc)
-    expr = time_expr.lower().strip()
-
-    # Relative expressions
-    if expr == "yesterday":
-        end = now.replace(hour=0, minute=0, second=0, microsecond=0)
-        start = end - timedelta(days=1)
-        return start, end
-
-    if expr in ("last week", "last 7 days"):
-        return now - timedelta(days=7), now
-
-    if expr in ("last month", "last 30 days"):
-        return now - timedelta(days=30), now
-
-    if expr == "today":
-        start = now.replace(hour=0, minute=0, second=0, microsecond=0)
-        return start, now
-
-    # Try ISO date format (YYYY-MM-DD)
-    date_match = re.match(r"^(\d{4})-(\d{2})-(\d{2})$", expr)
-    if date_match:
-        year, month, day = map(int, date_match.groups())
-        start = datetime(year, month, day, 0, 0, 0, tzinfo=timezone.utc)
-        end = start + timedelta(days=1)
-        return start, end
-
-    # Try ISO datetime
-    try:
-        parsed = datetime.fromisoformat(expr.replace("Z", "+00:00"))
-        if parsed.tzinfo is None:
-            parsed = parsed.replace(tzinfo=timezone.utc)
-        # Return +/- 1 hour window around the specified time
-        return parsed - timedelta(hours=1), parsed + timedelta(hours=1)
-    except ValueError:
-        pass
-
-    # Fallback: treat as "latest"
-    return None, None
-
-
-class AgentOutputTool(BaseTool):
-    """Tool for retrieving execution outputs from user's library agents."""
-
-    @property
-    def name(self) -> str:
-        return "agent_output"
-
-    @property
-    def description(self) -> str:
-        return """Retrieve execution outputs from agents in the user's library.
-
-        Identify the agent using one of:
-        - agent_name: Fuzzy search in user's library
-        - library_agent_id: Exact library agent ID
-        - store_slug: Marketplace format 'username/agent-name'
-
-        Select which run to retrieve using:
-        - execution_id: Specific execution ID
-        - run_time: 'latest' (default), 'yesterday', 'last week', or ISO date 'YYYY-MM-DD'
-        """
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "agent_name": {
-                    "type": "string",
-                    "description": "Agent name to search for in user's library (fuzzy match)",
-                },
-                "library_agent_id": {
-                    "type": "string",
-                    "description": "Exact library agent ID",
-                },
-                "store_slug": {
-                    "type": "string",
-                    "description": "Marketplace identifier: 'username/agent-slug'",
-                },
-                "execution_id": {
-                    "type": "string",
-                    "description": "Specific execution ID to retrieve",
-                },
-                "run_time": {
-                    "type": "string",
-                    "description": (
-                        "Time filter: 'latest', 'yesterday', 'last week', or 'YYYY-MM-DD'"
-                    ),
-                },
-            },
-            "required": [],
-        }
-
-    @property
-    def requires_auth(self) -> bool:
-        return True
-
-    async def _resolve_agent(
-        self,
-        user_id: str,
-        agent_name: str | None,
-        library_agent_id: str | None,
-        store_slug: str | None,
-    ) -> tuple[LibraryAgent | None, str | None]:
-        """
-        Resolve agent from provided identifiers.
-        Returns (library_agent, error_message).
-        """
-        # Priority 1: Exact library agent ID
-        if library_agent_id:
-            try:
-                agent = await library_db.get_library_agent(library_agent_id, user_id)
-                return agent, None
-            except Exception as e:
-                logger.warning(f"Failed to get library agent by ID: {e}")
-                return None, f"Library agent '{library_agent_id}' not found"
-
-        # Priority 2: Store slug (username/agent-name)
-        if store_slug and "/" in store_slug:
-            username, agent_slug = store_slug.split("/", 1)
-            graph, _ = await fetch_graph_from_store_slug(username, agent_slug)
-            if not graph:
-                return None, f"Agent '{store_slug}' not found in marketplace"
-
-            # Find in user's library by graph_id
-            agent = await library_db.get_library_agent_by_graph_id(user_id, graph.id)
-            if not agent:
-                return (
-                    None,
-                    f"Agent '{store_slug}' is not in your library. "
-                    "Add it first to see outputs.",
-                )
-            return agent, None
-
-        # Priority 3: Fuzzy name search in library
-        if agent_name:
-            try:
-                response = await library_db.list_library_agents(
-                    user_id=user_id,
-                    search_term=agent_name,
-                    page_size=5,
-                )
-                if not response.agents:
-                    return (
-                        None,
-                        f"No agents matching '{agent_name}' found in your library",
-                    )
-
-                # Return best match (first result from search)
-                return response.agents[0], None
-            except Exception as e:
-                logger.error(f"Error searching library agents: {e}")
-                return None, f"Error searching for agent: {e}"
-
-        return (
-            None,
-            "Please specify an agent name, library_agent_id, or store_slug",
-        )
-
-    async def _get_execution(
-        self,
-        user_id: str,
-        graph_id: str,
-        execution_id: str | None,
-        time_start: datetime | None,
-        time_end: datetime | None,
-    ) -> tuple[GraphExecution | None, list[GraphExecutionMeta], str | None]:
-        """
-        Fetch execution(s) based on filters.
-        Returns (single_execution, available_executions_meta, error_message).
-        """
-        # If specific execution_id provided, fetch it directly
-        if execution_id:
-            execution = await execution_db.get_graph_execution(
-                user_id=user_id,
-                execution_id=execution_id,
-                include_node_executions=False,
-            )
-            if not execution:
-                return None, [], f"Execution '{execution_id}' not found"
-            return execution, [], None
-
-        # Get completed executions with time filters
-        executions = await execution_db.get_graph_executions(
-            graph_id=graph_id,
-            user_id=user_id,
-            statuses=[ExecutionStatus.COMPLETED],
-            created_time_gte=time_start,
-            created_time_lte=time_end,
-            limit=10,
-        )
-
-        if not executions:
-            return None, [], None  # No error, just no executions
-
-        # If only one execution, fetch full details
-        if len(executions) == 1:
-            full_execution = await execution_db.get_graph_execution(
-                user_id=user_id,
-                execution_id=executions[0].id,
-                include_node_executions=False,
-            )
-            return full_execution, [], None
-
-        # Multiple executions - return latest with full details, plus list of available
-        full_execution = await execution_db.get_graph_execution(
-            user_id=user_id,
-            execution_id=executions[0].id,
-            include_node_executions=False,
-        )
-        return full_execution, executions, None
-
-    def _build_response(
-        self,
-        agent: LibraryAgent,
-        execution: GraphExecution | None,
-        available_executions: list[GraphExecutionMeta],
-        session_id: str | None,
-    ) -> AgentOutputResponse:
-        """Build the response based on execution data."""
-        library_agent_link = f"/library/agents/{agent.id}"
-
-        if not execution:
-            return AgentOutputResponse(
-                message=f"No completed executions found for agent '{agent.name}'",
-                session_id=session_id,
-                agent_name=agent.name,
-                agent_id=agent.graph_id,
-                library_agent_id=agent.id,
-                library_agent_link=library_agent_link,
-                total_executions=0,
-            )
-
-        execution_info = ExecutionOutputInfo(
-            execution_id=execution.id,
-            status=execution.status.value,
-            started_at=execution.started_at,
-            ended_at=execution.ended_at,
-            outputs=dict(execution.outputs),
-            inputs_summary=execution.inputs if execution.inputs else None,
-        )
-
-        available_list = None
-        if len(available_executions) > 1:
-            available_list = [
-                {
-                    "id": e.id,
-                    "status": e.status.value,
-                    "started_at": e.started_at.isoformat() if e.started_at else None,
-                }
-                for e in available_executions[:5]
-            ]
-
-        message = f"Found execution outputs for agent '{agent.name}'"
-        if len(available_executions) > 1:
-            message += (
-                f". Showing latest of {len(available_executions)} matching executions."
-            )
-
-        return AgentOutputResponse(
-            message=message,
-            session_id=session_id,
-            agent_name=agent.name,
-            agent_id=agent.graph_id,
-            library_agent_id=agent.id,
-            library_agent_link=library_agent_link,
-            execution=execution_info,
-            available_executions=available_list,
-            total_executions=len(available_executions) if available_executions else 1,
-        )
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Execute the agent_output tool."""
-        session_id = session.session_id
-
-        # Parse and validate input
-        try:
-            input_data = AgentOutputInput(**kwargs)
-        except Exception as e:
-            logger.error(f"Invalid input: {e}")
-            return ErrorResponse(
-                message="Invalid input parameters",
-                error=str(e),
-                session_id=session_id,
-            )
-
-        # Ensure user_id is present (should be guaranteed by requires_auth)
-        if not user_id:
-            return ErrorResponse(
-                message="User authentication required",
-                session_id=session_id,
-            )
-
-        # Check if at least one identifier is provided
-        if not any(
-            [
-                input_data.agent_name,
-                input_data.library_agent_id,
-                input_data.store_slug,
-                input_data.execution_id,
-            ]
-        ):
-            return ErrorResponse(
-                message=(
-                    "Please specify at least one of: agent_name, "
-                    "library_agent_id, store_slug, or execution_id"
-                ),
-                session_id=session_id,
-            )
-
-        # If only execution_id provided, we need to find the agent differently
-        if (
-            input_data.execution_id
-            and not input_data.agent_name
-            and not input_data.library_agent_id
-            and not input_data.store_slug
-        ):
-            # Fetch execution directly to get graph_id
-            execution = await execution_db.get_graph_execution(
-                user_id=user_id,
-                execution_id=input_data.execution_id,
-                include_node_executions=False,
-            )
-            if not execution:
-                return ErrorResponse(
-                    message=f"Execution '{input_data.execution_id}' not found",
-                    session_id=session_id,
-                )
-
-            # Find library agent by graph_id
-            agent = await library_db.get_library_agent_by_graph_id(
-                user_id, execution.graph_id
-            )
-            if not agent:
-                return NoResultsResponse(
-                    message=(
-                        f"Execution found but agent not in your library. "
-                        f"Graph ID: {execution.graph_id}"
-                    ),
-                    session_id=session_id,
-                    suggestions=["Add the agent to your library to see more details"],
-                )
-
-            return self._build_response(agent, execution, [], session_id)
-
-        # Resolve agent from identifiers
-        agent, error = await self._resolve_agent(
-            user_id=user_id,
-            agent_name=input_data.agent_name or None,
-            library_agent_id=input_data.library_agent_id or None,
-            store_slug=input_data.store_slug or None,
-        )
-
-        if error or not agent:
-            return NoResultsResponse(
-                message=error or "Agent not found",
-                session_id=session_id,
-                suggestions=[
-                    "Check the agent name or ID",
-                    "Make sure the agent is in your library",
-                ],
-            )
-
-        # Parse time expression
-        time_start, time_end = parse_time_expression(input_data.run_time)
-
-        # Fetch execution(s)
-        execution, available_executions, exec_error = await self._get_execution(
-            user_id=user_id,
-            graph_id=agent.graph_id,
-            execution_id=input_data.execution_id or None,
-            time_start=time_start,
-            time_end=time_end,
-        )
-
-        if exec_error:
-            return ErrorResponse(
-                message=exec_error,
-                session_id=session_id,
-            )
-
-        return self._build_response(agent, execution, available_executions, session_id)

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

@@ -1,157 +0,0 @@
-"""Tool for searching agents in the user's library."""
-
-import logging
-from typing import Any
-
-from backend.api.features.chat.model import ChatSession
-from backend.api.features.library import db as library_db
-from backend.util.exceptions import DatabaseError
-
-from .base import BaseTool
-from .models import (
-    AgentCarouselResponse,
-    AgentInfo,
-    ErrorResponse,
-    NoResultsResponse,
-    ToolResponseBase,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class FindLibraryAgentTool(BaseTool):
-    """Tool for searching agents in the user's library."""
-
-    @property
-    def name(self) -> str:
-        return "find_library_agent"
-
-    @property
-    def description(self) -> str:
-        return (
-            "Search for agents in the user's library. Use this to find agents "
-            "the user has already added to their library, including agents they "
-            "created or added from the marketplace."
-        )
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "query": {
-                    "type": "string",
-                    "description": (
-                        "Search query to find agents by name or description. "
-                        "Use keywords for best results."
-                    ),
-                },
-            },
-            "required": ["query"],
-        }
-
-    @property
-    def requires_auth(self) -> bool:
-        return True
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Search for agents in the user's library.
-
-        Args:
-            user_id: User ID (required)
-            session: Chat session
-            query: Search query
-
-        Returns:
-            AgentCarouselResponse: List of agents found in the library
-            NoResultsResponse: No agents found
-            ErrorResponse: Error message
-        """
-        query = kwargs.get("query", "").strip()
-        session_id = session.session_id
-
-        if not query:
-            return ErrorResponse(
-                message="Please provide a search query",
-                session_id=session_id,
-            )
-
-        if not user_id:
-            return ErrorResponse(
-                message="User authentication required to search library",
-                session_id=session_id,
-            )
-
-        agents = []
-        try:
-            logger.info(f"Searching user library for: {query}")
-            library_results = await library_db.list_library_agents(
-                user_id=user_id,
-                search_term=query,
-                page_size=10,
-            )
-
-            logger.info(
-                f"Find library agents tool found {len(library_results.agents)} agents"
-            )
-
-            for agent in library_results.agents:
-                agents.append(
-                    AgentInfo(
-                        id=agent.id,
-                        name=agent.name,
-                        description=agent.description or "",
-                        source="library",
-                        in_library=True,
-                        creator=agent.creator_name,
-                        status=agent.status.value,
-                        can_access_graph=agent.can_access_graph,
-                        has_external_trigger=agent.has_external_trigger,
-                        new_output=agent.new_output,
-                        graph_id=agent.graph_id,
-                    ),
-                )
-
-        except DatabaseError as e:
-            logger.error(f"Error searching library agents: {e}", exc_info=True)
-            return ErrorResponse(
-                message="Failed to search library. Please try again.",
-                error=str(e),
-                session_id=session_id,
-            )
-
-        if not agents:
-            return NoResultsResponse(
-                message=(
-                    f"No agents found matching '{query}' in your library. "
-                    "Try different keywords or use find_agent to search the marketplace."
-                ),
-                session_id=session_id,
-                suggestions=[
-                    "Try more general terms",
-                    "Use find_agent to search the marketplace",
-                    "Check your library at /library",
-                ],
-            )
-
-        title = (
-            f"Found {len(agents)} agent{'s' if len(agents) != 1 else ''} "
-            f"in your library for '{query}'"
-        )
-
-        return AgentCarouselResponse(
-            message=(
-                "Found agents in the user's library. You can provide a link to "
-                "view an agent at: /library/agents/{agent_id}. "
-                "Use agent_output to get execution results, or run_agent to execute."
-            ),
-            title=title,
-            agents=agents,
-            count=len(agents),
-            session_id=session_id,
-        )

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

@@ -1,6 +1,5 @@
 """Pydantic models for tool responses."""
 
-from datetime import datetime
 from enum import Enum
 from typing import Any
 
@@ -20,15 +19,6 @@ class ResponseType(str, Enum):
     ERROR = "error"
     NO_RESULTS = "no_results"
     SUCCESS = "success"
-    DOC_SEARCH_RESULTS = "doc_search_results"
-    AGENT_OUTPUT = "agent_output"
-    BLOCK_LIST = "block_list"
-    BLOCK_OUTPUT = "block_output"
-    UNDERSTANDING_UPDATED = "understanding_updated"
-    # Agent generation responses
-    AGENT_PREVIEW = "agent_preview"
-    AGENT_SAVED = "agent_saved"
-    CLARIFICATION_NEEDED = "clarification_needed"
 
 
 # Base response model
@@ -183,128 +173,3 @@ class ErrorResponse(ToolResponseBase):
     type: ResponseType = ResponseType.ERROR
     error: str | None = None
     details: dict[str, Any] | None = None
-
-
-# Documentation search models
-class DocSearchResult(BaseModel):
-    """A single documentation search result."""
-
-    title: str
-    path: str
-    section: str
-    snippet: str  # Short excerpt for UI display
-    content: str  # Full text content for LLM to read and understand
-    score: float
-    doc_url: str | None = None
-
-
-class DocSearchResultsResponse(ToolResponseBase):
-    """Response for search_docs tool."""
-
-    type: ResponseType = ResponseType.DOC_SEARCH_RESULTS
-    results: list[DocSearchResult]
-    count: int
-    query: str
-
-
-# Agent output models
-class ExecutionOutputInfo(BaseModel):
-    """Summary of a single execution's outputs."""
-
-    execution_id: str
-    status: str
-    started_at: datetime | None = None
-    ended_at: datetime | None = None
-    outputs: dict[str, list[Any]]
-    inputs_summary: dict[str, Any] | None = None
-
-
-class AgentOutputResponse(ToolResponseBase):
-    """Response for agent_output tool."""
-
-    type: ResponseType = ResponseType.AGENT_OUTPUT
-    agent_name: str
-    agent_id: str
-    library_agent_id: str | None = None
-    library_agent_link: str | None = None
-    execution: ExecutionOutputInfo | None = None
-    available_executions: list[dict[str, Any]] | None = None
-    total_executions: int = 0
-
-
-# Block models
-class BlockInfoSummary(BaseModel):
-    """Summary of a block for search results."""
-
-    id: str
-    name: str
-    description: str
-    categories: list[str]
-    input_schema: dict[str, Any]
-    output_schema: dict[str, Any]
-
-
-class BlockListResponse(ToolResponseBase):
-    """Response for find_block tool."""
-
-    type: ResponseType = ResponseType.BLOCK_LIST
-    blocks: list[BlockInfoSummary]
-    count: int
-    query: str
-
-
-class BlockOutputResponse(ToolResponseBase):
-    """Response for run_block tool."""
-
-    type: ResponseType = ResponseType.BLOCK_OUTPUT
-    block_id: str
-    block_name: str
-    outputs: dict[str, list[Any]]
-    success: bool = True
-
-
-# Business understanding models
-class UnderstandingUpdatedResponse(ToolResponseBase):
-    """Response for add_understanding tool."""
-
-    type: ResponseType = ResponseType.UNDERSTANDING_UPDATED
-    updated_fields: list[str] = Field(default_factory=list)
-    current_understanding: dict[str, Any] = Field(default_factory=dict)
-
-
-# Agent generation models
-class ClarifyingQuestion(BaseModel):
-    """A question that needs user clarification."""
-
-    question: str
-    keyword: str
-    example: str | None = None
-
-
-class AgentPreviewResponse(ToolResponseBase):
-    """Response for previewing a generated agent before saving."""
-
-    type: ResponseType = ResponseType.AGENT_PREVIEW
-    agent_json: dict[str, Any]
-    agent_name: str
-    description: str
-    node_count: int
-    link_count: int = 0
-
-
-class AgentSavedResponse(ToolResponseBase):
-    """Response when an agent is saved to the library."""
-
-    type: ResponseType = ResponseType.AGENT_SAVED
-    agent_id: str
-    agent_name: str
-    library_agent_id: str
-    library_agent_link: str
-    agent_page_link: str  # Link to the agent builder/editor page
-
-
-class ClarificationNeededResponse(ToolResponseBase):
-    """Response when the LLM needs more information from the user."""
-
-    type: ResponseType = ResponseType.CLARIFICATION_NEEDED
-    questions: list[ClarifyingQuestion] = Field(default_factory=list)

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

@@ -7,7 +7,6 @@ from pydantic import BaseModel, Field, field_validator
 
 from backend.api.features.chat.config import ChatConfig
 from backend.api.features.chat.model import ChatSession
-from backend.api.features.library import db as library_db
 from backend.data.graph import GraphModel
 from backend.data.model import CredentialsMetaInput
 from backend.data.user import get_user_by_id
@@ -58,7 +57,6 @@ class RunAgentInput(BaseModel):
     """Input parameters for the run_agent tool."""
 
     username_agent_slug: str = ""
-    library_agent_id: str = ""
     inputs: dict[str, Any] = Field(default_factory=dict)
     use_defaults: bool = False
     schedule_name: str = ""
@@ -66,12 +64,7 @@ class RunAgentInput(BaseModel):
     timezone: str = "UTC"
 
     @field_validator(
-        "username_agent_slug",
-        "library_agent_id",
-        "schedule_name",
-        "cron",
-        "timezone",
-        mode="before",
+        "username_agent_slug", "schedule_name", "cron", "timezone", mode="before"
     )
     @classmethod
     def strip_strings(cls, v: Any) -> Any:
@@ -97,7 +90,7 @@ class RunAgentTool(BaseTool):
 
     @property
     def description(self) -> str:
-        return """Run or schedule an agent from the marketplace or user's library.
+        return """Run or schedule an agent from the marketplace.
 
         The tool automatically handles the setup flow:
         - Returns missing inputs if required fields are not provided
@@ -105,10 +98,6 @@ class RunAgentTool(BaseTool):
         - Executes immediately if all requirements are met
         - Schedules execution if cron expression is provided
 
-        Identify the agent using either:
-        - username_agent_slug: Marketplace format 'username/agent-name'
-        - library_agent_id: ID of an agent in the user's library
-
         For scheduled execution, provide: schedule_name, cron, and optionally timezone."""
 
     @property
@@ -120,10 +109,6 @@ class RunAgentTool(BaseTool):
                     "type": "string",
                     "description": "Agent identifier in format 'username/agent-name'",
                 },
-                "library_agent_id": {
-                    "type": "string",
-                    "description": "Library agent ID from user's library",
-                },
                 "inputs": {
                     "type": "object",
                     "description": "Input values for the agent",
@@ -146,7 +131,7 @@ class RunAgentTool(BaseTool):
                     "description": "IANA timezone for schedule (default: UTC)",
                 },
             },
-            "required": [],
+            "required": ["username_agent_slug"],
         }
 
     @property
@@ -164,16 +149,10 @@ class RunAgentTool(BaseTool):
         params = RunAgentInput(**kwargs)
         session_id = session.session_id
 
-        # Validate at least one identifier is provided
-        has_slug = params.username_agent_slug and "/" in params.username_agent_slug
-        has_library_id = bool(params.library_agent_id)
-
-        if not has_slug and not has_library_id:
+        # Validate agent slug format
+        if not params.username_agent_slug or "/" not in params.username_agent_slug:
             return ErrorResponse(
-                message=(
-                    "Please provide either a username_agent_slug "
-                    "(format 'username/agent-name') or a library_agent_id"
-                ),
+                message="Please provide an agent slug in format 'username/agent-name'",
                 session_id=session_id,
             )
 
@@ -188,41 +167,13 @@ class RunAgentTool(BaseTool):
         is_schedule = bool(params.schedule_name or params.cron)
 
         try:
-            # Step 1: Fetch agent details
-            graph: GraphModel | None = None
-            library_agent = None
-
-            # Priority: library_agent_id if provided
-            if has_library_id:
-                library_agent = await library_db.get_library_agent(
-                    params.library_agent_id, user_id
-                )
-                if not library_agent:
-                    return ErrorResponse(
-                        message=f"Library agent '{params.library_agent_id}' not found",
-                        session_id=session_id,
-                    )
-                # Get the graph from the library agent
-                from backend.data.graph import get_graph
-
-                graph = await get_graph(
-                    library_agent.graph_id,
-                    library_agent.graph_version,
-                    user_id=user_id,
-                )
-            else:
-                # Fetch from marketplace slug
-                username, agent_name = params.username_agent_slug.split("/", 1)
-                graph, _ = await fetch_graph_from_store_slug(username, agent_name)
+            # Step 1: Fetch agent details (always happens first)
+            username, agent_name = params.username_agent_slug.split("/", 1)
+            graph, store_agent = await fetch_graph_from_store_slug(username, agent_name)
 
             if not graph:
-                identifier = (
-                    params.library_agent_id
-                    if has_library_id
-                    else params.username_agent_slug
-                )
                 return ErrorResponse(
-                    message=f"Agent '{identifier}' not found",
+                    message=f"Agent '{params.username_agent_slug}' not found in marketplace",
                     session_id=session_id,
                 )
 

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

@@ -23,6 +23,7 @@ from backend.data.notifications import (
     AgentApprovalData,
     AgentRejectionData,
     NotificationEventModel,
+    WaitlistLaunchData,
 )
 from backend.notifications.notifications import queue_notification_async
 from backend.util.exceptions import DatabaseError
@@ -1742,6 +1743,29 @@ async def review_store_submission(
                 # Don't fail the review process if email sending fails
                 pass
 
+        # Notify waitlist users if this is an approval and has a linked waitlist
+        if is_approved and submission.StoreListing:
+            try:
+                frontend_base_url = (
+                    settings.config.frontend_base_url
+                    or settings.config.platform_base_url
+                )
+                store_agent = (
+                    await prisma.models.StoreAgent.prisma().find_first_or_raise(
+                        where={"storeListingVersionId": submission.id}
+                    )
+                )
+                creator_username = store_agent.creator_username or "unknown"
+                store_url = f"{frontend_base_url}/marketplace/agent/{creator_username}/{store_agent.slug}"
+                await notify_waitlist_users_on_launch(
+                    store_listing_id=submission.StoreListing.id,
+                    agent_name=submission.name,
+                    store_url=store_url,
+                )
+            except Exception as e:
+                logger.error(f"Failed to notify waitlist users on agent approval: {e}")
+                # Don't fail the approval process
+
         # Convert to Pydantic model for consistency
         return store_model.StoreSubmission(
             listing_id=(submission.StoreListing.id if submission.StoreListing else ""),
@@ -1989,3 +2013,507 @@ 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
+    """
+    logger.debug(f"Adding user {user_id or email} to waitlist {waitlist_id}")
+
+    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:
+        # 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, typing.Any] = {
+            k: v for k, v in field_mappings.items() if k in data.model_fields_set
+        }
+
+        # Handle status separately due to enum conversion
+        if "status" in data.model_fields_set and data.status is not None:
+            update_data["status"] = prisma.enums.WaitlistExternalStatus(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},
+        )
+
+        if not waitlist:
+            raise ValueError(f"Waitlist {waitlist_id} not found")
+
+        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) -> bool:
+    """Soft delete a waitlist (admin only)."""
+    logger.info(f"Soft deleting waitlist {waitlist_id}")
+
+    try:
+        waitlist = await prisma.models.WaitlistEntry.prisma().update(
+            where={"id": waitlist_id},
+            data={"isDeleted": True},
+        )
+
+        return waitlist is not None
+    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 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")
+
+        waitlist = await prisma.models.WaitlistEntry.prisma().update(
+            where={"id": waitlist_id},
+            data={"StoreListing": {"connect": {"id": store_listing_id}}},
+            include={"joinedUsers": True},
+        )
+
+        if not waitlist:
+            raise ValueError(f"Waitlist {waitlist_id} not found")
+
+        return _waitlist_to_admin_response(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 waitlists linked to this store listing
+        waitlists = await prisma.models.WaitlistEntry.prisma().find_many(
+            where={
+                "storeListingId": store_listing_id,
+                "isDeleted": False,
+            },
+            include={"joinedUsers": True},
+        )
+
+        if not waitlists:
+            logger.info(f"No 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.
+            if waitlist.unaffiliatedEmailUsers:
+                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
+            if not failed_user_ids:
+                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")
+            else:
+                logger.warning(
+                    f"Waitlist {waitlist.id} not marked as DONE due to "
+                    f"{len(failed_user_ids)} failed notifications"
+                )
+
+        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

@@ -221,3 +221,99 @@ class ReviewSubmissionRequest(pydantic.BaseModel):
     is_approved: bool
     comments: str  # External comments visible to creator
     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: str | None = None  # WaitlistExternalStatus enum value
+    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

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

@@ -7,6 +7,7 @@ from typing import Literal
 import autogpt_libs.auth
 import fastapi
 import fastapi.responses
+from autogpt_libs.auth.dependencies import get_optional_user_id
 
 import backend.data.graph
 import backend.util.json
@@ -78,6 +79,63 @@ 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",
+        )
+
+    waitlist_entry = await store_db.add_user_to_waitlist(
+        waitlist_id=waitlist_id, user_id=user_id, email=email
+    )
+    return waitlist_entry
+
+
 ##############################################
 ############### Agent Endpoints ##############
 ##############################################

autogpt_platform/backend/backend/api/rest_api.py

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

autogpt_platform/backend/backend/blocks/wordpress/__init__.py

@@ -1,3 +1,3 @@
-from .blog import WordPressCreatePostBlock
+from .blog import WordPressCreatePostBlock, WordPressGetAllPostsBlock
 
-__all__ = ["WordPressCreatePostBlock"]
+__all__ = ["WordPressCreatePostBlock", "WordPressGetAllPostsBlock"]

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

@@ -161,7 +161,7 @@ async def oauth_exchange_code_for_tokens(
         grant_type="authorization_code",
     ).model_dump(exclude_none=True)
 
-    response = await Requests().post(
+    response = await Requests(raise_for_status=False).post(
         f"{WORDPRESS_BASE_URL}oauth2/token",
         headers=headers,
         data=data,
@@ -205,7 +205,7 @@ async def oauth_refresh_tokens(
         grant_type="refresh_token",
     ).model_dump(exclude_none=True)
 
-    response = await Requests().post(
+    response = await Requests(raise_for_status=False).post(
         f"{WORDPRESS_BASE_URL}oauth2/token",
         headers=headers,
         data=data,
@@ -252,7 +252,7 @@ async def validate_token(
         "token": token,
     }
 
-    response = await Requests().get(
+    response = await Requests(raise_for_status=False).get(
         f"{WORDPRESS_BASE_URL}oauth2/token-info",
         params=params,
     )
@@ -296,7 +296,7 @@ async def make_api_request(
 
     url = f"{WORDPRESS_BASE_URL.rstrip('/')}{endpoint}"
 
-    request_method = getattr(Requests(), method.lower())
+    request_method = getattr(Requests(raise_for_status=False), method.lower())
     response = await request_method(
         url,
         headers=headers,
@@ -476,6 +476,7 @@ async def create_post(
         data["tags"] = ",".join(str(t) for t in data["tags"])
 
     # Make the API request
+    site = normalize_site(site)
     endpoint = f"/rest/v1.1/sites/{site}/posts/new"
 
     headers = {
@@ -483,7 +484,7 @@ async def create_post(
         "Content-Type": "application/x-www-form-urlencoded",
     }
 
-    response = await Requests().post(
+    response = await Requests(raise_for_status=False).post(
         f"{WORDPRESS_BASE_URL.rstrip('/')}{endpoint}",
         headers=headers,
         data=data,
@@ -499,3 +500,132 @@ async def create_post(
     )
     error_message = error_data.get("message", response.text)
     raise ValueError(f"Failed to create post: {response.status} - {error_message}")
+
+
+class Post(BaseModel):
+    """Response model for individual posts in a posts list response.
+
+    This is a simplified version compared to PostResponse, as the list endpoint
+    returns less detailed information than the create/get single post endpoints.
+    """
+
+    ID: int
+    site_ID: int
+    author: PostAuthor
+    date: datetime
+    modified: datetime
+    title: str
+    URL: str
+    short_URL: str
+    content: str | None = None
+    excerpt: str | None = None
+    slug: str
+    guid: str
+    status: str
+    sticky: bool
+    password: str | None = ""
+    parent: Union[Dict[str, Any], bool, None] = None
+    type: str
+    discussion: Dict[str, Union[str, bool, int]] | None = None
+    likes_enabled: bool | None = None
+    sharing_enabled: bool | None = None
+    like_count: int | None = None
+    i_like: bool | None = None
+    is_reblogged: bool | None = None
+    is_following: bool | None = None
+    global_ID: str | None = None
+    featured_image: str | None = None
+    post_thumbnail: Dict[str, Any] | None = None
+    format: str | None = None
+    geo: Union[Dict[str, Any], bool, None] = None
+    menu_order: int | None = None
+    page_template: str | None = None
+    publicize_URLs: List[str] | None = None
+    terms: Dict[str, Dict[str, Any]] | None = None
+    tags: Dict[str, Dict[str, Any]] | None = None
+    categories: Dict[str, Dict[str, Any]] | None = None
+    attachments: Dict[str, Dict[str, Any]] | None = None
+    attachment_count: int | None = None
+    metadata: List[Dict[str, Any]] | None = None
+    meta: Dict[str, Any] | None = None
+    capabilities: Dict[str, bool] | None = None
+    revisions: List[int] | None = None
+    other_URLs: Dict[str, Any] | None = None
+
+
+class PostsResponse(BaseModel):
+    """Response model for WordPress posts list."""
+
+    found: int
+    posts: List[Post]
+    meta: Dict[str, Any]
+
+
+def normalize_site(site: str) -> str:
+    """
+    Normalize a site identifier by stripping protocol and trailing slashes.
+
+    Args:
+        site: Site URL, domain, or ID (e.g., "https://myblog.wordpress.com/", "myblog.wordpress.com", "123456789")
+
+    Returns:
+        Normalized site identifier (domain or ID only)
+    """
+    site = site.strip()
+    if site.startswith("https://"):
+        site = site[8:]
+    elif site.startswith("http://"):
+        site = site[7:]
+    return site.rstrip("/")
+
+
+async def get_posts(
+    credentials: Credentials,
+    site: str,
+    status: PostStatus | None = None,
+    number: int = 100,
+    offset: int = 0,
+) -> PostsResponse:
+    """
+    Get posts from a WordPress site.
+
+    Args:
+        credentials: OAuth credentials
+        site: Site ID or domain (e.g., "myblog.wordpress.com" or "123456789")
+        status: Filter by post status using PostStatus enum, or None for all
+        number: Number of posts to retrieve (max 100)
+        offset: Number of posts to skip (for pagination)
+
+    Returns:
+        PostsResponse with the list of posts
+    """
+    site = normalize_site(site)
+    endpoint = f"/rest/v1.1/sites/{site}/posts"
+
+    headers = {
+        "Authorization": credentials.auth_header(),
+    }
+
+    params: Dict[str, Any] = {
+        "number": max(1, min(number, 100)),  # 1–100 posts per request
+        "offset": offset,
+    }
+
+    if status:
+        params["status"] = status.value
+    response = await Requests(raise_for_status=False).get(
+        f"{WORDPRESS_BASE_URL.rstrip('/')}{endpoint}",
+        headers=headers,
+        params=params,
+    )
+
+    if response.ok:
+        return PostsResponse.model_validate(response.json())
+
+    error_data = (
+        response.json()
+        if response.headers.get("content-type", "").startswith("application/json")
+        else {}
+    )
+    error_message = error_data.get("message", response.text)
+    raise ValueError(f"Failed to get posts: {response.status} - {error_message}")

autogpt_platform/backend/backend/blocks/wordpress/blog.py

@@ -9,7 +9,15 @@ from backend.sdk import (
     SchemaField,
 )
 
-from ._api import CreatePostRequest, PostResponse, PostStatus, create_post
+from ._api import (
+    CreatePostRequest,
+    Post,
+    PostResponse,
+    PostsResponse,
+    PostStatus,
+    create_post,
+    get_posts,
+)
 from ._config import wordpress
 
 
@@ -49,8 +57,15 @@ class WordPressCreatePostBlock(Block):
         media_urls: list[str] = SchemaField(
             description="URLs of images to sideload and attach to the post", default=[]
         )
+        publish_as_draft: bool = SchemaField(
+            description="If True, publishes the post as a draft. If False, publishes it publicly.",
+            default=False,
+        )
 
     class Output(BlockSchemaOutput):
+        site: str = SchemaField(
+            description="The site ID or domain (pass-through for chaining with other blocks)"
+        )
         post_id: int = SchemaField(description="The ID of the created post")
         post_url: str = SchemaField(description="The full URL of the created post")
         short_url: str = SchemaField(description="The shortened wp.me URL")
@@ -78,7 +93,9 @@ class WordPressCreatePostBlock(Block):
             tags=input_data.tags,
             featured_image=input_data.featured_image,
             media_urls=input_data.media_urls,
-            status=PostStatus.PUBLISH,
+            status=(
+                PostStatus.DRAFT if input_data.publish_as_draft else PostStatus.PUBLISH
+            ),
         )
 
         post_response: PostResponse = await create_post(
@@ -87,7 +104,69 @@ class WordPressCreatePostBlock(Block):
             post_data=post_request,
         )
 
+        yield "site", input_data.site
         yield "post_id", post_response.ID
         yield "post_url", post_response.URL
         yield "short_url", post_response.short_URL
         yield "post_data", post_response.model_dump()
+
+
+class WordPressGetAllPostsBlock(Block):
+    """
+    Fetches all posts from a WordPress.com site or Jetpack-enabled site.
+    Supports filtering by status and pagination.
+    """
+
+    class Input(BlockSchemaInput):
+        credentials: CredentialsMetaInput = wordpress.credentials_field()
+        site: str = SchemaField(
+            description="Site ID or domain (e.g., 'myblog.wordpress.com' or '123456789')"
+        )
+        status: PostStatus | None = SchemaField(
+            description="Filter by post status, or None for all",
+            default=None,
+        )
+        number: int = SchemaField(
+            description="Number of posts to retrieve (max 100 per request)", default=20
+        )
+        offset: int = SchemaField(
+            description="Number of posts to skip (for pagination)", default=0
+        )
+
+    class Output(BlockSchemaOutput):
+        site: str = SchemaField(
+            description="The site ID or domain (pass-through for chaining with other blocks)"
+        )
+        found: int = SchemaField(description="Total number of posts found")
+        posts: list[Post] = SchemaField(
+            description="List of post objects with their details"
+        )
+        post: Post = SchemaField(
+            description="Individual post object (yielded for each post)"
+        )
+
+    def __init__(self):
+        super().__init__(
+            id="97728fa7-7f6f-4789-ba0c-f2c114119536",
+            description="Fetch all posts from WordPress.com or Jetpack sites",
+            categories={BlockCategory.SOCIAL},
+            input_schema=self.Input,
+            output_schema=self.Output,
+        )
+
+    async def run(
+        self, input_data: Input, *, credentials: Credentials, **kwargs
+    ) -> BlockOutput:
+        posts_response: PostsResponse = await get_posts(
+            credentials=credentials,
+            site=input_data.site,
+            status=input_data.status,
+            number=input_data.number,
+            offset=input_data.offset,
+        )
+
+        yield "site", input_data.site
+        yield "found", posts_response.found
+        yield "posts", posts_response.posts
+        for post in posts_response.posts:
+            yield "post", post

autogpt_platform/backend/backend/data/notifications.py

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

autogpt_platform/backend/backend/data/understanding.py

@@ -1,429 +0,0 @@
-"""Data models and access layer for user business understanding."""
-
-import logging
-from datetime import datetime
-from typing import Any, Optional, cast
-
-import pydantic
-from prisma.models import UserBusinessUnderstanding
-from prisma.types import (
-    UserBusinessUnderstandingCreateInput,
-    UserBusinessUnderstandingUpdateInput,
-)
-
-from backend.data.redis_client import get_redis_async
-from backend.util.json import SafeJson
-
-logger = logging.getLogger(__name__)
-
-# Cache configuration
-CACHE_KEY_PREFIX = "understanding"
-CACHE_TTL_SECONDS = 48 * 60 * 60  # 48 hours
-
-
-def _cache_key(user_id: str) -> str:
-    """Generate cache key for user business understanding."""
-    return f"{CACHE_KEY_PREFIX}:{user_id}"
-
-
-def _json_to_list(value: Any) -> list[str]:
-    """Convert Json field to list[str], handling None."""
-    if value is None:
-        return []
-    if isinstance(value, list):
-        return cast(list[str], value)
-    return []
-
-
-class BusinessUnderstandingInput(pydantic.BaseModel):
-    """Input model for updating business understanding - all fields optional for incremental updates."""
-
-    # User info
-    user_name: Optional[str] = pydantic.Field(None, description="The user's name")
-    job_title: Optional[str] = pydantic.Field(None, description="The user's job title")
-
-    # Business basics
-    business_name: Optional[str] = pydantic.Field(
-        None, description="Name of the user's business"
-    )
-    industry: Optional[str] = pydantic.Field(None, description="Industry or sector")
-    business_size: Optional[str] = pydantic.Field(
-        None, description="Company size (e.g., '1-10', '11-50')"
-    )
-    user_role: Optional[str] = pydantic.Field(
-        None,
-        description="User's role in the organization (e.g., 'decision maker', 'implementer')",
-    )
-
-    # Processes & activities
-    key_workflows: Optional[list[str]] = pydantic.Field(
-        None, description="Key business workflows"
-    )
-    daily_activities: Optional[list[str]] = pydantic.Field(
-        None, description="Daily activities performed"
-    )
-
-    # Pain points & goals
-    pain_points: Optional[list[str]] = pydantic.Field(
-        None, description="Current pain points"
-    )
-    bottlenecks: Optional[list[str]] = pydantic.Field(
-        None, description="Process bottlenecks"
-    )
-    manual_tasks: Optional[list[str]] = pydantic.Field(
-        None, description="Manual/repetitive tasks"
-    )
-    automation_goals: Optional[list[str]] = pydantic.Field(
-        None, description="Desired automation goals"
-    )
-
-    # Current tools
-    current_software: Optional[list[str]] = pydantic.Field(
-        None, description="Software/tools currently used"
-    )
-    existing_automation: Optional[list[str]] = pydantic.Field(
-        None, description="Existing automations"
-    )
-
-    # Additional context
-    additional_notes: Optional[str] = pydantic.Field(
-        None, description="Any additional context"
-    )
-
-
-class BusinessUnderstanding(pydantic.BaseModel):
-    """Full business understanding model returned from database."""
-
-    id: str
-    user_id: str
-    created_at: datetime
-    updated_at: datetime
-
-    # User info
-    user_name: Optional[str] = None
-    job_title: Optional[str] = None
-
-    # Business basics
-    business_name: Optional[str] = None
-    industry: Optional[str] = None
-    business_size: Optional[str] = None
-    user_role: Optional[str] = None
-
-    # Processes & activities
-    key_workflows: list[str] = pydantic.Field(default_factory=list)
-    daily_activities: list[str] = pydantic.Field(default_factory=list)
-
-    # Pain points & goals
-    pain_points: list[str] = pydantic.Field(default_factory=list)
-    bottlenecks: list[str] = pydantic.Field(default_factory=list)
-    manual_tasks: list[str] = pydantic.Field(default_factory=list)
-    automation_goals: list[str] = pydantic.Field(default_factory=list)
-
-    # Current tools
-    current_software: list[str] = pydantic.Field(default_factory=list)
-    existing_automation: list[str] = pydantic.Field(default_factory=list)
-
-    # Additional context
-    additional_notes: Optional[str] = None
-
-    @classmethod
-    def from_db(cls, db_record: UserBusinessUnderstanding) -> "BusinessUnderstanding":
-        """Convert database record to Pydantic model."""
-        return cls(
-            id=db_record.id,
-            user_id=db_record.userId,
-            created_at=db_record.createdAt,
-            updated_at=db_record.updatedAt,
-            user_name=db_record.userName,
-            job_title=db_record.jobTitle,
-            business_name=db_record.businessName,
-            industry=db_record.industry,
-            business_size=db_record.businessSize,
-            user_role=db_record.userRole,
-            key_workflows=_json_to_list(db_record.keyWorkflows),
-            daily_activities=_json_to_list(db_record.dailyActivities),
-            pain_points=_json_to_list(db_record.painPoints),
-            bottlenecks=_json_to_list(db_record.bottlenecks),
-            manual_tasks=_json_to_list(db_record.manualTasks),
-            automation_goals=_json_to_list(db_record.automationGoals),
-            current_software=_json_to_list(db_record.currentSoftware),
-            existing_automation=_json_to_list(db_record.existingAutomation),
-            additional_notes=db_record.additionalNotes,
-        )
-
-
-def _merge_lists(existing: list | None, new: list | None) -> list | None:
-    """Merge two lists, removing duplicates while preserving order."""
-    if new is None:
-        return existing
-    if existing is None:
-        return new
-    # Preserve order, add new items that don't exist
-    merged = list(existing)
-    for item in new:
-        if item not in merged:
-            merged.append(item)
-    return merged
-
-
-async def _get_from_cache(user_id: str) -> Optional[BusinessUnderstanding]:
-    """Get business understanding from Redis cache."""
-    try:
-        redis = await get_redis_async()
-        cached_data = await redis.get(_cache_key(user_id))
-        if cached_data:
-            return BusinessUnderstanding.model_validate_json(cached_data)
-    except Exception as e:
-        logger.warning(f"Failed to get understanding from cache: {e}")
-    return None
-
-
-async def _set_cache(user_id: str, understanding: BusinessUnderstanding) -> None:
-    """Set business understanding in Redis cache with TTL."""
-    try:
-        redis = await get_redis_async()
-        await redis.setex(
-            _cache_key(user_id),
-            CACHE_TTL_SECONDS,
-            understanding.model_dump_json(),
-        )
-    except Exception as e:
-        logger.warning(f"Failed to set understanding in cache: {e}")
-
-
-async def _delete_cache(user_id: str) -> None:
-    """Delete business understanding from Redis cache."""
-    try:
-        redis = await get_redis_async()
-        await redis.delete(_cache_key(user_id))
-    except Exception as e:
-        logger.warning(f"Failed to delete understanding from cache: {e}")
-
-
-async def get_business_understanding(
-    user_id: str,
-) -> Optional[BusinessUnderstanding]:
-    """Get the business understanding for a user.
-
-    Checks cache first, falls back to database if not cached.
-    Results are cached for 48 hours.
-    """
-    # Try cache first
-    cached = await _get_from_cache(user_id)
-    if cached:
-        logger.debug(f"Business understanding cache hit for user {user_id}")
-        return cached
-
-    # Cache miss - load from database
-    logger.debug(f"Business understanding cache miss for user {user_id}")
-    record = await UserBusinessUnderstanding.prisma().find_unique(
-        where={"userId": user_id}
-    )
-    if record is None:
-        return None
-
-    understanding = BusinessUnderstanding.from_db(record)
-
-    # Store in cache for next time
-    await _set_cache(user_id, understanding)
-
-    return understanding
-
-
-async def upsert_business_understanding(
-    user_id: str,
-    data: BusinessUnderstandingInput,
-) -> BusinessUnderstanding:
-    """
-    Create or update business understanding with incremental merge strategy.
-
-    - String fields: new value overwrites if provided (not None)
-    - List fields: new items are appended to existing (deduplicated)
-    """
-    # Get existing record for merge
-    existing = await UserBusinessUnderstanding.prisma().find_unique(
-        where={"userId": user_id}
-    )
-
-    # Build update data with merge strategy
-    update_data: UserBusinessUnderstandingUpdateInput = {}
-    create_data: dict[str, Any] = {"userId": user_id}
-
-    # String fields - overwrite if provided
-    if data.user_name is not None:
-        update_data["userName"] = data.user_name
-        create_data["userName"] = data.user_name
-    if data.job_title is not None:
-        update_data["jobTitle"] = data.job_title
-        create_data["jobTitle"] = data.job_title
-    if data.business_name is not None:
-        update_data["businessName"] = data.business_name
-        create_data["businessName"] = data.business_name
-    if data.industry is not None:
-        update_data["industry"] = data.industry
-        create_data["industry"] = data.industry
-    if data.business_size is not None:
-        update_data["businessSize"] = data.business_size
-        create_data["businessSize"] = data.business_size
-    if data.user_role is not None:
-        update_data["userRole"] = data.user_role
-        create_data["userRole"] = data.user_role
-    if data.additional_notes is not None:
-        update_data["additionalNotes"] = data.additional_notes
-        create_data["additionalNotes"] = data.additional_notes
-
-    # List fields - merge with existing
-    if data.key_workflows is not None:
-        existing_list = _json_to_list(existing.keyWorkflows) if existing else None
-        merged = _merge_lists(existing_list, data.key_workflows)
-        update_data["keyWorkflows"] = SafeJson(merged)
-        create_data["keyWorkflows"] = SafeJson(merged)
-
-    if data.daily_activities is not None:
-        existing_list = _json_to_list(existing.dailyActivities) if existing else None
-        merged = _merge_lists(existing_list, data.daily_activities)
-        update_data["dailyActivities"] = SafeJson(merged)
-        create_data["dailyActivities"] = SafeJson(merged)
-
-    if data.pain_points is not None:
-        existing_list = _json_to_list(existing.painPoints) if existing else None
-        merged = _merge_lists(existing_list, data.pain_points)
-        update_data["painPoints"] = SafeJson(merged)
-        create_data["painPoints"] = SafeJson(merged)
-
-    if data.bottlenecks is not None:
-        existing_list = _json_to_list(existing.bottlenecks) if existing else None
-        merged = _merge_lists(existing_list, data.bottlenecks)
-        update_data["bottlenecks"] = SafeJson(merged)
-        create_data["bottlenecks"] = SafeJson(merged)
-
-    if data.manual_tasks is not None:
-        existing_list = _json_to_list(existing.manualTasks) if existing else None
-        merged = _merge_lists(existing_list, data.manual_tasks)
-        update_data["manualTasks"] = SafeJson(merged)
-        create_data["manualTasks"] = SafeJson(merged)
-
-    if data.automation_goals is not None:
-        existing_list = _json_to_list(existing.automationGoals) if existing else None
-        merged = _merge_lists(existing_list, data.automation_goals)
-        update_data["automationGoals"] = SafeJson(merged)
-        create_data["automationGoals"] = SafeJson(merged)
-
-    if data.current_software is not None:
-        existing_list = _json_to_list(existing.currentSoftware) if existing else None
-        merged = _merge_lists(existing_list, data.current_software)
-        update_data["currentSoftware"] = SafeJson(merged)
-        create_data["currentSoftware"] = SafeJson(merged)
-
-    if data.existing_automation is not None:
-        existing_list = _json_to_list(existing.existingAutomation) if existing else None
-        merged = _merge_lists(existing_list, data.existing_automation)
-        update_data["existingAutomation"] = SafeJson(merged)
-        create_data["existingAutomation"] = SafeJson(merged)
-
-    # Upsert
-    record = await UserBusinessUnderstanding.prisma().upsert(
-        where={"userId": user_id},
-        data={
-            "create": UserBusinessUnderstandingCreateInput(**create_data),
-            "update": update_data,
-        },
-    )
-
-    understanding = BusinessUnderstanding.from_db(record)
-
-    # Update cache with new understanding
-    await _set_cache(user_id, understanding)
-
-    return understanding
-
-
-async def clear_business_understanding(user_id: str) -> bool:
-    """Clear/delete business understanding for a user from both DB and cache."""
-    # Delete from cache first
-    await _delete_cache(user_id)
-
-    try:
-        await UserBusinessUnderstanding.prisma().delete(where={"userId": user_id})
-        return True
-    except Exception:
-        # Record might not exist
-        return False
-
-
-def format_understanding_for_prompt(understanding: BusinessUnderstanding) -> str:
-    """Format business understanding as text for system prompt injection."""
-    sections = []
-
-    # User info section
-    user_info = []
-    if understanding.user_name:
-        user_info.append(f"Name: {understanding.user_name}")
-    if understanding.job_title:
-        user_info.append(f"Job Title: {understanding.job_title}")
-    if user_info:
-        sections.append("## User\n" + "\n".join(user_info))
-
-    # Business section
-    business_info = []
-    if understanding.business_name:
-        business_info.append(f"Company: {understanding.business_name}")
-    if understanding.industry:
-        business_info.append(f"Industry: {understanding.industry}")
-    if understanding.business_size:
-        business_info.append(f"Size: {understanding.business_size}")
-    if understanding.user_role:
-        business_info.append(f"Role Context: {understanding.user_role}")
-    if business_info:
-        sections.append("## Business\n" + "\n".join(business_info))
-
-    # Processes section
-    processes = []
-    if understanding.key_workflows:
-        processes.append(f"Key Workflows: {', '.join(understanding.key_workflows)}")
-    if understanding.daily_activities:
-        processes.append(
-            f"Daily Activities: {', '.join(understanding.daily_activities)}"
-        )
-    if processes:
-        sections.append("## Processes\n" + "\n".join(processes))
-
-    # Pain points section
-    pain_points = []
-    if understanding.pain_points:
-        pain_points.append(f"Pain Points: {', '.join(understanding.pain_points)}")
-    if understanding.bottlenecks:
-        pain_points.append(f"Bottlenecks: {', '.join(understanding.bottlenecks)}")
-    if understanding.manual_tasks:
-        pain_points.append(f"Manual Tasks: {', '.join(understanding.manual_tasks)}")
-    if pain_points:
-        sections.append("## Pain Points\n" + "\n".join(pain_points))
-
-    # Goals section
-    if understanding.automation_goals:
-        sections.append(
-            "## Automation Goals\n"
-            + "\n".join(f"- {goal}" for goal in understanding.automation_goals)
-        )
-
-    # Current tools section
-    tools_info = []
-    if understanding.current_software:
-        tools_info.append(
-            f"Current Software: {', '.join(understanding.current_software)}"
-        )
-    if understanding.existing_automation:
-        tools_info.append(
-            f"Existing Automation: {', '.join(understanding.existing_automation)}"
-        )
-    if tools_info:
-        sections.append("## Current Tools\n" + "\n".join(tools_info))
-
-    # Additional notes
-    if understanding.additional_notes:
-        sections.append(f"## Additional Context\n{understanding.additional_notes}")
-
-    if not sections:
-        return ""
-
-    return "# User Business Context\n\n" + "\n\n".join(sections)

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

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

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

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

@@ -1,81 +0,0 @@
--- DropIndex
-DROP INDEX "StoreListingVersion_storeListingId_version_key";
-
--- CreateTable
-CREATE TABLE "UserBusinessUnderstanding" (
-    "id" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "userId" TEXT NOT NULL,
-    "userName" TEXT,
-    "jobTitle" TEXT,
-    "businessName" TEXT,
-    "industry" TEXT,
-    "businessSize" TEXT,
-    "userRole" TEXT,
-    "keyWorkflows" JSONB,
-    "dailyActivities" JSONB,
-    "painPoints" JSONB,
-    "bottlenecks" JSONB,
-    "manualTasks" JSONB,
-    "automationGoals" JSONB,
-    "currentSoftware" JSONB,
-    "existingAutomation" JSONB,
-    "additionalNotes" TEXT,
-
-    CONSTRAINT "UserBusinessUnderstanding_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "ChatSession" (
-    "id" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "userId" TEXT,
-    "title" TEXT,
-    "credentials" JSONB NOT NULL DEFAULT '{}',
-    "successfulAgentRuns" JSONB NOT NULL DEFAULT '{}',
-    "successfulAgentSchedules" JSONB NOT NULL DEFAULT '{}',
-    "totalPromptTokens" INTEGER NOT NULL DEFAULT 0,
-    "totalCompletionTokens" INTEGER NOT NULL DEFAULT 0,
-
-    CONSTRAINT "ChatSession_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "ChatMessage" (
-    "id" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "sessionId" TEXT NOT NULL,
-    "role" TEXT NOT NULL,
-    "content" TEXT,
-    "name" TEXT,
-    "toolCallId" TEXT,
-    "refusal" TEXT,
-    "toolCalls" JSONB,
-    "functionCall" JSONB,
-    "sequence" INTEGER NOT NULL,
-
-    CONSTRAINT "ChatMessage_pkey" PRIMARY KEY ("id")
-);
-
--- CreateIndex
-CREATE UNIQUE INDEX "UserBusinessUnderstanding_userId_key" ON "UserBusinessUnderstanding"("userId");
-
--- CreateIndex
-CREATE INDEX "UserBusinessUnderstanding_userId_idx" ON "UserBusinessUnderstanding"("userId");
-
--- CreateIndex
-CREATE INDEX "ChatSession_userId_updatedAt_idx" ON "ChatSession"("userId", "updatedAt");
-
--- CreateIndex
-CREATE INDEX "ChatMessage_sessionId_sequence_idx" ON "ChatMessage"("sessionId", "sequence");
-
--- CreateIndex
-CREATE UNIQUE INDEX "ChatMessage_sessionId_sequence_key" ON "ChatMessage"("sessionId", "sequence");
-
--- AddForeignKey
-ALTER TABLE "UserBusinessUnderstanding" ADD CONSTRAINT "UserBusinessUnderstanding_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "ChatMessage" ADD CONSTRAINT "ChatMessage_sessionId_fkey" FOREIGN KEY ("sessionId") REFERENCES "ChatSession"("id") ON DELETE CASCADE ON UPDATE CASCADE;

autogpt_platform/backend/schema.prisma

@@ -53,7 +53,6 @@ model User {
 
   Profile               Profile[]
   UserOnboarding        UserOnboarding?
-  BusinessUnderstanding UserBusinessUnderstanding?
   BuilderSearchHistory  BuilderSearchHistory[]
   StoreListings         StoreListing[]
   StoreListingReviews   StoreListingReview[]
@@ -68,6 +67,10 @@ model User {
   OAuthAuthorizationCodes OAuthAuthorizationCode[]
   OAuthAccessTokens       OAuthAccessToken[]
   OAuthRefreshTokens      OAuthRefreshToken[]
+
+  // Waitlist relations
+  waitlistEntries       WaitlistEntry[]
+  joinedWaitlists       WaitlistEntry[] @relation("joinedWaitlists")
 }
 
 enum OnboardingStep {
@@ -122,109 +125,19 @@ model UserOnboarding {
   User   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
 }
 
-model UserBusinessUnderstanding {
-  id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @default(now()) @updatedAt
-
-  userId String @unique
-  User   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
-
-  // User info
-  userName String?
-  jobTitle String?
-
-  // Business basics (string columns)
-  businessName String?
-  industry     String?
-  businessSize String? // "1-10", "11-50", "51-200", "201-1000", "1000+"
-  userRole     String? // Role in organization context (e.g., "decision maker", "implementer")
-
-  // Processes & activities (JSON arrays)
-  keyWorkflows    Json?
-  dailyActivities Json?
-
-  // Pain points & goals (JSON arrays)
-  painPoints      Json?
-  bottlenecks     Json?
-  manualTasks     Json?
-  automationGoals Json?
-
-  // Current tools (JSON arrays)
-  currentSoftware    Json?
-  existingAutomation Json?
-
-  additionalNotes String?
-
-  @@index([userId])
-}
-
 model BuilderSearchHistory {
   id        String   @id @default(uuid())
   createdAt DateTime @default(now())
   updatedAt DateTime @default(now()) @updatedAt
 
   searchQuery String
-  filter      String[] @default([])
-  byCreator   String[] @default([])
+  filter      String[]  @default([])
+  byCreator   String[]  @default([])
 
   userId String
   User   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
 }
 
-////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////
-////////////////   CHAT SESSION TABLES   ///////////////////
-////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////
-
-model ChatSession {
-  id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @default(now()) @updatedAt
-
-  userId String?
-
-  // Session metadata
-  title       String?
-  credentials Json    @default("{}") // Map of provider -> credential metadata
-
-  // Rate limiting counters (stored as JSON maps)
-  successfulAgentRuns      Json @default("{}") // Map of graph_id -> count
-  successfulAgentSchedules Json @default("{}") // Map of graph_id -> count
-
-  // Usage tracking
-  totalPromptTokens     Int @default(0)
-  totalCompletionTokens Int @default(0)
-
-  Messages ChatMessage[]
-
-  @@index([userId, updatedAt])
-}
-
-model ChatMessage {
-  id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-
-  sessionId String
-  Session   ChatSession @relation(fields: [sessionId], references: [id], onDelete: Cascade)
-
-  // Message content
-  role         String // "user", "assistant", "system", "tool", "function"
-  content      String?
-  name         String?
-  toolCallId   String?
-  refusal      String?
-  toolCalls    Json? // List of tool calls for assistant messages
-  functionCall Json? // Deprecated but kept for compatibility
-
-  // Ordering within session
-  sequence Int
-
-  @@unique([sessionId, sequence])
-  @@index([sessionId, sequence])
-}
-
 // This model describes the Agent Graph/Flow (Multi Agent System).
 model AgentGraph {
   id        String    @default(uuid())
@@ -319,6 +232,7 @@ enum NotificationType {
   REFUND_PROCESSED
   AGENT_APPROVED
   AGENT_REJECTED
+  WAITLIST_LAUNCH
 }
 
 model NotificationEvent {
@@ -812,26 +726,26 @@ view StoreAgent {
   storeListingVersionId String
   updated_at            DateTime
 
-  slug              String
-  agent_name        String
-  agent_video       String?
-  agent_output_demo String?
-  agent_image       String[]
+  slug                String
+  agent_name          String
+  agent_video         String?
+  agent_output_demo   String?
+  agent_image         String[]
 
-  featured           Boolean                  @default(false)
-  creator_username   String?
-  creator_avatar     String?
-  sub_heading        String
-  description        String
-  categories         String[]
-  search             Unsupported("tsvector")? @default(dbgenerated("''::tsvector"))
-  runs               Int
-  rating             Float
-  versions           String[]
-  agentGraphVersions String[]
-  agentGraphId       String
-  is_available       Boolean                  @default(true)
-  useForOnboarding   Boolean                  @default(false)
+  featured         Boolean                  @default(false)
+  creator_username String?
+  creator_avatar   String?
+  sub_heading      String
+  description      String
+  categories       String[]
+  search           Unsupported("tsvector")? @default(dbgenerated("''::tsvector"))
+  runs                Int
+  rating              Float
+  versions            String[]
+  agentGraphVersions  String[]
+  agentGraphId        String
+  is_available        Boolean                  @default(true)
+  useForOnboarding    Boolean                  @default(false)
 
   // Materialized views used (refreshed every 15 minutes via pg_cron):
   // - mv_agent_run_counts - Pre-aggregated agent execution counts by agentGraphId
@@ -925,7 +839,8 @@ model StoreListing {
   OwningUser   User   @relation(fields: [owningUserId], references: [id])
 
   // Relations
-  Versions StoreListingVersion[] @relation("ListingVersions")
+  Versions        StoreListingVersion[] @relation("ListingVersions")
+  waitlistEntries WaitlistEntry[]
 
   // Unique index on agentId to ensure only one listing per agent, regardless of number of versions the agent has.
   @@unique([agentGraphId])
@@ -947,14 +862,14 @@ model StoreListingVersion {
   AgentGraph        AgentGraph @relation(fields: [agentGraphId, agentGraphVersion], references: [id, version])
 
   // Content fields
-  name               String
-  subHeading         String
-  videoUrl           String?
-  agentOutputDemoUrl String?
-  imageUrls          String[]
-  description        String
-  instructions       String?
-  categories         String[]
+  name                String
+  subHeading          String
+  videoUrl            String?
+  agentOutputDemoUrl  String?
+  imageUrls           String[]
+  description         String
+  instructions        String?
+  categories          String[]
 
   isFeatured Boolean @default(false)
 
@@ -990,6 +905,7 @@ model StoreListingVersion {
   // Reviews for this specific version
   Reviews StoreListingReview[]
 
+  @@unique([storeListingId, version])
   @@index([storeListingId, submissionStatus, isAvailable])
   @@index([submissionStatus])
   @@index([reviewerId])
@@ -1014,6 +930,47 @@ model StoreListingReview {
   @@index([reviewByUserId])
 }
 
+enum WaitlistExternalStatus {
+  DONE
+  NOT_STARTED
+  CANCELED
+  WORK_IN_PROGRESS
+}
+
+model WaitlistEntry {
+  id        String   @id @default(uuid())
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  storeListingId String?
+  StoreListing   StoreListing? @relation(fields: [storeListingId], references: [id], onDelete: SetNull)
+
+  owningUserId String
+  OwningUser   User   @relation(fields: [owningUserId], references: [id])
+
+  slug   String
+  search Unsupported("tsvector")? @default(dbgenerated("''::tsvector"))
+
+  // Content fields
+  name               String
+  subHeading         String
+  videoUrl           String?
+  agentOutputDemoUrl String?
+  imageUrls          String[]
+  description        String
+  categories         String[]
+
+  //Waitlist specific fields
+  status                 WaitlistExternalStatus @default(NOT_STARTED)
+  votes                  Int                    @default(0) // Hide from frontend api
+  joinedUsers            User[]                 @relation("joinedWaitlists")
+  // NOTE: DO NOT DOUBLE SEND TO THESE USERS, IF THEY HAVE SIGNED UP SINCE THEY MAY HAVE ALREADY RECEIVED AN EMAIL
+  // DOUBLE CHECK WHEN SENDING THAT THEY ARE NOT IN THE JOINED USERS LIST ALSO
+  unaffiliatedEmailUsers String[]               @default([])
+
+  isDeleted Boolean @default(false)
+}
+
 enum SubmissionStatus {
   DRAFT // Being prepared, not yet submitted
   PENDING // Submitted, awaiting review
@@ -1088,16 +1045,16 @@ model OAuthApplication {
   updatedAt DateTime @updatedAt
 
   // Application metadata
-  name             String
-  description      String?
-  logoUrl          String? // URL to app logo stored in GCS
-  clientId         String  @unique
-  clientSecret     String // Hashed with Scrypt (same as API keys)
-  clientSecretSalt String // Salt for Scrypt hashing
+  name               String
+  description        String?
+  logoUrl            String? // URL to app logo stored in GCS
+  clientId           String @unique
+  clientSecret       String // Hashed with Scrypt (same as API keys)
+  clientSecretSalt   String // Salt for Scrypt hashing
 
   // OAuth configuration
   redirectUris String[] // Allowed callback URLs
-  grantTypes   String[]           @default(["authorization_code", "refresh_token"])
+  grantTypes   String[] @default(["authorization_code", "refresh_token"])
   scopes       APIKeyPermission[] // Which permissions the app can request
 
   // Application management

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,36 @@
+import { withRoleAccess } from "@/lib/withRoleAccess";
+import { Suspense } from "react";
+import { WaitlistTable } from "./components/WaitlistTable";
+import { CreateWaitlistButton } from "./components/CreateWaitlistButton";
+
+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>
+
+        <Suspense
+          fallback={
+            <div className="py-10 text-center">Loading waitlists...</div>
+          }
+        >
+          <WaitlistTable />
+        </Suspense>
+      </div>
+    </div>
+  );
+}
+
+export default async function WaitlistDashboardPage() {
+  const withAdminAccess = await withRoleAccess(["admin"]);
+  const ProtectedWaitlistDashboard = await withAdminAccess(WaitlistDashboard);
+  return <ProtectedWaitlistDashboard />;
+}

autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/helpers.ts

@@ -89,6 +89,18 @@ export function extractOptions(
 
 // get display type and color for schema types [need for type display next to field name]
 export const getTypeDisplayInfo = (schema: any) => {
+  if (
+    schema?.type === "array" &&
+    "format" in schema &&
+    schema.format === "table"
+  ) {
+    return {
+      displayType: "table",
+      colorClass: "!text-indigo-500",
+      hexColor: "#6366f1",
+    };
+  }
+
   if (schema?.type === "string" && schema?.format) {
     const formatMap: Record<
       string,

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

@@ -36,6 +36,7 @@ type Props = {
   readOnly?: boolean;
   isOptional?: boolean;
   showTitle?: boolean;
+  variant?: "default" | "node";
 };
 
 export function CredentialsInput({
@@ -48,6 +49,7 @@ export function CredentialsInput({
   readOnly = false,
   isOptional = false,
   showTitle = true,
+  variant = "default",
 }: Props) {
   const hookData = useCredentialsInput({
     schema,
@@ -123,6 +125,7 @@ export function CredentialsInput({
               onClearCredential={() => onSelectCredential(undefined)}
               readOnly={readOnly}
               allowNone={isOptional}
+              variant={variant}
             />
           ) : (
             <div className="mb-4 space-y-2">

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

@@ -30,6 +30,8 @@ type CredentialRowProps = {
   readOnly?: boolean;
   showCaret?: boolean;
   asSelectTrigger?: boolean;
+  /** When "node", applies compact styling for node context */
+  variant?: "default" | "node";
 };
 
 export function CredentialRow({
@@ -41,14 +43,22 @@ export function CredentialRow({
   readOnly = false,
   showCaret = false,
   asSelectTrigger = false,
+  variant = "default",
 }: CredentialRowProps) {
   const ProviderIcon = providerIcons[provider] || fallbackIcon;
+  const isNodeVariant = variant === "node";
 
   return (
     <div
       className={cn(
         "flex items-center gap-3 rounded-medium border border-zinc-200 bg-white p-3 transition-colors",
-        asSelectTrigger ? "border-0 bg-transparent" : readOnly ? "w-fit" : "",
+        asSelectTrigger && isNodeVariant
+          ? "min-w-0 flex-1 overflow-hidden border-0 bg-transparent"
+          : asSelectTrigger
+            ? "border-0 bg-transparent"
+            : readOnly
+              ? "w-fit"
+              : "",
       )}
       onClick={readOnly || showCaret || asSelectTrigger ? undefined : onSelect}
       style={
@@ -61,19 +71,31 @@ export function CredentialRow({
         <ProviderIcon className="h-3 w-3 text-white" />
       </div>
       <IconKey className="h-5 w-5 shrink-0 text-zinc-800" />
-      <div className="flex min-w-0 flex-1 flex-nowrap items-center gap-4">
+      <div
+        className={cn(
+          "flex min-w-0 flex-1 flex-nowrap items-center gap-4",
+          isNodeVariant && "overflow-hidden",
+        )}
+      >
         <Text
           variant="body"
-          className="line-clamp-1 flex-[0_0_50%] text-ellipsis tracking-tight"
+          className={cn(
+            "tracking-tight",
+            isNodeVariant
+              ? "truncate"
+              : "line-clamp-1 flex-[0_0_50%] text-ellipsis",
+          )}
         >
           {getCredentialDisplayName(credential, displayName)}
         </Text>
-        <Text
-          variant="large"
-          className="lex-[0_0_40%] relative top-1 hidden overflow-hidden whitespace-nowrap font-mono tracking-tight md:block"
-        >
-          {"*".repeat(MASKED_KEY_LENGTH)}
-        </Text>
+        {!(asSelectTrigger && isNodeVariant) && (
+          <Text
+            variant="large"
+            className="relative top-1 hidden overflow-hidden whitespace-nowrap font-mono tracking-tight md:block"
+          >
+            {"*".repeat(MASKED_KEY_LENGTH)}
+          </Text>
+        )}
       </div>
       {showCaret && !asSelectTrigger && (
         <CaretDown className="h-4 w-4 shrink-0 text-gray-400" />

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

@@ -7,6 +7,7 @@ import {
 } from "@/components/__legacy__/ui/select";
 import { Text } from "@/components/atoms/Text/Text";
 import { CredentialsMetaInput } from "@/lib/autogpt-server-api/types";
+import { cn } from "@/lib/utils";
 import { useEffect } from "react";
 import { getCredentialDisplayName } from "../../helpers";
 import { CredentialRow } from "../CredentialRow/CredentialRow";
@@ -26,6 +27,8 @@ interface Props {
   onClearCredential?: () => void;
   readOnly?: boolean;
   allowNone?: boolean;
+  /** When "node", applies compact styling for node context */
+  variant?: "default" | "node";
 }
 
 export function CredentialsSelect({
@@ -37,6 +40,7 @@ export function CredentialsSelect({
   onClearCredential,
   readOnly = false,
   allowNone = true,
+  variant = "default",
 }: Props) {
   // Auto-select first credential if none is selected (only if allowNone is false)
   useEffect(() => {
@@ -59,7 +63,12 @@ export function CredentialsSelect({
         value={selectedCredentials?.id || (allowNone ? "__none__" : "")}
         onValueChange={handleValueChange}
       >
-        <SelectTrigger className="h-auto min-h-12 w-full rounded-medium border-zinc-200 p-0 pr-4 shadow-none">
+        <SelectTrigger
+          className={cn(
+            "h-auto min-h-12 w-full rounded-medium border-zinc-200 p-0 pr-4 shadow-none",
+            variant === "node" && "overflow-hidden",
+          )}
+        >
           {selectedCredentials ? (
             <SelectValue key={selectedCredentials.id} asChild>
               <CredentialRow
@@ -75,6 +84,7 @@ export function CredentialsSelect({
                 onDelete={() => {}}
                 readOnly={readOnly}
                 asSelectTrigger={true}
+                variant={variant}
               />
             </SelectValue>
           ) : (

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

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

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

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

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

@@ -0,0 +1,300 @@
+"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;
+}
+
+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"
+          />
+        ) : (
+          <video
+            src={item.url}
+            controls
+            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 ? (
+                <video
+                  src={item.url}
+                  controls
+                  autoPlay
+                  className="h-full w-full object-cover"
+                />
+              ) : (
+                <button
+                  onClick={() => setActiveVideo(item.url)}
+                  className="group relative h-full w-full bg-zinc-900"
+                >
+                  <div className="absolute inset-0 flex items-center justify-center">
+                    <div className="flex h-16 w-16 items-center justify-center rounded-full bg-white/90 transition-transform group-hover:scale-110">
+                      <Play size={32} weight="fill" className="text-zinc-800" />
+                    </div>
+                  </div>
+                  <span className="absolute bottom-3 left-3 text-sm text-white">
+                    {item.label}
+                  </span>
+                </button>
+              )}
+            </div>
+          </CarouselItem>
+        ))}
+      </CarouselContent>
+      <CarouselPrevious className="left-2 top-1/2 -translate-y-1/2" />
+      <CarouselNext className="right-2 top-1/2 -translate-y-1/2" />
+    </Carousel>
+  );
+}
+
+interface WaitlistDetailModalProps {
+  waitlist: StoreWaitlistEntry;
+  isMember?: boolean;
+  onClose: () => void;
+  onJoinSuccess?: (waitlistId: string) => void;
+}
+
+export function WaitlistDetailModal({
+  waitlist,
+  isMember = false,
+  onClose,
+  onJoinSuccess,
+}: WaitlistDetailModalProps) {
+  const { user } = useSupabaseStore();
+  const [email, setEmail] = useState("");
+  const [success, setSuccess] = useState(false);
+  const { toast } = useToast();
+  const joinWaitlistMutation = usePostV2AddSelfToTheAgentWaitlist();
+
+  function handleJoin() {
+    joinWaitlistMutation.mutate(
+      {
+        waitlistId: waitlist.waitlistId,
+        data: { email: user ? undefined : email },
+      },
+      {
+        onSuccess: (response) => {
+          if (response.status === 200) {
+            setSuccess(true);
+            toast({
+              title: "You're on the waitlist!",
+              description: `We'll notify you when ${waitlist.name} goes live.`,
+            });
+            onJoinSuccess?.(waitlist.waitlistId);
+          } else {
+            toast({
+              variant: "destructive",
+              title: "Error",
+              description: "Failed to join waitlist. Please try again.",
+            });
+          }
+        },
+        onError: () => {
+          toast({
+            variant: "destructive",
+            title: "Error",
+            description: "Failed to join waitlist. Please try again.",
+          });
+        },
+      },
+    );
+  }
+
+  // Success state
+  if (success) {
+    return (
+      <Dialog
+        title=""
+        controlled={{
+          isOpen: true,
+          set: async (open) => {
+            if (!open) onClose();
+          },
+        }}
+        onClose={onClose}
+        styling={{ maxWidth: "500px" }}
+      >
+        <Dialog.Content>
+          <div className="flex flex-col items-center justify-center py-4 text-center">
+            {/* Party emoji */}
+            <span className="mb-2 text-5xl">🎉</span>
+
+            {/* Title */}
+            <h2 className="mb-2 font-poppins text-[22px] font-medium leading-7 text-zinc-900 dark:text-zinc-100">
+              You&apos;re on the waitlist
+            </h2>
+
+            {/* Subtitle */}
+            <p className="text-base leading-[26px] text-zinc-600 dark:text-zinc-400">
+              Thanks for helping us prioritize which agents to build next.
+              We&apos;ll notify you when this agent goes live in the
+              marketplace.
+            </p>
+          </div>
+
+          {/* Close button */}
+          <Dialog.Footer className="flex justify-center pb-2 pt-4">
+            <Button
+              variant="secondary"
+              onClick={onClose}
+              className="rounded-full border border-zinc-700 bg-white px-4 py-3 text-zinc-900 hover:bg-zinc-100 dark:border-zinc-500 dark:bg-zinc-800 dark:text-zinc-100 dark:hover:bg-zinc-700"
+            >
+              Close
+            </Button>
+          </Dialog.Footer>
+        </Dialog.Content>
+      </Dialog>
+    );
+  }
+
+  // Main modal - handles both member and non-member states
+  return (
+    <Dialog
+      title="Join the waitlist"
+      controlled={{
+        isOpen: true,
+        set: async (open) => {
+          if (!open) onClose();
+        },
+      }}
+      onClose={onClose}
+      styling={{ maxWidth: "500px" }}
+    >
+      <Dialog.Content>
+        {/* Subtitle */}
+        <p className="mb-6 text-center text-base text-zinc-600 dark:text-zinc-400">
+          Help us decide what to build next — and get notified when this agent
+          is ready
+        </p>
+
+        {/* Media Carousel */}
+        <MediaCarousel waitlist={waitlist} />
+
+        {/* Agent Name */}
+        <h3 className="mt-4 font-poppins text-[22px] font-medium leading-7 text-zinc-800 dark:text-zinc-100">
+          {waitlist.name}
+        </h3>
+
+        {/* Agent Description */}
+        <p className="mt-2 line-clamp-5 text-sm leading-[22px] text-zinc-500 dark:text-zinc-400">
+          {waitlist.description}
+        </p>
+
+        {/* Email input for non-logged-in users who haven't joined */}
+        {!isMember && !user && (
+          <div className="mt-4 pr-1">
+            <Input
+              id="email"
+              label="Email address"
+              type="email"
+              placeholder="you@example.com"
+              value={email}
+              onChange={(e) => setEmail(e.target.value)}
+              required
+            />
+          </div>
+        )}
+
+        {/* Footer buttons */}
+        <Dialog.Footer className="sticky bottom-0 mt-6 flex justify-center gap-3 bg-white pb-2 pt-4 dark:bg-zinc-900">
+          {isMember ? (
+            <Button
+              disabled
+              className="rounded-full bg-green-600 px-4 py-3 text-white hover:bg-green-600 dark:bg-green-700 dark:hover:bg-green-700"
+            >
+              <Check size={16} className="mr-2" />
+              You&apos;re on the waitlist
+            </Button>
+          ) : (
+            <>
+              <Button
+                onClick={handleJoin}
+                loading={joinWaitlistMutation.isPending}
+                disabled={!user && !email}
+                className="rounded-full bg-zinc-800 px-4 py-3 text-white hover:bg-zinc-700 dark:bg-zinc-700 dark:hover:bg-zinc-600"
+              >
+                Join waitlist
+              </Button>
+              <Button
+                type="button"
+                variant="secondary"
+                onClick={onClose}
+                className="rounded-full bg-zinc-200 px-4 py-3 text-zinc-900 hover:bg-zinc-300 dark:bg-zinc-700 dark:text-zinc-100 dark:hover:bg-zinc-600"
+              >
+                Not now
+              </Button>
+            </>
+          )}
+        </Dialog.Footer>
+      </Dialog.Content>
+    </Dialog>
+  );
+}

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

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

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

@@ -0,0 +1,57 @@
+"use client";
+
+import { useMemo } from "react";
+import { useSupabaseStore } from "@/lib/supabase/hooks/useSupabaseStore";
+import {
+  useGetV2GetTheAgentWaitlist,
+  useGetV2GetWaitlistIdsTheCurrentUserHasJoined,
+} 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: ["getV2GetWaitlistIdsTheCurrentUserHasJoined"],
+    });
+  }
+
+  return { waitlists, joinedWaitlistIds, isLoading, hasError, markAsJoined };
+}

autogpt_platform/frontend/src/components/molecules/Table/Table.stories.tsx

@@ -0,0 +1,116 @@
+import type { Meta, StoryObj } from "@storybook/nextjs";
+import { TooltipProvider } from "@/components/atoms/Tooltip/BaseTooltip";
+import { Table } from "./Table";
+
+const meta = {
+  title: "Molecules/Table",
+  component: Table,
+  decorators: [
+    (Story) => (
+      <TooltipProvider>
+        <Story />
+      </TooltipProvider>
+    ),
+  ],
+  parameters: {
+    layout: "centered",
+  },
+  tags: ["autodocs"],
+  argTypes: {
+    allowAddRow: {
+      control: "boolean",
+      description: "Whether to show the Add row button",
+    },
+    allowDeleteRow: {
+      control: "boolean",
+      description: "Whether to show delete buttons for each row",
+    },
+    readOnly: {
+      control: "boolean",
+      description:
+        "Whether the table is read-only (renders text instead of inputs)",
+    },
+    addRowLabel: {
+      control: "text",
+      description: "Label for the Add row button",
+    },
+  },
+} satisfies Meta<typeof Table>;
+
+export default meta;
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    columns: ["name", "email", "role"],
+    allowAddRow: true,
+    allowDeleteRow: true,
+  },
+};
+
+export const WithDefaultValues: Story = {
+  args: {
+    columns: ["name", "email", "role"],
+    defaultValues: [
+      { name: "John Doe", email: "john@example.com", role: "Admin" },
+      { name: "Jane Smith", email: "jane@example.com", role: "User" },
+      { name: "Bob Wilson", email: "bob@example.com", role: "Editor" },
+    ],
+    allowAddRow: true,
+    allowDeleteRow: true,
+  },
+};
+
+export const ReadOnly: Story = {
+  args: {
+    columns: ["name", "email"],
+    defaultValues: [
+      { name: "John Doe", email: "john@example.com" },
+      { name: "Jane Smith", email: "jane@example.com" },
+    ],
+    readOnly: true,
+  },
+};
+
+export const NoAddOrDelete: Story = {
+  args: {
+    columns: ["name", "email"],
+    defaultValues: [
+      { name: "John Doe", email: "john@example.com" },
+      { name: "Jane Smith", email: "jane@example.com" },
+    ],
+    allowAddRow: false,
+    allowDeleteRow: false,
+  },
+};
+
+export const SingleColumn: Story = {
+  args: {
+    columns: ["item"],
+    allowAddRow: true,
+    allowDeleteRow: true,
+    addRowLabel: "Add item",
+  },
+};
+
+export const CustomAddLabel: Story = {
+  args: {
+    columns: ["key", "value"],
+    allowAddRow: true,
+    allowDeleteRow: true,
+    addRowLabel: "Add new entry",
+  },
+};
+
+export const KeyValuePairs: Story = {
+  args: {
+    columns: ["key", "value"],
+    defaultValues: [
+      { key: "API_KEY", value: "sk-..." },
+      { key: "DATABASE_URL", value: "postgres://..." },
+    ],
+    allowAddRow: true,
+    allowDeleteRow: true,
+    addRowLabel: "Add variable",
+  },
+};

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

@@ -0,0 +1,133 @@
+import * as React from "react";
+import {
+  Table as BaseTable,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/__legacy__/ui/table";
+import { Button } from "@/components/atoms/Button/Button";
+import { Input } from "@/components/atoms/Input/Input";
+import { Text } from "@/components/atoms/Text/Text";
+import { Plus, Trash2 } from "lucide-react";
+import { cn } from "@/lib/utils";
+import { useTable, RowData } from "./useTable";
+import { formatColumnTitle, formatPlaceholder } from "./helpers";
+
+export interface TableProps {
+  columns: string[];
+  defaultValues?: RowData[];
+  onChange?: (rows: RowData[]) => void;
+  allowAddRow?: boolean;
+  allowDeleteRow?: boolean;
+  addRowLabel?: string;
+  className?: string;
+  readOnly?: boolean;
+}
+
+export function Table({
+  columns,
+  defaultValues,
+  onChange,
+  allowAddRow = true,
+  allowDeleteRow = true,
+  addRowLabel = "Add row",
+  className,
+  readOnly = false,
+}: TableProps) {
+  const { rows, handleAddRow, handleDeleteRow, handleCellChange } = useTable({
+    columns,
+    defaultValues,
+    onChange,
+  });
+
+  const showDeleteColumn = allowDeleteRow && !readOnly;
+  const showAddButton = allowAddRow && !readOnly;
+
+  return (
+    <div className={cn("flex flex-col gap-3", className)}>
+      <div className="overflow-hidden rounded-xl border border-zinc-200 bg-white">
+        <BaseTable>
+          <TableHeader>
+            <TableRow className="border-b border-zinc-100 bg-zinc-50/50">
+              {columns.map((column) => (
+                <TableHead
+                  key={column}
+                  className="h-10 px-3 text-sm font-medium text-zinc-600"
+                >
+                  {formatColumnTitle(column)}
+                </TableHead>
+              ))}
+              {showDeleteColumn && <TableHead className="w-[50px]" />}
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {rows.map((row, rowIndex) => (
+              <TableRow key={rowIndex} className="border-none">
+                {columns.map((column) => (
+                  <TableCell key={`${rowIndex}-${column}`} className="p-2">
+                    {readOnly ? (
+                      <Text
+                        variant="body"
+                        className="px-3 py-2 text-sm text-zinc-800"
+                      >
+                        {row[column] || "-"}
+                      </Text>
+                    ) : (
+                      <Input
+                        id={`table-${rowIndex}-${column}`}
+                        label={formatColumnTitle(column)}
+                        hideLabel
+                        value={row[column] ?? ""}
+                        onChange={(e) =>
+                          handleCellChange(rowIndex, column, e.target.value)
+                        }
+                        placeholder={formatPlaceholder(column)}
+                        size="small"
+                        wrapperClassName="mb-0"
+                      />
+                    )}
+                  </TableCell>
+                ))}
+                {showDeleteColumn && (
+                  <TableCell className="p-2">
+                    <Button
+                      variant="icon"
+                      size="icon"
+                      onClick={() => handleDeleteRow(rowIndex)}
+                      aria-label="Delete row"
+                      className="text-zinc-400 transition-colors hover:text-red-500"
+                    >
+                      <Trash2 className="h-4 w-4" />
+                    </Button>
+                  </TableCell>
+                )}
+              </TableRow>
+            ))}
+            {showAddButton && (
+              <TableRow>
+                <TableCell
+                  colSpan={columns.length + (showDeleteColumn ? 1 : 0)}
+                  className="p-2"
+                >
+                  <Button
+                    variant="outline"
+                    size="small"
+                    onClick={handleAddRow}
+                    leftIcon={<Plus className="h-4 w-4" />}
+                    className="w-fit"
+                  >
+                    {addRowLabel}
+                  </Button>
+                </TableCell>
+              </TableRow>
+            )}
+          </TableBody>
+        </BaseTable>
+      </div>
+    </div>
+  );
+}
+
+export { type RowData } from "./useTable";

autogpt_platform/frontend/src/components/molecules/Table/helpers.ts

@@ -0,0 +1,7 @@
+export const formatColumnTitle = (key: string): string => {
+  return key.charAt(0).toUpperCase() + key.slice(1);
+};
+
+export const formatPlaceholder = (key: string): string => {
+  return `Enter ${key.toLowerCase()}`;
+};

autogpt_platform/frontend/src/components/molecules/Table/useTable.ts

@@ -0,0 +1,81 @@
+import { useState, useEffect } from "react";
+
+export type RowData = Record<string, string>;
+
+interface UseTableOptions {
+  columns: string[];
+  defaultValues?: RowData[];
+  onChange?: (rows: RowData[]) => void;
+}
+
+export function useTable({
+  columns,
+  defaultValues,
+  onChange,
+}: UseTableOptions) {
+  const createEmptyRow = (): RowData => {
+    const emptyRow: RowData = {};
+    columns.forEach((column) => {
+      emptyRow[column] = "";
+    });
+    return emptyRow;
+  };
+
+  const [rows, setRows] = useState<RowData[]>(() => {
+    if (defaultValues && defaultValues.length > 0) {
+      return defaultValues;
+    }
+    return [];
+  });
+
+  useEffect(() => {
+    if (defaultValues !== undefined) {
+      setRows(defaultValues);
+    }
+  }, [defaultValues]);
+
+  const updateRows = (newRows: RowData[]) => {
+    setRows(newRows);
+    onChange?.(newRows);
+  };
+
+  const handleAddRow = () => {
+    const newRows = [...rows, createEmptyRow()];
+    updateRows(newRows);
+  };
+
+  const handleDeleteRow = (rowIndex: number) => {
+    const newRows = rows.filter((_, index) => index !== rowIndex);
+    updateRows(newRows);
+  };
+
+  const handleCellChange = (
+    rowIndex: number,
+    columnKey: string,
+    value: string,
+  ) => {
+    const newRows = rows.map((row, index) => {
+      if (index === rowIndex) {
+        return {
+          ...row,
+          [columnKey]: value,
+        };
+      }
+      return row;
+    });
+    updateRows(newRows);
+  };
+
+  const clearAll = () => {
+    updateRows([]);
+  };
+
+  return {
+    rows,
+    handleAddRow,
+    handleDeleteRow,
+    handleCellChange,
+    clearAll,
+    createEmptyRow,
+  };
+}

autogpt_platform/frontend/src/components/renderers/InputRenderer/FormRenderer.tsx

@@ -30,6 +30,8 @@ export const FormRenderer = ({
     return generateUiSchemaForCustomFields(preprocessedSchema, uiSchema);
   }, [preprocessedSchema, uiSchema]);
 
+  console.log("preprocessedSchema", preprocessedSchema);
+
   return (
     <div className={"mb-6 mt-4"}>
       <Form

autogpt_platform/frontend/src/components/renderers/InputRenderer/base/anyof/AnyOfField.tsx

@@ -12,13 +12,7 @@ export const AnyOfField = (props: FieldProps) => {
   const { fields } = registry;
   const { SchemaField: _SchemaField } = fields;
   const { nodeId } = registry.formContext;
-
   const { isInputConnected } = useEdgeStore();
-
-  const uiOptions = getUiOptions(props.uiSchema, props.globalUiOptions);
-
-  const Widget = getWidget({ type: "string" }, "select", registry.widgets);
-
   const {
     handleOptionChange,
     enumOptions,
@@ -27,6 +21,15 @@ export const AnyOfField = (props: FieldProps) => {
     field_id,
   } = useAnyOfField(props);
 
+  const parentCustomFieldId = findCustomFieldId(schema);
+  if (parentCustomFieldId) {
+    return null;
+  }
+
+  const uiOptions = getUiOptions(props.uiSchema, props.globalUiOptions);
+
+  const Widget = getWidget({ type: "string" }, "select", registry.widgets);
+
   const handleId = getHandleId({
     uiOptions,
     id: field_id + ANY_OF_FLAG,

autogpt_platform/frontend/src/components/renderers/InputRenderer/base/standard/widgets/TextInput/TextInputExpanderModal.tsx

@@ -17,6 +17,7 @@ interface InputExpanderModalProps {
   defaultValue: string;
   description?: string;
   placeholder?: string;
+  inputType?: "text" | "json";
 }
 
 export const InputExpanderModal: FC<InputExpanderModalProps> = ({
@@ -27,6 +28,7 @@ export const InputExpanderModal: FC<InputExpanderModalProps> = ({
   defaultValue,
   description,
   placeholder,
+  inputType = "text",
 }) => {
   const [tempValue, setTempValue] = useState(defaultValue);
   const [isCopied, setIsCopied] = useState(false);
@@ -78,7 +80,10 @@ export const InputExpanderModal: FC<InputExpanderModalProps> = ({
             hideLabel
             id="input-expander-modal"
             value={tempValue}
-            className="!min-h-[300px] rounded-2xlarge"
+            className={cn(
+              "!min-h-[300px] rounded-2xlarge",
+              inputType === "json" && "font-mono text-sm",
+            )}
             onChange={(e) => setTempValue(e.target.value)}
             placeholder={placeholder || "Enter text..."}
             autoFocus

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

@@ -88,6 +88,8 @@ export const CredentialsField = (props: FieldProps) => {
         showTitle={false}
         readOnly={formContext?.readOnly}
         isOptional={!isRequired}
+        className="w-full"
+        variant="node"
       />
 
       {/* Optional credentials toggle - only show in builder canvas, not run dialogs */}

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

@@ -0,0 +1,124 @@
+"use client";
+
+import { FieldProps, getTemplate, getUiOptions } from "@rjsf/utils";
+import { Input } from "@/components/atoms/Input/Input";
+import { Button } from "@/components/atoms/Button/Button";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+} from "@/components/atoms/Tooltip/BaseTooltip";
+import { ArrowsOutIcon } from "@phosphor-icons/react";
+import { InputExpanderModal } from "../../base/standard/widgets/TextInput/TextInputExpanderModal";
+import { getHandleId, updateUiOption } from "../../helpers";
+import { useJsonTextField } from "./useJsonTextField";
+import { getPlaceholder } from "./helpers";
+
+export const JsonTextField = (props: FieldProps) => {
+  const {
+    formData,
+    onChange,
+    schema,
+    registry,
+    uiSchema,
+    required,
+    name,
+    fieldPathId,
+  } = props;
+
+  const uiOptions = getUiOptions(uiSchema);
+
+  const TitleFieldTemplate = getTemplate(
+    "TitleFieldTemplate",
+    registry,
+    uiOptions,
+  );
+
+  const fieldId = fieldPathId?.$id ?? props.id ?? "json-field";
+
+  const handleId = getHandleId({
+    uiOptions,
+    id: fieldId,
+    schema: schema,
+  });
+
+  const updatedUiSchema = updateUiOption(uiSchema, {
+    handleId: handleId,
+  });
+
+  const {
+    textValue,
+    isModalOpen,
+    handleChange,
+    handleModalOpen,
+    handleModalClose,
+    handleModalSave,
+  } = useJsonTextField({
+    formData,
+    onChange,
+    path: fieldPathId?.path,
+  });
+
+  const placeholder = getPlaceholder(schema);
+  const title = schema.title || name || "JSON Value";
+
+  return (
+    <div className="flex flex-col gap-2">
+      <TitleFieldTemplate
+        id={fieldId}
+        title={title}
+        required={required}
+        schema={schema}
+        uiSchema={updatedUiSchema}
+        registry={registry}
+      />
+      <div className="nodrag relative flex items-center gap-2">
+        <Input
+          id={fieldId}
+          hideLabel={true}
+          type="textarea"
+          label=""
+          size="small"
+          wrapperClassName="mb-0 flex-1 "
+          value={textValue}
+          onChange={handleChange}
+          placeholder={placeholder}
+          required={required}
+          disabled={props.disabled}
+          className="min-h-[60px] pr-8 font-mono text-xs"
+        />
+
+        <Tooltip delayDuration={0}>
+          <TooltipTrigger asChild>
+            <Button
+              variant="ghost"
+              size="icon"
+              onClick={handleModalOpen}
+              type="button"
+              className="p-1"
+            >
+              <ArrowsOutIcon className="size-4" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent>Expand input</TooltipContent>
+        </Tooltip>
+      </div>
+      {schema.description && (
+        <span className="text-xs text-gray-500">{schema.description}</span>
+      )}
+
+      <InputExpanderModal
+        isOpen={isModalOpen}
+        onClose={handleModalClose}
+        onSave={handleModalSave}
+        title={`Edit ${title}`}
+        description={schema.description || "Enter valid JSON"}
+        defaultValue={textValue}
+        placeholder={placeholder}
+        inputType="json"
+      />
+    </div>
+  );
+};
+
+export default JsonTextField;

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

@@ -0,0 +1,67 @@
+import { RJSFSchema } from "@rjsf/utils";
+
+/**
+ * Converts form data to a JSON string for display
+ * @param formData - The data to stringify
+ * @returns JSON string or empty string if data is null/undefined
+ */
+export function stringifyFormData(formData: unknown): string {
+  if (formData === undefined || formData === null) {
+    return "";
+  }
+  try {
+    return JSON.stringify(formData, null, 2);
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Parses a JSON string into an object/array
+ * @param value - The JSON string to parse
+ * @returns Parsed value or undefined if parsing fails or empty
+ */
+export function parseJsonValue(value: string): unknown | undefined {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return undefined;
+  }
+
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Gets the appropriate placeholder text based on schema type
+ * @param schema - The JSON schema
+ * @returns Placeholder string
+ */
+export function getPlaceholder(schema: RJSFSchema): string {
+  if (schema.type === "array") {
+    return '["item1", "item2"] or [{"key": "value"}]';
+  }
+  if (schema.type === "object") {
+    return '{"key": "value"}';
+  }
+  return "Enter JSON value...";
+}
+
+/**
+ * Checks if a JSON string is valid
+ * @param value - The JSON string to validate
+ * @returns true if valid JSON, false otherwise
+ */
+export function isValidJson(value: string): boolean {
+  if (value.trim() === "") {
+    return true; // Empty is considered valid (will be undefined)
+  }
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/JsonTextField/useJsonTextField.ts

@@ -0,0 +1,107 @@
+import { useState, useEffect, useCallback } from "react";
+import { FieldProps } from "@rjsf/utils";
+import { stringifyFormData, parseJsonValue, isValidJson } from "./helpers";
+
+type FieldOnChange = FieldProps["onChange"];
+type FieldPathId = FieldProps["fieldPathId"];
+
+interface UseJsonTextFieldOptions {
+  formData: unknown;
+  onChange: FieldOnChange;
+  path?: FieldPathId["path"];
+}
+
+interface UseJsonTextFieldReturn {
+  textValue: string;
+  isModalOpen: boolean;
+  hasError: boolean;
+  handleChange: (
+    e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>,
+  ) => void;
+  handleModalOpen: () => void;
+  handleModalClose: () => void;
+  handleModalSave: (value: string) => void;
+}
+
+/**
+ * Custom hook for managing JSON text field state and handlers
+ */
+export function useJsonTextField({
+  formData,
+  onChange,
+  path,
+}: UseJsonTextFieldOptions): UseJsonTextFieldReturn {
+  const [textValue, setTextValue] = useState(() => stringifyFormData(formData));
+  const [isModalOpen, setIsModalOpen] = useState(false);
+  const [hasError, setHasError] = useState(false);
+
+  // Update text value when formData changes externally
+  useEffect(() => {
+    const newValue = stringifyFormData(formData);
+    setTextValue(newValue);
+    setHasError(false);
+  }, [formData]);
+
+  const handleChange = useCallback(
+    (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
+      const value = e.target.value;
+      setTextValue(value);
+
+      // Validate JSON and update error state
+      const valid = isValidJson(value);
+      setHasError(!valid);
+
+      // Try to parse and update formData
+      if (value.trim() === "") {
+        onChange(undefined, path ?? []);
+        return;
+      }
+
+      const parsed = parseJsonValue(value);
+      if (parsed !== undefined) {
+        onChange(parsed, path ?? []);
+      }
+    },
+    [onChange, path],
+  );
+
+  const handleModalOpen = useCallback(() => {
+    setIsModalOpen(true);
+  }, []);
+
+  const handleModalClose = useCallback(() => {
+    setIsModalOpen(false);
+  }, []);
+
+  const handleModalSave = useCallback(
+    (value: string) => {
+      setTextValue(value);
+      setIsModalOpen(false);
+
+      // Validate and update
+      const valid = isValidJson(value);
+      setHasError(!valid);
+
+      if (value.trim() === "") {
+        onChange(undefined, path ?? []);
+        return;
+      }
+
+      const parsed = parseJsonValue(value);
+      if (parsed !== undefined) {
+        onChange(parsed, path ?? []);
+      }
+    },
+    [onChange, path],
+  );
+
+  return {
+    textValue,
+    isModalOpen,
+    hasError,
+    handleChange,
+    handleModalOpen,
+    handleModalClose,
+    handleModalSave,
+  };
+}

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

@@ -0,0 +1,52 @@
+import { descriptionId, FieldProps, getTemplate, titleId } from "@rjsf/utils";
+import { Table, RowData } from "@/components/molecules/Table/Table";
+import { useMemo } from "react";
+
+export const TableField = (props: FieldProps) => {
+  const { schema, formData, onChange, fieldPathId, registry, uiSchema } = props;
+
+  const itemSchema = schema.items as any;
+  const properties = itemSchema?.properties || {};
+
+  const columns: string[] = useMemo(() => {
+    return Object.keys(properties);
+  }, [properties]);
+
+  const handleChange = (rows: RowData[]) => {
+    onChange(rows, fieldPathId?.path.slice(0, -1));
+  };
+
+  const TitleFieldTemplate = getTemplate("TitleFieldTemplate", registry);
+  const DescriptionFieldTemplate = getTemplate(
+    "DescriptionFieldTemplate",
+    registry,
+  );
+
+  return (
+    <div className="flex flex-col gap-2">
+      <TitleFieldTemplate
+        id={titleId(fieldPathId)}
+        title={schema.title || ""}
+        required={true}
+        schema={schema}
+        uiSchema={uiSchema}
+        registry={registry}
+      />
+      <DescriptionFieldTemplate
+        id={descriptionId(fieldPathId)}
+        description={schema.description || ""}
+        schema={schema}
+        registry={registry}
+      />
+
+      <Table
+        columns={columns}
+        defaultValues={formData}
+        onChange={handleChange}
+        allowAddRow={true}
+        allowDeleteRow={true}
+        addRowLabel="Add row"
+      />
+    </div>
+  );
+};

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

@@ -1,8 +1,10 @@
 import { FieldProps, RJSFSchema, RegistryFieldsType } from "@rjsf/utils";
 import { CredentialsField } from "./CredentialField/CredentialField";
 import { GoogleDrivePickerField } from "./GoogleDrivePickerField/GoogleDrivePickerField";
+import { JsonTextField } from "./JsonTextField/JsonTextField";
 import { MultiSelectField } from "./MultiSelectField/MultiSelectField";
 import { isMultiSelectSchema } from "../utils/schema-utils";
+import { TableField } from "./TableField/TableField";
 
 export interface CustomFieldDefinition {
   id: string;
@@ -10,6 +12,9 @@ export interface CustomFieldDefinition {
   component: (props: FieldProps<any, RJSFSchema, any>) => JSX.Element | null;
 }
 
+/** Field ID for JsonTextField - used to render nested complex types as text input */
+export const JSON_TEXT_FIELD_ID = "custom/json_text_field";
+
 export const CUSTOM_FIELDS: CustomFieldDefinition[] = [
   {
     id: "custom/credential_field",
@@ -32,11 +37,28 @@ export const CUSTOM_FIELDS: CustomFieldDefinition[] = [
     },
     component: GoogleDrivePickerField,
   },
+  {
+    id: "custom/json_text_field",
+    // Not matched by schema - assigned via uiSchema for nested complex types
+    matcher: () => false,
+    component: JsonTextField,
+  },
   {
     id: "custom/multi_select_field",
     matcher: isMultiSelectSchema,
     component: MultiSelectField,
   },
+  {
+    id: "custom/table_field",
+    matcher: (schema: any) => {
+      return (
+        schema.type === "array" &&
+        "format" in schema &&
+        schema.format === "table"
+      );
+    },
+    component: TableField,
+  },
 ];
 
 export function findCustomFieldId(schema: any): string | null {

autogpt_platform/frontend/src/components/renderers/InputRenderer/utils/generate-ui-schema.ts

@@ -1,19 +1,46 @@
 import { RJSFSchema, UiSchema } from "@rjsf/utils";
-import { findCustomFieldId } from "../custom/custom-registry";
+import {
+  findCustomFieldId,
+  JSON_TEXT_FIELD_ID,
+} from "../custom/custom-registry";
+
+function isComplexType(schema: RJSFSchema): boolean {
+  return schema.type === "object" || schema.type === "array";
+}
+
+function hasComplexAnyOfOptions(schema: RJSFSchema): boolean {
+  const options = schema.anyOf || schema.oneOf;
+  if (!Array.isArray(options)) return false;
+  return options.some(
+    (opt: any) =>
+      opt &&
+      typeof opt === "object" &&
+      (opt.type === "object" || opt.type === "array"),
+  );
+}
 
 /**
  * Generates uiSchema with ui:field settings for custom fields based on schema matchers.
  * This is the standard RJSF way to route fields to custom components.
+ *
+ * Nested complex types (arrays/objects inside arrays/objects) are rendered as JsonTextField
+ * to avoid deeply nested form UIs. Users can enter raw JSON for these fields.
+ *
+ * @param schema - The JSON schema
+ * @param existingUiSchema - Existing uiSchema to merge with
+ * @param insideComplexType - Whether we're already inside a complex type (object/array)
  */
 export function generateUiSchemaForCustomFields(
   schema: RJSFSchema,
   existingUiSchema: UiSchema = {},
+  insideComplexType: boolean = false,
 ): UiSchema {
   const uiSchema: UiSchema = { ...existingUiSchema };
 
   if (schema.properties) {
     for (const [key, propSchema] of Object.entries(schema.properties)) {
       if (propSchema && typeof propSchema === "object") {
+        // First check for custom field matchers (credentials, google drive, etc.)
         const customFieldId = findCustomFieldId(propSchema);
 
         if (customFieldId) {
@@ -21,8 +48,33 @@ export function generateUiSchemaForCustomFields(
             ...(uiSchema[key] as object),
             "ui:field": customFieldId,
           };
+          // Skip further processing for custom fields
+          continue;
         }
 
+        // Handle nested complex types - render as JsonTextField
+        if (insideComplexType && isComplexType(propSchema as RJSFSchema)) {
+          uiSchema[key] = {
+            ...(uiSchema[key] as object),
+            "ui:field": JSON_TEXT_FIELD_ID,
+          };
+          // Don't recurse further - this field is now a text input
+          continue;
+        }
+
+        // Handle anyOf/oneOf inside complex types
+        if (
+          insideComplexType &&
+          hasComplexAnyOfOptions(propSchema as RJSFSchema)
+        ) {
+          uiSchema[key] = {
+            ...(uiSchema[key] as object),
+            "ui:field": JSON_TEXT_FIELD_ID,
+          };
+          continue;
+        }
+
+        // Recurse into object properties
         if (
           propSchema.type === "object" &&
           propSchema.properties &&
@@ -31,6 +83,7 @@ export function generateUiSchemaForCustomFields(
           const nestedUiSchema = generateUiSchemaForCustomFields(
             propSchema as RJSFSchema,
             (uiSchema[key] as UiSchema) || {},
+            true, // Now inside a complex type
           );
           uiSchema[key] = {
             ...(uiSchema[key] as object),
@@ -38,9 +91,11 @@ export function generateUiSchemaForCustomFields(
           };
         }
 
+        // Handle arrays
         if (propSchema.type === "array" && propSchema.items) {
           const itemsSchema = propSchema.items as RJSFSchema;
           if (itemsSchema && typeof itemsSchema === "object") {
+            // Check for custom field on array items
             const itemsCustomFieldId = findCustomFieldId(itemsSchema);
             if (itemsCustomFieldId) {
               uiSchema[key] = {
@@ -49,10 +104,28 @@ export function generateUiSchemaForCustomFields(
                   "ui:field": itemsCustomFieldId,
                 },
               };
+            } else if (isComplexType(itemsSchema)) {
+              // Array items that are complex types become JsonTextField
+              uiSchema[key] = {
+                ...(uiSchema[key] as object),
+                items: {
+                  "ui:field": JSON_TEXT_FIELD_ID,
+                },
+              };
+            } else if (hasComplexAnyOfOptions(itemsSchema)) {
+              // Array items with anyOf containing complex types become JsonTextField
+              uiSchema[key] = {
+                ...(uiSchema[key] as object),
+                items: {
+                  "ui:field": JSON_TEXT_FIELD_ID,
+                },
+              };
             } else if (itemsSchema.properties) {
+              // Recurse into object items (but they're now inside a complex type)
               const itemsUiSchema = generateUiSchemaForCustomFields(
                 itemsSchema,
                 ((uiSchema[key] as UiSchema)?.items as UiSchema) || {},
+                true, // Inside complex type (array)
               );
               if (Object.keys(itemsUiSchema).length > 0) {
                 uiSchema[key] = {
@@ -63,6 +136,61 @@ export function generateUiSchemaForCustomFields(
             }
           }
         }
+
+        // Handle anyOf/oneOf at root level - process complex options
+        if (!insideComplexType) {
+          const anyOfOptions = propSchema.anyOf || propSchema.oneOf;
+
+          if (Array.isArray(anyOfOptions)) {
+            for (let i = 0; i < anyOfOptions.length; i++) {
+              const option = anyOfOptions[i] as RJSFSchema;
+              if (option && typeof option === "object") {
+                // Handle anyOf array options with complex items
+                if (option.type === "array" && option.items) {
+                  const itemsSchema = option.items as RJSFSchema;
+                  if (itemsSchema && typeof itemsSchema === "object") {
+                    // Array items that are complex types become JsonTextField
+                    if (isComplexType(itemsSchema)) {
+                      uiSchema[key] = {
+                        ...(uiSchema[key] as object),
+                        items: {
+                          "ui:field": JSON_TEXT_FIELD_ID,
+                        },
+                      };
+                    } else if (hasComplexAnyOfOptions(itemsSchema)) {
+                      uiSchema[key] = {
+                        ...(uiSchema[key] as object),
+                        items: {
+                          "ui:field": JSON_TEXT_FIELD_ID,
+                        },
+                      };
+                    }
+                  }
+                }
+
+                // Recurse into anyOf object options with properties
+                if (
+                  option.type === "object" &&
+                  option.properties &&
+                  typeof option.properties === "object"
+                ) {
+                  const optionUiSchema = generateUiSchemaForCustomFields(
+                    option,
+                    {},
+                    true, // Inside complex type (anyOf object option)
+                  );
+                  if (Object.keys(optionUiSchema).length > 0) {
+                    // Store under the property key - RJSF will apply it
+                    uiSchema[key] = {
+                      ...(uiSchema[key] as object),
+                      ...optionUiSchema,
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
       }
     }
   }