fix: correct library agent link path from /library to /library/agents

The "View in Library" link was returning 404 because the path was
missing the /agents/ segment. Fixed in both create_agent.py and
edit_agent.py to match the correct route used elsewhere.

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

@@ -1834,6 +1834,11 @@ async def _execute_long_running_tool(
             tool_call_id=tool_call_id,
             result=error_response.model_dump_json(),
         )
+        # Generate LLM continuation so user sees explanation even for errors
+        try:
+            await _generate_llm_continuation(session_id=session_id, user_id=user_id)
+        except Exception as llm_err:
+            logger.warning(f"Failed to generate LLM continuation for error: {llm_err}")
     finally:
         await _mark_operation_completed(tool_call_id)
 

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

@@ -2,30 +2,52 @@
 
 from .core import (
     AgentGeneratorNotConfiguredError,
+    AgentSummary,
+    DecompositionResult,
+    DecompositionStep,
+    LibraryAgentSummary,
+    MarketplaceAgentSummary,
     decompose_goal,
+    enrich_library_agents_from_steps,
+    extract_search_terms_from_steps,
+    extract_uuids_from_text,
     generate_agent,
     generate_agent_patch,
     get_agent_as_json,
+    get_all_relevant_agents_for_generation,
+    get_library_agent_by_graph_id,
+    get_library_agent_by_id,
+    get_library_agents_for_generation,
     json_to_graph,
     save_agent_to_library,
+    search_marketplace_agents_for_generation,
 )
 from .errors import get_user_message_for_error
 from .service import health_check as check_external_service_health
 from .service import is_external_service_configured
 
 __all__ = [
-    # Core functions
+    "AgentGeneratorNotConfiguredError",
+    "AgentSummary",
+    "DecompositionResult",
+    "DecompositionStep",
+    "LibraryAgentSummary",
+    "MarketplaceAgentSummary",
+    "check_external_service_health",
     "decompose_goal",
+    "enrich_library_agents_from_steps",
+    "extract_search_terms_from_steps",
+    "extract_uuids_from_text",
     "generate_agent",
     "generate_agent_patch",
-    "save_agent_to_library",
     "get_agent_as_json",
-    "json_to_graph",
-    # Exceptions
-    "AgentGeneratorNotConfiguredError",
-    # Service
-    "is_external_service_configured",
-    "check_external_service_health",
-    # Error handling
+    "get_all_relevant_agents_for_generation",
+    "get_library_agent_by_graph_id",
+    "get_library_agent_by_id",
+    "get_library_agents_for_generation",
     "get_user_message_for_error",
+    "is_external_service_configured",
+    "json_to_graph",
+    "save_agent_to_library",
+    "search_marketplace_agents_for_generation",
 ]

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

@@ -1,11 +1,21 @@
 """Core agent generation functions."""
 
 import logging
+import re
 import uuid
-from typing import Any
+from typing import Any, TypedDict
 
 from backend.api.features.library import db as library_db
-from backend.data.graph import Graph, Link, Node, create_graph
+from backend.api.features.store import db as store_db
+from backend.data.graph import (
+    Graph,
+    Link,
+    Node,
+    create_graph,
+    get_graph,
+    get_graph_all_versions,
+)
+from backend.util.exceptions import NotFoundError
 
 from .service import (
     decompose_goal_external,
@@ -17,6 +27,60 @@ from .service import (
 logger = logging.getLogger(__name__)
 
 
+class LibraryAgentSummary(TypedDict):
+    """Summary of a library agent for sub-agent composition."""
+
+    graph_id: str
+    graph_version: int
+    name: str
+    description: str
+    input_schema: dict[str, Any]
+    output_schema: dict[str, Any]
+
+
+class MarketplaceAgentSummary(TypedDict):
+    """Summary of a marketplace agent for sub-agent composition."""
+
+    name: str
+    description: str
+    sub_heading: str
+    creator: str
+    is_marketplace_agent: bool
+
+
+class DecompositionStep(TypedDict, total=False):
+    """A single step in decomposed instructions."""
+
+    description: str
+    action: str
+    block_name: str
+    tool: str
+    name: str
+
+
+class DecompositionResult(TypedDict, total=False):
+    """Result from decompose_goal - can be instructions, questions, or error."""
+
+    type: str  # "instructions", "clarifying_questions", "error", etc.
+    steps: list[DecompositionStep]
+    questions: list[dict[str, Any]]
+    error: str
+    error_type: str
+
+
+# Type alias for agent summaries (can be either library or marketplace)
+AgentSummary = LibraryAgentSummary | MarketplaceAgentSummary | dict[str, Any]
+
+
+def _to_dict_list(
+    agents: list[AgentSummary] | list[dict[str, Any]] | None,
+) -> list[dict[str, Any]] | None:
+    """Convert typed agent summaries to plain dicts for external service calls."""
+    if agents is None:
+        return None
+    return [dict(a) for a in agents]
+
+
 class AgentGeneratorNotConfiguredError(Exception):
     """Raised when the external Agent Generator service is not configured."""
 
@@ -36,15 +100,382 @@ def _check_service_configured() -> None:
         )
 
 
-async def decompose_goal(description: str, context: str = "") -> dict[str, Any] | None:
+_UUID_PATTERN = 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}",
+    re.IGNORECASE,
+)
+
+
+def extract_uuids_from_text(text: str) -> list[str]:
+    """Extract all UUID v4 strings from text.
+
+    Args:
+        text: Text that may contain UUIDs (e.g., user's goal description)
+
+    Returns:
+        List of unique UUIDs found in the text (lowercase)
+    """
+    matches = _UUID_PATTERN.findall(text)
+    return list({m.lower() for m in matches})
+
+
+async def get_library_agent_by_id(
+    user_id: str, agent_id: str
+) -> LibraryAgentSummary | None:
+    """Fetch a specific library agent by its ID (library agent ID or graph_id).
+
+    This function tries multiple lookup strategies:
+    1. First tries to find by graph_id (AgentGraph primary key)
+    2. If not found, tries to find by library agent ID (LibraryAgent primary key)
+
+    This handles both cases:
+    - User provides graph_id (e.g., from AgentExecutorBlock)
+    - User provides library agent ID (e.g., from library URL)
+
+    Args:
+        user_id: The user ID
+        agent_id: The ID to look up (can be graph_id or library agent ID)
+
+    Returns:
+        LibraryAgentSummary if found, None otherwise
+    """
+    try:
+        agent = await library_db.get_library_agent_by_graph_id(user_id, agent_id)
+        if agent:
+            logger.debug(f"Found library agent by graph_id: {agent.name}")
+            return LibraryAgentSummary(
+                graph_id=agent.graph_id,
+                graph_version=agent.graph_version,
+                name=agent.name,
+                description=agent.description,
+                input_schema=agent.input_schema,
+                output_schema=agent.output_schema,
+            )
+    except Exception as e:
+        logger.debug(f"Could not fetch library agent by graph_id {agent_id}: {e}")
+
+    try:
+        agent = await library_db.get_library_agent(agent_id, user_id)
+        if agent:
+            logger.debug(f"Found library agent by library_id: {agent.name}")
+            return LibraryAgentSummary(
+                graph_id=agent.graph_id,
+                graph_version=agent.graph_version,
+                name=agent.name,
+                description=agent.description,
+                input_schema=agent.input_schema,
+                output_schema=agent.output_schema,
+            )
+    except NotFoundError:
+        logger.debug(f"Library agent not found by library_id: {agent_id}")
+    except Exception as e:
+        logger.debug(f"Could not fetch library agent by library_id {agent_id}: {e}")
+
+    return None
+
+
+# Alias for backward compatibility
+get_library_agent_by_graph_id = get_library_agent_by_id
+
+
+async def get_library_agents_for_generation(
+    user_id: str,
+    search_query: str | None = None,
+    exclude_graph_id: str | None = None,
+    max_results: int = 15,
+) -> list[LibraryAgentSummary]:
+    """Fetch user's library agents formatted for Agent Generator.
+
+    Uses search-based fetching to return relevant agents instead of all agents.
+    This is more scalable for users with large libraries.
+
+    Args:
+        user_id: The user ID
+        search_query: Optional search term to find relevant agents (user's goal/description)
+        exclude_graph_id: Optional graph ID to exclude (prevents circular references)
+        max_results: Maximum number of agents to return (default 15)
+
+    Returns:
+        List of LibraryAgentSummary with schemas for sub-agent composition
+    """
+    try:
+        response = await library_db.list_library_agents(
+            user_id=user_id,
+            search_term=search_query,
+            page=1,
+            page_size=max_results,
+        )
+
+        results: list[LibraryAgentSummary] = []
+        for agent in response.agents:
+            # Exclude the agent being generated/edited to prevent circular references
+            if exclude_graph_id is not None and agent.graph_id == exclude_graph_id:
+                continue
+
+            results.append(
+                LibraryAgentSummary(
+                    graph_id=agent.graph_id,
+                    graph_version=agent.graph_version,
+                    name=agent.name,
+                    description=agent.description,
+                    input_schema=agent.input_schema,
+                    output_schema=agent.output_schema,
+                )
+            )
+        return results
+    except Exception as e:
+        logger.warning(f"Failed to fetch library agents: {e}")
+        return []
+
+
+async def search_marketplace_agents_for_generation(
+    search_query: str,
+    max_results: int = 10,
+) -> list[MarketplaceAgentSummary]:
+    """Search marketplace agents formatted for Agent Generator.
+
+    Note: This returns basic agent info. Full input/output schemas would require
+    additional graph fetches and is a potential future enhancement.
+
+    Args:
+        search_query: Search term to find relevant public agents
+        max_results: Maximum number of agents to return (default 10)
+
+    Returns:
+        List of MarketplaceAgentSummary (without detailed schemas for now)
+    """
+    try:
+        response = await store_db.get_store_agents(
+            search_query=search_query,
+            page=1,
+            page_size=max_results,
+        )
+
+        results: list[MarketplaceAgentSummary] = []
+        for agent in response.agents:
+            results.append(
+                MarketplaceAgentSummary(
+                    name=agent.agent_name,
+                    description=agent.description,
+                    sub_heading=agent.sub_heading,
+                    creator=agent.creator,
+                    is_marketplace_agent=True,
+                )
+            )
+        return results
+    except Exception as e:
+        logger.warning(f"Failed to search marketplace agents: {e}")
+        return []
+
+
+async def get_all_relevant_agents_for_generation(
+    user_id: str,
+    search_query: str | None = None,
+    exclude_graph_id: str | None = None,
+    include_marketplace: bool = True,
+    max_library_results: int = 15,
+    max_marketplace_results: int = 10,
+) -> list[AgentSummary]:
+    """Fetch relevant agents from library and optionally marketplace.
+
+    Combines search results from user's library and public marketplace,
+    with library agents taking priority (they have full schemas).
+
+    Also extracts UUIDs from the search_query and fetches those agents
+    directly to ensure explicitly referenced agents are included.
+
+    Args:
+        user_id: The user ID
+        search_query: Search term to find relevant agents (user's goal/description)
+        exclude_graph_id: Optional graph ID to exclude (prevents circular references)
+        include_marketplace: Whether to also search marketplace (default True)
+        max_library_results: Max library agents to return (default 15)
+        max_marketplace_results: Max marketplace agents to return (default 10)
+
+    Returns:
+        List of AgentSummary, library agents first (with full schemas),
+        then marketplace agents (basic info only)
+    """
+    agents: list[AgentSummary] = []
+    seen_graph_ids: set[str] = set()
+
+    if search_query:
+        mentioned_uuids = extract_uuids_from_text(search_query)
+        for graph_id in mentioned_uuids:
+            if graph_id == exclude_graph_id:
+                continue
+            agent = await get_library_agent_by_graph_id(user_id, graph_id)
+            if agent and agent["graph_id"] not in seen_graph_ids:
+                agents.append(agent)
+                seen_graph_ids.add(agent["graph_id"])
+                logger.debug(f"Found explicitly mentioned agent: {agent['name']}")
+
+    library_agents = await get_library_agents_for_generation(
+        user_id=user_id,
+        search_query=search_query,
+        exclude_graph_id=exclude_graph_id,
+        max_results=max_library_results,
+    )
+    for agent in library_agents:
+        if agent["graph_id"] not in seen_graph_ids:
+            agents.append(agent)
+            seen_graph_ids.add(agent["graph_id"])
+
+    if include_marketplace and search_query:
+        marketplace_agents = await search_marketplace_agents_for_generation(
+            search_query=search_query,
+            max_results=max_marketplace_results,
+        )
+        library_names = {a["name"].lower() for a in agents if a.get("name")}
+        for agent in marketplace_agents:
+            agent_name = agent.get("name")
+            if agent_name and agent_name.lower() not in library_names:
+                agents.append(agent)
+
+    return agents
+
+
+def extract_search_terms_from_steps(
+    decomposition_result: DecompositionResult | dict[str, Any],
+) -> list[str]:
+    """Extract search terms from decomposed instruction steps.
+
+    Analyzes the decomposition result to extract relevant keywords
+    for additional library agent searches.
+
+    Args:
+        decomposition_result: Result from decompose_goal containing steps
+
+    Returns:
+        List of unique search terms extracted from steps
+    """
+    search_terms: list[str] = []
+
+    if decomposition_result.get("type") != "instructions":
+        return search_terms
+
+    steps = decomposition_result.get("steps", [])
+    if not steps:
+        return search_terms
+
+    step_keys: list[str] = ["description", "action", "block_name", "tool", "name"]
+
+    for step in steps:
+        for key in step_keys:
+            value = step.get(key)  # type: ignore[union-attr]
+            if isinstance(value, str) and len(value) > 3:
+                search_terms.append(value)
+
+    seen: set[str] = set()
+    unique_terms: list[str] = []
+    for term in search_terms:
+        term_lower = term.lower()
+        if term_lower not in seen:
+            seen.add(term_lower)
+            unique_terms.append(term)
+
+    return unique_terms
+
+
+async def enrich_library_agents_from_steps(
+    user_id: str,
+    decomposition_result: DecompositionResult | dict[str, Any],
+    existing_agents: list[AgentSummary] | list[dict[str, Any]],
+    exclude_graph_id: str | None = None,
+    include_marketplace: bool = True,
+    max_additional_results: int = 10,
+) -> list[AgentSummary] | list[dict[str, Any]]:
+    """Enrich library agents list with additional searches based on decomposed steps.
+
+    This implements two-phase search: after decomposition, we search for additional
+    relevant agents based on the specific steps identified.
+
+    Args:
+        user_id: The user ID
+        decomposition_result: Result from decompose_goal containing steps
+        existing_agents: Already fetched library agents from initial search
+        exclude_graph_id: Optional graph ID to exclude
+        include_marketplace: Whether to also search marketplace
+        max_additional_results: Max additional agents per search term (default 10)
+
+    Returns:
+        Combined list of library agents (existing + newly discovered)
+    """
+    # Extract search terms from steps
+    search_terms = extract_search_terms_from_steps(decomposition_result)
+
+    if not search_terms:
+        return existing_agents
+
+    existing_ids: set[str] = set()
+    existing_names: set[str] = set()
+
+    for agent in existing_agents:
+        agent_name = agent.get("name", "")
+        if agent_name:
+            existing_names.add(agent_name.lower())
+        graph_id = agent.get("graph_id")  # type: ignore[call-overload]
+        if graph_id:
+            existing_ids.add(graph_id)
+
+    all_agents: list[AgentSummary] | list[dict[str, Any]] = list(existing_agents)
+
+    for term in search_terms[:3]:
+        try:
+            additional_agents = await get_all_relevant_agents_for_generation(
+                user_id=user_id,
+                search_query=term,
+                exclude_graph_id=exclude_graph_id,
+                include_marketplace=include_marketplace,
+                max_library_results=max_additional_results,
+                max_marketplace_results=5,
+            )
+
+            for agent in additional_agents:
+                agent_name = agent.get("name", "")
+                if not agent_name:
+                    continue
+                agent_name_lower = agent_name.lower()
+
+                if agent_name_lower in existing_names:
+                    continue
+
+                graph_id = agent.get("graph_id")  # type: ignore[call-overload]
+                if graph_id and graph_id in existing_ids:
+                    continue
+
+                all_agents.append(agent)
+                existing_names.add(agent_name_lower)
+                if graph_id:
+                    existing_ids.add(graph_id)
+
+        except Exception as e:
+            logger.warning(
+                f"Failed to search for additional agents with term '{term}': {e}"
+            )
+
+    logger.debug(
+        f"Enriched library agents: {len(existing_agents)} initial + "
+        f"{len(all_agents) - len(existing_agents)} additional = {len(all_agents)} total"
+    )
+
+    return all_agents
+
+
+async def decompose_goal(
+    description: str,
+    context: str = "",
+    library_agents: list[AgentSummary] | None = None,
+) -> DecompositionResult | None:
     """Break down a goal into steps or return clarifying questions.
 
     Args:
         description: Natural language goal description
         context: Additional context (e.g., answers to previous questions)
+        library_agents: User's library agents available for sub-agent composition
 
     Returns:
-        Dict with either:
+        DecompositionResult with either:
         - {"type": "clarifying_questions", "questions": [...]}
         - {"type": "instructions", "steps": [...]}
         Or None on error
@@ -54,14 +485,23 @@ async def decompose_goal(description: str, context: str = "") -> dict[str, Any]
     """
     _check_service_configured()
     logger.info("Calling external Agent Generator service for decompose_goal")
-    return await decompose_goal_external(description, context)
+    # Convert typed dicts to plain dicts for external service
+    result = await decompose_goal_external(
+        description, context, _to_dict_list(library_agents)
+    )
+    # Cast the result to DecompositionResult (external service returns dict)
+    return result  # type: ignore[return-value]
 
 
-async def generate_agent(instructions: dict[str, Any]) -> dict[str, Any] | None:
+async def generate_agent(
+    instructions: DecompositionResult | dict[str, Any],
+    library_agents: list[AgentSummary] | list[dict[str, Any]] | None = None,
+) -> dict[str, Any] | None:
     """Generate agent JSON from instructions.
 
     Args:
         instructions: Structured instructions from decompose_goal
+        library_agents: User's library agents available for sub-agent composition
 
     Returns:
         Agent JSON dict, error dict {"type": "error", ...}, or None on error
@@ -71,7 +511,10 @@ async def generate_agent(instructions: dict[str, Any]) -> dict[str, Any] | None:
     """
     _check_service_configured()
     logger.info("Calling external Agent Generator service for generate_agent")
-    result = await generate_agent_external(instructions)
+    # Convert typed dicts to plain dicts for external service
+    result = await generate_agent_external(
+        dict(instructions), _to_dict_list(library_agents)
+    )
     if result:
         # Check if it's an error response - pass through as-is
         if isinstance(result, dict) and result.get("type") == "error":
@@ -162,8 +605,6 @@ async def save_agent_to_library(
     Returns:
         Tuple of (created Graph, LibraryAgent)
     """
-    from backend.data.graph import get_graph_all_versions
-
     graph = json_to_graph(agent_json)
 
     if is_update:
@@ -200,21 +641,28 @@ async def save_agent_to_library(
 
 
 async def get_agent_as_json(
-    graph_id: str, user_id: str | None
+    agent_id: str, user_id: str | None
 ) -> dict[str, Any] | None:
     """Fetch an agent and convert to JSON format for editing.
 
     Args:
-        graph_id: Graph ID or library agent ID
+        agent_id: Graph ID or library agent ID
         user_id: User ID
 
     Returns:
         Agent as JSON dict or None if not found
     """
-    from backend.data.graph import get_graph
+    graph = await get_graph(agent_id, version=None, user_id=user_id)
+
+    if not graph and user_id:
+        try:
+            library_agent = await library_db.get_library_agent(agent_id, user_id)
+            graph = await get_graph(
+                library_agent.graph_id, version=None, user_id=user_id
+            )
+        except NotFoundError:
+            pass
 
-    # Try to get the graph (version=None gets the active version)
-    graph = await get_graph(graph_id, version=None, user_id=user_id)
     if not graph:
         return None
 
@@ -256,7 +704,9 @@ async def get_agent_as_json(
 
 
 async def generate_agent_patch(
-    update_request: str, current_agent: dict[str, Any]
+    update_request: str,
+    current_agent: dict[str, Any],
+    library_agents: list[AgentSummary] | None = None,
 ) -> dict[str, Any] | None:
     """Update an existing agent using natural language.
 
@@ -268,6 +718,7 @@ async def generate_agent_patch(
     Args:
         update_request: Natural language description of changes
         current_agent: Current agent JSON
+        library_agents: User's library agents available for sub-agent composition
 
     Returns:
         Updated agent JSON, clarifying questions dict {"type": "clarifying_questions", ...},
@@ -278,4 +729,7 @@ async def generate_agent_patch(
     """
     _check_service_configured()
     logger.info("Calling external Agent Generator service for generate_agent_patch")
-    return await generate_agent_patch_external(update_request, current_agent)
+    # Convert typed dicts to plain dicts for external service
+    return await generate_agent_patch_external(
+        update_request, current_agent, _to_dict_list(library_agents)
+    )

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

@@ -6,6 +6,7 @@ def get_user_message_for_error(
     operation: str = "process the request",
     llm_parse_message: str | None = None,
     validation_message: str | None = None,
+    error_details: str | None = None,
 ) -> str:
     """Get a user-friendly error message based on error type.
 
@@ -19,25 +20,47 @@ def get_user_message_for_error(
             message (e.g., "analyze the goal", "generate the agent")
         llm_parse_message: Custom message for llm_parse_error type
         validation_message: Custom message for validation_error type
+        error_details: Optional additional details about the error
 
     Returns:
         User-friendly error message suitable for display to the user
     """
+    base_message = ""
+
     if error_type == "llm_parse_error":
-        return (
+        base_message = (
             llm_parse_message
             or "The AI had trouble processing this request. Please try again."
         )
     elif error_type == "validation_error":
-        return (
+        base_message = (
             validation_message
-            or "The request failed validation. Please try rephrasing."
+            or "The generated agent failed validation. "
+            "This usually happens when the agent structure doesn't match "
+            "what the platform expects. Please try simplifying your goal "
+            "or breaking it into smaller parts."
         )
     elif error_type == "patch_error":
-        return "Failed to apply the changes. Please try a different approach."
+        base_message = (
+            "Failed to apply the changes. The modification couldn't be "
+            "validated. Please try a different approach or simplify the change."
+        )
     elif error_type in ("timeout", "llm_timeout"):
-        return "The request took too long. Please try again."
+        base_message = (
+            "The request took too long to process. This can happen with "
+            "complex agents. Please try again or simplify your goal."
+        )
     elif error_type in ("rate_limit", "llm_rate_limit"):
-        return "The service is currently busy. Please try again in a moment."
+        base_message = "The service is currently busy. Please try again in a moment."
     else:
-        return f"Failed to {operation}. Please try again."
+        base_message = f"Failed to {operation}. Please try again."
+
+    # Add error details if provided (for debugging, truncated)
+    if error_details:
+        # Truncate long error details
+        details = (
+            error_details[:200] + "..." if len(error_details) > 200 else error_details
+        )
+        base_message += f"\n\nTechnical details: {details}"
+
+    return base_message

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

@@ -117,13 +117,16 @@ def _get_client() -> httpx.AsyncClient:
 
 
 async def decompose_goal_external(
-    description: str, context: str = ""
+    description: str,
+    context: str = "",
+    library_agents: list[dict[str, Any]] | None = None,
 ) -> 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)
+        library_agents: User's library agents available for sub-agent composition
 
     Returns:
         Dict with either:
@@ -141,6 +144,8 @@ async def decompose_goal_external(
     if context:
         # The external service uses user_instruction for additional context
         payload["user_instruction"] = context
+    if library_agents:
+        payload["library_agents"] = library_agents
 
     try:
         response = await client.post("/api/decompose-description", json=payload)
@@ -207,21 +212,25 @@ async def decompose_goal_external(
 
 async def generate_agent_external(
     instructions: dict[str, Any],
+    library_agents: list[dict[str, Any]] | None = None,
 ) -> dict[str, Any] | None:
     """Call the external service to generate an agent from instructions.
 
     Args:
         instructions: Structured instructions from decompose_goal
+        library_agents: User's library agents available for sub-agent composition
 
     Returns:
         Agent JSON dict on success, or error dict {"type": "error", ...} on error
     """
     client = _get_client()
 
+    payload: dict[str, Any] = {"instructions": instructions}
+    if library_agents:
+        payload["library_agents"] = library_agents
+
     try:
-        response = await client.post(
-            "/api/generate-agent", json={"instructions": instructions}
-        )
+        response = await client.post("/api/generate-agent", json=payload)
         response.raise_for_status()
         data = response.json()
 
@@ -251,27 +260,31 @@ async def generate_agent_external(
 
 
 async def generate_agent_patch_external(
-    update_request: str, current_agent: dict[str, Any]
+    update_request: str,
+    current_agent: dict[str, Any],
+    library_agents: list[dict[str, Any]] | None = None,
 ) -> 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
+        library_agents: User's library agents available for sub-agent composition
 
     Returns:
         Updated agent JSON, clarifying questions dict, or error dict on error
     """
     client = _get_client()
 
+    payload: dict[str, Any] = {
+        "update_request": update_request,
+        "current_agent_json": current_agent,
+    }
+    if library_agents:
+        payload["library_agents"] = library_agents
+
     try:
-        response = await client.post(
-            "/api/update-agent",
-            json={
-                "update_request": update_request,
-                "current_agent_json": current_agent,
-            },
-        )
+        response = await client.post("/api/update-agent", json=payload)
         response.raise_for_status()
         data = response.json()
 

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

@@ -1,6 +1,7 @@
 """Shared agent search functionality for find_agent and find_library_agent tools."""
 
 import logging
+import re
 from typing import Literal
 
 from backend.api.features.library import db as library_db
@@ -19,6 +20,86 @@ logger = logging.getLogger(__name__)
 
 SearchSource = Literal["marketplace", "library"]
 
+# UUID v4 pattern for direct agent ID lookup
+_UUID_PATTERN = 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}$",
+    re.IGNORECASE,
+)
+
+
+def _is_uuid(text: str) -> bool:
+    """Check if text is a valid UUID v4."""
+    return bool(_UUID_PATTERN.match(text.strip()))
+
+
+async def _get_library_agent_by_id(user_id: str, agent_id: str) -> AgentInfo | None:
+    """Fetch a library agent by ID (library agent ID or graph_id).
+
+    Tries multiple lookup strategies:
+    1. First by graph_id (AgentGraph primary key)
+    2. Then by library agent ID (LibraryAgent primary key)
+
+    Args:
+        user_id: The user ID
+        agent_id: The ID to look up (can be graph_id or library agent ID)
+
+    Returns:
+        AgentInfo if found, None otherwise
+    """
+    try:
+        agent = await library_db.get_library_agent_by_graph_id(user_id, agent_id)
+        if agent:
+            logger.debug(f"Found library agent by graph_id: {agent.name}")
+            return AgentInfo(
+                id=agent.id,
+                name=agent.name,
+                description=agent.description or "",
+                source="library",
+                in_library=True,
+                creator=agent.creator_name,
+                status=agent.status.value,
+                can_access_graph=agent.can_access_graph,
+                has_external_trigger=agent.has_external_trigger,
+                new_output=agent.new_output,
+                graph_id=agent.graph_id,
+            )
+    except DatabaseError:
+        raise
+    except Exception as e:
+        logger.warning(
+            f"Could not fetch library agent by graph_id {agent_id}: {e}",
+            exc_info=True,
+        )
+
+    try:
+        agent = await library_db.get_library_agent(agent_id, user_id)
+        if agent:
+            logger.debug(f"Found library agent by library_id: {agent.name}")
+            return AgentInfo(
+                id=agent.id,
+                name=agent.name,
+                description=agent.description or "",
+                source="library",
+                in_library=True,
+                creator=agent.creator_name,
+                status=agent.status.value,
+                can_access_graph=agent.can_access_graph,
+                has_external_trigger=agent.has_external_trigger,
+                new_output=agent.new_output,
+                graph_id=agent.graph_id,
+            )
+    except NotFoundError:
+        logger.debug(f"Library agent not found by library_id: {agent_id}")
+    except DatabaseError:
+        raise
+    except Exception as e:
+        logger.warning(
+            f"Could not fetch library agent by library_id {agent_id}: {e}",
+            exc_info=True,
+        )
+
+    return None
+
 
 async def search_agents(
     query: str,
@@ -70,28 +151,38 @@ async def search_agents(
                     )
                 )
         else:  # library
-            logger.info(f"Searching user library for: {query}")
-            results = await library_db.list_library_agents(
-                user_id=user_id,  # type: ignore[arg-type]
-                search_term=query,
-                page_size=10,
-            )
-            for agent in results.agents:
-                agents.append(
-                    AgentInfo(
-                        id=agent.id,
-                        name=agent.name,
-                        description=agent.description or "",
-                        source="library",
-                        in_library=True,
-                        creator=agent.creator_name,
-                        status=agent.status.value,
-                        can_access_graph=agent.can_access_graph,
-                        has_external_trigger=agent.has_external_trigger,
-                        new_output=agent.new_output,
-                        graph_id=agent.graph_id,
-                    )
+            # If query looks like a UUID, try direct lookup first
+            if _is_uuid(query):
+                logger.info(f"Query looks like UUID, trying direct lookup: {query}")
+                agent = await _get_library_agent_by_id(user_id, query)  # type: ignore[arg-type]
+                if agent:
+                    agents.append(agent)
+                    logger.info(f"Found agent by direct ID lookup: {agent.name}")
+
+            # If no results from UUID lookup, do text search
+            if not agents:
+                logger.info(f"Searching user library for: {query}")
+                results = await library_db.list_library_agents(
+                    user_id=user_id,  # type: ignore[arg-type]
+                    search_term=query,
+                    page_size=10,
                 )
+                for agent in results.agents:
+                    agents.append(
+                        AgentInfo(
+                            id=agent.id,
+                            name=agent.name,
+                            description=agent.description or "",
+                            source="library",
+                            in_library=True,
+                            creator=agent.creator_name,
+                            status=agent.status.value,
+                            can_access_graph=agent.can_access_graph,
+                            has_external_trigger=agent.has_external_trigger,
+                            new_output=agent.new_output,
+                            graph_id=agent.graph_id,
+                        )
+                    )
         logger.info(f"Found {len(agents)} agents in {source}")
     except NotFoundError:
         pass

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

@@ -8,7 +8,9 @@ from backend.api.features.chat.model import ChatSession
 from .agent_generator import (
     AgentGeneratorNotConfiguredError,
     decompose_goal,
+    enrich_library_agents_from_steps,
     generate_agent,
+    get_all_relevant_agents_for_generation,
     get_user_message_for_error,
     save_agent_to_library,
 )
@@ -103,9 +105,27 @@ class CreateAgentTool(BaseTool):
                 session_id=session_id,
             )
 
+        # Fetch relevant library and marketplace agents for sub-agent composition
+        library_agents = None
+        if user_id:
+            try:
+                library_agents = await get_all_relevant_agents_for_generation(
+                    user_id=user_id,
+                    search_query=description,  # Use goal as search term
+                    include_marketplace=True,
+                )
+                logger.debug(
+                    f"Found {len(library_agents)} relevant agents for sub-agent composition"
+                )
+            except Exception as e:
+                # Log but don't fail - agent generation can work without sub-agents
+                logger.warning(f"Failed to fetch library agents: {e}")
+
         # Step 1: Decompose goal into steps
         try:
-            decomposition_result = await decompose_goal(description, context)
+            decomposition_result = await decompose_goal(
+                description, context, library_agents
+            )
         except AgentGeneratorNotConfiguredError:
             return ErrorResponse(
                 message=(
@@ -190,9 +210,26 @@ class CreateAgentTool(BaseTool):
                 session_id=session_id,
             )
 
+        # Step 1.5: Enrich library agents with step-based search (two-phase search)
+        # After decomposition, search for additional relevant agents based on the steps
+        if user_id and library_agents is not None:
+            try:
+                library_agents = await enrich_library_agents_from_steps(
+                    user_id=user_id,
+                    decomposition_result=decomposition_result,
+                    existing_agents=library_agents,
+                    include_marketplace=True,
+                )
+                logger.debug(
+                    f"After enrichment: {len(library_agents)} total agents for sub-agent composition"
+                )
+            except Exception as e:
+                # Log but don't fail - continue with existing agents
+                logger.warning(f"Failed to enrich library agents from steps: {e}")
+
         # Step 2: Generate agent JSON (external service handles fixing and validation)
         try:
-            agent_json = await generate_agent(decomposition_result)
+            agent_json = await generate_agent(decomposition_result, library_agents)
         except AgentGeneratorNotConfiguredError:
             return ErrorResponse(
                 message=(
@@ -219,7 +256,12 @@ class CreateAgentTool(BaseTool):
                 error_type,
                 operation="generate the agent",
                 llm_parse_message="The AI had trouble generating the agent. Please try again or simplify your goal.",
-                validation_message="The generated agent failed validation. Please try rephrasing your goal.",
+                validation_message=(
+                    "I wasn't able to create a valid agent for this request. "
+                    "The generated workflow had some structural issues. "
+                    "Please try simplifying your goal or breaking it into smaller steps."
+                ),
+                error_details=error_msg if error_type == "validation_error" else None,
             )
             return ErrorResponse(
                 message=user_message,
@@ -270,7 +312,7 @@ class CreateAgentTool(BaseTool):
                 agent_id=created_graph.id,
                 agent_name=created_graph.name,
                 library_agent_id=library_agent.id,
-                library_agent_link=f"/library/{library_agent.id}",
+                library_agent_link=f"/library/agents/{library_agent.id}",
                 agent_page_link=f"/build?flowID={created_graph.id}",
                 session_id=session_id,
             )

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

@@ -9,6 +9,7 @@ from .agent_generator import (
     AgentGeneratorNotConfiguredError,
     generate_agent_patch,
     get_agent_as_json,
+    get_all_relevant_agents_for_generation,
     get_user_message_for_error,
     save_agent_to_library,
 )
@@ -127,6 +128,26 @@ class EditAgentTool(BaseTool):
                 session_id=session_id,
             )
 
+        # Fetch relevant library and marketplace agents for sub-agent composition
+        library_agents = None
+        if user_id:
+            try:
+                # Use the actual graph ID from current_agent to properly exclude
+                # the agent being edited (agent_id might be a library agent ID)
+                exclude_id = current_agent.get("id") or agent_id
+                library_agents = await get_all_relevant_agents_for_generation(
+                    user_id=user_id,
+                    search_query=changes,  # Use changes as search term
+                    exclude_graph_id=exclude_id,  # Don't include the agent being edited
+                    include_marketplace=True,
+                )
+                logger.debug(
+                    f"Found {len(library_agents)} relevant agents for sub-agent composition"
+                )
+            except Exception as e:
+                # Log but don't fail - agent editing can work without sub-agents
+                logger.warning(f"Failed to fetch library agents: {e}")
+
         # Build the update request with context
         update_request = changes
         if context:
@@ -134,7 +155,9 @@ class EditAgentTool(BaseTool):
 
         # Step 2: Generate updated agent (external service handles fixing and validation)
         try:
-            result = await generate_agent_patch(update_request, current_agent)
+            result = await generate_agent_patch(
+                update_request, current_agent, library_agents
+            )
         except AgentGeneratorNotConfiguredError:
             return ErrorResponse(
                 message=(
@@ -236,7 +259,7 @@ class EditAgentTool(BaseTool):
                 agent_id=created_graph.id,
                 agent_name=created_graph.name,
                 library_agent_id=library_agent.id,
-                library_agent_link=f"/library/{library_agent.id}",
+                library_agent_link=f"/library/agents/{library_agent.id}",
                 agent_page_link=f"/build?flowID={created_graph.id}",
                 session_id=session_id,
             )

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

@@ -77,21 +77,32 @@ async def list_library_agents(
     }
 
     # Build search filter if applicable
+    # Split into words and match ANY word in name or description
     if search_term:
-        where_clause["OR"] = [
-            {
-                "AgentGraph": {
-                    "is": {"name": {"contains": search_term, "mode": "insensitive"}}
-                }
-            },
-            {
-                "AgentGraph": {
-                    "is": {
-                        "description": {"contains": search_term, "mode": "insensitive"}
+        words = [w.strip() for w in search_term.split() if len(w.strip()) >= 3]
+        if words:
+            or_conditions: list[prisma.types.LibraryAgentWhereInput] = []
+            for word in words:
+                or_conditions.append(
+                    {
+                        "AgentGraph": {
+                            "is": {"name": {"contains": word, "mode": "insensitive"}}
+                        }
                     }
-                }
-            },
-        ]
+                )
+                or_conditions.append(
+                    {
+                        "AgentGraph": {
+                            "is": {
+                                "description": {
+                                    "contains": word,
+                                    "mode": "insensitive",
+                                }
+                            }
+                        }
+                    }
+                )
+            where_clause["OR"] = or_conditions
 
     # Determine sorting
     order_by: prisma.types.LibraryAgentOrderByInput | None = None

autogpt_platform/backend/test/agent_generator/test_core_integration.py

@@ -57,7 +57,8 @@ class TestDecomposeGoal:
 
             result = await core.decompose_goal("Build a chatbot")
 
-            mock_external.assert_called_once_with("Build a chatbot", "")
+            # library_agents defaults to None
+            mock_external.assert_called_once_with("Build a chatbot", "", None)
             assert result == expected_result
 
     @pytest.mark.asyncio
@@ -74,7 +75,8 @@ class TestDecomposeGoal:
 
             await core.decompose_goal("Build a chatbot", "Use Python")
 
-            mock_external.assert_called_once_with("Build a chatbot", "Use Python")
+            # library_agents defaults to None
+            mock_external.assert_called_once_with("Build a chatbot", "Use Python", None)
 
     @pytest.mark.asyncio
     async def test_returns_none_on_service_failure(self):
@@ -109,7 +111,8 @@ class TestGenerateAgent:
             instructions = {"type": "instructions", "steps": ["Step 1"]}
             result = await core.generate_agent(instructions)
 
-            mock_external.assert_called_once_with(instructions)
+            # library_agents defaults to None
+            mock_external.assert_called_once_with(instructions, None)
             # Result should have id, version, is_active added if not present
             assert result is not None
             assert result["name"] == "Test Agent"
@@ -174,7 +177,8 @@ class TestGenerateAgentPatch:
             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)
+            # library_agents defaults to None
+            mock_external.assert_called_once_with("Add a node", current_agent, None)
             assert result == expected_result
 
     @pytest.mark.asyncio

autogpt_platform/backend/test/agent_generator/test_library_agents.py

@@ -0,0 +1,838 @@
+"""
+Tests for library agent fetching functionality in agent generator.
+
+This test suite verifies the search-based library agent fetching,
+including the combination of library and marketplace agents.
+"""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from backend.api.features.chat.tools.agent_generator import core
+
+
+class TestGetLibraryAgentsForGeneration:
+    """Test get_library_agents_for_generation function."""
+
+    @pytest.mark.asyncio
+    async def test_fetches_agents_with_search_term(self):
+        """Test that search_term is passed to the library db."""
+        # Create a mock agent with proper attribute values
+        mock_agent = MagicMock()
+        mock_agent.graph_id = "agent-123"
+        mock_agent.graph_version = 1
+        mock_agent.name = "Email Agent"
+        mock_agent.description = "Sends emails"
+        mock_agent.input_schema = {"properties": {}}
+        mock_agent.output_schema = {"properties": {}}
+
+        mock_response = MagicMock()
+        mock_response.agents = [mock_agent]
+
+        with patch.object(
+            core.library_db,
+            "list_library_agents",
+            new_callable=AsyncMock,
+            return_value=mock_response,
+        ) as mock_list:
+            result = await core.get_library_agents_for_generation(
+                user_id="user-123",
+                search_query="send email",
+            )
+
+            # Verify search_term was passed
+            mock_list.assert_called_once_with(
+                user_id="user-123",
+                search_term="send email",
+                page=1,
+                page_size=15,
+            )
+
+        # Verify result format
+        assert len(result) == 1
+        assert result[0]["graph_id"] == "agent-123"
+        assert result[0]["name"] == "Email Agent"
+
+    @pytest.mark.asyncio
+    async def test_excludes_specified_graph_id(self):
+        """Test that agents with excluded graph_id are filtered out."""
+        mock_response = MagicMock()
+        mock_response.agents = [
+            MagicMock(
+                graph_id="agent-123",
+                graph_version=1,
+                name="Agent 1",
+                description="First agent",
+                input_schema={},
+                output_schema={},
+            ),
+            MagicMock(
+                graph_id="agent-456",
+                graph_version=1,
+                name="Agent 2",
+                description="Second agent",
+                input_schema={},
+                output_schema={},
+            ),
+        ]
+
+        with patch.object(
+            core.library_db,
+            "list_library_agents",
+            new_callable=AsyncMock,
+            return_value=mock_response,
+        ):
+            result = await core.get_library_agents_for_generation(
+                user_id="user-123",
+                exclude_graph_id="agent-123",
+            )
+
+        # Verify the excluded agent is not in results
+        assert len(result) == 1
+        assert result[0]["graph_id"] == "agent-456"
+
+    @pytest.mark.asyncio
+    async def test_respects_max_results(self):
+        """Test that max_results parameter limits the page_size."""
+        mock_response = MagicMock()
+        mock_response.agents = []
+
+        with patch.object(
+            core.library_db,
+            "list_library_agents",
+            new_callable=AsyncMock,
+            return_value=mock_response,
+        ) as mock_list:
+            await core.get_library_agents_for_generation(
+                user_id="user-123",
+                max_results=5,
+            )
+
+            # Verify page_size was set to max_results
+            mock_list.assert_called_once_with(
+                user_id="user-123",
+                search_term=None,
+                page=1,
+                page_size=5,
+            )
+
+
+class TestSearchMarketplaceAgentsForGeneration:
+    """Test search_marketplace_agents_for_generation function."""
+
+    @pytest.mark.asyncio
+    async def test_searches_marketplace_with_query(self):
+        """Test that marketplace is searched with the query."""
+        mock_response = MagicMock()
+        mock_response.agents = [
+            MagicMock(
+                agent_name="Public Agent",
+                description="A public agent",
+                sub_heading="Does something useful",
+                creator="creator-1",
+            )
+        ]
+
+        # The store_db is dynamically imported, so patch the import path
+        with patch(
+            "backend.api.features.store.db.get_store_agents",
+            new_callable=AsyncMock,
+            return_value=mock_response,
+        ) as mock_search:
+            result = await core.search_marketplace_agents_for_generation(
+                search_query="automation",
+                max_results=10,
+            )
+
+            mock_search.assert_called_once_with(
+                search_query="automation",
+                page=1,
+                page_size=10,
+            )
+
+        assert len(result) == 1
+        assert result[0]["name"] == "Public Agent"
+        assert result[0]["is_marketplace_agent"] is True
+
+    @pytest.mark.asyncio
+    async def test_handles_marketplace_error_gracefully(self):
+        """Test that marketplace errors don't crash the function."""
+        with patch(
+            "backend.api.features.store.db.get_store_agents",
+            new_callable=AsyncMock,
+            side_effect=Exception("Marketplace unavailable"),
+        ):
+            result = await core.search_marketplace_agents_for_generation(
+                search_query="test"
+            )
+
+        # Should return empty list, not raise exception
+        assert result == []
+
+
+class TestGetAllRelevantAgentsForGeneration:
+    """Test get_all_relevant_agents_for_generation function."""
+
+    @pytest.mark.asyncio
+    async def test_combines_library_and_marketplace_agents(self):
+        """Test that agents from both sources are combined."""
+        library_agents = [
+            {
+                "graph_id": "lib-123",
+                "graph_version": 1,
+                "name": "Library Agent",
+                "description": "From library",
+                "input_schema": {},
+                "output_schema": {},
+            }
+        ]
+
+        marketplace_agents = [
+            {
+                "name": "Market Agent",
+                "description": "From marketplace",
+                "sub_heading": "Sub heading",
+                "creator": "creator-1",
+                "is_marketplace_agent": True,
+            }
+        ]
+
+        with patch.object(
+            core,
+            "get_library_agents_for_generation",
+            new_callable=AsyncMock,
+            return_value=library_agents,
+        ):
+            with patch.object(
+                core,
+                "search_marketplace_agents_for_generation",
+                new_callable=AsyncMock,
+                return_value=marketplace_agents,
+            ):
+                result = await core.get_all_relevant_agents_for_generation(
+                    user_id="user-123",
+                    search_query="test query",
+                    include_marketplace=True,
+                )
+
+        # Library agents should come first
+        assert len(result) == 2
+        assert result[0]["name"] == "Library Agent"
+        assert result[1]["name"] == "Market Agent"
+
+    @pytest.mark.asyncio
+    async def test_deduplicates_by_name(self):
+        """Test that marketplace agents with same name as library are excluded."""
+        library_agents = [
+            {
+                "graph_id": "lib-123",
+                "graph_version": 1,
+                "name": "Shared Agent",
+                "description": "From library",
+                "input_schema": {},
+                "output_schema": {},
+            }
+        ]
+
+        marketplace_agents = [
+            {
+                "name": "Shared Agent",  # Same name, should be deduplicated
+                "description": "From marketplace",
+                "sub_heading": "Sub heading",
+                "creator": "creator-1",
+                "is_marketplace_agent": True,
+            },
+            {
+                "name": "Unique Agent",
+                "description": "Only in marketplace",
+                "sub_heading": "Sub heading",
+                "creator": "creator-2",
+                "is_marketplace_agent": True,
+            },
+        ]
+
+        with patch.object(
+            core,
+            "get_library_agents_for_generation",
+            new_callable=AsyncMock,
+            return_value=library_agents,
+        ):
+            with patch.object(
+                core,
+                "search_marketplace_agents_for_generation",
+                new_callable=AsyncMock,
+                return_value=marketplace_agents,
+            ):
+                result = await core.get_all_relevant_agents_for_generation(
+                    user_id="user-123",
+                    search_query="test",
+                    include_marketplace=True,
+                )
+
+        # Shared Agent from marketplace should be excluded
+        assert len(result) == 2
+        names = [a["name"] for a in result]
+        assert "Shared Agent" in names
+        assert "Unique Agent" in names
+
+    @pytest.mark.asyncio
+    async def test_skips_marketplace_when_disabled(self):
+        """Test that marketplace is not searched when include_marketplace=False."""
+        library_agents = [
+            {
+                "graph_id": "lib-123",
+                "graph_version": 1,
+                "name": "Library Agent",
+                "description": "From library",
+                "input_schema": {},
+                "output_schema": {},
+            }
+        ]
+
+        with patch.object(
+            core,
+            "get_library_agents_for_generation",
+            new_callable=AsyncMock,
+            return_value=library_agents,
+        ):
+            with patch.object(
+                core,
+                "search_marketplace_agents_for_generation",
+                new_callable=AsyncMock,
+            ) as mock_marketplace:
+                result = await core.get_all_relevant_agents_for_generation(
+                    user_id="user-123",
+                    search_query="test",
+                    include_marketplace=False,
+                )
+
+        # Marketplace should not be called
+        mock_marketplace.assert_not_called()
+        assert len(result) == 1
+
+    @pytest.mark.asyncio
+    async def test_skips_marketplace_when_no_search_query(self):
+        """Test that marketplace is not searched without a search query."""
+        library_agents = [
+            {
+                "graph_id": "lib-123",
+                "graph_version": 1,
+                "name": "Library Agent",
+                "description": "From library",
+                "input_schema": {},
+                "output_schema": {},
+            }
+        ]
+
+        with patch.object(
+            core,
+            "get_library_agents_for_generation",
+            new_callable=AsyncMock,
+            return_value=library_agents,
+        ):
+            with patch.object(
+                core,
+                "search_marketplace_agents_for_generation",
+                new_callable=AsyncMock,
+            ) as mock_marketplace:
+                result = await core.get_all_relevant_agents_for_generation(
+                    user_id="user-123",
+                    search_query=None,  # No search query
+                    include_marketplace=True,
+                )
+
+        # Marketplace should not be called without search query
+        mock_marketplace.assert_not_called()
+        assert len(result) == 1
+
+
+class TestExtractSearchTermsFromSteps:
+    """Test extract_search_terms_from_steps function."""
+
+    def test_extracts_terms_from_instructions_type(self):
+        """Test extraction from valid instructions decomposition result."""
+        decomposition_result = {
+            "type": "instructions",
+            "steps": [
+                {
+                    "description": "Send an email notification",
+                    "block_name": "GmailSendBlock",
+                },
+                {"description": "Fetch weather data", "action": "Get weather API"},
+            ],
+        }
+
+        result = core.extract_search_terms_from_steps(decomposition_result)
+
+        assert "Send an email notification" in result
+        assert "GmailSendBlock" in result
+        assert "Fetch weather data" in result
+        assert "Get weather API" in result
+
+    def test_returns_empty_for_non_instructions_type(self):
+        """Test that non-instructions types return empty list."""
+        decomposition_result = {
+            "type": "clarifying_questions",
+            "questions": [{"question": "What email?"}],
+        }
+
+        result = core.extract_search_terms_from_steps(decomposition_result)
+
+        assert result == []
+
+    def test_deduplicates_terms_case_insensitively(self):
+        """Test that duplicate terms are removed (case-insensitive)."""
+        decomposition_result = {
+            "type": "instructions",
+            "steps": [
+                {"description": "Send Email", "name": "send email"},
+                {"description": "Other task"},
+            ],
+        }
+
+        result = core.extract_search_terms_from_steps(decomposition_result)
+
+        # Should only have one "send email" variant
+        email_terms = [t for t in result if "email" in t.lower()]
+        assert len(email_terms) == 1
+
+    def test_filters_short_terms(self):
+        """Test that terms with 3 or fewer characters are filtered out."""
+        decomposition_result = {
+            "type": "instructions",
+            "steps": [
+                {"description": "ab", "action": "xyz"},  # Both too short
+                {"description": "Valid term here"},
+            ],
+        }
+
+        result = core.extract_search_terms_from_steps(decomposition_result)
+
+        assert "ab" not in result
+        assert "xyz" not in result
+        assert "Valid term here" in result
+
+    def test_handles_empty_steps(self):
+        """Test handling of empty steps list."""
+        decomposition_result = {
+            "type": "instructions",
+            "steps": [],
+        }
+
+        result = core.extract_search_terms_from_steps(decomposition_result)
+
+        assert result == []
+
+
+class TestEnrichLibraryAgentsFromSteps:
+    """Test enrich_library_agents_from_steps function."""
+
+    @pytest.mark.asyncio
+    async def test_enriches_with_additional_agents(self):
+        """Test that additional agents are found based on steps."""
+        existing_agents = [
+            {
+                "graph_id": "existing-123",
+                "graph_version": 1,
+                "name": "Existing Agent",
+                "description": "Already fetched",
+                "input_schema": {},
+                "output_schema": {},
+            }
+        ]
+
+        additional_agents = [
+            {
+                "graph_id": "new-456",
+                "graph_version": 1,
+                "name": "Email Agent",
+                "description": "For sending emails",
+                "input_schema": {},
+                "output_schema": {},
+            }
+        ]
+
+        decomposition_result = {
+            "type": "instructions",
+            "steps": [
+                {"description": "Send email notification"},
+            ],
+        }
+
+        with patch.object(
+            core,
+            "get_all_relevant_agents_for_generation",
+            new_callable=AsyncMock,
+            return_value=additional_agents,
+        ):
+            result = await core.enrich_library_agents_from_steps(
+                user_id="user-123",
+                decomposition_result=decomposition_result,
+                existing_agents=existing_agents,
+            )
+
+        # Should have both existing and new agents
+        assert len(result) == 2
+        names = [a["name"] for a in result]
+        assert "Existing Agent" in names
+        assert "Email Agent" in names
+
+    @pytest.mark.asyncio
+    async def test_deduplicates_by_graph_id(self):
+        """Test that agents with same graph_id are not duplicated."""
+        existing_agents = [
+            {
+                "graph_id": "agent-123",
+                "graph_version": 1,
+                "name": "Existing Agent",
+                "description": "Already fetched",
+                "input_schema": {},
+                "output_schema": {},
+            }
+        ]
+
+        # Additional search returns same agent
+        additional_agents = [
+            {
+                "graph_id": "agent-123",  # Same ID
+                "graph_version": 1,
+                "name": "Existing Agent Copy",
+                "description": "Same agent different name",
+                "input_schema": {},
+                "output_schema": {},
+            }
+        ]
+
+        decomposition_result = {
+            "type": "instructions",
+            "steps": [{"description": "Some action"}],
+        }
+
+        with patch.object(
+            core,
+            "get_all_relevant_agents_for_generation",
+            new_callable=AsyncMock,
+            return_value=additional_agents,
+        ):
+            result = await core.enrich_library_agents_from_steps(
+                user_id="user-123",
+                decomposition_result=decomposition_result,
+                existing_agents=existing_agents,
+            )
+
+        # Should not duplicate
+        assert len(result) == 1
+
+    @pytest.mark.asyncio
+    async def test_deduplicates_by_name(self):
+        """Test that agents with same name are not duplicated."""
+        existing_agents = [
+            {
+                "graph_id": "agent-123",
+                "graph_version": 1,
+                "name": "Email Agent",
+                "description": "Already fetched",
+                "input_schema": {},
+                "output_schema": {},
+            }
+        ]
+
+        # Additional search returns agent with same name but different ID
+        additional_agents = [
+            {
+                "graph_id": "agent-456",  # Different ID
+                "graph_version": 1,
+                "name": "Email Agent",  # Same name
+                "description": "Different agent same name",
+                "input_schema": {},
+                "output_schema": {},
+            }
+        ]
+
+        decomposition_result = {
+            "type": "instructions",
+            "steps": [{"description": "Send email"}],
+        }
+
+        with patch.object(
+            core,
+            "get_all_relevant_agents_for_generation",
+            new_callable=AsyncMock,
+            return_value=additional_agents,
+        ):
+            result = await core.enrich_library_agents_from_steps(
+                user_id="user-123",
+                decomposition_result=decomposition_result,
+                existing_agents=existing_agents,
+            )
+
+        # Should not duplicate by name
+        assert len(result) == 1
+        assert result[0].get("graph_id") == "agent-123"  # Original kept
+
+    @pytest.mark.asyncio
+    async def test_returns_existing_when_no_steps(self):
+        """Test that existing agents are returned when no search terms extracted."""
+        existing_agents = [
+            {
+                "graph_id": "existing-123",
+                "graph_version": 1,
+                "name": "Existing Agent",
+                "description": "Already fetched",
+                "input_schema": {},
+                "output_schema": {},
+            }
+        ]
+
+        decomposition_result = {
+            "type": "clarifying_questions",  # Not instructions type
+            "questions": [],
+        }
+
+        result = await core.enrich_library_agents_from_steps(
+            user_id="user-123",
+            decomposition_result=decomposition_result,
+            existing_agents=existing_agents,
+        )
+
+        # Should return existing unchanged
+        assert result == existing_agents
+
+    @pytest.mark.asyncio
+    async def test_limits_search_terms_to_three(self):
+        """Test that only first 3 search terms are used."""
+        existing_agents = []
+
+        decomposition_result = {
+            "type": "instructions",
+            "steps": [
+                {"description": "First action"},
+                {"description": "Second action"},
+                {"description": "Third action"},
+                {"description": "Fourth action"},
+                {"description": "Fifth action"},
+            ],
+        }
+
+        call_count = 0
+
+        async def mock_get_agents(*args, **kwargs):
+            nonlocal call_count
+            call_count += 1
+            return []
+
+        with patch.object(
+            core,
+            "get_all_relevant_agents_for_generation",
+            side_effect=mock_get_agents,
+        ):
+            await core.enrich_library_agents_from_steps(
+                user_id="user-123",
+                decomposition_result=decomposition_result,
+                existing_agents=existing_agents,
+            )
+
+        # Should only make 3 calls (limited to first 3 terms)
+        assert call_count == 3
+
+
+class TestExtractUuidsFromText:
+    """Test extract_uuids_from_text function."""
+
+    def test_extracts_single_uuid(self):
+        """Test extraction of a single UUID from text."""
+        text = "Use my agent 46631191-e8a8-486f-ad90-84f89738321d for this task"
+        result = core.extract_uuids_from_text(text)
+        assert len(result) == 1
+        assert "46631191-e8a8-486f-ad90-84f89738321d" in result
+
+    def test_extracts_multiple_uuids(self):
+        """Test extraction of multiple UUIDs from text."""
+        text = (
+            "Combine agents 11111111-1111-4111-8111-111111111111 "
+            "and 22222222-2222-4222-9222-222222222222"
+        )
+        result = core.extract_uuids_from_text(text)
+        assert len(result) == 2
+        assert "11111111-1111-4111-8111-111111111111" in result
+        assert "22222222-2222-4222-9222-222222222222" in result
+
+    def test_deduplicates_uuids(self):
+        """Test that duplicate UUIDs are deduplicated."""
+        text = (
+            "Use 46631191-e8a8-486f-ad90-84f89738321d twice: "
+            "46631191-e8a8-486f-ad90-84f89738321d"
+        )
+        result = core.extract_uuids_from_text(text)
+        assert len(result) == 1
+
+    def test_normalizes_to_lowercase(self):
+        """Test that UUIDs are normalized to lowercase."""
+        text = "Use 46631191-E8A8-486F-AD90-84F89738321D"
+        result = core.extract_uuids_from_text(text)
+        assert result[0] == "46631191-e8a8-486f-ad90-84f89738321d"
+
+    def test_returns_empty_for_no_uuids(self):
+        """Test that empty list is returned when no UUIDs found."""
+        text = "Create an email agent that sends notifications"
+        result = core.extract_uuids_from_text(text)
+        assert result == []
+
+    def test_ignores_invalid_uuids(self):
+        """Test that invalid UUID-like strings are ignored."""
+        text = "Not a valid UUID: 12345678-1234-1234-1234-123456789abc"
+        result = core.extract_uuids_from_text(text)
+        # UUID v4 requires specific patterns (4 in third group, 8/9/a/b in fourth)
+        assert len(result) == 0
+
+
+class TestGetLibraryAgentById:
+    """Test get_library_agent_by_id function (and its alias get_library_agent_by_graph_id)."""
+
+    @pytest.mark.asyncio
+    async def test_returns_agent_when_found_by_graph_id(self):
+        """Test that agent is returned when found by graph_id."""
+        mock_agent = MagicMock()
+        mock_agent.graph_id = "agent-123"
+        mock_agent.graph_version = 1
+        mock_agent.name = "Test Agent"
+        mock_agent.description = "Test description"
+        mock_agent.input_schema = {"properties": {}}
+        mock_agent.output_schema = {"properties": {}}
+
+        with patch.object(
+            core.library_db,
+            "get_library_agent_by_graph_id",
+            new_callable=AsyncMock,
+            return_value=mock_agent,
+        ):
+            result = await core.get_library_agent_by_id("user-123", "agent-123")
+
+        assert result is not None
+        assert result["graph_id"] == "agent-123"
+        assert result["name"] == "Test Agent"
+
+    @pytest.mark.asyncio
+    async def test_falls_back_to_library_agent_id(self):
+        """Test that lookup falls back to library agent ID when graph_id not found."""
+        mock_agent = MagicMock()
+        mock_agent.graph_id = "graph-456"  # Different from the lookup ID
+        mock_agent.graph_version = 1
+        mock_agent.name = "Library Agent"
+        mock_agent.description = "Found by library ID"
+        mock_agent.input_schema = {"properties": {}}
+        mock_agent.output_schema = {"properties": {}}
+
+        with (
+            patch.object(
+                core.library_db,
+                "get_library_agent_by_graph_id",
+                new_callable=AsyncMock,
+                return_value=None,  # Not found by graph_id
+            ),
+            patch.object(
+                core.library_db,
+                "get_library_agent",
+                new_callable=AsyncMock,
+                return_value=mock_agent,  # Found by library ID
+            ),
+        ):
+            result = await core.get_library_agent_by_id("user-123", "library-id-123")
+
+        assert result is not None
+        assert result["graph_id"] == "graph-456"
+        assert result["name"] == "Library Agent"
+
+    @pytest.mark.asyncio
+    async def test_returns_none_when_not_found_by_either_method(self):
+        """Test that None is returned when agent not found by either method."""
+        with (
+            patch.object(
+                core.library_db,
+                "get_library_agent_by_graph_id",
+                new_callable=AsyncMock,
+                return_value=None,
+            ),
+            patch.object(
+                core.library_db,
+                "get_library_agent",
+                new_callable=AsyncMock,
+                side_effect=core.NotFoundError("Not found"),
+            ),
+        ):
+            result = await core.get_library_agent_by_id("user-123", "nonexistent")
+
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_returns_none_on_exception(self):
+        """Test that None is returned when exception occurs in both lookups."""
+        with (
+            patch.object(
+                core.library_db,
+                "get_library_agent_by_graph_id",
+                new_callable=AsyncMock,
+                side_effect=Exception("Database error"),
+            ),
+            patch.object(
+                core.library_db,
+                "get_library_agent",
+                new_callable=AsyncMock,
+                side_effect=Exception("Database error"),
+            ),
+        ):
+            result = await core.get_library_agent_by_id("user-123", "agent-123")
+
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_alias_works(self):
+        """Test that get_library_agent_by_graph_id is an alias for get_library_agent_by_id."""
+        assert core.get_library_agent_by_graph_id is core.get_library_agent_by_id
+
+
+class TestGetAllRelevantAgentsWithUuids:
+    """Test UUID extraction in get_all_relevant_agents_for_generation."""
+
+    @pytest.mark.asyncio
+    async def test_fetches_explicitly_mentioned_agents(self):
+        """Test that agents mentioned by UUID are fetched directly."""
+        mock_agent = MagicMock()
+        mock_agent.graph_id = "46631191-e8a8-486f-ad90-84f89738321d"
+        mock_agent.graph_version = 1
+        mock_agent.name = "Mentioned Agent"
+        mock_agent.description = "Explicitly mentioned"
+        mock_agent.input_schema = {}
+        mock_agent.output_schema = {}
+
+        mock_response = MagicMock()
+        mock_response.agents = []
+
+        with (
+            patch.object(
+                core.library_db,
+                "get_library_agent_by_graph_id",
+                new_callable=AsyncMock,
+                return_value=mock_agent,
+            ),
+            patch.object(
+                core.library_db,
+                "list_library_agents",
+                new_callable=AsyncMock,
+                return_value=mock_response,
+            ),
+        ):
+            result = await core.get_all_relevant_agents_for_generation(
+                user_id="user-123",
+                search_query="Use agent 46631191-e8a8-486f-ad90-84f89738321d",
+                include_marketplace=False,
+            )
+
+        assert len(result) == 1
+        assert result[0].get("graph_id") == "46631191-e8a8-486f-ad90-84f89738321d"
+        assert result[0].get("name") == "Mentioned Agent"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

autogpt_platform/backend/test/agent_generator/test_service.py

@@ -433,5 +433,139 @@ class TestGetBlocksExternal:
         assert result is None
 
 
+class TestLibraryAgentsPassthrough:
+    """Test that library_agents are passed correctly in all requests."""
+
+    def setup_method(self):
+        """Reset client singleton before each test."""
+        service._settings = None
+        service._client = None
+
+    @pytest.mark.asyncio
+    async def test_decompose_goal_passes_library_agents(self):
+        """Test that library_agents are included in decompose goal payload."""
+        library_agents = [
+            {
+                "graph_id": "agent-123",
+                "graph_version": 1,
+                "name": "Email Sender",
+                "description": "Sends emails",
+                "input_schema": {"properties": {"to": {"type": "string"}}},
+                "output_schema": {"properties": {"sent": {"type": "boolean"}}},
+            },
+        ]
+
+        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(
+                "Send an email",
+                library_agents=library_agents,
+            )
+
+        # Verify library_agents was passed in the payload
+        call_args = mock_client.post.call_args
+        assert call_args[1]["json"]["library_agents"] == library_agents
+
+    @pytest.mark.asyncio
+    async def test_generate_agent_passes_library_agents(self):
+        """Test that library_agents are included in generate agent payload."""
+        library_agents = [
+            {
+                "graph_id": "agent-456",
+                "graph_version": 2,
+                "name": "Data Fetcher",
+                "description": "Fetches data from API",
+                "input_schema": {"properties": {"url": {"type": "string"}}},
+                "output_schema": {"properties": {"data": {"type": "object"}}},
+            },
+        ]
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "success": True,
+            "agent_json": {"name": "Test Agent", "nodes": []},
+        }
+        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.generate_agent_external(
+                {"steps": ["Step 1"]},
+                library_agents=library_agents,
+            )
+
+        # Verify library_agents was passed in the payload
+        call_args = mock_client.post.call_args
+        assert call_args[1]["json"]["library_agents"] == library_agents
+
+    @pytest.mark.asyncio
+    async def test_generate_agent_patch_passes_library_agents(self):
+        """Test that library_agents are included in patch generation payload."""
+        library_agents = [
+            {
+                "graph_id": "agent-789",
+                "graph_version": 1,
+                "name": "Slack Notifier",
+                "description": "Sends Slack messages",
+                "input_schema": {"properties": {"message": {"type": "string"}}},
+                "output_schema": {"properties": {"success": {"type": "boolean"}}},
+            },
+        ]
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "success": True,
+            "agent_json": {"name": "Updated Agent", "nodes": []},
+        }
+        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.generate_agent_patch_external(
+                "Add error handling",
+                {"name": "Original Agent", "nodes": []},
+                library_agents=library_agents,
+            )
+
+        # Verify library_agents was passed in the payload
+        call_args = mock_client.post.call_args
+        assert call_args[1]["json"]["library_agents"] == library_agents
+
+    @pytest.mark.asyncio
+    async def test_decompose_goal_without_library_agents(self):
+        """Test that decompose goal works without library_agents."""
+        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 workflow")
+
+        # Verify library_agents was NOT passed when not provided
+        call_args = mock_client.post.call_args
+        assert "library_agents" not in call_args[1]["json"]
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])

autogpt_platform/backend/test/e2e_test_data.py

@@ -43,24 +43,19 @@ faker = Faker()
 # Constants for data generation limits (reduced for E2E tests)
 NUM_USERS = 15
 NUM_AGENT_BLOCKS = 30
-MIN_GRAPHS_PER_USER = 25
-MAX_GRAPHS_PER_USER = 25
+MIN_GRAPHS_PER_USER = 15
+MAX_GRAPHS_PER_USER = 15
 MIN_NODES_PER_GRAPH = 3
 MAX_NODES_PER_GRAPH = 6
 MIN_PRESETS_PER_USER = 2
 MAX_PRESETS_PER_USER = 3
-MIN_AGENTS_PER_USER = 25
-MAX_AGENTS_PER_USER = 25
+MIN_AGENTS_PER_USER = 15
+MAX_AGENTS_PER_USER = 15
 MIN_EXECUTIONS_PER_GRAPH = 2
 MAX_EXECUTIONS_PER_GRAPH = 8
 MIN_REVIEWS_PER_VERSION = 2
 MAX_REVIEWS_PER_VERSION = 5
 
-# Guaranteed minimums for marketplace tests (deterministic)
-GUARANTEED_FEATURED_AGENTS = 8
-GUARANTEED_FEATURED_CREATORS = 5
-GUARANTEED_TOP_AGENTS = 10
-
 
 def get_image():
     """Generate a consistent image URL using picsum.photos service."""
@@ -390,7 +385,7 @@ class TestDataCreator:
 
         library_agents = []
         for user in self.users:
-            num_agents = random.randint(MIN_AGENTS_PER_USER, MAX_AGENTS_PER_USER)
+            num_agents = 10  # Create exactly 10 agents per user
 
             # Get available graphs for this user
             user_graphs = [
@@ -512,17 +507,14 @@ class TestDataCreator:
             existing_profiles, min(num_creators, len(existing_profiles))
         )
 
-        # Guarantee at least GUARANTEED_FEATURED_CREATORS featured creators
-        num_featured = max(GUARANTEED_FEATURED_CREATORS, int(num_creators * 0.5))
+        # Mark about 50% of creators as featured (more for testing)
+        num_featured = max(2, int(num_creators * 0.5))
         num_featured = min(
             num_featured, len(selected_profiles)
         )  # Don't exceed available profiles
         featured_profile_ids = set(
             random.sample([p.id for p in selected_profiles], num_featured)
         )
-        print(
-            f"🎯 Creating {num_featured} featured creators (min: {GUARANTEED_FEATURED_CREATORS})"
-        )
 
         for profile in selected_profiles:
             try:
@@ -553,25 +545,21 @@ class TestDataCreator:
         return profiles
 
     async def create_test_store_submissions(self) -> List[Dict[str, Any]]:
-        """Create test store submissions using the API function.
-
-        DETERMINISTIC: Guarantees minimum featured agents for E2E tests.
-        """
+        """Create test store submissions using the API function."""
         print("Creating test store submissions...")
 
         submissions = []
         approved_submissions = []
-        featured_count = 0
-        submission_counter = 0
 
-        # Create a special test submission for test123@gmail.com (ALWAYS approved + featured)
+        # Create a special test submission for test123@gmail.com
         test_user = next(
             (user for user in self.users if user["email"] == "test123@gmail.com"), None
         )
-        if test_user and self.agent_graphs:
+        if test_user:
+            # Special test data for consistent testing
             test_submission_data = {
                 "user_id": test_user["id"],
-                "agent_id": self.agent_graphs[0]["id"],
+                "agent_id": self.agent_graphs[0]["id"],  # Use first available graph
                 "agent_version": 1,
                 "slug": "test-agent-submission",
                 "name": "Test Agent Submission",
@@ -592,24 +580,37 @@ class TestDataCreator:
                 submissions.append(test_submission.model_dump())
                 print("✅ Created special test store submission for test123@gmail.com")
 
-                # ALWAYS approve and feature the test submission
+                # Randomly approve, reject, or leave pending the test submission
                 if test_submission.store_listing_version_id:
-                    approved_submission = await review_store_submission(
-                        store_listing_version_id=test_submission.store_listing_version_id,
-                        is_approved=True,
-                        external_comments="Test submission approved",
-                        internal_comments="Auto-approved test submission",
-                        reviewer_id=test_user["id"],
-                    )
-                    approved_submissions.append(approved_submission.model_dump())
-                    print("✅ Approved test store submission")
+                    random_value = random.random()
+                    if random_value < 0.4:  # 40% chance to approve
+                        approved_submission = await review_store_submission(
+                            store_listing_version_id=test_submission.store_listing_version_id,
+                            is_approved=True,
+                            external_comments="Test submission approved",
+                            internal_comments="Auto-approved test submission",
+                            reviewer_id=test_user["id"],
+                        )
+                        approved_submissions.append(approved_submission.model_dump())
+                        print("✅ Approved test store submission")
 
-                    await prisma.storelistingversion.update(
-                        where={"id": test_submission.store_listing_version_id},
-                        data={"isFeatured": True},
-                    )
-                    featured_count += 1
-                    print("🌟 Marked test agent as FEATURED")
+                        # Mark approved submission as featured
+                        await prisma.storelistingversion.update(
+                            where={"id": test_submission.store_listing_version_id},
+                            data={"isFeatured": True},
+                        )
+                        print("🌟 Marked test agent as FEATURED")
+                    elif random_value < 0.7:  # 30% chance to reject (40% to 70%)
+                        await review_store_submission(
+                            store_listing_version_id=test_submission.store_listing_version_id,
+                            is_approved=False,
+                            external_comments="Test submission rejected - needs improvements",
+                            internal_comments="Auto-rejected test submission for E2E testing",
+                            reviewer_id=test_user["id"],
+                        )
+                        print("❌ Rejected test store submission")
+                    else:  # 30% chance to leave pending (70% to 100%)
+                        print("⏳ Left test submission pending for review")
 
             except Exception as e:
                 print(f"Error creating test store submission: {e}")
@@ -619,6 +620,7 @@ class TestDataCreator:
 
         # Create regular submissions for all users
         for user in self.users:
+            # Get available graphs for this specific user
             user_graphs = [
                 g for g in self.agent_graphs if g.get("userId") == user["id"]
             ]
@@ -629,17 +631,18 @@ class TestDataCreator:
                 )
                 continue
 
+            # Create exactly 4 store submissions per user
             for submission_index in range(4):
                 graph = random.choice(user_graphs)
-                submission_counter += 1
 
                 try:
                     print(
-                        f"Creating store submission for user {user['id']} with graph {graph['id']}"
+                        f"Creating store submission for user {user['id']} with graph {graph['id']} (owner: {graph.get('userId')})"
                     )
 
+                    # Use the API function to create store submission with correct parameters
                     submission = await create_store_submission(
-                        user_id=user["id"],
+                        user_id=user["id"],  # Must match graph's userId
                         agent_id=graph["id"],
                         agent_version=graph.get("version", 1),
                         slug=faker.slug(),
@@ -648,24 +651,22 @@ class TestDataCreator:
                         video_url=get_video_url() if random.random() < 0.3 else None,
                         image_urls=[get_image() for _ in range(3)],
                         description=faker.text(),
-                        categories=[get_category()],
+                        categories=[
+                            get_category()
+                        ],  # Single category from predefined list
                         changes_summary="Initial E2E test submission",
                     )
                     submissions.append(submission.model_dump())
                     print(f"✅ Created store submission: {submission.name}")
 
+                    # Randomly approve, reject, or leave pending the submission
                     if submission.store_listing_version_id:
-                        # DETERMINISTIC: First N submissions are always approved
-                        # First GUARANTEED_FEATURED_AGENTS of those are always featured
-                        should_approve = (
-                            submission_counter <= GUARANTEED_TOP_AGENTS
-                            or random.random() < 0.4
-                        )
-                        should_feature = featured_count < GUARANTEED_FEATURED_AGENTS
-
-                        if should_approve:
+                        random_value = random.random()
+                        if random_value < 0.4:  # 40% chance to approve
                             try:
+                                # Pick a random user as the reviewer (admin)
                                 reviewer_id = random.choice(self.users)["id"]
+
                                 approved_submission = await review_store_submission(
                                     store_listing_version_id=submission.store_listing_version_id,
                                     is_approved=True,
@@ -680,7 +681,16 @@ class TestDataCreator:
                                     f"✅ Approved store submission: {submission.name}"
                                 )
 
-                                if should_feature:
+                                # Mark some agents as featured during creation (30% chance)
+                                # More likely for creators and first submissions
+                                is_creator = user["id"] in [
+                                    p.get("userId") for p in self.profiles
+                                ]
+                                feature_chance = (
+                                    0.5 if is_creator else 0.2
+                                )  # 50% for creators, 20% for others
+
+                                if random.random() < feature_chance:
                                     try:
                                         await prisma.storelistingversion.update(
                                             where={
@@ -688,25 +698,8 @@ class TestDataCreator:
                                             },
                                             data={"isFeatured": True},
                                         )
-                                        featured_count += 1
                                         print(
-                                            f"🌟 Marked agent as FEATURED ({featured_count}/{GUARANTEED_FEATURED_AGENTS}): {submission.name}"
-                                        )
-                                    except Exception as e:
-                                        print(
-                                            f"Warning: Could not mark submission as featured: {e}"
-                                        )
-                                elif random.random() < 0.2:
-                                    try:
-                                        await prisma.storelistingversion.update(
-                                            where={
-                                                "id": submission.store_listing_version_id
-                                            },
-                                            data={"isFeatured": True},
-                                        )
-                                        featured_count += 1
-                                        print(
-                                            f"🌟 Marked agent as FEATURED (bonus): {submission.name}"
+                                            f"🌟 Marked agent as FEATURED: {submission.name}"
                                         )
                                     except Exception as e:
                                         print(
@@ -717,9 +710,11 @@ class TestDataCreator:
                                 print(
                                     f"Warning: Could not approve submission {submission.name}: {e}"
                                 )
-                        elif random.random() < 0.5:
+                        elif random_value < 0.7:  # 30% chance to reject (40% to 70%)
                             try:
+                                # Pick a random user as the reviewer (admin)
                                 reviewer_id = random.choice(self.users)["id"]
+
                                 await review_store_submission(
                                     store_listing_version_id=submission.store_listing_version_id,
                                     is_approved=False,
@@ -734,7 +729,7 @@ class TestDataCreator:
                                 print(
                                     f"Warning: Could not reject submission {submission.name}: {e}"
                                 )
-                        else:
+                        else:  # 30% chance to leave pending (70% to 100%)
                             print(
                                 f"⏳ Left submission pending for review: {submission.name}"
                             )
@@ -748,13 +743,9 @@ class TestDataCreator:
                     traceback.print_exc()
                     continue
 
-        print("\n📊 Store Submissions Summary:")
-        print(f"   Created: {len(submissions)}")
-        print(f"   Approved: {len(approved_submissions)}")
         print(
-            f"   Featured: {featured_count} (guaranteed min: {GUARANTEED_FEATURED_AGENTS})"
+            f"Created {len(submissions)} store submissions, approved {len(approved_submissions)}"
         )
-
         self.store_submissions = submissions
         return submissions
 
@@ -834,15 +825,12 @@ class TestDataCreator:
         print(f"✅ Agent blocks available: {len(self.agent_blocks)}")
         print(f"✅ Agent graphs created: {len(self.agent_graphs)}")
         print(f"✅ Library agents created: {len(self.library_agents)}")
-        print(f"✅ Creator profiles updated: {len(self.profiles)}")
-        print(f"✅ Store submissions created: {len(self.store_submissions)}")
+        print(f"✅ Creator profiles updated: {len(self.profiles)} (some featured)")
+        print(
+            f"✅ Store submissions created: {len(self.store_submissions)} (some marked as featured during creation)"
+        )
         print(f"✅ API keys created: {len(self.api_keys)}")
         print(f"✅ Presets created: {len(self.presets)}")
-        print("\n🎯 Deterministic Guarantees:")
-        print(f"   • Featured agents: >= {GUARANTEED_FEATURED_AGENTS}")
-        print(f"   • Featured creators: >= {GUARANTEED_FEATURED_CREATORS}")
-        print(f"   • Top agents (approved): >= {GUARANTEED_TOP_AGENTS}")
-        print(f"   • Library agents per user: >= {MIN_AGENTS_PER_USER}")
         print("\n🚀 Your E2E test database is ready to use!")
 
 

autogpt_platform/frontend/package.json

@@ -132,7 +132,6 @@
     "@tanstack/eslint-plugin-query": "5.91.2",
     "@tanstack/react-query-devtools": "5.90.2",
     "@testing-library/dom": "10.4.1",
-    "@testing-library/jest-dom": "6.9.1",
     "@testing-library/react": "16.3.2",
     "@types/canvas-confetti": "1.9.0",
     "@types/lodash": "4.17.20",

autogpt_platform/frontend/pnpm-lock.yaml

@@ -312,9 +312,6 @@ importers:
       '@testing-library/dom':
         specifier: 10.4.1
         version: 10.4.1
-      '@testing-library/jest-dom':
-        specifier: 6.9.1
-        version: 6.9.1
       '@testing-library/react':
         specifier: 16.3.2
         version: 16.3.2(@testing-library/dom@10.4.1)(@types/react-dom@18.3.5(@types/react@18.3.17))(@types/react@18.3.17)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)

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

@@ -80,7 +80,6 @@ export const AgentInfo = ({
   const allVersions = storeData?.versions
     ? storeData.versions
         .map((versionStr: string) => parseInt(versionStr, 10))
-        .filter((versionNum: number) => !isNaN(versionNum))
         .sort((a: number, b: number) => b - a)
         .map((versionNum: number) => ({
           version: versionNum,

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainAgentPage/__tests__/auth-state.test.tsx

@@ -1,64 +0,0 @@
-import { describe, expect, test, afterEach } from "vitest";
-import { render, screen, waitFor } from "@/tests/integrations/test-utils";
-import { MainAgentPage } from "../MainAgentPage";
-import {
-  mockAuthenticatedUser,
-  mockUnauthenticatedUser,
-  resetAuthState,
-} from "@/tests/integrations/helpers/mock-supabase-auth";
-
-const defaultParams = {
-  creator: "test-creator",
-  slug: "test-agent",
-};
-
-describe("MainAgentPage - Auth State", () => {
-  afterEach(() => {
-    resetAuthState();
-  });
-
-  test("shows add to library button when authenticated", async () => {
-    mockAuthenticatedUser();
-    render(<MainAgentPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByTestId("agent-add-library-button"),
-      ).toBeInTheDocument();
-    });
-  });
-
-  test("hides add to library button when not authenticated", async () => {
-    mockUnauthenticatedUser();
-    render(<MainAgentPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId("agent-title")).toBeInTheDocument();
-    });
-    expect(
-      screen.queryByTestId("agent-add-library-button"),
-    ).not.toBeInTheDocument();
-  });
-
-  test("renders page correctly when logged out", async () => {
-    mockUnauthenticatedUser();
-    render(<MainAgentPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId("agent-title")).toBeInTheDocument();
-    });
-    expect(screen.getByTestId("agent-download-button")).toBeInTheDocument();
-  });
-
-  test("renders page correctly when logged in", async () => {
-    mockAuthenticatedUser();
-    render(<MainAgentPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId("agent-title")).toBeInTheDocument();
-    });
-    expect(
-      screen.getByTestId("agent-add-library-button"),
-    ).toBeInTheDocument();
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainAgentPage/__tests__/error-handling.test.tsx

@@ -1,57 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { render, screen, waitFor, act } from "@/tests/integrations/test-utils";
-import { MainAgentPage } from "../MainAgentPage";
-import { server } from "@/mocks/mock-server";
-import { getGetV2GetSpecificAgentMockHandler422 } from "@/app/api/__generated__/endpoints/store/store.msw";
-import { create500Handler } from "@/tests/integrations/helpers/create-500-handler";
-
-const defaultParams = {
-  creator: "test-creator",
-  slug: "test-agent",
-};
-
-describe("MainAgentPage - Error Handling", () => {
-  test("displays error when agent API returns 422", async () => {
-    server.use(getGetV2GetSpecificAgentMockHandler422());
-
-    render(<MainAgentPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText("Failed to load agent data", { exact: false }),
-      ).toBeInTheDocument();
-    });
-
-    await act(async () => {});
-  });
-
-  test("displays error when API returns 500", async () => {
-    server.use(
-      create500Handler("get", "*/api/store/agents/test-creator/test-agent"),
-    );
-
-    render(<MainAgentPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText("Failed to load agent data", { exact: false }),
-      ).toBeInTheDocument();
-    });
-
-    await act(async () => {});
-  });
-
-  test("retry button is visible on error", async () => {
-    server.use(getGetV2GetSpecificAgentMockHandler422());
-
-    render(<MainAgentPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByRole("button", { name: /try again/i }),
-      ).toBeInTheDocument();
-    });
-
-    await act(async () => {});
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainAgentPage/__tests__/rendering.test.tsx

@@ -1,61 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { render, screen, waitFor } from "@/tests/integrations/test-utils";
-import { MainAgentPage } from "../MainAgentPage";
-
-const defaultParams = {
-  creator: "test-creator",
-  slug: "test-agent",
-};
-
-describe("MainAgentPage - Rendering", () => {
-  test("renders agent info with title", async () => {
-    render(<MainAgentPage params={defaultParams} />);
-    await waitFor(() => {
-      expect(screen.getByTestId("agent-title")).toBeInTheDocument();
-    });
-  });
-
-  test("renders agent creator info", async () => {
-    render(<MainAgentPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId("agent-creator")).toBeInTheDocument();
-    });
-  });
-
-  test("renders agent description", async () => {
-    render(<MainAgentPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId("agent-description")).toBeInTheDocument();
-    });
-  });
-
-  test("renders breadcrumbs with marketplace link", async () => {
-    render(<MainAgentPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByRole("link", { name: /marketplace/i }),
-      ).toBeInTheDocument();
-    });
-  });
-
-  test("renders download button", async () => {
-    render(<MainAgentPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId("agent-download-button")).toBeInTheDocument();
-    });
-  });
-
-  test("renders similar agents section", async () => {
-    render(<MainAgentPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText("Similar agents", { exact: false }),
-      ).toBeInTheDocument();
-    });
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainCreatorPage/__tests__/auth-state.test.tsx

@@ -1,36 +0,0 @@
-import { describe, expect, test, afterEach } from "vitest";
-import { render, screen, waitFor } from "@/tests/integrations/test-utils";
-import { MainCreatorPage } from "../MainCreatorPage";
-import {
-  mockAuthenticatedUser,
-  mockUnauthenticatedUser,
-  resetAuthState,
-} from "@/tests/integrations/helpers/mock-supabase-auth";
-
-const defaultParams = {
-  creator: "test-creator",
-};
-
-describe("MainCreatorPage - Auth State", () => {
-  afterEach(() => {
-    resetAuthState();
-  });
-
-  test("renders page correctly when logged out", async () => {
-    mockUnauthenticatedUser();
-    render(<MainCreatorPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId("creator-description")).toBeInTheDocument();
-    });
-  });
-
-  test("renders page correctly when logged in", async () => {
-    mockAuthenticatedUser();
-    render(<MainCreatorPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId("creator-description")).toBeInTheDocument();
-    });
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainCreatorPage/__tests__/error-handling.test.tsx

@@ -1,63 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { render, screen, waitFor } from "@/tests/integrations/test-utils";
-import { MainCreatorPage } from "../MainCreatorPage";
-import { server } from "@/mocks/mock-server";
-import {
-  getGetV2GetCreatorDetailsMockHandler422,
-  getGetV2ListStoreAgentsMockHandler422,
-} from "@/app/api/__generated__/endpoints/store/store.msw";
-import { create500Handler } from "@/tests/integrations/helpers/create-500-handler";
-
-const defaultParams = {
-  creator: "test-creator",
-};
-
-describe("MainCreatorPage - Error Handling", () => {
-  test("displays error when creator details API returns 422", async () => {
-    server.use(getGetV2GetCreatorDetailsMockHandler422());
-
-    render(<MainCreatorPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText("Failed to load creator data", { exact: false }),
-      ).toBeInTheDocument();
-    });
-  });
-
-  test("displays error when creator agents API returns 422", async () => {
-    server.use(getGetV2ListStoreAgentsMockHandler422());
-
-    render(<MainCreatorPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText("Failed to load creator data", { exact: false }),
-      ).toBeInTheDocument();
-    });
-  });
-
-  test("displays error when API returns 500", async () => {
-    server.use(create500Handler("get", "*/api/store/creator/test-creator"));
-
-    render(<MainCreatorPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText("Failed to load creator data", { exact: false }),
-      ).toBeInTheDocument();
-    });
-  });
-
-  test("retry button is visible on error", async () => {
-    server.use(getGetV2GetCreatorDetailsMockHandler422());
-
-    render(<MainCreatorPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByRole("button", { name: /try again/i }),
-      ).toBeInTheDocument();
-    });
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainCreatorPage/__tests__/rendering.test.tsx

@@ -1,44 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { render, screen, waitFor } from "@/tests/integrations/test-utils";
-import { MainCreatorPage } from "../MainCreatorPage";
-
-const defaultParams = {
-  creator: "test-creator",
-};
-
-describe("MainCreatorPage - Rendering", () => {
-  test("renders creator info card", async () => {
-    render(<MainCreatorPage params={defaultParams} />);
-    await waitFor(() => {
-      expect(screen.getByTestId("creator-description")).toBeInTheDocument();
-    });
-  });
-
-  test("renders breadcrumbs with marketplace link", async () => {
-    render(<MainCreatorPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByRole("link", { name: /marketplace/i }),
-      ).toBeInTheDocument();
-    });
-  });
-
-  test("renders about section", async () => {
-    render(<MainCreatorPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(screen.getByText("About")).toBeInTheDocument();
-    });
-  });
-
-  test("renders agents by creator section", async () => {
-    render(<MainCreatorPage params={defaultParams} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText(/Agents by/i, { exact: false }),
-      ).toBeInTheDocument();
-    });
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainMarketplacePage/__tests__/auth-state.test.tsx

@@ -1,38 +0,0 @@
-import { describe, expect, test, afterEach } from "vitest";
-import { render, screen } from "@/tests/integrations/test-utils";
-import { MainMarkeplacePage } from "../MainMarketplacePage";
-import {
-  mockAuthenticatedUser,
-  mockUnauthenticatedUser,
-  resetAuthState,
-} from "@/tests/integrations/helpers/mock-supabase-auth";
-
-describe("MainMarketplacePage - Auth State", () => {
-  afterEach(() => {
-    resetAuthState();
-  });
-
-  test("renders page correctly when logged out", async () => {
-    mockUnauthenticatedUser();
-    render(<MainMarkeplacePage />);
-
-    expect(
-      await screen.findByText("Featured agents", { exact: false }),
-    ).toBeInTheDocument();
-    expect(
-      screen.getByText("Top Agents", { exact: false }),
-    ).toBeInTheDocument();
-  });
-
-  test("renders page correctly when logged in", async () => {
-    mockAuthenticatedUser();
-    render(<MainMarkeplacePage />);
-
-    expect(
-      await screen.findByText("Featured agents", { exact: false }),
-    ).toBeInTheDocument();
-    expect(
-      screen.getByText("Top Agents", { exact: false }),
-    ).toBeInTheDocument();
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainMarketplacePage/__tests__/empty-state.test.tsx

@@ -1,87 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { render, screen } from "@/tests/integrations/test-utils";
-import { MainMarkeplacePage } from "../MainMarketplacePage";
-import { server } from "@/mocks/mock-server";
-import { http, HttpResponse } from "msw";
-
-describe("MainMarketplacePage - Empty State", () => {
-  test("handles empty featured agents gracefully", async () => {
-    server.use(
-      http.get("*/api/store/agents*", () => {
-        return HttpResponse.json({
-          agents: [],
-          pagination: {
-            total_items: 0,
-            total_pages: 0,
-            current_page: 1,
-            page_size: 10,
-          },
-        });
-      }),
-    );
-
-    render(<MainMarkeplacePage />);
-
-    // Page should still render without crashing
-    expect(
-      await screen.findByText("Featured creators", { exact: false }),
-    ).toBeInTheDocument();
-  });
-
-  test("handles empty creators gracefully", async () => {
-    server.use(
-      http.get("*/api/store/creators*", () => {
-        return HttpResponse.json({
-          creators: [],
-          pagination: {
-            total_items: 0,
-            total_pages: 0,
-            current_page: 1,
-            page_size: 10,
-          },
-        });
-      }),
-    );
-
-    render(<MainMarkeplacePage />);
-
-    // Page should still render without crashing
-    expect(
-      await screen.findByText("Featured agents", { exact: false }),
-    ).toBeInTheDocument();
-  });
-
-  test("handles all empty data gracefully", async () => {
-    server.use(
-      http.get("*/api/store/agents*", () => {
-        return HttpResponse.json({
-          agents: [],
-          pagination: {
-            total_items: 0,
-            total_pages: 0,
-            current_page: 1,
-            page_size: 10,
-          },
-        });
-      }),
-      http.get("*/api/store/creators*", () => {
-        return HttpResponse.json({
-          creators: [],
-          pagination: {
-            total_items: 0,
-            total_pages: 0,
-            current_page: 1,
-            page_size: 10,
-          },
-        });
-      }),
-    );
-
-    render(<MainMarkeplacePage />);
-
-    // Page should still render the search bar
-    expect(
-      await screen.findByPlaceholderText(/search/i),
-    ).toBeInTheDocument();
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainMarketplacePage/__tests__/error-handling.test.tsx

@@ -1,59 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { render, screen, waitFor } from "@/tests/integrations/test-utils";
-import { MainMarkeplacePage } from "../MainMarketplacePage";
-import { server } from "@/mocks/mock-server";
-import {
-  getGetV2ListStoreAgentsMockHandler422,
-  getGetV2ListStoreCreatorsMockHandler422,
-} from "@/app/api/__generated__/endpoints/store/store.msw";
-import { create500Handler } from "@/tests/integrations/helpers/create-500-handler";
-
-describe("MainMarketplacePage - Error Handling", () => {
-  test("displays error when featured agents API returns 422", async () => {
-    server.use(getGetV2ListStoreAgentsMockHandler422());
-
-    render(<MainMarkeplacePage />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText("Failed to load marketplace data", { exact: false }),
-      ).toBeInTheDocument();
-    });
-  });
-
-  test("displays error when creators API returns 422", async () => {
-    server.use(getGetV2ListStoreCreatorsMockHandler422());
-
-    render(<MainMarkeplacePage />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText("Failed to load marketplace data", { exact: false }),
-      ).toBeInTheDocument();
-    });
-  });
-
-  test("displays error when API returns 500", async () => {
-    server.use(create500Handler("get", "*/api/store/agents*"));
-
-    render(<MainMarkeplacePage />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText("Failed to load marketplace data", { exact: false }),
-      ).toBeInTheDocument();
-    });
-  });
-
-  test("retry button is visible on error", async () => {
-    server.use(getGetV2ListStoreAgentsMockHandler422());
-
-    render(<MainMarkeplacePage />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByRole("button", { name: /try again/i }),
-      ).toBeInTheDocument();
-    });
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainMarketplacePage/__tests__/loading-state.test.tsx

@@ -1,43 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { render } from "@/tests/integrations/test-utils";
-import { MainMarkeplacePage } from "../MainMarketplacePage";
-import { server } from "@/mocks/mock-server";
-import { http, HttpResponse, delay } from "msw";
-
-describe("MainMarketplacePage - Loading State", () => {
-  test("shows loading skeleton while data is being fetched", async () => {
-    // Override handlers to add delay to simulate loading
-    server.use(
-      http.get("*/api/store/agents*", async () => {
-        await delay(500);
-        return HttpResponse.json({
-          agents: [],
-          pagination: {
-            total_items: 0,
-            total_pages: 0,
-            current_page: 1,
-            page_size: 10,
-          },
-        });
-      }),
-      http.get("*/api/store/creators*", async () => {
-        await delay(500);
-        return HttpResponse.json({
-          creators: [],
-          pagination: {
-            total_items: 0,
-            total_pages: 0,
-            current_page: 1,
-            page_size: 10,
-          },
-        });
-      }),
-    );
-
-    const { container } = render(<MainMarkeplacePage />);
-
-    // Check for loading skeleton elements (animated pulse elements)
-    const loadingElements = container.querySelectorAll('[class*="animate-pulse"]');
-    expect(loadingElements.length).toBeGreaterThan(0);
-  });
-});

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

@@ -0,0 +1,15 @@
+import { expect, test } from "vitest";
+import { render, screen } from "@/tests/integrations/test-utils";
+import { MainMarkeplacePage } from "../MainMarketplacePage";
+import { server } from "@/mocks/mock-server";
+import { getDeleteV2DeleteStoreSubmissionMockHandler422 } from "@/app/api/__generated__/endpoints/store/store.msw";
+
+// Only for CI testing purpose, will remove it in future PR
+test("MainMarketplacePage", async () => {
+  server.use(getDeleteV2DeleteStoreSubmissionMockHandler422());
+
+  render(<MainMarkeplacePage />);
+  expect(
+    await screen.findByText("Featured agents", { exact: false }),
+  ).toBeDefined();
+});

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

@@ -1,39 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { render, screen } from "@/tests/integrations/test-utils";
-import { MainMarkeplacePage } from "../MainMarketplacePage";
-
-describe("MainMarketplacePage - Rendering", () => {
-  test("renders hero section with search bar", async () => {
-    render(<MainMarkeplacePage />);
-
-    expect(
-      await screen.findByText("Featured agents", { exact: false }),
-    ).toBeInTheDocument();
-
-    expect(screen.getByPlaceholderText(/search/i)).toBeInTheDocument();
-  });
-
-  test("renders featured agents section", async () => {
-    render(<MainMarkeplacePage />);
-
-    expect(
-      await screen.findByText("Featured agents", { exact: false }),
-    ).toBeInTheDocument();
-  });
-
-  test("renders top agents section", async () => {
-    render(<MainMarkeplacePage />);
-
-    expect(
-      await screen.findByText("Top Agents", { exact: false }),
-    ).toBeInTheDocument();
-  });
-
-  test("renders featured creators section", async () => {
-    render(<MainMarkeplacePage />);
-
-    expect(
-      await screen.findByText("Featured creators", { exact: false }),
-    ).toBeInTheDocument();
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainSearchResultPage/__tests__/auth-state.test.tsx

@@ -1,37 +0,0 @@
-import { describe, expect, test, afterEach } from "vitest";
-import { render, screen, waitFor } from "@/tests/integrations/test-utils";
-import { MainSearchResultPage } from "../MainSearchResultPage";
-import {
-  mockAuthenticatedUser,
-  mockUnauthenticatedUser,
-  resetAuthState,
-} from "@/tests/integrations/helpers/mock-supabase-auth";
-
-const defaultProps = {
-  searchTerm: "test-search",
-  sort: undefined as undefined,
-};
-
-describe("MainSearchResultPage - Auth State", () => {
-  afterEach(() => {
-    resetAuthState();
-  });
-
-  test("renders page correctly when logged out", async () => {
-    mockUnauthenticatedUser();
-    render(<MainSearchResultPage {...defaultProps} />);
-
-    await waitFor(() => {
-      expect(screen.getByText("Results for:")).toBeInTheDocument();
-    });
-  });
-
-  test("renders page correctly when logged in", async () => {
-    mockAuthenticatedUser();
-    render(<MainSearchResultPage {...defaultProps} />);
-
-    await waitFor(() => {
-      expect(screen.getByText("Results for:")).toBeInTheDocument();
-    });
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainSearchResultPage/__tests__/error-handling.test.tsx

@@ -1,64 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { render, screen, waitFor } from "@/tests/integrations/test-utils";
-import { MainSearchResultPage } from "../MainSearchResultPage";
-import { server } from "@/mocks/mock-server";
-import {
-  getGetV2ListStoreAgentsMockHandler422,
-  getGetV2ListStoreCreatorsMockHandler422,
-} from "@/app/api/__generated__/endpoints/store/store.msw";
-import { create500Handler } from "@/tests/integrations/helpers/create-500-handler";
-
-const defaultProps = {
-  searchTerm: "test-search",
-  sort: undefined as undefined,
-};
-
-describe("MainSearchResultPage - Error Handling", () => {
-  test("displays error when agents API returns 422", async () => {
-    server.use(getGetV2ListStoreAgentsMockHandler422());
-
-    render(<MainSearchResultPage {...defaultProps} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText("Failed to load marketplace data", { exact: false }),
-      ).toBeInTheDocument();
-    });
-  });
-
-  test("displays error when creators API returns 422", async () => {
-    server.use(getGetV2ListStoreCreatorsMockHandler422());
-
-    render(<MainSearchResultPage {...defaultProps} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText("Failed to load marketplace data", { exact: false }),
-      ).toBeInTheDocument();
-    });
-  });
-
-  test("displays error when API returns 500", async () => {
-    server.use(create500Handler("get", "*/api/store/agents*"));
-
-    render(<MainSearchResultPage {...defaultProps} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByText("Failed to load marketplace data", { exact: false }),
-      ).toBeInTheDocument();
-    });
-  });
-
-  test("retry button is visible on error", async () => {
-    server.use(getGetV2ListStoreAgentsMockHandler422());
-
-    render(<MainSearchResultPage {...defaultProps} />);
-
-    await waitFor(() => {
-      expect(
-        screen.getByRole("button", { name: /try again/i }),
-      ).toBeInTheDocument();
-    });
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainSearchResultPage/__tests__/no-results.test.tsx

@@ -1,92 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { render, screen, waitFor } from "@/tests/integrations/test-utils";
-import { MainSearchResultPage } from "../MainSearchResultPage";
-import { server } from "@/mocks/mock-server";
-import { http, HttpResponse } from "msw";
-
-const defaultProps = {
-  searchTerm: "nonexistent-search-term-xyz",
-  sort: undefined as undefined,
-};
-
-describe("MainSearchResultPage - No Results", () => {
-  test("shows empty state when no agents match search", async () => {
-    server.use(
-      http.get("*/api/store/agents*", () => {
-        return HttpResponse.json({
-          agents: [],
-          pagination: {
-            total_items: 0,
-            total_pages: 0,
-            current_page: 1,
-            page_size: 10,
-          },
-        });
-      }),
-      http.get("*/api/store/creators*", () => {
-        return HttpResponse.json({
-          creators: [],
-          pagination: {
-            total_items: 0,
-            total_pages: 0,
-            current_page: 1,
-            page_size: 10,
-          },
-        });
-      }),
-    );
-
-    render(<MainSearchResultPage {...defaultProps} />);
-
-    await waitFor(() => {
-      expect(screen.getByText("Results for:")).toBeInTheDocument();
-    });
-    
-    // Verify search term is displayed
-    expect(screen.getByText("nonexistent-search-term-xyz")).toBeInTheDocument();
-  });
-
-  test("displays search term even with no results", async () => {
-    server.use(
-      http.get("*/api/store/agents*", () => {
-        return HttpResponse.json({
-          agents: [],
-          pagination: {
-            total_items: 0,
-            total_pages: 0,
-            current_page: 1,
-            page_size: 10,
-          },
-        });
-      }),
-    );
-
-    render(<MainSearchResultPage {...defaultProps} />);
-
-    await waitFor(() => {
-      expect(screen.getByText("nonexistent-search-term-xyz")).toBeInTheDocument();
-    });
-  });
-
-  test("search bar remains functional with no results", async () => {
-    server.use(
-      http.get("*/api/store/agents*", () => {
-        return HttpResponse.json({
-          agents: [],
-          pagination: {
-            total_items: 0,
-            total_pages: 0,
-            current_page: 1,
-            page_size: 10,
-          },
-        });
-      }),
-    );
-
-    render(<MainSearchResultPage {...defaultProps} />);
-
-    await waitFor(() => {
-      expect(screen.getByPlaceholderText(/search/i)).toBeInTheDocument();
-    });
-  });
-});

autogpt_platform/frontend/src/app/(platform)/marketplace/components/MainSearchResultPage/__tests__/rendering.test.tsx

@@ -1,27 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { render, screen, waitFor } from "@/tests/integrations/test-utils";
-import { MainSearchResultPage } from "../MainSearchResultPage";
-
-const defaultProps = {
-  searchTerm: "test-search",
-  sort: undefined as undefined,
-};
-
-describe("MainSearchResultPage - Rendering", () => {
-  test("renders search results header with search term", async () => {
-    render(<MainSearchResultPage {...defaultProps} />);
-
-    await waitFor(() => {
-      expect(screen.getByText("Results for:")).toBeInTheDocument();
-    });
-    expect(screen.getByText("test-search")).toBeInTheDocument();
-  });
-
-  test("renders search bar", async () => {
-    render(<MainSearchResultPage {...defaultProps} />);
-
-    await waitFor(() => {
-      expect(screen.getByPlaceholderText(/search/i)).toBeInTheDocument();
-    });
-  });
-});

autogpt_platform/frontend/src/app/api/mutators/custom-mutator.ts

@@ -136,19 +136,16 @@ export const customMutator = async <
       response.statusText ||
       `HTTP ${response.status}`;
 
-      const isTestEnv = process.env.NODE_ENV === 'test';
-      if (!isTestEnv) {
-        console.error(
-          `Request failed ${environment.isServerSide() ? "on server" : "on client"}`,
-          {
-            status: response.status,
-            method,
-            url: fullUrl.replace(baseUrl, ""), // Show relative URL for cleaner logs
-            errorMessage,
-            responseData: responseData || "No response data",
-          },
-        );
-      }
+    console.error(
+      `Request failed ${environment.isServerSide() ? "on server" : "on client"}`,
+      {
+        status: response.status,
+        method,
+        url: fullUrl.replace(baseUrl, ""), // Show relative URL for cleaner logs
+        errorMessage,
+        responseData: responseData || "No response data",
+      },
+    );
 
     throw new ApiError(errorMessage, response.status, responseData);
   }

autogpt_platform/frontend/src/components/contextual/Chat/components/ToolResponseMessage/helpers.ts

@@ -30,9 +30,9 @@ export function getErrorMessage(result: unknown): string {
   }
   if (typeof result === "object" && result !== null) {
     const response = result as Record<string, unknown>;
-    if (response.error) return stripInternalReasoning(String(response.error));
     if (response.message)
       return stripInternalReasoning(String(response.message));
+    if (response.error) return stripInternalReasoning(String(response.error));
   }
   return "An error occurred";
 }
@@ -363,8 +363,8 @@ export function formatToolResponse(result: unknown, toolName: string): string {
 
     case "error":
       const errorMsg =
-        (response.error as string) || response.message || "An error occurred";
-      return `Error: ${errorMsg}`;
+        (response.message as string) || response.error || "An error occurred";
+      return String(errorMsg);
 
     case "no_results":
       const suggestions = (response.suggestions as string[]) || [];

autogpt_platform/frontend/src/tests/CLAUDE.md

@@ -218,61 +218,3 @@ test("shows error when deletion fails", async () => {
 4. **Co-locate integration tests** - Keep `__tests__/` folder next to the component
 5. **E2E is expensive** - Only for critical happy paths; prefer integration tests
 6. **AI agents are good at writing integration tests** - Start with these when adding test coverage
-
----
-
-## Testing 500 Server Errors
-
-Orval auto-generates 422 validation error handlers, but 500 errors must be created manually. Use the helper:
-
-```tsx
-import { create500Handler } from "@/tests/integrations/helpers/create-500-handler";
-
-test("handles server error", async () => {
-  server.use(create500Handler("get", "*/api/store/agents"));
-  render(<Component />);
-  expect(await screen.findByText("Failed to load")).toBeInTheDocument();
-});
-```
-
-Options:
-
-- `delayMs`: Add delay before response (for testing loading states)
-- `body`: Custom error response body
-
----
-
-## Testing Auth-Dependent Components
-
-For components that behave differently based on login state:
-
-```tsx
-import {
-  mockAuthenticatedUser,
-  mockUnauthenticatedUser,
-  resetAuthState,
-} from "@/tests/integrations/helpers/mock-supabase-auth";
-
-describe("MyComponent", () => {
-  afterEach(() => {
-    resetAuthState();
-  });
-
-  test("shows feature when logged in", async () => {
-    mockAuthenticatedUser();
-    render(<MyComponent />);
-    expect(await screen.findByText("Premium Feature")).toBeInTheDocument();
-  });
-
-  test("hides feature when logged out", async () => {
-    mockUnauthenticatedUser();
-    render(<MyComponent />);
-    expect(screen.queryByText("Premium Feature")).not.toBeInTheDocument();
-  });
-
-  test("with custom user data", async () => {
-    mockAuthenticatedUser({ email: "custom@test.com" });
-    // ...
-  });
-});
-```

autogpt_platform/frontend/src/tests/integrations/helpers/create-500-handler.ts

@@ -1,31 +0,0 @@
-import { http, HttpResponse, delay } from "msw";
-
-type HttpMethod = "get" | "post" | "put" | "patch" | "delete";
-
-interface Create500HandlerOptions {
-  delayMs?: number;
-  body?: Record<string, unknown>;
-}
-
-export function create500Handler(
-  method: HttpMethod,
-  url: string,
-  options?: Create500HandlerOptions,
-) {
-  const { delayMs = 0, body } = options ?? {};
-
-  const responseBody = body ?? {
-    detail: "Internal Server Error",
-  };
-
-  return http[method](url, async () => {
-    if (delayMs > 0) {
-      await delay(delayMs);
-    }
-
-    return HttpResponse.json(responseBody, {
-      status: 500,
-      headers: { "Content-Type": "application/json" },
-    });
-  });
-}

autogpt_platform/frontend/src/tests/integrations/helpers/mock-onboarding-provider.tsx

@@ -1,42 +0,0 @@
-import { createContext, useContext, ReactNode } from "react";
-import { UserOnboarding } from "@/lib/autogpt-server-api";
-import { PostV1CompleteOnboardingStepStep } from "@/app/api/__generated__/models/postV1CompleteOnboardingStepStep";
-import type { LocalOnboardingStateUpdate } from "@/providers/onboarding/helpers";
-
-const MockOnboardingContext = createContext<{
-  state: UserOnboarding | null;
-  updateState: (state: LocalOnboardingStateUpdate) => void;
-  step: number;
-  setStep: (step: number) => void;
-  completeStep: (step: PostV1CompleteOnboardingStepStep) => void;
-}>({
-  state: null,
-  updateState: () => {},
-  step: 1,
-  setStep: () => {},
-  completeStep: () => {},
-});
-
-export function useOnboarding(
-  step?: number,
-  completeStep?: PostV1CompleteOnboardingStepStep,
-) {
-  const context = useContext(MockOnboardingContext);
-  return context;
-}
-
-export function MockOnboardingProvider({ children }: { children: ReactNode }) {
-  return (
-    <MockOnboardingContext.Provider
-      value={{
-        state: null,
-        updateState: () => {},
-        step: 1,
-        setStep: () => {},
-        completeStep: () => {},
-      }}
-    >
-      {children}
-    </MockOnboardingContext.Provider>
-  );
-}

autogpt_platform/frontend/src/tests/integrations/helpers/mock-supabase-auth.ts

@@ -1,40 +0,0 @@
-import type { User } from "@supabase/supabase-js";
-import { useSupabaseStore } from "@/lib/supabase/hooks/useSupabaseStore";
-
-export const mockUser: User = {
-  id: "test-user-id",
-  email: "test@example.com",
-  aud: "authenticated",
-  role: "authenticated",
-  created_at: new Date().toISOString(),
-  app_metadata: {},
-  user_metadata: {},
-};
-
-export function mockAuthenticatedUser(user: Partial<User> = {}): User {
-  const mergedUser = { ...mockUser, ...user };
-
-  useSupabaseStore.setState({
-    user: mergedUser,
-    isUserLoading: false,
-    hasLoadedUser: true,
-  });
-
-  return mergedUser;
-}
-
-export function mockUnauthenticatedUser(): void {
-  useSupabaseStore.setState({
-    user: null,
-    isUserLoading: false,
-    hasLoadedUser: true,
-  });
-}
-
-export function resetAuthState(): void {
-  useSupabaseStore.setState({
-    user: null,
-    isUserLoading: true,
-    hasLoadedUser: false,
-  });
-}

autogpt_platform/frontend/src/tests/integrations/helpers/supress-react-query-update-warning.ts

@@ -1,37 +0,0 @@
-// Suppresses expected act(...) warnings from React Query and component async updates.
-// These warnings are normal behavior with React Query and don't indicate test failures.
-export function suppressReactQueryUpdateWarning() {
-    const originalError = console.error;
-  
-    console.error = (...args: unknown[]) => {
-      const isActWarning = args.some(
-        (arg) =>
-          typeof arg === "string" &&
-          (arg.includes("not wrapped in act(...)") ||
-            arg.includes("An update to") && arg.includes("inside a test"))
-      );
-  
-      if (isActWarning) {
-        const fullMessage = args
-          .map((arg) => String(arg))
-          .join("\n")
-          .toLowerCase();
-  
-        const isReactQueryRelated =
-          fullMessage.includes("queryclientprovider") ||
-          fullMessage.includes("react query") ||
-          fullMessage.includes("@tanstack/react-query");
-  
-        if (isReactQueryRelated || fullMessage.includes("testproviders")) {
-          return;
-        }
-      }
-  
-      originalError(...args);
-    };
-  
-    // Return cleanup function
-    return () => {
-      console.error = originalError;
-    };
-  }

autogpt_platform/frontend/src/tests/integrations/test-utils.tsx

@@ -1,22 +1,14 @@
 import { BackendAPIProvider } from "@/lib/autogpt-server-api/context";
+import OnboardingProvider from "@/providers/onboarding/onboarding-provider";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { render, RenderOptions, act } from "@testing-library/react";
+import { render, RenderOptions } from "@testing-library/react";
 import { ReactElement, ReactNode } from "react";
-import { MockOnboardingProvider, useOnboarding as mockUseOnboarding } from "./helpers/mock-onboarding-provider";
-
-vi.mock("@/providers/onboarding/onboarding-provider", () => ({
-  useOnboarding: mockUseOnboarding,
-  default: vi.fn(),
-}));
 
 function createTestQueryClient() {
   return new QueryClient({
     defaultOptions: {
       queries: {
         retry: false,
-        refetchOnWindowFocus: false,
-        refetchOnMount: false,
-        refetchOnReconnect: false,
       },
     },
   });
@@ -27,7 +19,7 @@ function TestProviders({ children }: { children: ReactNode }) {
   return (
     <QueryClientProvider client={queryClient}>
       <BackendAPIProvider>
-        <MockOnboardingProvider>{children}</MockOnboardingProvider>
+        <OnboardingProvider>{children}</OnboardingProvider>
       </BackendAPIProvider>
     </QueryClientProvider>
   );

autogpt_platform/frontend/src/tests/integrations/vitest.setup.tsx

@@ -2,17 +2,11 @@ import { beforeAll, afterAll, afterEach } from "vitest";
 import { server } from "@/mocks/mock-server";
 import { mockNextjsModules } from "./setup-nextjs-mocks";
 import { mockSupabaseRequest } from "./mock-supabase-request";
-import "@testing-library/jest-dom";
-import { suppressReactQueryUpdateWarning } from "./helpers/supress-react-query-update-warning";
 
 beforeAll(() => {
   mockNextjsModules();
-  mockSupabaseRequest();
-  const restoreConsoleError = suppressReactQueryUpdateWarning();
-  afterAll(() => {
-    restoreConsoleError();
-  });
+  mockSupabaseRequest(); // If you need user's data - please mock supabase actions in your specific test - it sends null user [It's only to avoid cookies() call]
   return server.listen({ onUnhandledRequest: "error" });
 });
-afterEach(() => {server.resetHandlers()});
+afterEach(() => server.resetHandlers());
 afterAll(() => server.close());

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

@@ -59,13 +59,12 @@ test.describe("Library", () => {
   });
 
   test("pagination works correctly", async ({ page }, testInfo) => {
-    test.setTimeout(testInfo.timeout * 3);
+    test.setTimeout(testInfo.timeout * 3); // Increase timeout for pagination operations
     await page.goto("/library");
 
-    const PAGE_SIZE = 20;
     const paginationResult = await libraryPage.testPagination();
 
-    if (paginationResult.initialCount >= PAGE_SIZE) {
+    if (paginationResult.initialCount >= 10) {
       expect(paginationResult.finalCount).toBeGreaterThanOrEqual(
         paginationResult.initialCount,
       );
@@ -134,10 +133,7 @@ test.describe("Library", () => {
     test.expect(clearedSearchValue).toBe("");
   });
 
-  test("pagination while searching works correctly", async ({
-    page,
-  }, testInfo) => {
-    test.setTimeout(testInfo.timeout * 3);
+  test("pagination while searching works correctly", async ({ page }) => {
     await page.goto("/library");
 
     const allAgents = await libraryPage.getAgents();
@@ -156,10 +152,9 @@ test.describe("Library", () => {
     );
     expect(matchingResults.length).toEqual(initialSearchResults.length);
 
-    const PAGE_SIZE = 20;
     const searchPaginationResult = await libraryPage.testPagination();
 
-    if (searchPaginationResult.initialCount >= PAGE_SIZE) {
+    if (searchPaginationResult.initialCount >= 10) {
       expect(searchPaginationResult.finalCount).toBeGreaterThanOrEqual(
         searchPaginationResult.initialCount,
       );

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

@@ -9,7 +9,78 @@ function escapeRegExp(value: string) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-test.describe("Marketplace Agent Page - Cross-Page Flows", () => {
+test.describe("Marketplace Agent Page - Basic Functionality", () => {
+  test("User can access agent page when logged out", async ({ page }) => {
+    const marketplacePage = new MarketplacePage(page);
+
+    await marketplacePage.goto(page);
+    await hasUrl(page, "/marketplace");
+
+    const firstStoreCard = await marketplacePage.getFirstTopAgent();
+    await firstStoreCard.click();
+
+    await page.waitForURL("**/marketplace/agent/**");
+    await matchesUrl(page, /\/marketplace\/agent\/.+/);
+  });
+
+  test("User can access agent page when logged in", async ({ page }) => {
+    const loginPage = new LoginPage(page);
+    const marketplacePage = new MarketplacePage(page);
+
+    await loginPage.goto();
+    const richUser = getTestUserWithLibraryAgents();
+    await loginPage.login(richUser.email, richUser.password);
+    await hasUrl(page, "/marketplace");
+    await marketplacePage.goto(page);
+    await hasUrl(page, "/marketplace");
+
+    const firstStoreCard = await marketplacePage.getFirstTopAgent();
+    await firstStoreCard.click();
+
+    await page.waitForURL("**/marketplace/agent/**");
+    await matchesUrl(page, /\/marketplace\/agent\/.+/);
+  });
+
+  test("Agent page details are visible", async ({ page }) => {
+    const { getId } = getSelectors(page);
+
+    const marketplacePage = new MarketplacePage(page);
+    await marketplacePage.goto(page);
+
+    const firstStoreCard = await marketplacePage.getFirstTopAgent();
+    await firstStoreCard.click();
+    await page.waitForURL("**/marketplace/agent/**");
+
+    const agentTitle = getId("agent-title");
+    await isVisible(agentTitle);
+
+    const agentDescription = getId("agent-description");
+    await isVisible(agentDescription);
+
+    const creatorInfo = getId("agent-creator");
+    await isVisible(creatorInfo);
+  });
+
+  test("Download button functionality works", async ({ page }) => {
+    const { getId, getText } = getSelectors(page);
+
+    const marketplacePage = new MarketplacePage(page);
+    await marketplacePage.goto(page);
+
+    const firstStoreCard = await marketplacePage.getFirstTopAgent();
+    await firstStoreCard.click();
+    await page.waitForURL("**/marketplace/agent/**");
+
+    const downloadButton = getId("agent-download-button");
+    await isVisible(downloadButton);
+    await downloadButton.click();
+
+    const downloadSuccessMessage = getText(
+      "Your agent has been successfully downloaded.",
+    );
+    await isVisible(downloadSuccessMessage);
+  });
+
   test("Add to library button works and agent appears in library", async ({
     page,
   }) => {

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

@@ -1,8 +1,64 @@
 import { test } from "@playwright/test";
+import { getTestUserWithLibraryAgents } from "./credentials";
+import { LoginPage } from "./pages/login.page";
 import { MarketplacePage } from "./pages/marketplace.page";
-import { hasUrl, matchesUrl } from "./utils/assertion";
+import { hasUrl, isVisible, matchesUrl } from "./utils/assertion";
+import { getSelectors } from "./utils/selectors";
+
+test.describe("Marketplace Creator Page – Basic Functionality", () => {
+  test("User can access creator's page when logged out", async ({ page }) => {
+    const marketplacePage = new MarketplacePage(page);
+
+    await marketplacePage.goto(page);
+    await hasUrl(page, "/marketplace");
+
+    const firstCreatorProfile =
+      await marketplacePage.getFirstCreatorProfile(page);
+    await firstCreatorProfile.click();
+
+    await page.waitForURL("**/marketplace/creator/**");
+    await matchesUrl(page, /\/marketplace\/creator\/.+/);
+  });
+
+  test("User can access creator's page when logged in", async ({ page }) => {
+    const loginPage = new LoginPage(page);
+    const marketplacePage = new MarketplacePage(page);
+
+    await loginPage.goto();
+    const richUser = getTestUserWithLibraryAgents();
+    await loginPage.login(richUser.email, richUser.password);
+    await hasUrl(page, "/marketplace");
+
+    await marketplacePage.goto(page);
+    await hasUrl(page, "/marketplace");
+
+    const firstCreatorProfile =
+      await marketplacePage.getFirstCreatorProfile(page);
+    await firstCreatorProfile.click();
+
+    await page.waitForURL("**/marketplace/creator/**");
+    await matchesUrl(page, /\/marketplace\/creator\/.+/);
+  });
+
+  test("Creator page details are visible", async ({ page }) => {
+    const { getId } = getSelectors(page);
+    const marketplacePage = new MarketplacePage(page);
+
+    await marketplacePage.goto(page);
+    await hasUrl(page, "/marketplace");
+
+    const firstCreatorProfile =
+      await marketplacePage.getFirstCreatorProfile(page);
+    await firstCreatorProfile.click();
+    await page.waitForURL("**/marketplace/creator/**");
+
+    const creatorTitle = getId("creator-title");
+    await isVisible(creatorTitle);
+
+    const creatorDescription = getId("creator-description");
+    await isVisible(creatorDescription);
+  });
 
-test.describe("Marketplace Creator Page – Cross-Page Flows", () => {
   test("Agents in agent by sections navigation works", async ({ page }) => {
     const marketplacePage = new MarketplacePage(page);
 
@@ -13,12 +69,9 @@ test.describe("Marketplace Creator Page – Cross-Page Flows", () => {
       await marketplacePage.getFirstCreatorProfile(page);
     await firstCreatorProfile.click();
     await page.waitForURL("**/marketplace/creator/**");
-    await page.waitForLoadState("networkidle").catch(() => {});
-
     const firstAgent = page
       .locator('[data-testid="store-card"]:visible')
       .first();
-    await firstAgent.waitFor({ state: "visible", timeout: 30000 });
 
     await firstAgent.click();
     await page.waitForURL("**/marketplace/agent/**");

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

@@ -1,8 +1,74 @@
 import { expect, test } from "@playwright/test";
+import { getTestUserWithLibraryAgents } from "./credentials";
+import { LoginPage } from "./pages/login.page";
 import { MarketplacePage } from "./pages/marketplace.page";
-import { isVisible, matchesUrl } from "./utils/assertion";
+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);
+
+    await marketplacePage.goto(page);
+    await hasUrl(page, "/marketplace");
+
+    const marketplaceTitle = await marketplacePage.getMarketplaceTitle(page);
+    await isVisible(marketplaceTitle);
+
+    console.log(
+      "User can access marketplace page when logged out test passed ✅",
+    );
+  });
+
+  test("User can access marketplace page when logged in", async ({ page }) => {
+    const loginPage = new LoginPage(page);
+    const marketplacePage = new MarketplacePage(page);
+
+    await loginPage.goto();
+    const richUser = getTestUserWithLibraryAgents();
+    await loginPage.login(richUser.email, richUser.password);
+    await hasUrl(page, "/marketplace");
+
+    await marketplacePage.goto(page);
+    await hasUrl(page, "/marketplace");
+
+    const marketplaceTitle = await marketplacePage.getMarketplaceTitle(page);
+    await isVisible(marketplaceTitle);
+
+    console.log(
+      "User can access marketplace page when logged in test passed ✅",
+    );
+  });
+
+  test("Featured agents, top agents, and featured creators are visible", async ({
+    page,
+  }) => {
+    const marketplacePage = new MarketplacePage(page);
+    await marketplacePage.goto(page);
+
+    const featuredAgentsSection =
+      await marketplacePage.getFeaturedAgentsSection(page);
+    await isVisible(featuredAgentsSection);
+    const featuredAgentCards =
+      await marketplacePage.getFeaturedAgentCards(page);
+    await hasMinCount(featuredAgentCards, 1);
+
+    const topAgentsSection = await marketplacePage.getTopAgentsSection(page);
+    await isVisible(topAgentsSection);
+    const topAgentCards = await marketplacePage.getTopAgentCards(page);
+    await hasMinCount(topAgentCards, 1);
+
+    const featuredCreatorsSection =
+      await marketplacePage.getFeaturedCreatorsSection(page);
+    await isVisible(featuredCreatorsSection);
+    const creatorProfiles = await marketplacePage.getCreatorProfiles(page);
+    await hasMinCount(creatorProfiles, 1);
+
+    console.log(
+      "Featured agents, top agents, and featured creators are visible test passed ✅",
+    );
+  });
 
-test.describe("Marketplace – Navigation", () => {
   test("Can navigate and interact with marketplace elements", async ({
     page,
   }) => {
@@ -11,6 +77,7 @@ test.describe("Marketplace – Navigation", () => {
 
     const firstFeaturedAgent =
       await marketplacePage.getFirstFeaturedAgent(page);
+    await firstFeaturedAgent.waitFor({ state: "visible" });
     await firstFeaturedAgent.click();
     await page.waitForURL("**/marketplace/agent/**");
     await matchesUrl(page, /\/marketplace\/agent\/.+/);
@@ -29,7 +96,7 @@ test.describe("Marketplace – Navigation", () => {
     await matchesUrl(page, /\/marketplace\/creator\/.+/);
 
     console.log(
-      "Can navigate and interact with marketplace elements test passed",
+      "Can navigate and interact with marketplace elements test passed ✅",
     );
   });
 
@@ -49,19 +116,37 @@ test.describe("Marketplace – Navigation", () => {
     const searchTerm = page.getByText("DummyInput").first();
     await isVisible(searchTerm);
 
-    await page.waitForLoadState("networkidle").catch(() => {});
-
-    await page
-      .waitForFunction(
-        () =>
-          document.querySelectorAll('[data-testid="store-card"]').length > 0,
-        { timeout: 15000 },
-      )
-      .catch(() => console.log("No search results appeared within timeout"));
+    await page.waitForTimeout(10000);
 
     const results = await marketplacePage.getSearchResultsCount(page);
     expect(results).toBeGreaterThan(0);
 
-    console.log("Complete search flow works correctly test passed");
+    console.log("Complete search flow works correctly test passed ✅");
+  });
+
+  // We need to add a test search with filters, but the current business logic for filters doesn't work as expected. We'll add it once we modify that.
+});
+
+test.describe("Marketplace – Edge Cases", () => {
+  test("Search for non-existent item shows no results", async ({ page }) => {
+    const marketplacePage = new MarketplacePage(page);
+    await marketplacePage.goto(page);
+
+    await marketplacePage.searchAndNavigate("xyznonexistentitemxyz123", page);
+
+    await marketplacePage.waitForSearchResults();
+
+    await matchesUrl(page, /\/marketplace\/search\?searchTerm=/);
+
+    const resultsHeading = page.getByText("Results for:");
+    await isVisible(resultsHeading);
+
+    const searchTerm = page.getByText("xyznonexistentitemxyz123");
+    await isVisible(searchTerm);
+
+    const results = await marketplacePage.getSearchResultsCount(page);
+    expect(results).toBe(0);
+
+    console.log("Search for non-existent item shows no results test passed ✅");
   });
 });

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

@@ -300,27 +300,21 @@ export class LibraryPage extends BasePage {
   async scrollToLoadMore(): Promise<void> {
     console.log(`scrolling to load more agents`);
 
-    const initialCount = await this.getAgentCountByListLength();
-    console.log(`Initial agent count (DOM cards): ${initialCount}`);
+    // Get initial agent count
+    const initialCount = await this.getAgentCount();
+    console.log(`Initial agent count: ${initialCount}`);
 
+    // Scroll down to trigger pagination
     await this.scrollToBottom();
 
-    await this.page
-      .waitForLoadState("networkidle", { timeout: 10000 })
-      .catch(() => console.log("Network idle timeout, continuing..."));
+    // Wait for potential new agents to load
+    await this.page.waitForTimeout(2000);
 
-    await this.page
-      .waitForFunction(
-        (prevCount) =>
-          document.querySelectorAll('[data-testid="library-agent-card"]')
-            .length > prevCount,
-        initialCount,
-        { timeout: 5000 },
-      )
-      .catch(() => {});
+    // Check if more agents loaded
+    const newCount = await this.getAgentCount();
+    console.log(`New agent count after scroll: ${newCount}`);
 
-    const newCount = await this.getAgentCountByListLength();
-    console.log(`New agent count after scroll (DOM cards): ${newCount}`);
+    return;
   }
 
   async testPagination(): Promise<{

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

@@ -9,7 +9,6 @@ export class MarketplacePage extends BasePage {
 
   async goto(page: Page) {
     await page.goto("/marketplace");
-    await page.waitForLoadState("networkidle").catch(() => {});
   }
 
   async getMarketplaceTitle(page: Page) {
@@ -110,24 +109,16 @@ export class MarketplacePage extends BasePage {
 
   async getFirstFeaturedAgent(page: Page) {
     const { getId } = getSelectors(page);
-    const card = getId("featured-store-card").first();
-    await card.waitFor({ state: "visible", timeout: 30000 });
-    return card;
+    return getId("featured-store-card").first();
   }
 
   async getFirstTopAgent() {
-    const card = this.page
-      .locator('[data-testid="store-card"]:visible')
-      .first();
-    await card.waitFor({ state: "visible", timeout: 30000 });
-    return card;
+    return this.page.locator('[data-testid="store-card"]:visible').first();
   }
 
   async getFirstCreatorProfile(page: Page) {
     const { getId } = getSelectors(page);
-    const card = getId("creator-card").first();
-    await card.waitFor({ state: "visible", timeout: 30000 });
-    return card;
+    return getId("creator-card").first();
   }
 
   async getSearchResultsCount(page: Page) {

autogpt_platform/frontend/tsconfig.json

@@ -14,7 +14,6 @@
     "jsx": "preserve",
     "incremental": true,
     "plugins": [{ "name": "next" }],
-    "types": ["vitest/globals", "@testing-library/jest-dom/vitest"],
     "paths": {
       "@/*": ["./src/*"]
     }

autogpt_platform/frontend/vitest.config.mts

@@ -8,6 +8,5 @@ export default defineConfig({
     environment: "happy-dom",
     include: ["src/**/*.test.tsx"],
     setupFiles: ["./src/tests/integrations/vitest.setup.tsx"],
-    globals: true,
   },
 });