fix: wrap generate_agent call in try/except for consistency

Add exception handler for AgentGeneratorNotConfiguredError in generate_agent
call for defensive consistency, even though decompose_goal would typically
catch it first.

Addresses CodeRabbit review suggestion.

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

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

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

@@ -1,29 +1,28 @@
 """Agent generator package - Creates agents from natural language."""
 
 from .core import (
-    apply_agent_patch,
+    AgentGeneratorNotConfiguredError,
     decompose_goal,
     generate_agent,
     generate_agent_patch,
     get_agent_as_json,
+    json_to_graph,
     save_agent_to_library,
 )
-from .fixer import apply_all_fixes
-from .utils import get_blocks_info
-from .validator import validate_agent
+from .service import health_check as check_external_service_health
+from .service import is_external_service_configured
 
 __all__ = [
     # Core functions
     "decompose_goal",
     "generate_agent",
     "generate_agent_patch",
-    "apply_agent_patch",
     "save_agent_to_library",
     "get_agent_as_json",
-    # Fixer
-    "apply_all_fixes",
-    # Validator
-    "validate_agent",
-    # Utils
-    "get_blocks_info",
+    "json_to_graph",
+    # Exceptions
+    "AgentGeneratorNotConfiguredError",
+    # Service
+    "is_external_service_configured",
+    "check_external_service_health",
 ]

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

@@ -1,25 +0,0 @@
-"""OpenRouter client configuration for agent generation."""
-
-import os
-
-from openai import AsyncOpenAI
-
-# Configuration - use OPEN_ROUTER_API_KEY for consistency with chat/config.py
-OPENROUTER_API_KEY = os.getenv("OPEN_ROUTER_API_KEY")
-AGENT_GENERATOR_MODEL = os.getenv("AGENT_GENERATOR_MODEL", "anthropic/claude-opus-4.5")
-
-# OpenRouter client (OpenAI-compatible API)
-_client: AsyncOpenAI | None = None
-
-
-def get_client() -> AsyncOpenAI:
-    """Get or create the OpenRouter client."""
-    global _client
-    if _client is None:
-        if not OPENROUTER_API_KEY:
-            raise ValueError("OPENROUTER_API_KEY environment variable is required")
-        _client = AsyncOpenAI(
-            base_url="https://openrouter.ai/api/v1",
-            api_key=OPENROUTER_API_KEY,
-        )
-    return _client

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

@@ -1,7 +1,5 @@
 """Core agent generation functions."""
 
-import copy
-import json
 import logging
 import uuid
 from typing import Any
@@ -9,13 +7,35 @@ from typing import Any
 from backend.api.features.library import db as library_db
 from backend.data.graph import Graph, Link, Node, create_graph
 
-from .client import AGENT_GENERATOR_MODEL, get_client
-from .prompts import DECOMPOSITION_PROMPT, GENERATION_PROMPT, PATCH_PROMPT
-from .utils import get_block_summaries, parse_json_from_llm
+from .service import (
+    decompose_goal_external,
+    generate_agent_external,
+    generate_agent_patch_external,
+    is_external_service_configured,
+)
 
 logger = logging.getLogger(__name__)
 
 
+class AgentGeneratorNotConfiguredError(Exception):
+    """Raised when the external Agent Generator service is not configured."""
+
+    pass
+
+
+def _check_service_configured() -> None:
+    """Check if the external Agent Generator service is configured.
+
+    Raises:
+        AgentGeneratorNotConfiguredError: If the service is not configured.
+    """
+    if not is_external_service_configured():
+        raise AgentGeneratorNotConfiguredError(
+            "Agent Generator service is not configured. "
+            "Set AGENTGENERATOR_HOST environment variable to enable agent generation."
+        )
+
+
 async def decompose_goal(description: str, context: str = "") -> dict[str, Any] | None:
     """Break down a goal into steps or return clarifying questions.
 
@@ -28,40 +48,13 @@ async def decompose_goal(description: str, context: str = "") -> dict[str, Any]
         - {"type": "clarifying_questions", "questions": [...]}
         - {"type": "instructions", "steps": [...]}
         Or None on error
+
+    Raises:
+        AgentGeneratorNotConfiguredError: If the external service is not configured.
     """
-    client = get_client()
-    prompt = DECOMPOSITION_PROMPT.format(block_summaries=get_block_summaries())
-
-    full_description = description
-    if context:
-        full_description = f"{description}\n\nAdditional context:\n{context}"
-
-    try:
-        response = await client.chat.completions.create(
-            model=AGENT_GENERATOR_MODEL,
-            messages=[
-                {"role": "system", "content": prompt},
-                {"role": "user", "content": full_description},
-            ],
-            temperature=0,
-        )
-
-        content = response.choices[0].message.content
-        if content is None:
-            logger.error("LLM returned empty content for decomposition")
-            return None
-
-        result = parse_json_from_llm(content)
-
-        if result is None:
-            logger.error(f"Failed to parse decomposition response: {content[:200]}")
-            return None
-
-        return result
-
-    except Exception as e:
-        logger.error(f"Error decomposing goal: {e}")
-        return None
+    _check_service_configured()
+    logger.info("Calling external Agent Generator service for decompose_goal")
+    return await decompose_goal_external(description, context)
 
 
 async def generate_agent(instructions: dict[str, Any]) -> dict[str, Any] | None:
@@ -72,31 +65,14 @@ async def generate_agent(instructions: dict[str, Any]) -> dict[str, Any] | None:
 
     Returns:
         Agent JSON dict or None on error
+
+    Raises:
+        AgentGeneratorNotConfiguredError: If the external service is not configured.
     """
-    client = get_client()
-    prompt = GENERATION_PROMPT.format(block_summaries=get_block_summaries())
-
-    try:
-        response = await client.chat.completions.create(
-            model=AGENT_GENERATOR_MODEL,
-            messages=[
-                {"role": "system", "content": prompt},
-                {"role": "user", "content": json.dumps(instructions, indent=2)},
-            ],
-            temperature=0,
-        )
-
-        content = response.choices[0].message.content
-        if content is None:
-            logger.error("LLM returned empty content for agent generation")
-            return None
-
-        result = parse_json_from_llm(content)
-
-        if result is None:
-            logger.error(f"Failed to parse agent JSON: {content[:200]}")
-            return None
-
+    _check_service_configured()
+    logger.info("Calling external Agent Generator service for generate_agent")
+    result = await generate_agent_external(instructions)
+    if result:
         # Ensure required fields
         if "id" not in result:
             result["id"] = str(uuid.uuid4())
@@ -104,12 +80,7 @@ async def generate_agent(instructions: dict[str, Any]) -> dict[str, Any] | None:
             result["version"] = 1
         if "is_active" not in result:
             result["is_active"] = True
-
-        return result
-
-    except Exception as e:
-        logger.error(f"Error generating agent: {e}")
-        return None
+    return result
 
 
 def json_to_graph(agent_json: dict[str, Any]) -> Graph:
@@ -218,6 +189,7 @@ async def save_agent_to_library(
     library_agents = await library_db.create_library_agent(
         graph=created_graph,
         user_id=user_id,
+        sensitive_action_safe_mode=True,
         create_library_agents_for_sub_graphs=False,
     )
 
@@ -283,108 +255,23 @@ async def get_agent_as_json(
 async def generate_agent_patch(
     update_request: str, current_agent: dict[str, Any]
 ) -> dict[str, Any] | None:
-    """Generate a patch to update an existing agent.
+    """Update an existing agent using natural language.
+
+    The external Agent Generator service handles:
+    - Generating the patch
+    - Applying the patch
+    - Fixing and validating the result
 
     Args:
         update_request: Natural language description of changes
         current_agent: Current agent JSON
 
     Returns:
-        Patch dict or clarifying questions, or None on error
+        Updated agent JSON, clarifying questions dict, or None on error
+
+    Raises:
+        AgentGeneratorNotConfiguredError: If the external service is not configured.
     """
-    client = get_client()
-    prompt = PATCH_PROMPT.format(
-        current_agent=json.dumps(current_agent, indent=2),
-        block_summaries=get_block_summaries(),
-    )
-
-    try:
-        response = await client.chat.completions.create(
-            model=AGENT_GENERATOR_MODEL,
-            messages=[
-                {"role": "system", "content": prompt},
-                {"role": "user", "content": update_request},
-            ],
-            temperature=0,
-        )
-
-        content = response.choices[0].message.content
-        if content is None:
-            logger.error("LLM returned empty content for patch generation")
-            return None
-
-        return parse_json_from_llm(content)
-
-    except Exception as e:
-        logger.error(f"Error generating patch: {e}")
-        return None
-
-
-def apply_agent_patch(
-    current_agent: dict[str, Any], patch: dict[str, Any]
-) -> dict[str, Any]:
-    """Apply a patch to an existing agent.
-
-    Args:
-        current_agent: Current agent JSON
-        patch: Patch dict with operations
-
-    Returns:
-        Updated agent JSON
-    """
-    agent = copy.deepcopy(current_agent)
-    patches = patch.get("patches", [])
-
-    for p in patches:
-        patch_type = p.get("type")
-
-        if patch_type == "modify":
-            node_id = p.get("node_id")
-            changes = p.get("changes", {})
-
-            for node in agent.get("nodes", []):
-                if node["id"] == node_id:
-                    _deep_update(node, changes)
-                    logger.debug(f"Modified node {node_id}")
-                    break
-
-        elif patch_type == "add":
-            new_nodes = p.get("new_nodes", [])
-            new_links = p.get("new_links", [])
-
-            agent["nodes"] = agent.get("nodes", []) + new_nodes
-            agent["links"] = agent.get("links", []) + new_links
-            logger.debug(f"Added {len(new_nodes)} nodes, {len(new_links)} links")
-
-        elif patch_type == "remove":
-            node_ids_to_remove = set(p.get("node_ids", []))
-            link_ids_to_remove = set(p.get("link_ids", []))
-
-            # Remove nodes
-            agent["nodes"] = [
-                n for n in agent.get("nodes", []) if n["id"] not in node_ids_to_remove
-            ]
-
-            # Remove links (both explicit and those referencing removed nodes)
-            agent["links"] = [
-                link
-                for link in agent.get("links", [])
-                if link["id"] not in link_ids_to_remove
-                and link["source_id"] not in node_ids_to_remove
-                and link["sink_id"] not in node_ids_to_remove
-            ]
-
-            logger.debug(
-                f"Removed {len(node_ids_to_remove)} nodes, {len(link_ids_to_remove)} links"
-            )
-
-    return agent
-
-
-def _deep_update(target: dict, source: dict) -> None:
-    """Recursively update a dict with another dict."""
-    for key, value in source.items():
-        if key in target and isinstance(target[key], dict) and isinstance(value, dict):
-            _deep_update(target[key], value)
-        else:
-            target[key] = value
+    _check_service_configured()
+    logger.info("Calling external Agent Generator service for generate_agent_patch")
+    return await generate_agent_patch_external(update_request, current_agent)

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

@@ -1,606 +0,0 @@
-"""Agent fixer - Fixes common LLM generation errors."""
-
-import logging
-import re
-import uuid
-from typing import Any
-
-from .utils import (
-    ADDTODICTIONARY_BLOCK_ID,
-    ADDTOLIST_BLOCK_ID,
-    CODE_EXECUTION_BLOCK_ID,
-    CONDITION_BLOCK_ID,
-    CREATEDICT_BLOCK_ID,
-    CREATELIST_BLOCK_ID,
-    DATA_SAMPLING_BLOCK_ID,
-    DOUBLE_CURLY_BRACES_BLOCK_IDS,
-    GET_CURRENT_DATE_BLOCK_ID,
-    STORE_VALUE_BLOCK_ID,
-    UNIVERSAL_TYPE_CONVERTER_BLOCK_ID,
-    get_blocks_info,
-    is_valid_uuid,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def fix_agent_ids(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix invalid UUIDs in agent and link IDs."""
-    # Fix agent ID
-    if not is_valid_uuid(agent.get("id", "")):
-        agent["id"] = str(uuid.uuid4())
-        logger.debug(f"Fixed agent ID: {agent['id']}")
-
-    # Fix node IDs
-    id_mapping = {}  # Old ID -> New ID
-    for node in agent.get("nodes", []):
-        if not is_valid_uuid(node.get("id", "")):
-            old_id = node.get("id", "")
-            new_id = str(uuid.uuid4())
-            id_mapping[old_id] = new_id
-            node["id"] = new_id
-            logger.debug(f"Fixed node ID: {old_id} -> {new_id}")
-
-    # Fix link IDs and update references
-    for link in agent.get("links", []):
-        if not is_valid_uuid(link.get("id", "")):
-            link["id"] = str(uuid.uuid4())
-            logger.debug(f"Fixed link ID: {link['id']}")
-
-        # Update source/sink IDs if they were remapped
-        if link.get("source_id") in id_mapping:
-            link["source_id"] = id_mapping[link["source_id"]]
-        if link.get("sink_id") in id_mapping:
-            link["sink_id"] = id_mapping[link["sink_id"]]
-
-    return agent
-
-
-def fix_double_curly_braces(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix single curly braces to double in template blocks."""
-    for node in agent.get("nodes", []):
-        if node.get("block_id") not in DOUBLE_CURLY_BRACES_BLOCK_IDS:
-            continue
-
-        input_data = node.get("input_default", {})
-        for key in ("prompt", "format"):
-            if key in input_data and isinstance(input_data[key], str):
-                original = input_data[key]
-                # Fix simple variable references: {var} -> {{var}}
-                fixed = re.sub(
-                    r"(?<!\{)\{([a-zA-Z_][a-zA-Z0-9_]*)\}(?!\})",
-                    r"{{\1}}",
-                    original,
-                )
-                if fixed != original:
-                    input_data[key] = fixed
-                    logger.debug(f"Fixed curly braces in {key}")
-
-    return agent
-
-
-def fix_storevalue_before_condition(agent: dict[str, Any]) -> dict[str, Any]:
-    """Add StoreValueBlock before ConditionBlock if needed for value2."""
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-
-    # Find all ConditionBlock nodes
-    condition_node_ids = {
-        node["id"] for node in nodes if node.get("block_id") == CONDITION_BLOCK_ID
-    }
-
-    if not condition_node_ids:
-        return agent
-
-    new_nodes = []
-    new_links = []
-    processed_conditions = set()
-
-    for link in links:
-        sink_id = link.get("sink_id")
-        sink_name = link.get("sink_name")
-
-        # Check if this link goes to a ConditionBlock's value2
-        if sink_id in condition_node_ids and sink_name == "value2":
-            source_node = next(
-                (n for n in nodes if n["id"] == link.get("source_id")), None
-            )
-
-            # Skip if source is already a StoreValueBlock
-            if source_node and source_node.get("block_id") == STORE_VALUE_BLOCK_ID:
-                continue
-
-            # Skip if we already processed this condition
-            if sink_id in processed_conditions:
-                continue
-
-            processed_conditions.add(sink_id)
-
-            # Create StoreValueBlock
-            store_node_id = str(uuid.uuid4())
-            store_node = {
-                "id": store_node_id,
-                "block_id": STORE_VALUE_BLOCK_ID,
-                "input_default": {"data": None},
-                "metadata": {"position": {"x": 0, "y": -100}},
-            }
-            new_nodes.append(store_node)
-
-            # Create link: original source -> StoreValueBlock
-            new_links.append(
-                {
-                    "id": str(uuid.uuid4()),
-                    "source_id": link["source_id"],
-                    "source_name": link["source_name"],
-                    "sink_id": store_node_id,
-                    "sink_name": "input",
-                    "is_static": False,
-                }
-            )
-
-            # Update original link: StoreValueBlock -> ConditionBlock
-            link["source_id"] = store_node_id
-            link["source_name"] = "output"
-
-            logger.debug(f"Added StoreValueBlock before ConditionBlock {sink_id}")
-
-    if new_nodes:
-        agent["nodes"] = nodes + new_nodes
-
-    return agent
-
-
-def fix_addtolist_blocks(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix AddToList blocks by adding prerequisite empty AddToList block.
-
-    When an AddToList block is found:
-    1. Checks if there's a CreateListBlock before it
-    2. Removes CreateListBlock if linked directly to AddToList
-    3. Adds an empty AddToList block before the original
-    4. Ensures the original has a self-referencing link
-    """
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-    new_nodes = []
-    original_addtolist_ids = set()
-    nodes_to_remove = set()
-    links_to_remove = []
-
-    # First pass: identify CreateListBlock nodes to remove
-    for link in links:
-        source_node = next(
-            (n for n in nodes if n.get("id") == link.get("source_id")), None
-        )
-        sink_node = next((n for n in nodes if n.get("id") == link.get("sink_id")), None)
-
-        if (
-            source_node
-            and sink_node
-            and source_node.get("block_id") == CREATELIST_BLOCK_ID
-            and sink_node.get("block_id") == ADDTOLIST_BLOCK_ID
-        ):
-            nodes_to_remove.add(source_node.get("id"))
-            links_to_remove.append(link)
-            logger.debug(f"Removing CreateListBlock {source_node.get('id')}")
-
-    # Second pass: process AddToList blocks
-    filtered_nodes = []
-    for node in nodes:
-        if node.get("id") in nodes_to_remove:
-            continue
-
-        if node.get("block_id") == ADDTOLIST_BLOCK_ID:
-            original_addtolist_ids.add(node.get("id"))
-            node_id = node.get("id")
-            pos = node.get("metadata", {}).get("position", {"x": 0, "y": 0})
-
-            # Check if already has prerequisite
-            has_prereq = any(
-                link.get("sink_id") == node_id
-                and link.get("sink_name") == "list"
-                and link.get("source_name") == "updated_list"
-                for link in links
-            )
-
-            if not has_prereq:
-                # Remove links to "list" input (except self-reference)
-                for link in links:
-                    if (
-                        link.get("sink_id") == node_id
-                        and link.get("sink_name") == "list"
-                        and link.get("source_id") != node_id
-                        and link not in links_to_remove
-                    ):
-                        links_to_remove.append(link)
-
-                # Create prerequisite AddToList block
-                prereq_id = str(uuid.uuid4())
-                prereq_node = {
-                    "id": prereq_id,
-                    "block_id": ADDTOLIST_BLOCK_ID,
-                    "input_default": {"list": [], "entry": None, "entries": []},
-                    "metadata": {
-                        "position": {"x": pos.get("x", 0) - 800, "y": pos.get("y", 0)}
-                    },
-                }
-                new_nodes.append(prereq_node)
-
-                # Link prerequisite to original
-                links.append(
-                    {
-                        "id": str(uuid.uuid4()),
-                        "source_id": prereq_id,
-                        "source_name": "updated_list",
-                        "sink_id": node_id,
-                        "sink_name": "list",
-                        "is_static": False,
-                    }
-                )
-                logger.debug(f"Added prerequisite AddToList block for {node_id}")
-
-        filtered_nodes.append(node)
-
-    # Remove marked links
-    filtered_links = [link for link in links if link not in links_to_remove]
-
-    # Add self-referencing links for original AddToList blocks
-    for node in filtered_nodes + new_nodes:
-        if (
-            node.get("block_id") == ADDTOLIST_BLOCK_ID
-            and node.get("id") in original_addtolist_ids
-        ):
-            node_id = node.get("id")
-            has_self_ref = any(
-                link["source_id"] == node_id
-                and link["sink_id"] == node_id
-                and link["source_name"] == "updated_list"
-                and link["sink_name"] == "list"
-                for link in filtered_links
-            )
-            if not has_self_ref:
-                filtered_links.append(
-                    {
-                        "id": str(uuid.uuid4()),
-                        "source_id": node_id,
-                        "source_name": "updated_list",
-                        "sink_id": node_id,
-                        "sink_name": "list",
-                        "is_static": False,
-                    }
-                )
-                logger.debug(f"Added self-reference for AddToList {node_id}")
-
-    agent["nodes"] = filtered_nodes + new_nodes
-    agent["links"] = filtered_links
-    return agent
-
-
-def fix_addtodictionary_blocks(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix AddToDictionary blocks by removing empty CreateDictionary nodes."""
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-    nodes_to_remove = set()
-    links_to_remove = []
-
-    for link in links:
-        source_node = next(
-            (n for n in nodes if n.get("id") == link.get("source_id")), None
-        )
-        sink_node = next((n for n in nodes if n.get("id") == link.get("sink_id")), None)
-
-        if (
-            source_node
-            and sink_node
-            and source_node.get("block_id") == CREATEDICT_BLOCK_ID
-            and sink_node.get("block_id") == ADDTODICTIONARY_BLOCK_ID
-        ):
-            nodes_to_remove.add(source_node.get("id"))
-            links_to_remove.append(link)
-            logger.debug(f"Removing CreateDictionary {source_node.get('id')}")
-
-    agent["nodes"] = [n for n in nodes if n.get("id") not in nodes_to_remove]
-    agent["links"] = [link for link in links if link not in links_to_remove]
-    return agent
-
-
-def fix_code_execution_output(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix CodeExecutionBlock output: change 'response' to 'stdout_logs'."""
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-
-    for link in links:
-        source_node = next(
-            (n for n in nodes if n.get("id") == link.get("source_id")), None
-        )
-        if (
-            source_node
-            and source_node.get("block_id") == CODE_EXECUTION_BLOCK_ID
-            and link.get("source_name") == "response"
-        ):
-            link["source_name"] = "stdout_logs"
-            logger.debug("Fixed CodeExecutionBlock output: response -> stdout_logs")
-
-    return agent
-
-
-def fix_data_sampling_sample_size(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix DataSamplingBlock by setting sample_size to 1 as default."""
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-    links_to_remove = []
-
-    for node in nodes:
-        if node.get("block_id") == DATA_SAMPLING_BLOCK_ID:
-            node_id = node.get("id")
-            input_default = node.get("input_default", {})
-
-            # Remove links to sample_size
-            for link in links:
-                if (
-                    link.get("sink_id") == node_id
-                    and link.get("sink_name") == "sample_size"
-                ):
-                    links_to_remove.append(link)
-
-            # Set default
-            input_default["sample_size"] = 1
-            node["input_default"] = input_default
-            logger.debug(f"Fixed DataSamplingBlock {node_id} sample_size to 1")
-
-    if links_to_remove:
-        agent["links"] = [link for link in links if link not in links_to_remove]
-
-    return agent
-
-
-def fix_node_x_coordinates(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix node x-coordinates to ensure 800+ unit spacing between linked nodes."""
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-    node_lookup = {n.get("id"): n for n in nodes}
-
-    for link in links:
-        source_id = link.get("source_id")
-        sink_id = link.get("sink_id")
-
-        source_node = node_lookup.get(source_id)
-        sink_node = node_lookup.get(sink_id)
-
-        if not source_node or not sink_node:
-            continue
-
-        source_pos = source_node.get("metadata", {}).get("position", {})
-        sink_pos = sink_node.get("metadata", {}).get("position", {})
-
-        source_x = source_pos.get("x", 0)
-        sink_x = sink_pos.get("x", 0)
-
-        if abs(sink_x - source_x) < 800:
-            new_x = source_x + 800
-            if "metadata" not in sink_node:
-                sink_node["metadata"] = {}
-            if "position" not in sink_node["metadata"]:
-                sink_node["metadata"]["position"] = {}
-            sink_node["metadata"]["position"]["x"] = new_x
-            logger.debug(f"Fixed node {sink_id} x: {sink_x} -> {new_x}")
-
-    return agent
-
-
-def fix_getcurrentdate_offset(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix GetCurrentDateBlock offset to ensure it's positive."""
-    for node in agent.get("nodes", []):
-        if node.get("block_id") == GET_CURRENT_DATE_BLOCK_ID:
-            input_default = node.get("input_default", {})
-            if "offset" in input_default:
-                offset = input_default["offset"]
-                if isinstance(offset, (int, float)) and offset < 0:
-                    input_default["offset"] = abs(offset)
-                    logger.debug(f"Fixed offset: {offset} -> {abs(offset)}")
-
-    return agent
-
-
-def fix_ai_model_parameter(
-    agent: dict[str, Any],
-    blocks_info: list[dict[str, Any]],
-    default_model: str = "gpt-4o",
-) -> dict[str, Any]:
-    """Add default model parameter to AI blocks if missing."""
-    block_map = {b.get("id"): b for b in blocks_info}
-
-    for node in agent.get("nodes", []):
-        block_id = node.get("block_id")
-        block = block_map.get(block_id)
-
-        if not block:
-            continue
-
-        # Check if block has AI category
-        categories = block.get("categories", [])
-        is_ai_block = any(
-            cat.get("category") == "AI" for cat in categories if isinstance(cat, dict)
-        )
-
-        if is_ai_block:
-            input_default = node.get("input_default", {})
-            if "model" not in input_default:
-                input_default["model"] = default_model
-                node["input_default"] = input_default
-                logger.debug(
-                    f"Added model '{default_model}' to AI block {node.get('id')}"
-                )
-
-    return agent
-
-
-def fix_link_static_properties(
-    agent: dict[str, Any], blocks_info: list[dict[str, Any]]
-) -> dict[str, Any]:
-    """Fix is_static property based on source block's staticOutput."""
-    block_map = {b.get("id"): b for b in blocks_info}
-    node_lookup = {n.get("id"): n for n in agent.get("nodes", [])}
-
-    for link in agent.get("links", []):
-        source_node = node_lookup.get(link.get("source_id"))
-        if not source_node:
-            continue
-
-        source_block = block_map.get(source_node.get("block_id"))
-        if not source_block:
-            continue
-
-        static_output = source_block.get("staticOutput", False)
-        if link.get("is_static") != static_output:
-            link["is_static"] = static_output
-            logger.debug(f"Fixed link {link.get('id')} is_static to {static_output}")
-
-    return agent
-
-
-def fix_data_type_mismatch(
-    agent: dict[str, Any], blocks_info: list[dict[str, Any]]
-) -> dict[str, Any]:
-    """Fix data type mismatches by inserting UniversalTypeConverterBlock."""
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-    block_map = {b.get("id"): b for b in blocks_info}
-    node_lookup = {n.get("id"): n for n in nodes}
-
-    def get_property_type(schema: dict, name: str) -> str | None:
-        if "_#_" in name:
-            parent, child = name.split("_#_", 1)
-            parent_schema = schema.get(parent, {})
-            if "properties" in parent_schema:
-                return parent_schema["properties"].get(child, {}).get("type")
-            return None
-        return schema.get(name, {}).get("type")
-
-    def are_types_compatible(src: str, sink: str) -> bool:
-        if {src, sink} <= {"integer", "number"}:
-            return True
-        return src == sink
-
-    type_mapping = {
-        "string": "string",
-        "text": "string",
-        "integer": "number",
-        "number": "number",
-        "float": "number",
-        "boolean": "boolean",
-        "bool": "boolean",
-        "array": "list",
-        "list": "list",
-        "object": "dictionary",
-        "dict": "dictionary",
-        "dictionary": "dictionary",
-    }
-
-    new_links = []
-    nodes_to_add = []
-
-    for link in links:
-        source_node = node_lookup.get(link.get("source_id"))
-        sink_node = node_lookup.get(link.get("sink_id"))
-
-        if not source_node or not sink_node:
-            new_links.append(link)
-            continue
-
-        source_block = block_map.get(source_node.get("block_id"))
-        sink_block = block_map.get(sink_node.get("block_id"))
-
-        if not source_block or not sink_block:
-            new_links.append(link)
-            continue
-
-        source_outputs = source_block.get("outputSchema", {}).get("properties", {})
-        sink_inputs = sink_block.get("inputSchema", {}).get("properties", {})
-
-        source_type = get_property_type(source_outputs, link.get("source_name", ""))
-        sink_type = get_property_type(sink_inputs, link.get("sink_name", ""))
-
-        if (
-            source_type
-            and sink_type
-            and not are_types_compatible(source_type, sink_type)
-        ):
-            # Insert type converter
-            converter_id = str(uuid.uuid4())
-            target_type = type_mapping.get(sink_type, sink_type)
-
-            converter_node = {
-                "id": converter_id,
-                "block_id": UNIVERSAL_TYPE_CONVERTER_BLOCK_ID,
-                "input_default": {"type": target_type},
-                "metadata": {"position": {"x": 0, "y": 100}},
-            }
-            nodes_to_add.append(converter_node)
-
-            # source -> converter
-            new_links.append(
-                {
-                    "id": str(uuid.uuid4()),
-                    "source_id": link["source_id"],
-                    "source_name": link["source_name"],
-                    "sink_id": converter_id,
-                    "sink_name": "value",
-                    "is_static": False,
-                }
-            )
-
-            # converter -> sink
-            new_links.append(
-                {
-                    "id": str(uuid.uuid4()),
-                    "source_id": converter_id,
-                    "source_name": "value",
-                    "sink_id": link["sink_id"],
-                    "sink_name": link["sink_name"],
-                    "is_static": False,
-                }
-            )
-
-            logger.debug(f"Inserted type converter: {source_type} -> {target_type}")
-        else:
-            new_links.append(link)
-
-    if nodes_to_add:
-        agent["nodes"] = nodes + nodes_to_add
-        agent["links"] = new_links
-
-    return agent
-
-
-def apply_all_fixes(
-    agent: dict[str, Any], blocks_info: list[dict[str, Any]] | None = None
-) -> dict[str, Any]:
-    """Apply all fixes to an agent JSON.
-
-    Args:
-        agent: Agent JSON dict
-        blocks_info: Optional list of block info dicts for advanced fixes
-
-    Returns:
-        Fixed agent JSON
-    """
-    # Basic fixes (no block info needed)
-    agent = fix_agent_ids(agent)
-    agent = fix_double_curly_braces(agent)
-    agent = fix_storevalue_before_condition(agent)
-    agent = fix_addtolist_blocks(agent)
-    agent = fix_addtodictionary_blocks(agent)
-    agent = fix_code_execution_output(agent)
-    agent = fix_data_sampling_sample_size(agent)
-    agent = fix_node_x_coordinates(agent)
-    agent = fix_getcurrentdate_offset(agent)
-
-    # Advanced fixes (require block info)
-    if blocks_info is None:
-        blocks_info = get_blocks_info()
-
-    agent = fix_ai_model_parameter(agent, blocks_info)
-    agent = fix_link_static_properties(agent, blocks_info)
-    agent = fix_data_type_mismatch(agent, blocks_info)
-
-    return agent

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

@@ -1,225 +0,0 @@
-"""Prompt templates for agent generation."""
-
-DECOMPOSITION_PROMPT = """
-You are an expert AutoGPT Workflow Decomposer. Your task is to analyze a user's high-level goal and break it down into a clear, step-by-step plan using the available blocks.
-
-Each step should represent a distinct, automatable action suitable for execution by an AI automation system.
-
----
-
-FIRST: Analyze the user's goal and determine:
-1) Design-time configuration (fixed settings that won't change per run)
-2) Runtime inputs (values the agent's end-user will provide each time it runs)
-
-For anything that can vary per run (email addresses, names, dates, search terms, etc.):
-- DO NOT ask for the actual value
-- Instead, define it as an Agent Input with a clear name, type, and description
-
-Only ask clarifying questions about design-time config that affects how you build the workflow:
-- Which external service to use (e.g., "Gmail vs Outlook", "Notion vs Google Docs")
-- Required formats or structures (e.g., "CSV, JSON, or PDF output?")
-- Business rules that must be hard-coded
-
-IMPORTANT CLARIFICATIONS POLICY:
-- Ask no more than five essential questions
-- Do not ask for concrete values that can be provided at runtime as Agent Inputs
-- Do not ask for API keys or credentials; the platform handles those directly
-- If there is enough information to infer reasonable defaults, prefer to propose defaults
-
----
-
-GUIDELINES:
-1. List each step as a numbered item
-2. Describe the action clearly and specify inputs/outputs
-3. Ensure steps are in logical, sequential order
-4. Mention block names naturally (e.g., "Use GetWeatherByLocationBlock to...")
-5. Help the user reach their goal efficiently
-
----
-
-RULES:
-1. OUTPUT FORMAT: Only output either clarifying questions OR step-by-step instructions, not both
-2. USE ONLY THE BLOCKS PROVIDED
-3. ALL required_input fields must be provided
-4. Data types of linked properties must match
-5. Write expert-level prompts for AI-related blocks
-
----
-
-CRITICAL BLOCK RESTRICTIONS:
-1. AddToListBlock: Outputs updated list EVERY addition, not after all additions
-2. SendEmailBlock: Draft the email for user review; set SMTP config based on email type
-3. ConditionBlock: value2 is reference, value1 is contrast
-4. CodeExecutionBlock: DO NOT USE - use AI blocks instead
-5. ReadCsvBlock: Only use the 'rows' output, not 'row'
-
----
-
-OUTPUT FORMAT:
-
-If more information is needed:
-```json
-{{
-  "type": "clarifying_questions",
-  "questions": [
-    {{
-      "question": "Which email provider should be used? (Gmail, Outlook, custom SMTP)",
-      "keyword": "email_provider",
-      "example": "Gmail"
-    }}
-  ]
-}}
-```
-
-If ready to proceed:
-```json
-{{
-  "type": "instructions",
-  "steps": [
-    {{
-      "step_number": 1,
-      "block_name": "AgentShortTextInputBlock",
-      "description": "Get the URL of the content to analyze.",
-      "inputs": [{{"name": "name", "value": "URL"}}],
-      "outputs": [{{"name": "result", "description": "The URL entered by user"}}]
-    }}
-  ]
-}}
-```
-
----
-
-AVAILABLE BLOCKS:
-{block_summaries}
-"""
-
-GENERATION_PROMPT = """
-You are an expert AI workflow builder. Generate a valid agent JSON from the given instructions.
-
----
-
-NODES:
-Each node must include:
-- `id`: Unique UUID v4 (e.g. `a8f5b1e2-c3d4-4e5f-8a9b-0c1d2e3f4a5b`)
-- `block_id`: The block identifier (must match an Allowed Block)
-- `input_default`: Dict of inputs (can be empty if no static inputs needed)
-- `metadata`: Must contain:
-  - `position`: {{"x": number, "y": number}} - adjacent nodes should differ by 800+ in X
-  - `customized_name`: Clear name describing this block's purpose in the workflow
-
----
-
-LINKS:
-Each link connects a source node's output to a sink node's input:
-- `id`: MUST be UUID v4 (NOT "link-1", "link-2", etc.)
-- `source_id`: ID of the source node
-- `source_name`: Output field name from the source block
-- `sink_id`: ID of the sink node
-- `sink_name`: Input field name on the sink block
-- `is_static`: true only if source block has static_output: true
-
-CRITICAL: All IDs must be valid UUID v4 format!
-
----
-
-AGENT (GRAPH):
-Wrap nodes and links in:
-- `id`: UUID of the agent
-- `name`: Short, generic name (avoid specific company names, URLs)
-- `description`: Short, generic description
-- `nodes`: List of all nodes
-- `links`: List of all links
-- `version`: 1
-- `is_active`: true
-
----
-
-TIPS:
-- All required_input fields must be provided via input_default or a valid link
-- Ensure consistent source_id and sink_id references
-- Avoid dangling links
-- Input/output pins must match block schemas
-- Do not invent unknown block_ids
-
----
-
-ALLOWED BLOCKS:
-{block_summaries}
-
----
-
-Generate the complete agent JSON. Output ONLY valid JSON, no explanation.
-"""
-
-PATCH_PROMPT = """
-You are an expert at modifying AutoGPT agent workflows. Given the current agent and a modification request, generate a JSON patch to update the agent.
-
-CURRENT AGENT:
-{current_agent}
-
-AVAILABLE BLOCKS:
-{block_summaries}
-
----
-
-PATCH FORMAT:
-Return a JSON object with the following structure:
-
-```json
-{{
-  "type": "patch",
-  "intent": "Brief description of what the patch does",
-  "patches": [
-    {{
-      "type": "modify",
-      "node_id": "uuid-of-node-to-modify",
-      "changes": {{
-        "input_default": {{"field": "new_value"}},
-        "metadata": {{"customized_name": "New Name"}}
-      }}
-    }},
-    {{
-      "type": "add",
-      "new_nodes": [
-        {{
-          "id": "new-uuid",
-          "block_id": "block-uuid",
-          "input_default": {{}},
-          "metadata": {{"position": {{"x": 0, "y": 0}}, "customized_name": "Name"}}
-        }}
-      ],
-      "new_links": [
-        {{
-          "id": "link-uuid",
-          "source_id": "source-node-id",
-          "source_name": "output_field",
-          "sink_id": "sink-node-id",
-          "sink_name": "input_field"
-        }}
-      ]
-    }},
-    {{
-      "type": "remove",
-      "node_ids": ["uuid-of-node-to-remove"],
-      "link_ids": ["uuid-of-link-to-remove"]
-    }}
-  ]
-}}
-```
-
-If you need more information, return:
-```json
-{{
-  "type": "clarifying_questions",
-  "questions": [
-    {{
-      "question": "What specific change do you want?",
-      "keyword": "change_type",
-      "example": "Add error handling"
-    }}
-  ]
-}}
-```
-
-Generate the minimal patch needed. Output ONLY valid JSON.
-"""

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

@@ -0,0 +1,269 @@
+"""External Agent Generator service client.
+
+This module provides a client for communicating with the external Agent Generator
+microservice. When AGENTGENERATOR_HOST is configured, the agent generation functions
+will delegate to the external service instead of using the built-in LLM-based implementation.
+"""
+
+import logging
+from typing import Any
+
+import httpx
+
+from backend.util.settings import Settings
+
+logger = logging.getLogger(__name__)
+
+_client: httpx.AsyncClient | None = None
+_settings: Settings | None = None
+
+
+def _get_settings() -> Settings:
+    """Get or create settings singleton."""
+    global _settings
+    if _settings is None:
+        _settings = Settings()
+    return _settings
+
+
+def is_external_service_configured() -> bool:
+    """Check if external Agent Generator service is configured."""
+    settings = _get_settings()
+    return bool(settings.config.agentgenerator_host)
+
+
+def _get_base_url() -> str:
+    """Get the base URL for the external service."""
+    settings = _get_settings()
+    host = settings.config.agentgenerator_host
+    port = settings.config.agentgenerator_port
+    return f"http://{host}:{port}"
+
+
+def _get_client() -> httpx.AsyncClient:
+    """Get or create the HTTP client for the external service."""
+    global _client
+    if _client is None:
+        settings = _get_settings()
+        _client = httpx.AsyncClient(
+            base_url=_get_base_url(),
+            timeout=httpx.Timeout(settings.config.agentgenerator_timeout),
+        )
+    return _client
+
+
+async def decompose_goal_external(
+    description: str, context: str = ""
+) -> dict[str, Any] | None:
+    """Call the external service to decompose a goal.
+
+    Args:
+        description: Natural language goal description
+        context: Additional context (e.g., answers to previous questions)
+
+    Returns:
+        Dict with either:
+        - {"type": "clarifying_questions", "questions": [...]}
+        - {"type": "instructions", "steps": [...]}
+        - {"type": "unachievable_goal", ...}
+        - {"type": "vague_goal", ...}
+        Or None on error
+    """
+    client = _get_client()
+
+    # Build the request payload
+    payload: dict[str, Any] = {"description": description}
+    if context:
+        # The external service uses user_instruction for additional context
+        payload["user_instruction"] = context
+
+    try:
+        response = await client.post("/api/decompose-description", json=payload)
+        response.raise_for_status()
+        data = response.json()
+
+        if not data.get("success"):
+            logger.error(f"External service returned error: {data.get('error')}")
+            return None
+
+        # Map the response to the expected format
+        response_type = data.get("type")
+        if response_type == "instructions":
+            return {"type": "instructions", "steps": data.get("steps", [])}
+        elif response_type == "clarifying_questions":
+            return {
+                "type": "clarifying_questions",
+                "questions": data.get("questions", []),
+            }
+        elif response_type == "unachievable_goal":
+            return {
+                "type": "unachievable_goal",
+                "reason": data.get("reason"),
+                "suggested_goal": data.get("suggested_goal"),
+            }
+        elif response_type == "vague_goal":
+            return {
+                "type": "vague_goal",
+                "suggested_goal": data.get("suggested_goal"),
+            }
+        else:
+            logger.error(
+                f"Unknown response type from external service: {response_type}"
+            )
+            return None
+
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error calling external agent generator: {e}")
+        return None
+    except httpx.RequestError as e:
+        logger.error(f"Request error calling external agent generator: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Unexpected error calling external agent generator: {e}")
+        return None
+
+
+async def generate_agent_external(
+    instructions: dict[str, Any]
+) -> dict[str, Any] | None:
+    """Call the external service to generate an agent from instructions.
+
+    Args:
+        instructions: Structured instructions from decompose_goal
+
+    Returns:
+        Agent JSON dict or None on error
+    """
+    client = _get_client()
+
+    try:
+        response = await client.post(
+            "/api/generate-agent", json={"instructions": instructions}
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        if not data.get("success"):
+            logger.error(f"External service returned error: {data.get('error')}")
+            return None
+
+        return data.get("agent_json")
+
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error calling external agent generator: {e}")
+        return None
+    except httpx.RequestError as e:
+        logger.error(f"Request error calling external agent generator: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Unexpected error calling external agent generator: {e}")
+        return None
+
+
+async def generate_agent_patch_external(
+    update_request: str, current_agent: dict[str, Any]
+) -> dict[str, Any] | None:
+    """Call the external service to generate a patch for an existing agent.
+
+    Args:
+        update_request: Natural language description of changes
+        current_agent: Current agent JSON
+
+    Returns:
+        Updated agent JSON, clarifying questions dict, or None on error
+    """
+    client = _get_client()
+
+    try:
+        response = await client.post(
+            "/api/update-agent",
+            json={
+                "update_request": update_request,
+                "current_agent_json": current_agent,
+            },
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        if not data.get("success"):
+            logger.error(f"External service returned error: {data.get('error')}")
+            return None
+
+        # Check if it's clarifying questions
+        if data.get("type") == "clarifying_questions":
+            return {
+                "type": "clarifying_questions",
+                "questions": data.get("questions", []),
+            }
+
+        # Otherwise return the updated agent JSON
+        return data.get("agent_json")
+
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error calling external agent generator: {e}")
+        return None
+    except httpx.RequestError as e:
+        logger.error(f"Request error calling external agent generator: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Unexpected error calling external agent generator: {e}")
+        return None
+
+
+async def get_blocks_external() -> list[dict[str, Any]] | None:
+    """Get available blocks from the external service.
+
+    Returns:
+        List of block info dicts or None on error
+    """
+    client = _get_client()
+
+    try:
+        response = await client.get("/api/blocks")
+        response.raise_for_status()
+        data = response.json()
+
+        if not data.get("success"):
+            logger.error("External service returned error getting blocks")
+            return None
+
+        return data.get("blocks", [])
+
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error getting blocks from external service: {e}")
+        return None
+    except httpx.RequestError as e:
+        logger.error(f"Request error getting blocks from external service: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Unexpected error getting blocks from external service: {e}")
+        return None
+
+
+async def health_check() -> bool:
+    """Check if the external service is healthy.
+
+    Returns:
+        True if healthy, False otherwise
+    """
+    if not is_external_service_configured():
+        return False
+
+    client = _get_client()
+
+    try:
+        response = await client.get("/health")
+        response.raise_for_status()
+        data = response.json()
+        return data.get("status") == "healthy" and data.get("blocks_loaded", False)
+    except Exception as e:
+        logger.warning(f"External agent generator health check failed: {e}")
+        return False
+
+
+async def close_client() -> None:
+    """Close the HTTP client."""
+    global _client
+    if _client is not None:
+        await _client.aclose()
+        _client = None

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

@@ -1,213 +0,0 @@
-"""Utilities for agent generation."""
-
-import json
-import re
-from typing import Any
-
-from backend.data.block import get_blocks
-
-# UUID validation regex
-UUID_REGEX = re.compile(
-    r"^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$"
-)
-
-# Block IDs for various fixes
-STORE_VALUE_BLOCK_ID = "1ff065e9-88e8-4358-9d82-8dc91f622ba9"
-CONDITION_BLOCK_ID = "715696a0-e1da-45c8-b209-c2fa9c3b0be6"
-ADDTOLIST_BLOCK_ID = "aeb08fc1-2fc1-4141-bc8e-f758f183a822"
-ADDTODICTIONARY_BLOCK_ID = "31d1064e-7446-4693-a7d4-65e5ca1180d1"
-CREATELIST_BLOCK_ID = "a912d5c7-6e00-4542-b2a9-8034136930e4"
-CREATEDICT_BLOCK_ID = "b924ddf4-de4f-4b56-9a85-358930dcbc91"
-CODE_EXECUTION_BLOCK_ID = "0b02b072-abe7-11ef-8372-fb5d162dd712"
-DATA_SAMPLING_BLOCK_ID = "4a448883-71fa-49cf-91cf-70d793bd7d87"
-UNIVERSAL_TYPE_CONVERTER_BLOCK_ID = "95d1b990-ce13-4d88-9737-ba5c2070c97b"
-GET_CURRENT_DATE_BLOCK_ID = "b29c1b50-5d0e-4d9f-8f9d-1b0e6fcbf0b1"
-
-DOUBLE_CURLY_BRACES_BLOCK_IDS = [
-    "44f6c8ad-d75c-4ae1-8209-aad1c0326928",  # FillTextTemplateBlock
-    "6ab085e2-20b3-4055-bc3e-08036e01eca6",
-    "90f8c45e-e983-4644-aa0b-b4ebe2f531bc",
-    "363ae599-353e-4804-937e-b2ee3cef3da4",  # AgentOutputBlock
-    "3b191d9f-356f-482d-8238-ba04b6d18381",
-    "db7d8f02-2f44-4c55-ab7a-eae0941f0c30",
-    "3a7c4b8d-6e2f-4a5d-b9c1-f8d23c5a9b0e",
-    "ed1ae7a0-b770-4089-b520-1f0005fad19a",
-    "a892b8d9-3e4e-4e9c-9c1e-75f8efcf1bfa",
-    "b29c1b50-5d0e-4d9f-8f9d-1b0e6fcbf0b1",
-    "716a67b3-6760-42e7-86dc-18645c6e00fc",
-    "530cf046-2ce0-4854-ae2c-659db17c7a46",
-    "ed55ac19-356e-4243-a6cb-bc599e9b716f",
-    "1f292d4a-41a4-4977-9684-7c8d560b9f91",  # LLM blocks
-    "32a87eab-381e-4dd4-bdb8-4c47151be35a",
-]
-
-
-def is_valid_uuid(value: str) -> bool:
-    """Check if a string is a valid UUID v4."""
-    return isinstance(value, str) and UUID_REGEX.match(value) is not None
-
-
-def _compact_schema(schema: dict) -> dict[str, str]:
-    """Extract compact type info from a JSON schema properties dict.
-
-    Returns a dict of {field_name: type_string} for essential info only.
-    """
-    props = schema.get("properties", {})
-    result = {}
-
-    for name, prop in props.items():
-        # Skip internal/complex fields
-        if name.startswith("_"):
-            continue
-
-        # Get type string
-        type_str = prop.get("type", "any")
-
-        # Handle anyOf/oneOf (optional types)
-        if "anyOf" in prop:
-            types = [t.get("type", "?") for t in prop["anyOf"] if t.get("type")]
-            type_str = "|".join(types) if types else "any"
-        elif "allOf" in prop:
-            type_str = "object"
-
-        # Add array item type if present
-        if type_str == "array" and "items" in prop:
-            items = prop["items"]
-            if isinstance(items, dict):
-                item_type = items.get("type", "any")
-                type_str = f"array[{item_type}]"
-
-        result[name] = type_str
-
-    return result
-
-
-def get_block_summaries(include_schemas: bool = True) -> str:
-    """Generate compact block summaries for prompts.
-
-    Args:
-        include_schemas: Whether to include input/output type info
-
-    Returns:
-        Formatted string of block summaries (compact format)
-    """
-    blocks = get_blocks()
-    summaries = []
-
-    for block_id, block_cls in blocks.items():
-        block = block_cls()
-        name = block.name
-        desc = getattr(block, "description", "") or ""
-
-        # Truncate description
-        if len(desc) > 150:
-            desc = desc[:147] + "..."
-
-        if not include_schemas:
-            summaries.append(f"- {name} (id: {block_id}): {desc}")
-        else:
-            # Compact format with type info only
-            inputs = {}
-            outputs = {}
-            required = []
-
-            if hasattr(block, "input_schema"):
-                try:
-                    schema = block.input_schema.jsonschema()
-                    inputs = _compact_schema(schema)
-                    required = schema.get("required", [])
-                except Exception:
-                    pass
-
-            if hasattr(block, "output_schema"):
-                try:
-                    schema = block.output_schema.jsonschema()
-                    outputs = _compact_schema(schema)
-                except Exception:
-                    pass
-
-            # Build compact line format
-            # Format: NAME (id): desc | in: {field:type, ...} [required] | out: {field:type}
-            in_str = ", ".join(f"{k}:{v}" for k, v in inputs.items())
-            out_str = ", ".join(f"{k}:{v}" for k, v in outputs.items())
-            req_str = f" req=[{','.join(required)}]" if required else ""
-
-            static = " [static]" if getattr(block, "static_output", False) else ""
-
-            line = f"- {name} (id: {block_id}): {desc}"
-            if in_str:
-                line += f"\n  in: {{{in_str}}}{req_str}"
-            if out_str:
-                line += f"\n  out: {{{out_str}}}{static}"
-
-            summaries.append(line)
-
-    return "\n".join(summaries)
-
-
-def get_blocks_info() -> list[dict[str, Any]]:
-    """Get block information with schemas for validation and fixing."""
-    blocks = get_blocks()
-    blocks_info = []
-    for block_id, block_cls in blocks.items():
-        block = block_cls()
-        blocks_info.append(
-            {
-                "id": block_id,
-                "name": block.name,
-                "description": getattr(block, "description", ""),
-                "categories": getattr(block, "categories", []),
-                "staticOutput": getattr(block, "static_output", False),
-                "inputSchema": (
-                    block.input_schema.jsonschema()
-                    if hasattr(block, "input_schema")
-                    else {}
-                ),
-                "outputSchema": (
-                    block.output_schema.jsonschema()
-                    if hasattr(block, "output_schema")
-                    else {}
-                ),
-            }
-        )
-    return blocks_info
-
-
-def parse_json_from_llm(text: str) -> dict[str, Any] | None:
-    """Extract JSON from LLM response (handles markdown code blocks)."""
-    if not text:
-        return None
-
-    # Try fenced code block
-    match = re.search(r"```(?:json)?\s*([\s\S]*?)```", text, re.IGNORECASE)
-    if match:
-        try:
-            return json.loads(match.group(1).strip())
-        except json.JSONDecodeError:
-            pass
-
-    # Try raw text
-    try:
-        return json.loads(text.strip())
-    except json.JSONDecodeError:
-        pass
-
-    # Try finding {...} span
-    start = text.find("{")
-    end = text.rfind("}")
-    if start != -1 and end > start:
-        try:
-            return json.loads(text[start : end + 1])
-        except json.JSONDecodeError:
-            pass
-
-    # Try finding [...] span
-    start = text.find("[")
-    end = text.rfind("]")
-    if start != -1 and end > start:
-        try:
-            return json.loads(text[start : end + 1])
-        except json.JSONDecodeError:
-            pass
-
-    return None

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

@@ -1,279 +0,0 @@
-"""Agent validator - Validates agent structure and connections."""
-
-import logging
-import re
-from typing import Any
-
-from .utils import get_blocks_info
-
-logger = logging.getLogger(__name__)
-
-
-class AgentValidator:
-    """Validator for AutoGPT agents with detailed error reporting."""
-
-    def __init__(self):
-        self.errors: list[str] = []
-
-    def add_error(self, error: str) -> None:
-        """Add an error message."""
-        self.errors.append(error)
-
-    def validate_block_existence(
-        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]]
-    ) -> bool:
-        """Validate all block IDs exist in the blocks library."""
-        valid = True
-        valid_block_ids = {b.get("id") for b in blocks_info if b.get("id")}
-
-        for node in agent.get("nodes", []):
-            block_id = node.get("block_id")
-            node_id = node.get("id")
-
-            if not block_id:
-                self.add_error(f"Node '{node_id}' is missing 'block_id' field.")
-                valid = False
-                continue
-
-            if block_id not in valid_block_ids:
-                self.add_error(
-                    f"Node '{node_id}' references block_id '{block_id}' which does not exist."
-                )
-                valid = False
-
-        return valid
-
-    def validate_link_node_references(self, agent: dict[str, Any]) -> bool:
-        """Validate all node IDs referenced in links exist."""
-        valid = True
-        valid_node_ids = {n.get("id") for n in agent.get("nodes", []) if n.get("id")}
-
-        for link in agent.get("links", []):
-            link_id = link.get("id", "Unknown")
-            source_id = link.get("source_id")
-            sink_id = link.get("sink_id")
-
-            if not source_id:
-                self.add_error(f"Link '{link_id}' is missing 'source_id'.")
-                valid = False
-            elif source_id not in valid_node_ids:
-                self.add_error(
-                    f"Link '{link_id}' references non-existent source_id '{source_id}'."
-                )
-                valid = False
-
-            if not sink_id:
-                self.add_error(f"Link '{link_id}' is missing 'sink_id'.")
-                valid = False
-            elif sink_id not in valid_node_ids:
-                self.add_error(
-                    f"Link '{link_id}' references non-existent sink_id '{sink_id}'."
-                )
-                valid = False
-
-        return valid
-
-    def validate_required_inputs(
-        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]]
-    ) -> bool:
-        """Validate required inputs are provided."""
-        valid = True
-        block_map = {b.get("id"): b for b in blocks_info}
-
-        for node in agent.get("nodes", []):
-            block_id = node.get("block_id")
-            block = block_map.get(block_id)
-
-            if not block:
-                continue
-
-            required_inputs = block.get("inputSchema", {}).get("required", [])
-            input_defaults = node.get("input_default", {})
-            node_id = node.get("id")
-
-            # Get linked inputs
-            linked_inputs = {
-                link["sink_name"]
-                for link in agent.get("links", [])
-                if link.get("sink_id") == node_id
-            }
-
-            for req_input in required_inputs:
-                if (
-                    req_input not in input_defaults
-                    and req_input not in linked_inputs
-                    and req_input != "credentials"
-                ):
-                    block_name = block.get("name", "Unknown Block")
-                    self.add_error(
-                        f"Node '{node_id}' ({block_name}) is missing required input '{req_input}'."
-                    )
-                    valid = False
-
-        return valid
-
-    def validate_data_type_compatibility(
-        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]]
-    ) -> bool:
-        """Validate linked data types are compatible."""
-        valid = True
-        block_map = {b.get("id"): b for b in blocks_info}
-        node_lookup = {n.get("id"): n for n in agent.get("nodes", [])}
-
-        def get_type(schema: dict, name: str) -> str | None:
-            if "_#_" in name:
-                parent, child = name.split("_#_", 1)
-                parent_schema = schema.get(parent, {})
-                if "properties" in parent_schema:
-                    return parent_schema["properties"].get(child, {}).get("type")
-                return None
-            return schema.get(name, {}).get("type")
-
-        def are_compatible(src: str, sink: str) -> bool:
-            if {src, sink} <= {"integer", "number"}:
-                return True
-            return src == sink
-
-        for link in agent.get("links", []):
-            source_node = node_lookup.get(link.get("source_id"))
-            sink_node = node_lookup.get(link.get("sink_id"))
-
-            if not source_node or not sink_node:
-                continue
-
-            source_block = block_map.get(source_node.get("block_id"))
-            sink_block = block_map.get(sink_node.get("block_id"))
-
-            if not source_block or not sink_block:
-                continue
-
-            source_outputs = source_block.get("outputSchema", {}).get("properties", {})
-            sink_inputs = sink_block.get("inputSchema", {}).get("properties", {})
-
-            source_type = get_type(source_outputs, link.get("source_name", ""))
-            sink_type = get_type(sink_inputs, link.get("sink_name", ""))
-
-            if source_type and sink_type and not are_compatible(source_type, sink_type):
-                self.add_error(
-                    f"Type mismatch: {source_block.get('name')} output '{link['source_name']}' "
-                    f"({source_type}) -> {sink_block.get('name')} input '{link['sink_name']}' ({sink_type})."
-                )
-                valid = False
-
-        return valid
-
-    def validate_nested_sink_links(
-        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]]
-    ) -> bool:
-        """Validate nested sink links (with _#_ notation)."""
-        valid = True
-        block_map = {b.get("id"): b for b in blocks_info}
-        node_lookup = {n.get("id"): n for n in agent.get("nodes", [])}
-
-        for link in agent.get("links", []):
-            sink_name = link.get("sink_name", "")
-
-            if "_#_" in sink_name:
-                parent, child = sink_name.split("_#_", 1)
-
-                sink_node = node_lookup.get(link.get("sink_id"))
-                if not sink_node:
-                    continue
-
-                block = block_map.get(sink_node.get("block_id"))
-                if not block:
-                    continue
-
-                input_props = block.get("inputSchema", {}).get("properties", {})
-                parent_schema = input_props.get(parent)
-
-                if not parent_schema:
-                    self.add_error(
-                        f"Invalid nested link '{sink_name}': parent '{parent}' not found."
-                    )
-                    valid = False
-                    continue
-
-                if not parent_schema.get("additionalProperties"):
-                    if not (
-                        isinstance(parent_schema, dict)
-                        and "properties" in parent_schema
-                        and child in parent_schema.get("properties", {})
-                    ):
-                        self.add_error(
-                            f"Invalid nested link '{sink_name}': child '{child}' not found in '{parent}'."
-                        )
-                        valid = False
-
-        return valid
-
-    def validate_prompt_spaces(self, agent: dict[str, Any]) -> bool:
-        """Validate prompts don't have spaces in template variables."""
-        valid = True
-
-        for node in agent.get("nodes", []):
-            input_default = node.get("input_default", {})
-            prompt = input_default.get("prompt", "")
-
-            if not isinstance(prompt, str):
-                continue
-
-            # Find {{...}} with spaces
-            matches = re.finditer(r"\{\{([^}]+)\}\}", prompt)
-            for match in matches:
-                content = match.group(1)
-                if " " in content:
-                    self.add_error(
-                        f"Node '{node.get('id')}' has spaces in template variable: "
-                        f"'{{{{{content}}}}}' should be '{{{{{content.replace(' ', '_')}}}}}'."
-                    )
-                    valid = False
-
-        return valid
-
-    def validate(
-        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]] | None = None
-    ) -> tuple[bool, str | None]:
-        """Run all validations.
-
-        Returns:
-            Tuple of (is_valid, error_message)
-        """
-        self.errors = []
-
-        if blocks_info is None:
-            blocks_info = get_blocks_info()
-
-        checks = [
-            self.validate_block_existence(agent, blocks_info),
-            self.validate_link_node_references(agent),
-            self.validate_required_inputs(agent, blocks_info),
-            self.validate_data_type_compatibility(agent, blocks_info),
-            self.validate_nested_sink_links(agent, blocks_info),
-            self.validate_prompt_spaces(agent),
-        ]
-
-        all_passed = all(checks)
-
-        if all_passed:
-            logger.info("Agent validation successful")
-            return True, None
-
-        error_message = "Agent validation failed:\n"
-        for i, error in enumerate(self.errors, 1):
-            error_message += f"{i}. {error}\n"
-
-        logger.warning(f"Agent validation failed with {len(self.errors)} errors")
-        return False, error_message
-
-
-def validate_agent(
-    agent: dict[str, Any], blocks_info: list[dict[str, Any]] | None = None
-) -> tuple[bool, str | None]:
-    """Convenience function to validate an agent.
-
-    Returns:
-        Tuple of (is_valid, error_message)
-    """
-    validator = AgentValidator()
-    return validator.validate(agent, blocks_info)

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

@@ -8,12 +8,10 @@ from langfuse import observe
 from backend.api.features.chat.model import ChatSession
 
 from .agent_generator import (
-    apply_all_fixes,
+    AgentGeneratorNotConfiguredError,
     decompose_goal,
     generate_agent,
-    get_blocks_info,
     save_agent_to_library,
-    validate_agent,
 )
 from .base import BaseTool
 from .models import (
@@ -27,9 +25,6 @@ from .models import (
 
 logger = logging.getLogger(__name__)
 
-# Maximum retries for agent generation with validation feedback
-MAX_GENERATION_RETRIES = 2
-
 
 class CreateAgentTool(BaseTool):
     """Tool for creating agents from natural language descriptions."""
@@ -91,9 +86,8 @@ class CreateAgentTool(BaseTool):
 
         Flow:
         1. Decompose the description into steps (may return clarifying questions)
-        2. Generate agent JSON from the steps
-        3. Apply fixes to correct common LLM errors
-        4. Preview or save based on the save parameter
+        2. Generate agent JSON (external service handles fixing and validation)
+        3. Preview or save based on the save parameter
         """
         description = kwargs.get("description", "").strip()
         context = kwargs.get("context", "")
@@ -110,11 +104,13 @@ class CreateAgentTool(BaseTool):
         # Step 1: Decompose goal into steps
         try:
             decomposition_result = await decompose_goal(description, context)
-        except ValueError as e:
-            # Handle missing API key or configuration errors
+        except AgentGeneratorNotConfiguredError:
             return ErrorResponse(
-                message=f"Agent generation is not configured: {str(e)}",
-                error="configuration_error",
+                message=(
+                    "Agent generation is not available. "
+                    "The Agent Generator service is not configured."
+                ),
+                error="service_not_configured",
                 session_id=session_id,
             )
 
@@ -171,72 +167,32 @@ class CreateAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Step 2: Generate agent JSON with retry on validation failure
-        blocks_info = get_blocks_info()
-        agent_json = None
-        validation_errors = None
-
-        for attempt in range(MAX_GENERATION_RETRIES + 1):
-            # Generate agent (include validation errors from previous attempt)
-            if attempt == 0:
-                agent_json = await generate_agent(decomposition_result)
-            else:
-                # Retry with validation error feedback
-                logger.info(
-                    f"Retry {attempt}/{MAX_GENERATION_RETRIES} with validation feedback"
-                )
-                retry_instructions = {
-                    **decomposition_result,
-                    "previous_errors": validation_errors,
-                    "retry_instructions": (
-                        "The previous generation had validation errors. "
-                        "Please fix these issues in the new generation:\n"
-                        f"{validation_errors}"
-                    ),
-                }
-                agent_json = await generate_agent(retry_instructions)
-
-            if agent_json is None:
-                if attempt == MAX_GENERATION_RETRIES:
-                    return ErrorResponse(
-                        message="Failed to generate the agent. Please try again.",
-                        error="Generation failed",
-                        session_id=session_id,
-                    )
-                continue
-
-            # Step 3: Apply fixes to correct common errors
-            agent_json = apply_all_fixes(agent_json, blocks_info)
-
-            # Step 4: Validate the agent
-            is_valid, validation_errors = validate_agent(agent_json, blocks_info)
-
-            if is_valid:
-                logger.info(f"Agent generated successfully on attempt {attempt + 1}")
-                break
-
-            logger.warning(
-                f"Validation failed on attempt {attempt + 1}: {validation_errors}"
+        # Step 2: Generate agent JSON (external service handles fixing and validation)
+        try:
+            agent_json = await generate_agent(decomposition_result)
+        except AgentGeneratorNotConfiguredError:
+            return ErrorResponse(
+                message=(
+                    "Agent generation is not available. "
+                    "The Agent Generator service is not configured."
+                ),
+                error="service_not_configured",
+                session_id=session_id,
             )
 
-            if attempt == MAX_GENERATION_RETRIES:
-                # Return error with validation details
-                return ErrorResponse(
-                    message=(
-                        f"Generated agent has validation errors after {MAX_GENERATION_RETRIES + 1} attempts. "
-                        f"Please try rephrasing your request or simplify the workflow."
-                    ),
-                    error="validation_failed",
-                    details={"validation_errors": validation_errors},
-                    session_id=session_id,
-                )
+        if agent_json is None:
+            return ErrorResponse(
+                message="Failed to generate the agent. Please try again.",
+                error="Generation failed",
+                session_id=session_id,
+            )
 
         agent_name = agent_json.get("name", "Generated Agent")
         agent_description = agent_json.get("description", "")
         node_count = len(agent_json.get("nodes", []))
         link_count = len(agent_json.get("links", []))
 
-        # Step 4: Preview or save
+        # Step 3: Preview or save
         if not save:
             return AgentPreviewResponse(
                 message=(

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

@@ -8,13 +8,10 @@ from langfuse import observe
 from backend.api.features.chat.model import ChatSession
 
 from .agent_generator import (
-    apply_agent_patch,
-    apply_all_fixes,
+    AgentGeneratorNotConfiguredError,
     generate_agent_patch,
     get_agent_as_json,
-    get_blocks_info,
     save_agent_to_library,
-    validate_agent,
 )
 from .base import BaseTool
 from .models import (
@@ -28,9 +25,6 @@ from .models import (
 
 logger = logging.getLogger(__name__)
 
-# Maximum retries for patch generation with validation feedback
-MAX_GENERATION_RETRIES = 2
-
 
 class EditAgentTool(BaseTool):
     """Tool for editing existing agents using natural language."""
@@ -43,7 +37,7 @@ class EditAgentTool(BaseTool):
     def description(self) -> str:
         return (
             "Edit an existing agent from the user's library using natural language. "
-            "Generates a patch to update the agent while preserving unchanged parts."
+            "Generates updates to the agent while preserving unchanged parts."
         )
 
     @property
@@ -98,9 +92,8 @@ class EditAgentTool(BaseTool):
 
         Flow:
         1. Fetch the current agent
-        2. Generate a patch based on the requested changes
-        3. Apply the patch to create an updated agent
-        4. Preview or save based on the save parameter
+        2. Generate updated agent (external service handles fixing and validation)
+        3. Preview or save based on the save parameter
         """
         agent_id = kwargs.get("agent_id", "").strip()
         changes = kwargs.get("changes", "").strip()
@@ -137,121 +130,58 @@ class EditAgentTool(BaseTool):
         if context:
             update_request = f"{changes}\n\nAdditional context:\n{context}"
 
-        # Step 2: Generate patch with retry on validation failure
-        blocks_info = get_blocks_info()
-        updated_agent = None
-        validation_errors = None
-        intent = "Applied requested changes"
-
-        for attempt in range(MAX_GENERATION_RETRIES + 1):
-            # Generate patch (include validation errors from previous attempt)
-            try:
-                if attempt == 0:
-                    patch_result = await generate_agent_patch(
-                        update_request, current_agent
-                    )
-                else:
-                    # Retry with validation error feedback
-                    logger.info(
-                        f"Retry {attempt}/{MAX_GENERATION_RETRIES} with validation feedback"
-                    )
-                    retry_request = (
-                        f"{update_request}\n\n"
-                        f"IMPORTANT: The previous edit had validation errors. "
-                        f"Please fix these issues:\n{validation_errors}"
-                    )
-                    patch_result = await generate_agent_patch(
-                        retry_request, current_agent
-                    )
-            except ValueError as e:
-                # Handle missing API key or configuration errors
-                return ErrorResponse(
-                    message=f"Agent generation is not configured: {str(e)}",
-                    error="configuration_error",
-                    session_id=session_id,
-                )
-
-            if patch_result is None:
-                if attempt == MAX_GENERATION_RETRIES:
-                    return ErrorResponse(
-                        message="Failed to generate changes. Please try rephrasing.",
-                        error="Patch generation failed",
-                        session_id=session_id,
-                    )
-                continue
-
-            # Check if LLM returned clarifying questions
-            if patch_result.get("type") == "clarifying_questions":
-                questions = patch_result.get("questions", [])
-                return ClarificationNeededResponse(
-                    message=(
-                        "I need some more information about the changes. "
-                        "Please answer the following questions:"
-                    ),
-                    questions=[
-                        ClarifyingQuestion(
-                            question=q.get("question", ""),
-                            keyword=q.get("keyword", ""),
-                            example=q.get("example"),
-                        )
-                        for q in questions
-                    ],
-                    session_id=session_id,
-                )
-
-            # Step 3: Apply patch and fixes
-            try:
-                updated_agent = apply_agent_patch(current_agent, patch_result)
-                updated_agent = apply_all_fixes(updated_agent, blocks_info)
-            except Exception as e:
-                if attempt == MAX_GENERATION_RETRIES:
-                    return ErrorResponse(
-                        message=f"Failed to apply changes: {str(e)}",
-                        error="patch_apply_failed",
-                        details={"exception": str(e)},
-                        session_id=session_id,
-                    )
-                validation_errors = str(e)
-                continue
-
-            # Step 4: Validate the updated agent
-            is_valid, validation_errors = validate_agent(updated_agent, blocks_info)
-
-            if is_valid:
-                logger.info(f"Agent edited successfully on attempt {attempt + 1}")
-                intent = patch_result.get("intent", "Applied requested changes")
-                break
-
-            logger.warning(
-                f"Validation failed on attempt {attempt + 1}: {validation_errors}"
+        # Step 2: Generate updated agent (external service handles fixing and validation)
+        try:
+            result = await generate_agent_patch(update_request, current_agent)
+        except AgentGeneratorNotConfiguredError:
+            return ErrorResponse(
+                message=(
+                    "Agent editing is not available. "
+                    "The Agent Generator service is not configured."
+                ),
+                error="service_not_configured",
+                session_id=session_id,
             )
 
-            if attempt == MAX_GENERATION_RETRIES:
-                # Return error with validation details
-                return ErrorResponse(
-                    message=(
-                        f"Updated agent has validation errors after "
-                        f"{MAX_GENERATION_RETRIES + 1} attempts. "
-                        f"Please try rephrasing your request or simplify the changes."
-                    ),
-                    error="validation_failed",
-                    details={"validation_errors": validation_errors},
-                    session_id=session_id,
-                )
+        if result is None:
+            return ErrorResponse(
+                message="Failed to generate changes. Please try rephrasing.",
+                error="Update generation failed",
+                session_id=session_id,
+            )
 
-        # At this point, updated_agent is guaranteed to be set (we return on all failure paths)
-        assert updated_agent is not None
+        # Check if LLM returned clarifying questions
+        if result.get("type") == "clarifying_questions":
+            questions = result.get("questions", [])
+            return ClarificationNeededResponse(
+                message=(
+                    "I need some more information about the changes. "
+                    "Please answer the following questions:"
+                ),
+                questions=[
+                    ClarifyingQuestion(
+                        question=q.get("question", ""),
+                        keyword=q.get("keyword", ""),
+                        example=q.get("example"),
+                    )
+                    for q in questions
+                ],
+                session_id=session_id,
+            )
+
+        # Result is the updated agent JSON
+        updated_agent = result
 
         agent_name = updated_agent.get("name", "Updated Agent")
         agent_description = updated_agent.get("description", "")
         node_count = len(updated_agent.get("nodes", []))
         link_count = len(updated_agent.get("links", []))
 
-        # Step 5: Preview or save
+        # Step 3: Preview or save
         if not save:
             return AgentPreviewResponse(
                 message=(
-                    f"I've updated the agent. Changes: {intent}. "
+                    f"I've updated the agent. "
                     f"The agent now has {node_count} blocks. "
                     f"Review it and call edit_agent with save=true to save the changes."
                 ),
@@ -277,10 +207,7 @@ class EditAgentTool(BaseTool):
             )
 
             return AgentSavedResponse(
-                message=(
-                    f"Updated agent '{created_graph.name}' has been saved to your library! "
-                    f"Changes: {intent}"
-                ),
+                message=f"Updated agent '{created_graph.name}' has been saved to your library!",
                 agent_id=created_graph.id,
                 agent_name=created_graph.name,
                 library_agent_id=library_agent.id,

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

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

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

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

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

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

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

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

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

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

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

@@ -295,7 +295,7 @@ async def unified_hybrid_search(
                 FROM {{schema_prefix}}"UnifiedContentEmbedding" uce
                 WHERE uce."contentType" = ANY({content_types_param}::{{schema_prefix}}"ContentType"[])
                 {user_filter}
-                ORDER BY uce.embedding OPERATOR({{pgvector_schema}}.<=>)  {embedding_param}::{{pgvector_schema}}.vector
+                ORDER BY uce.embedding <=> {embedding_param}::vector
                 LIMIT 200
             )
         ),
@@ -307,7 +307,7 @@ async def unified_hybrid_search(
                 uce.metadata,
                 uce."updatedAt" as updated_at,
                 -- Semantic score: cosine similarity (1 - distance)
-                COALESCE(1 - (uce.embedding OPERATOR({{pgvector_schema}}.<=>)  {embedding_param}::{{pgvector_schema}}.vector), 0) as semantic_score,
+                COALESCE(1 - (uce.embedding <=> {embedding_param}::vector), 0) as semantic_score,
                 -- Lexical score: ts_rank_cd
                 COALESCE(ts_rank_cd(uce.search, plainto_tsquery('english', {query_param})), 0) as lexical_raw,
                 -- Category match from metadata
@@ -583,7 +583,7 @@ async def hybrid_search(
                 WHERE uce."contentType" = 'STORE_AGENT'::{{schema_prefix}}"ContentType"
                 AND uce."userId" IS NULL
                 AND {where_clause}
-                ORDER BY uce.embedding OPERATOR({{pgvector_schema}}.<=>)  {embedding_param}::{{pgvector_schema}}.vector
+                ORDER BY uce.embedding <=> {embedding_param}::vector
                 LIMIT 200
             ) uce
         ),
@@ -605,7 +605,7 @@ async def hybrid_search(
                 -- Searchable text for BM25 reranking
                 COALESCE(sa.agent_name, '') || ' ' || COALESCE(sa.sub_heading, '') || ' ' || COALESCE(sa.description, '') as searchable_text,
                 -- Semantic score
-                COALESCE(1 - (uce.embedding OPERATOR({{pgvector_schema}}.<=>)  {embedding_param}::{{pgvector_schema}}.vector), 0) as semantic_score,
+                COALESCE(1 - (uce.embedding <=> {embedding_param}::vector), 0) as semantic_score,
                 -- Lexical score (raw, will normalize)
                 COALESCE(ts_rank_cd(uce.search, plainto_tsquery('english', {query_param})), 0) as lexical_raw,
                 -- Category match

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

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

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

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

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

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

autogpt_platform/backend/backend/api/rest_api.py

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

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

@@ -84,7 +84,7 @@ class HITLReviewHelper:
             Exception: If review creation or status update fails
         """
         # Skip review if safe mode is disabled - return auto-approved result
-        if not execution_context.safe_mode:
+        if not execution_context.human_in_the_loop_safe_mode:
             logger.info(
                 f"Block {block_name} skipping review for node {node_exec_id} - safe mode disabled"
             )

autogpt_platform/backend/backend/blocks/human_in_the_loop.py

@@ -104,7 +104,7 @@ class HumanInTheLoopBlock(Block):
         execution_context: ExecutionContext,
         **_kwargs,
     ) -> BlockOutput:
-        if not execution_context.safe_mode:
+        if not execution_context.human_in_the_loop_safe_mode:
             logger.info(
                 f"HITL block skipping review for node {node_exec_id} - safe mode disabled"
             )

autogpt_platform/backend/backend/blocks/llm.py

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

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

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

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

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

autogpt_platform/backend/backend/data/block.py

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

autogpt_platform/backend/backend/data/block_cost_config.py

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

autogpt_platform/backend/backend/data/db.py

@@ -121,10 +121,14 @@ async def _raw_with_schema(
     Supports placeholders:
         - {schema_prefix}: Table/type prefix (e.g., "platform".)
         - {schema}: Raw schema name for application tables (e.g., platform)
-        - {pgvector_schema}: Schema where pgvector is installed (defaults to "public")
+
+    Note on pgvector types:
+        Use unqualified ::vector and <=> operator in queries. PostgreSQL resolves
+        these via search_path, which includes the schema where pgvector is installed
+        on all environments (local, CI, dev).
 
     Args:
-        query_template: SQL query with {schema_prefix}, {schema}, and/or {pgvector_schema} placeholders
+        query_template: SQL query with {schema_prefix} and/or {schema} placeholders
         *args: Query parameters
         execute: If False, executes SELECT query. If True, executes INSERT/UPDATE/DELETE.
         client: Optional Prisma client for transactions (only used when execute=True).
@@ -135,20 +139,16 @@ async def _raw_with_schema(
 
     Example with vector type:
         await execute_raw_with_schema(
-            'INSERT INTO {schema_prefix}"Embedding" (vec) VALUES ($1::{pgvector_schema}.vector)',
+            'INSERT INTO {schema_prefix}"Embedding" (vec) VALUES ($1::vector)',
             embedding_data
         )
     """
     schema = get_database_schema()
     schema_prefix = f'"{schema}".' if schema != "public" else ""
-    # pgvector extension is typically installed in "public" schema
-    # On Supabase it may be in "extensions" but "public" is the common default
-    pgvector_schema = "public"
 
     formatted_query = query_template.format(
         schema_prefix=schema_prefix,
         schema=schema,
-        pgvector_schema=pgvector_schema,
     )
 
     import prisma as prisma_module

autogpt_platform/backend/backend/data/event_bus.py

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

autogpt_platform/backend/backend/data/event_bus_test.py

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

autogpt_platform/backend/backend/data/execution.py

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

autogpt_platform/backend/backend/data/graph.py

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

autogpt_platform/backend/backend/data/notifications.py

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

autogpt_platform/backend/backend/executor/scheduler.py

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

autogpt_platform/backend/backend/executor/utils.py

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

autogpt_platform/backend/backend/executor/utils_test.py

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

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

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

autogpt_platform/backend/backend/util/settings.py

@@ -350,6 +350,19 @@ class Config(UpdateTrackingModel["Config"], BaseSettings):
         description="Whether to mark failed scans as clean or not",
     )
 
+    agentgenerator_host: str = Field(
+        default="",
+        description="The host for the Agent Generator service (empty to use built-in)",
+    )
+    agentgenerator_port: int = Field(
+        default=8000,
+        description="The port for the Agent Generator service",
+    )
+    agentgenerator_timeout: int = Field(
+        default=120,
+        description="The timeout in seconds for Agent Generator service requests",
+    )
+
     enable_example_blocks: bool = Field(
         default=False,
         description="Whether to enable example blocks in production",

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

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

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

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

autogpt_platform/backend/schema.prisma

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

autogpt_platform/backend/scripts/generate_block_docs.py

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

autogpt_platform/backend/snapshots/grph_single

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

autogpt_platform/backend/snapshots/grphs_all

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

autogpt_platform/backend/snapshots/lib_agts_search

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

autogpt_platform/backend/test/agent_generator/__init__.py

@@ -0,0 +1 @@
+"""Tests for agent generator module."""

autogpt_platform/backend/test/agent_generator/test_core_integration.py

@@ -0,0 +1,273 @@
+"""
+Tests for the Agent Generator core module.
+
+This test suite verifies that the core functions correctly delegate to
+the external Agent Generator service.
+"""
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from backend.api.features.chat.tools.agent_generator import core
+from backend.api.features.chat.tools.agent_generator.core import (
+    AgentGeneratorNotConfiguredError,
+)
+
+
+class TestServiceNotConfigured:
+    """Test that functions raise AgentGeneratorNotConfiguredError when service is not configured."""
+
+    @pytest.mark.asyncio
+    async def test_decompose_goal_raises_when_not_configured(self):
+        """Test that decompose_goal raises error when service not configured."""
+        with patch.object(core, "is_external_service_configured", return_value=False):
+            with pytest.raises(AgentGeneratorNotConfiguredError):
+                await core.decompose_goal("Build a chatbot")
+
+    @pytest.mark.asyncio
+    async def test_generate_agent_raises_when_not_configured(self):
+        """Test that generate_agent raises error when service not configured."""
+        with patch.object(core, "is_external_service_configured", return_value=False):
+            with pytest.raises(AgentGeneratorNotConfiguredError):
+                await core.generate_agent({"steps": []})
+
+    @pytest.mark.asyncio
+    async def test_generate_agent_patch_raises_when_not_configured(self):
+        """Test that generate_agent_patch raises error when service not configured."""
+        with patch.object(core, "is_external_service_configured", return_value=False):
+            with pytest.raises(AgentGeneratorNotConfiguredError):
+                await core.generate_agent_patch("Add a node", {"nodes": []})
+
+
+class TestDecomposeGoal:
+    """Test decompose_goal function service delegation."""
+
+    @pytest.mark.asyncio
+    async def test_calls_external_service(self):
+        """Test that decompose_goal calls the external service."""
+        expected_result = {"type": "instructions", "steps": ["Step 1"]}
+
+        with patch.object(
+            core, "is_external_service_configured", return_value=True
+        ), patch.object(
+            core, "decompose_goal_external", new_callable=AsyncMock
+        ) as mock_external:
+            mock_external.return_value = expected_result
+
+            result = await core.decompose_goal("Build a chatbot")
+
+            mock_external.assert_called_once_with("Build a chatbot", "")
+            assert result == expected_result
+
+    @pytest.mark.asyncio
+    async def test_passes_context_to_external_service(self):
+        """Test that decompose_goal passes context to external service."""
+        expected_result = {"type": "instructions", "steps": ["Step 1"]}
+
+        with patch.object(
+            core, "is_external_service_configured", return_value=True
+        ), patch.object(
+            core, "decompose_goal_external", new_callable=AsyncMock
+        ) as mock_external:
+            mock_external.return_value = expected_result
+
+            await core.decompose_goal("Build a chatbot", "Use Python")
+
+            mock_external.assert_called_once_with("Build a chatbot", "Use Python")
+
+    @pytest.mark.asyncio
+    async def test_returns_none_on_service_failure(self):
+        """Test that decompose_goal returns None when external service fails."""
+        with patch.object(
+            core, "is_external_service_configured", return_value=True
+        ), patch.object(
+            core, "decompose_goal_external", new_callable=AsyncMock
+        ) as mock_external:
+            mock_external.return_value = None
+
+            result = await core.decompose_goal("Build a chatbot")
+
+            assert result is None
+
+
+class TestGenerateAgent:
+    """Test generate_agent function service delegation."""
+
+    @pytest.mark.asyncio
+    async def test_calls_external_service(self):
+        """Test that generate_agent calls the external service."""
+        expected_result = {"name": "Test Agent", "nodes": [], "links": []}
+
+        with patch.object(
+            core, "is_external_service_configured", return_value=True
+        ), patch.object(
+            core, "generate_agent_external", new_callable=AsyncMock
+        ) as mock_external:
+            mock_external.return_value = expected_result
+
+            instructions = {"type": "instructions", "steps": ["Step 1"]}
+            result = await core.generate_agent(instructions)
+
+            mock_external.assert_called_once_with(instructions)
+            # Result should have id, version, is_active added if not present
+            assert result is not None
+            assert result["name"] == "Test Agent"
+            assert "id" in result
+            assert result["version"] == 1
+            assert result["is_active"] is True
+
+    @pytest.mark.asyncio
+    async def test_preserves_existing_id_and_version(self):
+        """Test that external service result preserves existing id and version."""
+        expected_result = {
+            "id": "existing-id",
+            "version": 3,
+            "is_active": False,
+            "name": "Test Agent",
+        }
+
+        with patch.object(
+            core, "is_external_service_configured", return_value=True
+        ), patch.object(
+            core, "generate_agent_external", new_callable=AsyncMock
+        ) as mock_external:
+            mock_external.return_value = expected_result.copy()
+
+            result = await core.generate_agent({"steps": []})
+
+            assert result is not None
+            assert result["id"] == "existing-id"
+            assert result["version"] == 3
+            assert result["is_active"] is False
+
+    @pytest.mark.asyncio
+    async def test_returns_none_when_external_service_fails(self):
+        """Test that generate_agent returns None when external service fails."""
+        with patch.object(
+            core, "is_external_service_configured", return_value=True
+        ), patch.object(
+            core, "generate_agent_external", new_callable=AsyncMock
+        ) as mock_external:
+            mock_external.return_value = None
+
+            result = await core.generate_agent({"steps": []})
+
+            assert result is None
+
+
+class TestGenerateAgentPatch:
+    """Test generate_agent_patch function service delegation."""
+
+    @pytest.mark.asyncio
+    async def test_calls_external_service(self):
+        """Test that generate_agent_patch calls the external service."""
+        expected_result = {"name": "Updated Agent", "nodes": [], "links": []}
+
+        with patch.object(
+            core, "is_external_service_configured", return_value=True
+        ), patch.object(
+            core, "generate_agent_patch_external", new_callable=AsyncMock
+        ) as mock_external:
+            mock_external.return_value = expected_result
+
+            current_agent = {"nodes": [], "links": []}
+            result = await core.generate_agent_patch("Add a node", current_agent)
+
+            mock_external.assert_called_once_with("Add a node", current_agent)
+            assert result == expected_result
+
+    @pytest.mark.asyncio
+    async def test_returns_clarifying_questions(self):
+        """Test that generate_agent_patch returns clarifying questions."""
+        expected_result = {
+            "type": "clarifying_questions",
+            "questions": [{"question": "What type of node?"}],
+        }
+
+        with patch.object(
+            core, "is_external_service_configured", return_value=True
+        ), patch.object(
+            core, "generate_agent_patch_external", new_callable=AsyncMock
+        ) as mock_external:
+            mock_external.return_value = expected_result
+
+            result = await core.generate_agent_patch("Add a node", {"nodes": []})
+
+            assert result == expected_result
+
+    @pytest.mark.asyncio
+    async def test_returns_none_when_external_service_fails(self):
+        """Test that generate_agent_patch returns None when service fails."""
+        with patch.object(
+            core, "is_external_service_configured", return_value=True
+        ), patch.object(
+            core, "generate_agent_patch_external", new_callable=AsyncMock
+        ) as mock_external:
+            mock_external.return_value = None
+
+            result = await core.generate_agent_patch("Add a node", {"nodes": []})
+
+            assert result is None
+
+
+class TestJsonToGraph:
+    """Test json_to_graph function."""
+
+    def test_converts_agent_json_to_graph(self):
+        """Test conversion of agent JSON to Graph model."""
+        agent_json = {
+            "id": "test-id",
+            "version": 2,
+            "is_active": True,
+            "name": "Test Agent",
+            "description": "A test agent",
+            "nodes": [
+                {
+                    "id": "node1",
+                    "block_id": "block1",
+                    "input_default": {"key": "value"},
+                    "metadata": {"x": 100},
+                }
+            ],
+            "links": [
+                {
+                    "id": "link1",
+                    "source_id": "node1",
+                    "sink_id": "output",
+                    "source_name": "result",
+                    "sink_name": "input",
+                    "is_static": False,
+                }
+            ],
+        }
+
+        graph = core.json_to_graph(agent_json)
+
+        assert graph.id == "test-id"
+        assert graph.version == 2
+        assert graph.is_active is True
+        assert graph.name == "Test Agent"
+        assert graph.description == "A test agent"
+        assert len(graph.nodes) == 1
+        assert graph.nodes[0].id == "node1"
+        assert graph.nodes[0].block_id == "block1"
+        assert len(graph.links) == 1
+        assert graph.links[0].source_id == "node1"
+
+    def test_generates_ids_if_missing(self):
+        """Test that missing IDs are generated."""
+        agent_json = {
+            "name": "Test Agent",
+            "nodes": [{"block_id": "block1"}],
+            "links": [],
+        }
+
+        graph = core.json_to_graph(agent_json)
+
+        assert graph.id is not None
+        assert graph.nodes[0].id is not None
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

autogpt_platform/backend/test/agent_generator/test_service.py

@@ -0,0 +1,422 @@
+"""
+Tests for the Agent Generator external service client.
+
+This test suite verifies the external Agent Generator service integration,
+including service detection, API calls, and error handling.
+"""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+
+from backend.api.features.chat.tools.agent_generator import service
+
+
+class TestServiceConfiguration:
+    """Test service configuration detection."""
+
+    def setup_method(self):
+        """Reset settings singleton before each test."""
+        service._settings = None
+        service._client = None
+
+    def test_external_service_not_configured_when_host_empty(self):
+        """Test that external service is not configured when host is empty."""
+        mock_settings = MagicMock()
+        mock_settings.config.agentgenerator_host = ""
+
+        with patch.object(service, "_get_settings", return_value=mock_settings):
+            assert service.is_external_service_configured() is False
+
+    def test_external_service_configured_when_host_set(self):
+        """Test that external service is configured when host is set."""
+        mock_settings = MagicMock()
+        mock_settings.config.agentgenerator_host = "agent-generator.local"
+
+        with patch.object(service, "_get_settings", return_value=mock_settings):
+            assert service.is_external_service_configured() is True
+
+    def test_get_base_url(self):
+        """Test base URL construction."""
+        mock_settings = MagicMock()
+        mock_settings.config.agentgenerator_host = "agent-generator.local"
+        mock_settings.config.agentgenerator_port = 8000
+
+        with patch.object(service, "_get_settings", return_value=mock_settings):
+            url = service._get_base_url()
+            assert url == "http://agent-generator.local:8000"
+
+
+class TestDecomposeGoalExternal:
+    """Test decompose_goal_external function."""
+
+    def setup_method(self):
+        """Reset client singleton before each test."""
+        service._settings = None
+        service._client = None
+
+    @pytest.mark.asyncio
+    async def test_decompose_goal_returns_instructions(self):
+        """Test successful decomposition returning instructions."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "success": True,
+            "type": "instructions",
+            "steps": ["Step 1", "Step 2"],
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.post.return_value = mock_response
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            result = await service.decompose_goal_external("Build a chatbot")
+
+        assert result == {"type": "instructions", "steps": ["Step 1", "Step 2"]}
+        mock_client.post.assert_called_once_with(
+            "/api/decompose-description", json={"description": "Build a chatbot"}
+        )
+
+    @pytest.mark.asyncio
+    async def test_decompose_goal_returns_clarifying_questions(self):
+        """Test decomposition returning clarifying questions."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "success": True,
+            "type": "clarifying_questions",
+            "questions": ["What platform?", "What language?"],
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.post.return_value = mock_response
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            result = await service.decompose_goal_external("Build something")
+
+        assert result == {
+            "type": "clarifying_questions",
+            "questions": ["What platform?", "What language?"],
+        }
+
+    @pytest.mark.asyncio
+    async def test_decompose_goal_with_context(self):
+        """Test decomposition with additional context."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "success": True,
+            "type": "instructions",
+            "steps": ["Step 1"],
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.post.return_value = mock_response
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            await service.decompose_goal_external(
+                "Build a chatbot", context="Use Python"
+            )
+
+        mock_client.post.assert_called_once_with(
+            "/api/decompose-description",
+            json={"description": "Build a chatbot", "user_instruction": "Use Python"},
+        )
+
+    @pytest.mark.asyncio
+    async def test_decompose_goal_returns_unachievable_goal(self):
+        """Test decomposition returning unachievable goal response."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "success": True,
+            "type": "unachievable_goal",
+            "reason": "Cannot do X",
+            "suggested_goal": "Try Y instead",
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.post.return_value = mock_response
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            result = await service.decompose_goal_external("Do something impossible")
+
+        assert result == {
+            "type": "unachievable_goal",
+            "reason": "Cannot do X",
+            "suggested_goal": "Try Y instead",
+        }
+
+    @pytest.mark.asyncio
+    async def test_decompose_goal_handles_http_error(self):
+        """Test decomposition handles HTTP errors gracefully."""
+        mock_client = AsyncMock()
+        mock_client.post.side_effect = httpx.HTTPStatusError(
+            "Server error", request=MagicMock(), response=MagicMock()
+        )
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            result = await service.decompose_goal_external("Build a chatbot")
+
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_decompose_goal_handles_request_error(self):
+        """Test decomposition handles request errors gracefully."""
+        mock_client = AsyncMock()
+        mock_client.post.side_effect = httpx.RequestError("Connection failed")
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            result = await service.decompose_goal_external("Build a chatbot")
+
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_decompose_goal_handles_service_error(self):
+        """Test decomposition handles service returning error."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "success": False,
+            "error": "Internal error",
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.post.return_value = mock_response
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            result = await service.decompose_goal_external("Build a chatbot")
+
+        assert result is None
+
+
+class TestGenerateAgentExternal:
+    """Test generate_agent_external function."""
+
+    def setup_method(self):
+        """Reset client singleton before each test."""
+        service._settings = None
+        service._client = None
+
+    @pytest.mark.asyncio
+    async def test_generate_agent_success(self):
+        """Test successful agent generation."""
+        agent_json = {
+            "name": "Test Agent",
+            "nodes": [],
+            "links": [],
+        }
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "success": True,
+            "agent_json": agent_json,
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.post.return_value = mock_response
+
+        instructions = {"type": "instructions", "steps": ["Step 1"]}
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            result = await service.generate_agent_external(instructions)
+
+        assert result == agent_json
+        mock_client.post.assert_called_once_with(
+            "/api/generate-agent", json={"instructions": instructions}
+        )
+
+    @pytest.mark.asyncio
+    async def test_generate_agent_handles_error(self):
+        """Test agent generation handles errors gracefully."""
+        mock_client = AsyncMock()
+        mock_client.post.side_effect = httpx.RequestError("Connection failed")
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            result = await service.generate_agent_external({"steps": []})
+
+        assert result is None
+
+
+class TestGenerateAgentPatchExternal:
+    """Test generate_agent_patch_external function."""
+
+    def setup_method(self):
+        """Reset client singleton before each test."""
+        service._settings = None
+        service._client = None
+
+    @pytest.mark.asyncio
+    async def test_generate_patch_returns_updated_agent(self):
+        """Test successful patch generation returning updated agent."""
+        updated_agent = {
+            "name": "Updated Agent",
+            "nodes": [{"id": "1", "block_id": "test"}],
+            "links": [],
+        }
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "success": True,
+            "agent_json": updated_agent,
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.post.return_value = mock_response
+
+        current_agent = {"name": "Old Agent", "nodes": [], "links": []}
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            result = await service.generate_agent_patch_external(
+                "Add a new node", current_agent
+            )
+
+        assert result == updated_agent
+        mock_client.post.assert_called_once_with(
+            "/api/update-agent",
+            json={
+                "update_request": "Add a new node",
+                "current_agent_json": current_agent,
+            },
+        )
+
+    @pytest.mark.asyncio
+    async def test_generate_patch_returns_clarifying_questions(self):
+        """Test patch generation returning clarifying questions."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "success": True,
+            "type": "clarifying_questions",
+            "questions": ["What type of node?"],
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.post.return_value = mock_response
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            result = await service.generate_agent_patch_external(
+                "Add something", {"nodes": []}
+            )
+
+        assert result == {
+            "type": "clarifying_questions",
+            "questions": ["What type of node?"],
+        }
+
+
+class TestHealthCheck:
+    """Test health_check function."""
+
+    def setup_method(self):
+        """Reset singletons before each test."""
+        service._settings = None
+        service._client = None
+
+    @pytest.mark.asyncio
+    async def test_health_check_returns_false_when_not_configured(self):
+        """Test health check returns False when service not configured."""
+        with patch.object(
+            service, "is_external_service_configured", return_value=False
+        ):
+            result = await service.health_check()
+            assert result is False
+
+    @pytest.mark.asyncio
+    async def test_health_check_returns_true_when_healthy(self):
+        """Test health check returns True when service is healthy."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "status": "healthy",
+            "blocks_loaded": True,
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.get.return_value = mock_response
+
+        with patch.object(service, "is_external_service_configured", return_value=True):
+            with patch.object(service, "_get_client", return_value=mock_client):
+                result = await service.health_check()
+
+        assert result is True
+        mock_client.get.assert_called_once_with("/health")
+
+    @pytest.mark.asyncio
+    async def test_health_check_returns_false_when_not_healthy(self):
+        """Test health check returns False when service is not healthy."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "status": "unhealthy",
+            "blocks_loaded": False,
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.get.return_value = mock_response
+
+        with patch.object(service, "is_external_service_configured", return_value=True):
+            with patch.object(service, "_get_client", return_value=mock_client):
+                result = await service.health_check()
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_health_check_returns_false_on_error(self):
+        """Test health check returns False on connection error."""
+        mock_client = AsyncMock()
+        mock_client.get.side_effect = httpx.RequestError("Connection failed")
+
+        with patch.object(service, "is_external_service_configured", return_value=True):
+            with patch.object(service, "_get_client", return_value=mock_client):
+                result = await service.health_check()
+
+        assert result is False
+
+
+class TestGetBlocksExternal:
+    """Test get_blocks_external function."""
+
+    def setup_method(self):
+        """Reset client singleton before each test."""
+        service._settings = None
+        service._client = None
+
+    @pytest.mark.asyncio
+    async def test_get_blocks_success(self):
+        """Test successful blocks retrieval."""
+        blocks = [
+            {"id": "block1", "name": "Block 1"},
+            {"id": "block2", "name": "Block 2"},
+        ]
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "success": True,
+            "blocks": blocks,
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.get.return_value = mock_response
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            result = await service.get_blocks_external()
+
+        assert result == blocks
+        mock_client.get.assert_called_once_with("/api/blocks")
+
+    @pytest.mark.asyncio
+    async def test_get_blocks_handles_error(self):
+        """Test blocks retrieval handles errors gracefully."""
+        mock_client = AsyncMock()
+        mock_client.get.side_effect = httpx.RequestError("Connection failed")
+
+        with patch.object(service, "_get_client", return_value=mock_client):
+            result = await service.get_blocks_external()
+
+        assert result is None
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -5082,301 +5082,6 @@
         }
       }
     },
-    "/api/store/admin/waitlist": {
-      "get": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "List All Waitlists",
-        "description": "Get all waitlists with admin details (admin only).\n\nReturns:\n    WaitlistAdminListResponse with all waitlists",
-        "operationId": "getV2List all waitlists",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminListResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          }
-        },
-        "security": [{ "HTTPBearerJWT": [] }]
-      },
-      "post": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Create Waitlist",
-        "description": "Create a new waitlist (admin only).\n\nArgs:\n    request: Waitlist creation details\n    user_id: Authenticated admin user creating the waitlist\n\nReturns:\n    WaitlistAdminResponse with the created waitlist details",
-        "operationId": "postV2Create waitlist",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": { "$ref": "#/components/schemas/WaitlistCreateRequest" }
-            }
-          },
-          "required": true
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        },
-        "security": [{ "HTTPBearerJWT": [] }]
-      }
-    },
-    "/api/store/admin/waitlist/{waitlist_id}": {
-      "delete": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Delete Waitlist",
-        "description": "Soft delete a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to delete\n\nReturns:\n    Success message",
-        "operationId": "deleteV2Delete waitlist",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": { "application/json": { "schema": {} } }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      },
-      "get": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Get Waitlist Details",
-        "description": "Get a single waitlist with admin details (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to retrieve\n\nReturns:\n    WaitlistAdminResponse with waitlist details",
-        "operationId": "getV2Get waitlist details",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      },
-      "put": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Update Waitlist",
-        "description": "Update a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist to update\n    request: Fields to update\n\nReturns:\n    WaitlistAdminResponse with updated waitlist details",
-        "operationId": "putV2Update waitlist",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": {
-              "schema": { "$ref": "#/components/schemas/WaitlistUpdateRequest" }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/store/admin/waitlist/{waitlist_id}/link": {
-      "post": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Link Waitlist to Store Listing",
-        "description": "Link a waitlist to a store listing (admin only).\n\nWhen the linked store listing is approved/published, waitlist users\nwill be automatically notified.\n\nArgs:\n    waitlist_id: ID of the waitlist\n    store_listing_id: ID of the store listing to link\n\nReturns:\n    WaitlistAdminResponse with updated waitlist details",
-        "operationId": "postV2Link waitlist to store listing",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/Body_postV2Link_waitlist_to_store_listing"
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistAdminResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/store/admin/waitlist/{waitlist_id}/signups": {
-      "get": {
-        "tags": ["v2", "admin", "store", "admin", "waitlist"],
-        "summary": "Get Waitlist Signups",
-        "description": "Get all signups for a waitlist (admin only).\n\nArgs:\n    waitlist_id: ID of the waitlist\n\nReturns:\n    WaitlistSignupListResponse with all signups",
-        "operationId": "getV2Get waitlist signups",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/WaitlistSignupListResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
     "/api/store/agents": {
       "get": {
         "tags": ["v2", "store", "public"],
@@ -6222,101 +5927,6 @@
         }
       }
     },
-    "/api/store/waitlist": {
-      "get": {
-        "tags": ["v2", "store", "public"],
-        "summary": "Get the agent waitlist",
-        "description": "Get all active waitlists for public display.",
-        "operationId": "getV2Get the agent waitlist",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/StoreWaitlistsAllResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/store/waitlist/my-memberships": {
-      "get": {
-        "tags": ["v2", "store", "private"],
-        "summary": "Get waitlist IDs the current user has joined",
-        "description": "Returns list of waitlist IDs the authenticated user has joined.",
-        "operationId": "getV2Get waitlist ids the current user has joined",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "items": { "type": "string" },
-                  "type": "array",
-                  "title": "Response Getv2Get Waitlist Ids The Current User Has Joined"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          }
-        },
-        "security": [{ "HTTPBearerJWT": [] }]
-      }
-    },
-    "/api/store/waitlist/{waitlist_id}/join": {
-      "post": {
-        "tags": ["v2", "store", "public"],
-        "summary": "Add self to the agent waitlist",
-        "description": "Add the current user to the agent waitlist.",
-        "operationId": "postV2Add self to the agent waitlist",
-        "security": [{ "HTTPBearer": [] }],
-        "parameters": [
-          {
-            "name": "waitlist_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "description": "The ID of the waitlist to join",
-              "title": "Waitlist Id"
-            },
-            "description": "The ID of the waitlist to join"
-          }
-        ],
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/Body_postV2Add_self_to_the_agent_waitlist"
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/StoreWaitlistEntry" }
-              }
-            }
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
     "/health": {
       "get": {
         "tags": ["health"],
@@ -6773,6 +6383,11 @@
             "title": "Has Human In The Loop",
             "readOnly": true
           },
+          "has_sensitive_action": {
+            "type": "boolean",
+            "title": "Has Sensitive Action",
+            "readOnly": true
+          },
           "trigger_setup_info": {
             "anyOf": [
               { "$ref": "#/components/schemas/GraphTriggerInfo" },
@@ -6789,6 +6404,7 @@
           "output_schema",
           "has_external_trigger",
           "has_human_in_the_loop",
+          "has_sensitive_action",
           "trigger_setup_info"
         ],
         "title": "BaseGraph"
@@ -7064,17 +6680,6 @@
         "required": ["store_listing_version_id"],
         "title": "Body_postV2Add marketplace agent"
       },
-      "Body_postV2Add_self_to_the_agent_waitlist": {
-        "properties": {
-          "email": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Email",
-            "description": "Email address for unauthenticated users"
-          }
-        },
-        "type": "object",
-        "title": "Body_postV2Add self to the agent waitlist"
-      },
       "Body_postV2Execute_a_preset": {
         "properties": {
           "inputs": {
@@ -7093,18 +6698,6 @@
         "type": "object",
         "title": "Body_postV2Execute a preset"
       },
-      "Body_postV2Link_waitlist_to_store_listing": {
-        "properties": {
-          "store_listing_id": {
-            "type": "string",
-            "title": "Store Listing Id",
-            "description": "The ID of the store listing"
-          }
-        },
-        "type": "object",
-        "required": ["store_listing_id"],
-        "title": "Body_postV2Link waitlist to store listing"
-      },
       "Body_postV2Upload_submission_media": {
         "properties": {
           "file": { "type": "string", "format": "binary", "title": "File" }
@@ -8042,6 +7635,11 @@
             "title": "Has Human In The Loop",
             "readOnly": true
           },
+          "has_sensitive_action": {
+            "type": "boolean",
+            "title": "Has Sensitive Action",
+            "readOnly": true
+          },
           "trigger_setup_info": {
             "anyOf": [
               { "$ref": "#/components/schemas/GraphTriggerInfo" },
@@ -8065,6 +7663,7 @@
           "output_schema",
           "has_external_trigger",
           "has_human_in_the_loop",
+          "has_sensitive_action",
           "trigger_setup_info",
           "credentials_input_schema"
         ],
@@ -8143,6 +7742,11 @@
             "title": "Has Human In The Loop",
             "readOnly": true
           },
+          "has_sensitive_action": {
+            "type": "boolean",
+            "title": "Has Sensitive Action",
+            "readOnly": true
+          },
           "trigger_setup_info": {
             "anyOf": [
               { "$ref": "#/components/schemas/GraphTriggerInfo" },
@@ -8167,6 +7771,7 @@
           "output_schema",
           "has_external_trigger",
           "has_human_in_the_loop",
+          "has_sensitive_action",
           "trigger_setup_info",
           "credentials_input_schema"
         ],
@@ -8175,8 +7780,14 @@
       "GraphSettings": {
         "properties": {
           "human_in_the_loop_safe_mode": {
-            "anyOf": [{ "type": "boolean" }, { "type": "null" }],
-            "title": "Human In The Loop Safe Mode"
+            "type": "boolean",
+            "title": "Human In The Loop Safe Mode",
+            "default": true
+          },
+          "sensitive_action_safe_mode": {
+            "type": "boolean",
+            "title": "Sensitive Action Safe Mode",
+            "default": false
           }
         },
         "type": "object",
@@ -8334,6 +7945,16 @@
             "title": "Has External Trigger",
             "description": "Whether the agent has an external trigger (e.g. webhook) node"
           },
+          "has_human_in_the_loop": {
+            "type": "boolean",
+            "title": "Has Human In The Loop",
+            "description": "Whether the agent has human-in-the-loop blocks"
+          },
+          "has_sensitive_action": {
+            "type": "boolean",
+            "title": "Has Sensitive Action",
+            "description": "Whether the agent has sensitive action blocks"
+          },
           "trigger_setup_info": {
             "anyOf": [
               { "$ref": "#/components/schemas/GraphTriggerInfo" },
@@ -8380,6 +8001,8 @@
           "output_schema",
           "credentials_input_schema",
           "has_external_trigger",
+          "has_human_in_the_loop",
+          "has_sensitive_action",
           "new_output",
           "can_access_graph",
           "is_latest_version",
@@ -8984,8 +8607,7 @@
           "REFUND_REQUEST",
           "REFUND_PROCESSED",
           "AGENT_APPROVED",
-          "AGENT_REJECTED",
-          "WAITLIST_LAUNCH"
+          "AGENT_REJECTED"
         ],
         "title": "NotificationType"
       },
@@ -10548,57 +10170,6 @@
         "required": ["submissions", "pagination"],
         "title": "StoreSubmissionsResponse"
       },
-      "StoreWaitlistEntry": {
-        "properties": {
-          "waitlistId": { "type": "string", "title": "Waitlistid" },
-          "slug": { "type": "string", "title": "Slug" },
-          "name": { "type": "string", "title": "Name" },
-          "subHeading": { "type": "string", "title": "Subheading" },
-          "videoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Videourl"
-          },
-          "agentOutputDemoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Agentoutputdemourl"
-          },
-          "imageUrls": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Imageurls"
-          },
-          "description": { "type": "string", "title": "Description" },
-          "categories": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Categories"
-          }
-        },
-        "type": "object",
-        "required": [
-          "waitlistId",
-          "slug",
-          "name",
-          "subHeading",
-          "imageUrls",
-          "description",
-          "categories"
-        ],
-        "title": "StoreWaitlistEntry",
-        "description": "Public waitlist entry - no PII fields exposed."
-      },
-      "StoreWaitlistsAllResponse": {
-        "properties": {
-          "listings": {
-            "items": { "$ref": "#/components/schemas/StoreWaitlistEntry" },
-            "type": "array",
-            "title": "Listings"
-          }
-        },
-        "type": "object",
-        "required": ["listings"],
-        "title": "StoreWaitlistsAllResponse"
-      },
       "StreamChatRequest": {
         "properties": {
           "message": { "type": "string", "title": "Message" },
@@ -12418,203 +11989,6 @@
         "required": ["loc", "msg", "type"],
         "title": "ValidationError"
       },
-      "WaitlistAdminListResponse": {
-        "properties": {
-          "waitlists": {
-            "items": { "$ref": "#/components/schemas/WaitlistAdminResponse" },
-            "type": "array",
-            "title": "Waitlists"
-          },
-          "totalCount": { "type": "integer", "title": "Totalcount" }
-        },
-        "type": "object",
-        "required": ["waitlists", "totalCount"],
-        "title": "WaitlistAdminListResponse",
-        "description": "Response model for listing all waitlists (admin view)."
-      },
-      "WaitlistAdminResponse": {
-        "properties": {
-          "id": { "type": "string", "title": "Id" },
-          "createdAt": { "type": "string", "title": "Createdat" },
-          "updatedAt": { "type": "string", "title": "Updatedat" },
-          "slug": { "type": "string", "title": "Slug" },
-          "name": { "type": "string", "title": "Name" },
-          "subHeading": { "type": "string", "title": "Subheading" },
-          "description": { "type": "string", "title": "Description" },
-          "categories": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Categories"
-          },
-          "imageUrls": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Imageurls"
-          },
-          "videoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Videourl"
-          },
-          "agentOutputDemoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Agentoutputdemourl"
-          },
-          "status": { "$ref": "#/components/schemas/WaitlistExternalStatus" },
-          "votes": { "type": "integer", "title": "Votes" },
-          "signupCount": { "type": "integer", "title": "Signupcount" },
-          "storeListingId": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Storelistingid"
-          },
-          "owningUserId": { "type": "string", "title": "Owninguserid" }
-        },
-        "type": "object",
-        "required": [
-          "id",
-          "createdAt",
-          "updatedAt",
-          "slug",
-          "name",
-          "subHeading",
-          "description",
-          "categories",
-          "imageUrls",
-          "status",
-          "votes",
-          "signupCount",
-          "owningUserId"
-        ],
-        "title": "WaitlistAdminResponse",
-        "description": "Admin response model with full waitlist details including internal data."
-      },
-      "WaitlistCreateRequest": {
-        "properties": {
-          "name": { "type": "string", "title": "Name" },
-          "slug": { "type": "string", "title": "Slug" },
-          "subHeading": { "type": "string", "title": "Subheading" },
-          "description": { "type": "string", "title": "Description" },
-          "categories": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Categories",
-            "default": []
-          },
-          "imageUrls": {
-            "items": { "type": "string" },
-            "type": "array",
-            "title": "Imageurls",
-            "default": []
-          },
-          "videoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Videourl"
-          },
-          "agentOutputDemoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Agentoutputdemourl"
-          }
-        },
-        "type": "object",
-        "required": ["name", "slug", "subHeading", "description"],
-        "title": "WaitlistCreateRequest",
-        "description": "Request model for creating a new waitlist."
-      },
-      "WaitlistExternalStatus": {
-        "type": "string",
-        "enum": ["DONE", "NOT_STARTED", "CANCELED", "WORK_IN_PROGRESS"],
-        "title": "WaitlistExternalStatus"
-      },
-      "WaitlistSignup": {
-        "properties": {
-          "type": { "type": "string", "title": "Type" },
-          "userId": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Userid"
-          },
-          "email": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Email"
-          },
-          "username": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Username"
-          }
-        },
-        "type": "object",
-        "required": ["type"],
-        "title": "WaitlistSignup",
-        "description": "Individual signup entry for a waitlist."
-      },
-      "WaitlistSignupListResponse": {
-        "properties": {
-          "waitlistId": { "type": "string", "title": "Waitlistid" },
-          "signups": {
-            "items": { "$ref": "#/components/schemas/WaitlistSignup" },
-            "type": "array",
-            "title": "Signups"
-          },
-          "totalCount": { "type": "integer", "title": "Totalcount" }
-        },
-        "type": "object",
-        "required": ["waitlistId", "signups", "totalCount"],
-        "title": "WaitlistSignupListResponse",
-        "description": "Response model for listing waitlist signups."
-      },
-      "WaitlistUpdateRequest": {
-        "properties": {
-          "name": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Name"
-          },
-          "slug": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Slug"
-          },
-          "subHeading": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Subheading"
-          },
-          "description": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Description"
-          },
-          "categories": {
-            "anyOf": [
-              { "items": { "type": "string" }, "type": "array" },
-              { "type": "null" }
-            ],
-            "title": "Categories"
-          },
-          "imageUrls": {
-            "anyOf": [
-              { "items": { "type": "string" }, "type": "array" },
-              { "type": "null" }
-            ],
-            "title": "Imageurls"
-          },
-          "videoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Videourl"
-          },
-          "agentOutputDemoUrl": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Agentoutputdemourl"
-          },
-          "status": {
-            "anyOf": [
-              { "$ref": "#/components/schemas/WaitlistExternalStatus" },
-              { "type": "null" }
-            ]
-          },
-          "storeListingId": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Storelistingid"
-          }
-        },
-        "type": "object",
-        "title": "WaitlistUpdateRequest",
-        "description": "Request model for updating a waitlist."
-      },
       "Webhook": {
         "properties": {
           "id": { "type": "string", "title": "Id" },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

autogpt_platform/frontend/src/hooks/useAgentSafeMode.ts

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

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

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

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

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