fix: determine clarification answered state from conversation

Instead of localStorage, check if there's a user message after the
clarification request in the conversation. This works across browsers
since the conversation is stored in the backend.

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,54 @@
 
 from .core import (
     AgentGeneratorNotConfiguredError,
+    AgentJsonValidationError,
+    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",
+    "AgentJsonValidationError",
+    "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",
+    "get_all_relevant_agents_for_generation",
-    # Exceptions
+    "get_library_agent_by_graph_id",
-    "AgentGeneratorNotConfiguredError",
+    "get_library_agent_by_id",
-    # Service
+    "get_library_agents_for_generation",
-    "is_external_service_configured",
-    "check_external_service_health",
-    # Error handling
     "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, NotRequired, 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 DatabaseError, NotFoundError
 
 from .service import (
     decompose_goal_external,
@@ -16,6 +26,75 @@ from .service import (
 
 logger = logging.getLogger(__name__)
 
+# Block ID for AgentExecutorBlock - used to identify sub-agent nodes
+AGENT_EXECUTOR_BLOCK_ID = "e189baac-8c20-45a1-94a7-55177ea42565"
+
+
+class ExecutionSummary(TypedDict):
+    """Summary of a single execution for quality assessment."""
+
+    status: str
+    correctness_score: NotRequired[float]
+    activity_summary: NotRequired[str]
+
+
+class LibraryAgentSummary(TypedDict):
+    """Summary of a library agent for sub-agent composition.
+
+    Includes recent executions to help the LLM decide whether to use this agent.
+    Each execution shows status, correctness_score (0-1), and activity_summary.
+    """
+
+    graph_id: str
+    graph_version: int
+    name: str
+    description: str
+    input_schema: dict[str, Any]
+    output_schema: dict[str, Any]
+    recent_executions: NotRequired[list[ExecutionSummary]]
+
+
+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
+    steps: list[DecompositionStep]
+    questions: list[dict[str, Any]]
+    error: str
+    error_type: str
+
+
+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 +115,421 @@ 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 DatabaseError:
+        raise
+    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 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
+
+
+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.
+
+    Includes recent_executions list to help the LLM assess agent quality:
+    - Each execution has status, correctness_score (0-1), and activity_summary
+    - This gives the LLM concrete examples of recent performance
+
+    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 and recent executions 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,
+            include_executions=True,
+        )
+
+        results: list[LibraryAgentSummary] = []
+        for agent in response.agents:
+            if exclude_graph_id is not None and agent.graph_id == exclude_graph_id:
+                continue
+
+            summary = 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,
+            )
+            if agent.recent_executions:
+                exec_summaries: list[ExecutionSummary] = []
+                for ex in agent.recent_executions:
+                    exec_sum = ExecutionSummary(status=ex.status)
+                    if ex.correctness_score is not None:
+                        exec_sum["correctness_score"] = ex.correctness_score
+                    if ex.activity_summary:
+                        exec_sum["activity_summary"] = ex.activity_summary
+                    exec_summaries.append(exec_sum)
+                summary["recent_executions"] = exec_summaries
+            results.append(summary)
+        return results
+    except DatabaseError:
+        raise
+    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_library: bool = True,
+    include_marketplace: bool = True,
+    max_library_results: int = 15,
+    max_marketplace_results: int = 10,
+) -> list[AgentSummary]:
+    """Fetch relevant agents from library and/or marketplace.
+
+    Searches both user's library and marketplace by default.
+    Explicitly mentioned UUIDs in the search query are always looked up.
+
+    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_library: Whether to search user's library (default True)
+        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
+            try:
+                agent = await get_library_agent_by_graph_id(user_id, graph_id)
+            except Exception as e:
+                logger.warning(
+                    f"Failed to fetch explicitly mentioned agent {graph_id}: {e}",
+                    exc_info=True,
+                )
+                continue
+            agent_graph_id = agent.get("graph_id") if agent else None
+            if agent and agent_graph_id 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.get('name') or 'Unknown'}"
+                )
+
+    if include_library:
+        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:
+            graph_id = agent.get("graph_id")
+            if graph_id and graph_id not in seen_graph_ids:
+                agents.append(agent)
+                seen_graph_ids.add(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: set[str] = set()
+        for a in agents:
+            name = a.get("name")
+            if name and isinstance(name, str):
+                library_names.add(name.lower())
+        for agent in marketplace_agents:
+            agent_name = agent.get("name")
+            if agent_name and isinstance(agent_name, str):
+                if 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)
+    """
+    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 and isinstance(agent_name, str):
+            existing_names.add(agent_name.lower())
+        graph_id = agent.get("graph_id")  # type: ignore[call-overload]
+        if graph_id and isinstance(graph_id, str):
+            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 or not isinstance(agent_name, str):
+                    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 and isinstance(graph_id, str):
+                    existing_ids.add(graph_id)
+
+        except DatabaseError:
+            logger.error(f"Database error searching for agents with term '{term}'")
+            raise
+        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 +539,21 @@ 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)
+    result = await decompose_goal_external(
+        description, context, _to_dict_list(library_agents)
+    )
+    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,12 +563,12 @@ 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)
+    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":
             return result
-        # Ensure required fields for successful agent generation
         if "id" not in result:
             result["id"] = str(uuid.uuid4())
         if "version" not in result:
@@ -86,6 +578,12 @@ async def generate_agent(instructions: dict[str, Any]) -> dict[str, Any] | None:
     return result
 
 
+class AgentJsonValidationError(Exception):
+    """Raised when agent JSON is invalid or missing required fields."""
+
+    pass
+
+
 def json_to_graph(agent_json: dict[str, Any]) -> Graph:
     """Convert agent JSON dict to Graph model.
 
@@ -94,25 +592,55 @@ def json_to_graph(agent_json: dict[str, Any]) -> Graph:
 
     Returns:
         Graph ready for saving
+
+    Raises:
+        AgentJsonValidationError: If required fields are missing from nodes or links
     """
     nodes = []
-    for n in agent_json.get("nodes", []):
+    for idx, n in enumerate(agent_json.get("nodes", [])):
+        block_id = n.get("block_id")
+        if not block_id:
+            node_id = n.get("id", f"index_{idx}")
+            raise AgentJsonValidationError(
+                f"Node '{node_id}' is missing required field 'block_id'"
+            )
         node = Node(
             id=n.get("id", str(uuid.uuid4())),
-            block_id=n["block_id"],
+            block_id=block_id,
             input_default=n.get("input_default", {}),
             metadata=n.get("metadata", {}),
         )
         nodes.append(node)
 
     links = []
-    for link_data in agent_json.get("links", []):
+    for idx, link_data in enumerate(agent_json.get("links", [])):
+        source_id = link_data.get("source_id")
+        sink_id = link_data.get("sink_id")
+        source_name = link_data.get("source_name")
+        sink_name = link_data.get("sink_name")
+
+        missing_fields = []
+        if not source_id:
+            missing_fields.append("source_id")
+        if not sink_id:
+            missing_fields.append("sink_id")
+        if not source_name:
+            missing_fields.append("source_name")
+        if not sink_name:
+            missing_fields.append("sink_name")
+
+        if missing_fields:
+            link_id = link_data.get("id", f"index_{idx}")
+            raise AgentJsonValidationError(
+                f"Link '{link_id}' is missing required fields: {', '.join(missing_fields)}"
+            )
+
         link = Link(
             id=link_data.get("id", str(uuid.uuid4())),
-            source_id=link_data["source_id"],
+            source_id=source_id,
-            sink_id=link_data["sink_id"],
+            sink_id=sink_id,
-            source_name=link_data["source_name"],
+            source_name=source_name,
-            sink_name=link_data["sink_name"],
+            sink_name=sink_name,
             is_static=link_data.get("is_static", False),
         )
         links.append(link)
@@ -133,22 +661,40 @@ def _reassign_node_ids(graph: Graph) -> None:
 
     This is needed when creating a new version to avoid unique constraint violations.
     """
-    # Create mapping from old node IDs to new UUIDs
     id_map = {node.id: str(uuid.uuid4()) for node in graph.nodes}
 
-    # Reassign node IDs
     for node in graph.nodes:
         node.id = id_map[node.id]
 
-    # Update link references to use new node IDs
     for link in graph.links:
-        link.id = str(uuid.uuid4())  # Also give links new IDs
+        link.id = str(uuid.uuid4())
         if link.source_id in id_map:
             link.source_id = id_map[link.source_id]
         if link.sink_id in id_map:
             link.sink_id = id_map[link.sink_id]
 
 
+def _populate_agent_executor_user_ids(agent_json: dict[str, Any], user_id: str) -> None:
+    """Populate user_id in AgentExecutorBlock nodes.
+
+    The external agent generator creates AgentExecutorBlock nodes with empty user_id.
+    This function fills in the actual user_id so sub-agents run with correct permissions.
+
+    Args:
+        agent_json: Agent JSON dict (modified in place)
+        user_id: User ID to set
+    """
+    for node in agent_json.get("nodes", []):
+        if node.get("block_id") == AGENT_EXECUTOR_BLOCK_ID:
+            input_default = node.get("input_default", {})
+            if not input_default.get("user_id"):
+                input_default["user_id"] = user_id
+                node["input_default"] = input_default
+                logger.debug(
+                    f"Set user_id for AgentExecutorBlock node {node.get('id')}"
+                )
+
+
 async def save_agent_to_library(
     agent_json: dict[str, Any], user_id: str, is_update: bool = False
 ) -> tuple[Graph, Any]:
@@ -162,33 +708,27 @@ async def save_agent_to_library(
     Returns:
         Tuple of (created Graph, LibraryAgent)
     """
-    from backend.data.graph import get_graph_all_versions
+    # Populate user_id in AgentExecutorBlock nodes before conversion
+    _populate_agent_executor_user_ids(agent_json, user_id)
 
     graph = json_to_graph(agent_json)
 
     if is_update:
-        # For updates, keep the same graph ID but increment version
-        # and reassign node/link IDs to avoid conflicts
         if graph.id:
             existing_versions = await get_graph_all_versions(graph.id, user_id)
             if existing_versions:
                 latest_version = max(v.version for v in existing_versions)
                 graph.version = latest_version + 1
-                # Reassign node IDs (but keep graph ID the same)
                 _reassign_node_ids(graph)
                 logger.info(f"Updating agent {graph.id} to version {graph.version}")
     else:
-        # For new agents, always generate a fresh UUID to avoid collisions
         graph.id = str(uuid.uuid4())
         graph.version = 1
-        # Reassign all node IDs as well
         _reassign_node_ids(graph)
         logger.info(f"Creating new agent with ID {graph.id}")
 
-    # Save to database
     created_graph = await create_graph(graph, user_id)
 
-    # Add to user's library (or update existing library agent)
     library_agents = await library_db.create_library_agent(
         graph=created_graph,
         user_id=user_id,
@@ -200,25 +740,31 @@ 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
 
-    # Convert to JSON format
     nodes = []
     for node in graph.nodes:
         nodes.append(
@@ -256,7 +802,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 +816,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 +827,6 @@ 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)
+    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

@@ -1,11 +1,43 @@
 """Error handling utilities for agent generator."""
 
+import re
+
+
+def _sanitize_error_details(details: str) -> str:
+    """Sanitize error details to remove sensitive information.
+
+    Strips common patterns that could expose internal system info:
+    - File paths (Unix and Windows)
+    - Database connection strings
+    - URLs with credentials
+    - Stack trace internals
+
+    Args:
+        details: Raw error details string
+
+    Returns:
+        Sanitized error details safe for user display
+    """
+    sanitized = re.sub(
+        r"/[a-zA-Z0-9_./\-]+\.(py|js|ts|json|yaml|yml)", "[path]", details
+    )
+    sanitized = re.sub(r"[A-Z]:\\[a-zA-Z0-9_\\.\\-]+", "[path]", sanitized)
+    sanitized = re.sub(
+        r"(postgres|mysql|mongodb|redis)://[^\s]+", "[database_url]", sanitized
+    )
+    sanitized = re.sub(r"https?://[^:]+:[^@]+@[^\s]+", "[url]", sanitized)
+    sanitized = re.sub(r", line \d+", "", sanitized)
+    sanitized = re.sub(r'File "[^"]+",?', "", sanitized)
+
+    return sanitized.strip()
+
 
 def get_user_message_for_error(
     error_type: str,
     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 +51,45 @@ 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."
+
+    if error_details:
+        details = _sanitize_error_details(error_details)
+        if len(details) > 200:
+            details = details[:200] + "..."
+        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(
+        response = await client.post("/api/generate-agent", json=payload)
-            "/api/generate-agent", json={"instructions": instructions}
-        )
         response.raise_for_status()
         data = response.json()
 
@@ -229,8 +238,7 @@ async def generate_agent_external(
             error_msg = data.get("error", "Unknown error from Agent Generator")
             error_type = data.get("error_type", "unknown")
             logger.error(
-                f"Agent Generator generation failed: {error_msg} "
+                f"Agent Generator generation failed: {error_msg} (type: {error_type})"
-                f"(type: {error_type})"
             )
             return _create_error_response(error_msg, error_type)
 
@@ -251,27 +259,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()
 
-    try:
+    payload: dict[str, Any] = {
-        response = await client.post(
-            "/api/update-agent",
-            json={
         "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=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,85 @@ logger = logging.getLogger(__name__)
 
 SearchSource = Literal["marketplace", "library"]
 
+_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,
@@ -69,7 +149,15 @@ async def search_agents(
                         is_featured=False,
                     )
                 )
-        else:  # library
+        else:
+            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 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]

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,24 @@ class CreateAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Step 1: Decompose goal into steps
+        library_agents = None
+        if user_id:
             try:
-            decomposition_result = await decompose_goal(description, context)
+                library_agents = await get_all_relevant_agents_for_generation(
+                    user_id=user_id,
+                    search_query=description,
+                    include_marketplace=True,
+                )
+                logger.debug(
+                    f"Found {len(library_agents)} relevant agents for sub-agent composition"
+                )
+            except Exception as e:
+                logger.warning(f"Failed to fetch library agents: {e}")
+
+        try:
+            decomposition_result = await decompose_goal(
+                description, context, library_agents
+            )
         except AgentGeneratorNotConfiguredError:
             return ErrorResponse(
                 message=(
@@ -124,7 +141,6 @@ class CreateAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Check if the result is an error from the external service
         if decomposition_result.get("type") == "error":
             error_msg = decomposition_result.get("error", "Unknown error")
             error_type = decomposition_result.get("error_type", "unknown")
@@ -144,7 +160,6 @@ class CreateAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Check if LLM returned clarifying questions
         if decomposition_result.get("type") == "clarifying_questions":
             questions = decomposition_result.get("questions", [])
             return ClarificationNeededResponse(
@@ -163,7 +178,6 @@ class CreateAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Check for unachievable/vague goals
         if decomposition_result.get("type") == "unachievable_goal":
             suggested = decomposition_result.get("suggested_goal", "")
             reason = decomposition_result.get("reason", "")
@@ -190,9 +204,22 @@ class CreateAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Step 2: Generate agent JSON (external service handles fixing and validation)
+        if user_id and library_agents is not None:
             try:
-            agent_json = await generate_agent(decomposition_result)
+                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:
+                logger.warning(f"Failed to enrich library agents from steps: {e}")
+
+        try:
+            agent_json = await generate_agent(decomposition_result, library_agents)
         except AgentGeneratorNotConfiguredError:
             return ErrorResponse(
                 message=(
@@ -211,7 +238,6 @@ class CreateAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Check if the result is an error from the external service
         if isinstance(agent_json, dict) and agent_json.get("type") == "error":
             error_msg = agent_json.get("error", "Unknown error")
             error_type = agent_json.get("error_type", "unknown")
@@ -219,7 +245,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,
             )
             return ErrorResponse(
                 message=user_message,
@@ -237,7 +268,6 @@ class CreateAgentTool(BaseTool):
         node_count = len(agent_json.get("nodes", []))
         link_count = len(agent_json.get("links", []))
 
-        # Step 3: Preview or save
         if not save:
             return AgentPreviewResponse(
                 message=(
@@ -252,7 +282,6 @@ class CreateAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Save to library
         if not user_id:
             return ErrorResponse(
                 message="You must be logged in to save agents.",
@@ -270,7 +299,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,
 )
@@ -117,7 +118,6 @@ class EditAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Step 1: Fetch current agent
         current_agent = await get_agent_as_json(agent_id, user_id)
 
         if current_agent is None:
@@ -127,14 +127,30 @@ class EditAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Build the update request with context
+        library_agents = None
+        if user_id:
+            try:
+                graph_id = current_agent.get("id")
+                library_agents = await get_all_relevant_agents_for_generation(
+                    user_id=user_id,
+                    search_query=changes,
+                    exclude_graph_id=graph_id,
+                    include_marketplace=True,
+                )
+                logger.debug(
+                    f"Found {len(library_agents)} relevant agents for sub-agent composition"
+                )
+            except Exception as e:
+                logger.warning(f"Failed to fetch library agents: {e}")
+
         update_request = changes
         if context:
             update_request = f"{changes}\n\nAdditional context:\n{context}"
 
-        # 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=(
@@ -153,7 +169,6 @@ class EditAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Check if the result is an error from the external service
         if isinstance(result, dict) and result.get("type") == "error":
             error_msg = result.get("error", "Unknown error")
             error_type = result.get("error_type", "unknown")
@@ -162,6 +177,7 @@ class EditAgentTool(BaseTool):
                 operation="generate the changes",
                 llm_parse_message="The AI had trouble generating the changes. Please try again or simplify your request.",
                 validation_message="The generated changes failed validation. Please try rephrasing your request.",
+                error_details=error_msg,
             )
             return ErrorResponse(
                 message=user_message,
@@ -175,7 +191,6 @@ class EditAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Check if LLM returned clarifying questions
         if result.get("type") == "clarifying_questions":
             questions = result.get("questions", [])
             return ClarificationNeededResponse(
@@ -194,7 +209,6 @@ class EditAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Result is the updated agent JSON
         updated_agent = result
 
         agent_name = updated_agent.get("name", "Updated Agent")
@@ -202,7 +216,6 @@ class EditAgentTool(BaseTool):
         node_count = len(updated_agent.get("nodes", []))
         link_count = len(updated_agent.get("links", []))
 
-        # Step 3: Preview or save
         if not save:
             return AgentPreviewResponse(
                 message=(
@@ -218,7 +231,6 @@ class EditAgentTool(BaseTool):
                 session_id=session_id,
             )
 
-        # Save to library (creates a new version)
         if not user_id:
             return ErrorResponse(
                 message="You must be logged in to save agents.",
@@ -236,7 +248,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

@@ -39,6 +39,7 @@ async def list_library_agents(
     sort_by: library_model.LibraryAgentSort = library_model.LibraryAgentSort.UPDATED_AT,
     page: int = 1,
     page_size: int = 50,
+    include_executions: bool = False,
 ) -> library_model.LibraryAgentResponse:
     """
     Retrieves a paginated list of LibraryAgent records for a given user.
@@ -49,6 +50,9 @@ async def list_library_agents(
         sort_by: Sorting field (createdAt, updatedAt, isFavorite, isCreatedByUser).
         page: Current page (1-indexed).
         page_size: Number of items per page.
+        include_executions: Whether to include execution data for status calculation.
+            Defaults to False for performance (UI fetches status separately).
+            Set to True when accurate status/metrics are needed (e.g., agent generator).
 
     Returns:
         A LibraryAgentResponse containing the list of agents and pagination details.
@@ -76,24 +80,32 @@ async def list_library_agents(
         "isArchived": False,
     }
 
-    # Build search filter if applicable
     if search_term:
-        where_clause["OR"] = [
+        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": search_term, "mode": "insensitive"}}
+                            "is": {"name": {"contains": word, "mode": "insensitive"}}
                         }
-            },
+                    }
+                )
+                or_conditions.append(
                     {
                         "AgentGraph": {
                             "is": {
-                        "description": {"contains": search_term, "mode": "insensitive"}
+                                "description": {
+                                    "contains": word,
+                                    "mode": "insensitive",
                                 }
                             }
-            },
+                        }
-        ]
+                    }
+                )
+            where_clause["OR"] = or_conditions
 
-    # Determine sorting
     order_by: prisma.types.LibraryAgentOrderByInput | None = None
 
     if sort_by == library_model.LibraryAgentSort.CREATED_AT:
@@ -105,7 +117,7 @@ async def list_library_agents(
         library_agents = await prisma.models.LibraryAgent.prisma().find_many(
             where=where_clause,
             include=library_agent_include(
-                user_id, include_nodes=False, include_executions=False
+                user_id, include_nodes=False, include_executions=include_executions
             ),
             order=order_by,
             skip=(page - 1) * page_size,

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

@@ -9,6 +9,7 @@ import pydantic
 from backend.data.block import BlockInput
 from backend.data.graph import GraphModel, GraphSettings, GraphTriggerInfo
 from backend.data.model import CredentialsMetaInput, is_credentials_field_name
+from backend.util.json import loads as json_loads
 from backend.util.models import Pagination
 
 if TYPE_CHECKING:
@@ -16,10 +17,10 @@ if TYPE_CHECKING:
 
 
 class LibraryAgentStatus(str, Enum):
-    COMPLETED = "COMPLETED"  # All runs completed
+    COMPLETED = "COMPLETED"
-    HEALTHY = "HEALTHY"  # Agent is running (not all runs have completed)
+    HEALTHY = "HEALTHY"
-    WAITING = "WAITING"  # Agent is queued or waiting to start
+    WAITING = "WAITING"
-    ERROR = "ERROR"  # Agent is in an error state
+    ERROR = "ERROR"
 
 
 class MarketplaceListingCreator(pydantic.BaseModel):
@@ -39,6 +40,30 @@ class MarketplaceListing(pydantic.BaseModel):
     creator: MarketplaceListingCreator
 
 
+class RecentExecution(pydantic.BaseModel):
+    """Summary of a recent execution for quality assessment.
+
+    Used by the LLM to understand the agent's recent performance with specific examples
+    rather than just aggregate statistics.
+    """
+
+    status: str
+    correctness_score: float | None = None
+    activity_summary: str | None = None
+
+
+def _parse_settings(settings: dict | str | None) -> GraphSettings:
+    """Parse settings from database, handling both dict and string formats."""
+    if settings is None:
+        return GraphSettings()
+    try:
+        if isinstance(settings, str):
+            settings = json_loads(settings)
+        return GraphSettings.model_validate(settings)
+    except Exception:
+        return GraphSettings()
+
+
 class LibraryAgent(pydantic.BaseModel):
     """
     Represents an agent in the library, including metadata for display and
@@ -48,7 +73,7 @@ class LibraryAgent(pydantic.BaseModel):
     id: str
     graph_id: str
     graph_version: int
-    owner_user_id: str  # ID of user who owns/created this agent graph
+    owner_user_id: str
 
     image_url: str | None
 
@@ -64,7 +89,7 @@ class LibraryAgent(pydantic.BaseModel):
     description: str
     instructions: str | None = None
 
-    input_schema: dict[str, Any]  # Should be BlockIOObjectSubSchema in frontend
+    input_schema: dict[str, Any]
     output_schema: dict[str, Any]
     credentials_input_schema: dict[str, Any] | None = pydantic.Field(
         description="Input schema for credentials required by the agent",
@@ -81,25 +106,19 @@ class LibraryAgent(pydantic.BaseModel):
     )
     trigger_setup_info: Optional[GraphTriggerInfo] = None
 
-    # Indicates whether there's a new output (based on recent runs)
     new_output: bool
-
+    execution_count: int = 0
-    # Whether the user can access the underlying graph
+    success_rate: float | None = None
+    avg_correctness_score: float | None = None
+    recent_executions: list[RecentExecution] = pydantic.Field(
+        default_factory=list,
+        description="List of recent executions with status, score, and summary",
+    )
     can_access_graph: bool
-
-    # Indicates if this agent is the latest version
     is_latest_version: bool
-
-    # Whether the agent is marked as favorite by the user
     is_favorite: bool
-
-    # Recommended schedule cron (from marketplace agents)
     recommended_schedule_cron: str | None = None
-
-    # User-specific settings for this library agent
     settings: GraphSettings = pydantic.Field(default_factory=GraphSettings)
-
-    # Marketplace listing information if the agent has been published
     marketplace_listing: Optional["MarketplaceListing"] = None
 
     @staticmethod
@@ -123,7 +142,6 @@ class LibraryAgent(pydantic.BaseModel):
         agent_updated_at = agent.AgentGraph.updatedAt
         lib_agent_updated_at = agent.updatedAt
 
-        # Compute updated_at as the latest between library agent and graph
         updated_at = (
             max(agent_updated_at, lib_agent_updated_at)
             if agent_updated_at
@@ -136,7 +154,6 @@ class LibraryAgent(pydantic.BaseModel):
             creator_name = agent.Creator.name or "Unknown"
             creator_image_url = agent.Creator.avatarUrl or ""
 
-        # Logic to calculate status and new_output
         week_ago = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(
             days=7
         )
@@ -145,13 +162,55 @@ class LibraryAgent(pydantic.BaseModel):
         status = status_result.status
         new_output = status_result.new_output
 
-        # Check if user can access the graph
+        execution_count = len(executions)
-        can_access_graph = agent.AgentGraph.userId == agent.userId
+        success_rate: float | None = None
+        avg_correctness_score: float | None = None
+        if execution_count > 0:
+            success_count = sum(
+                1
+                for e in executions
+                if e.executionStatus == prisma.enums.AgentExecutionStatus.COMPLETED
+            )
+            success_rate = (success_count / execution_count) * 100
 
-        # Hard-coded to True until a method to check is implemented
+            correctness_scores = []
+            for e in executions:
+                if e.stats and isinstance(e.stats, dict):
+                    score = e.stats.get("correctness_score")
+                    if score is not None and isinstance(score, (int, float)):
+                        correctness_scores.append(float(score))
+            if correctness_scores:
+                avg_correctness_score = sum(correctness_scores) / len(
+                    correctness_scores
+                )
+
+        recent_executions: list[RecentExecution] = []
+        for e in executions:
+            exec_score: float | None = None
+            exec_summary: str | None = None
+            if e.stats and isinstance(e.stats, dict):
+                score = e.stats.get("correctness_score")
+                if score is not None and isinstance(score, (int, float)):
+                    exec_score = float(score)
+                summary = e.stats.get("activity_status")
+                if summary is not None and isinstance(summary, str):
+                    exec_summary = summary
+            exec_status = (
+                e.executionStatus.value
+                if hasattr(e.executionStatus, "value")
+                else str(e.executionStatus)
+            )
+            recent_executions.append(
+                RecentExecution(
+                    status=exec_status,
+                    correctness_score=exec_score,
+                    activity_summary=exec_summary,
+                )
+            )
+
+        can_access_graph = agent.AgentGraph.userId == agent.userId
         is_latest_version = True
 
-        # Build marketplace_listing if available
         marketplace_listing_data = None
         if store_listing and store_listing.ActiveVersion and profile:
             creator_data = MarketplaceListingCreator(
@@ -190,11 +249,15 @@ class LibraryAgent(pydantic.BaseModel):
             has_sensitive_action=graph.has_sensitive_action,
             trigger_setup_info=graph.trigger_setup_info,
             new_output=new_output,
+            execution_count=execution_count,
+            success_rate=success_rate,
+            avg_correctness_score=avg_correctness_score,
+            recent_executions=recent_executions,
             can_access_graph=can_access_graph,
             is_latest_version=is_latest_version,
             is_favorite=agent.isFavorite,
             recommended_schedule_cron=agent.AgentGraph.recommendedScheduleCron,
-            settings=GraphSettings.model_validate(agent.settings),
+            settings=_parse_settings(agent.settings),
             marketplace_listing=marketplace_listing_data,
         )
 
@@ -220,18 +283,15 @@ def _calculate_agent_status(
     if not executions:
         return AgentStatusResult(status=LibraryAgentStatus.COMPLETED, new_output=False)
 
-    # Track how many times each execution status appears
     status_counts = {status: 0 for status in prisma.enums.AgentExecutionStatus}
     new_output = False
 
     for execution in executions:
-        # Check if there's a completed run more recent than `recent_threshold`
         if execution.createdAt >= recent_threshold:
             if execution.executionStatus == prisma.enums.AgentExecutionStatus.COMPLETED:
                 new_output = True
         status_counts[execution.executionStatus] += 1
 
-    # Determine the final status based on counts
     if status_counts[prisma.enums.AgentExecutionStatus.FAILED] > 0:
         return AgentStatusResult(status=LibraryAgentStatus.ERROR, new_output=new_output)
     elif status_counts[prisma.enums.AgentExecutionStatus.QUEUED] > 0:

autogpt_platform/backend/snapshots/lib_agts_search

@@ -31,6 +31,10 @@
       "has_sensitive_action": false,
       "trigger_setup_info": null,
       "new_output": false,
+      "execution_count": 0,
+      "success_rate": null,
+      "avg_correctness_score": null,
+      "recent_executions": [],
       "can_access_graph": true,
       "is_latest_version": true,
       "is_favorite": false,
@@ -72,6 +76,10 @@
       "has_sensitive_action": false,
       "trigger_setup_info": null,
       "new_output": false,
+      "execution_count": 0,
+      "success_rate": null,
+      "avg_correctness_score": null,
+      "recent_executions": [],
       "can_access_graph": false,
       "is_latest_version": true,
       "is_favorite": false,

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,841 @@
+"""
+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_agent.recent_executions = []
+
+        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",
+            )
+
+            mock_list.assert_called_once_with(
+                user_id="user-123",
+                search_term="send email",
+                page=1,
+                page_size=15,
+                include_executions=True,
+            )
+
+        # 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={},
+                recent_executions=[],
+            ),
+            MagicMock(
+                graph_id="agent-456",
+                graph_version=1,
+                name="Agent 2",
+                description="Second agent",
+                input_schema={},
+                output_schema={},
+                recent_executions=[],
+            ),
+        ]
+
+        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,
+            )
+
+            mock_list.assert_called_once_with(
+                user_id="user-123",
+                search_term=None,
+                page=1,
+                page_size=5,
+                include_executions=True,
+            )
+
+
+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/frontend/src/app/(platform)/build/components/legacy-builder/CustomNode/CustomNode.tsx

@@ -528,6 +528,10 @@ export const CustomNode = React.memo(
           const getInputPropKey = (key: string) =>
             nodeType == BlockUIType.AGENT ? `inputs.${key}` : key;
 
+          // For AGENT blocks, handle IDs need the inputs_#_ prefix to match link sink_names
+          const getHandleKey = (key: string) =>
+            nodeType == BlockUIType.AGENT ? `inputs_#_${key}` : key;
+
           return keys.map(([propKey, propSchema]) => {
             const isRequired = data.inputSchema.required?.includes(propKey);
             const isAdvanced = propSchema.advanced;
@@ -544,7 +548,8 @@ export const CustomNode = React.memo(
               !propKey.endsWith("_credentials") &&
               // For OUTPUT blocks, only show the 'value' (hides 'name') input connection handle
               !(nodeType == BlockUIType.OUTPUT && propKey == "name");
-            const isConnected = isInputHandleConnected(propKey);
+            const handleKey = getHandleKey(propKey);
+            const isConnected = isInputHandleConnected(handleKey);
 
             return (
               !isHidden &&
@@ -562,12 +567,12 @@ export const CustomNode = React.memo(
                     propSchema.discriminator
                   ) ? (
                     <NodeHandle
-                      keyName={propKey}
+                      keyName={handleKey}
                       isConnected={isConnected}
                       isRequired={isRequired}
                       schema={propSchema}
                       side="left"
-                      isBroken={isInputHandleBroken(propKey)}
+                      isBroken={isInputHandleBroken(handleKey)}
                     />
                   ) : (
                     propKey !== "credentials" &&
@@ -857,7 +862,7 @@ export const CustomNode = React.memo(
     })();
 
     const hasAdvancedFields =
-      data.inputSchema &&
+      data.inputSchema?.properties &&
       Object.entries(data.inputSchema.properties).some(([key, value]) => {
         return (
           value.advanced === true && !data.inputSchema.required?.includes(key)

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

@@ -7981,6 +7981,25 @@
             ]
           },
           "new_output": { "type": "boolean", "title": "New Output" },
+          "execution_count": {
+            "type": "integer",
+            "title": "Execution Count",
+            "default": 0
+          },
+          "success_rate": {
+            "anyOf": [{ "type": "number" }, { "type": "null" }],
+            "title": "Success Rate"
+          },
+          "avg_correctness_score": {
+            "anyOf": [{ "type": "number" }, { "type": "null" }],
+            "title": "Avg Correctness Score"
+          },
+          "recent_executions": {
+            "items": { "$ref": "#/components/schemas/RecentExecution" },
+            "type": "array",
+            "title": "Recent Executions",
+            "description": "List of recent executions with status, score, and summary"
+          },
           "can_access_graph": {
             "type": "boolean",
             "title": "Can Access Graph"
@@ -9374,6 +9393,23 @@
         "required": ["providers", "pagination"],
         "title": "ProviderResponse"
       },
+      "RecentExecution": {
+        "properties": {
+          "status": { "type": "string", "title": "Status" },
+          "correctness_score": {
+            "anyOf": [{ "type": "number" }, { "type": "null" }],
+            "title": "Correctness Score"
+          },
+          "activity_summary": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Activity Summary"
+          }
+        },
+        "type": "object",
+        "required": ["status"],
+        "title": "RecentExecution",
+        "description": "Summary of a recent execution for quality assessment.\n\nUsed by the LLM to understand the agent's recent performance with specific examples\nrather than just aggregate statistics."
+      },
       "RefundRequest": {
         "properties": {
           "id": { "type": "string", "title": "Id" },

autogpt_platform/frontend/src/components/contextual/Chat/components/ChatMessage/ChatMessage.tsx

@@ -156,11 +156,20 @@ export function ChatMessage({
   }
 
   if (isClarificationNeeded && message.type === "clarification_needed") {
+    // Check if user already replied after this clarification (answered)
+    const hasUserReplyAfter =
+      index >= 0 &&
+      messages
+        .slice(index + 1)
+        .some((m) => m.type === "message" && m.role === "user");
+
     return (
       <ClarificationQuestionsWidget
         questions={message.questions}
         message={message.message}
+        sessionId={message.sessionId}
         onSubmitAnswers={handleClarificationAnswers}
+        isAnswered={hasUserReplyAfter}
         className={className}
       />
     );

autogpt_platform/frontend/src/components/contextual/Chat/components/ClarificationQuestionsWidget/ClarificationQuestionsWidget.tsx

@@ -6,7 +6,7 @@ import { Input } from "@/components/atoms/Input/Input";
 import { Text } from "@/components/atoms/Text/Text";
 import { cn } from "@/lib/utils";
 import { CheckCircleIcon, QuestionIcon } from "@phosphor-icons/react";
-import { useState } from "react";
+import { useState, useEffect, useRef } from "react";
 
 export interface ClarifyingQuestion {
   question: string;
@@ -17,39 +17,97 @@ export interface ClarifyingQuestion {
 interface Props {
   questions: ClarifyingQuestion[];
   message: string;
+  sessionId?: string;
   onSubmitAnswers: (answers: Record<string, string>) => void;
   onCancel?: () => void;
+  isAnswered?: boolean;
   className?: string;
 }
 
+function getStorageKey(sessionId?: string): string | null {
+  if (!sessionId) return null;
+  return `clarification_answers_${sessionId}`;
+}
+
 export function ClarificationQuestionsWidget({
   questions,
   message,
+  sessionId,
   onSubmitAnswers,
   onCancel,
+  isAnswered = false,
   className,
 }: Props) {
   const [answers, setAnswers] = useState<Record<string, string>>({});
   const [isSubmitted, setIsSubmitted] = useState(false);
+  const lastSessionIdRef = useRef<string | undefined>(undefined);
+
+  useEffect(() => {
+    const storageKey = getStorageKey(sessionId);
+    if (!storageKey) {
+      setAnswers({});
+      setIsSubmitted(false);
+      lastSessionIdRef.current = sessionId;
+      return;
+    }
+
+    try {
+      const saved = localStorage.getItem(storageKey);
+      if (saved) {
+        const parsed = JSON.parse(saved) as Record<string, string>;
+        setAnswers(parsed);
+      } else {
+        setAnswers({});
+      }
+      setIsSubmitted(false);
+    } catch {
+      setAnswers({});
+      setIsSubmitted(false);
+    }
+    lastSessionIdRef.current = sessionId;
+  }, [sessionId]);
+
+  useEffect(() => {
+    if (lastSessionIdRef.current !== sessionId) {
+      return;
+    }
+    const storageKey = getStorageKey(sessionId);
+    if (!storageKey) return;
+
+    const hasAnswers = Object.values(answers).some((v) => v.trim());
+    try {
+      if (hasAnswers) {
+        localStorage.setItem(storageKey, JSON.stringify(answers));
+      } else {
+        localStorage.removeItem(storageKey);
+      }
+    } catch {}
+  }, [answers, sessionId]);
 
   function handleAnswerChange(keyword: string, value: string) {
     setAnswers((prev) => ({ ...prev, [keyword]: value }));
   }
 
   function handleSubmit() {
-    // Check if all questions are answered
     const allAnswered = questions.every((q) => answers[q.keyword]?.trim());
     if (!allAnswered) {
       return;
     }
     setIsSubmitted(true);
     onSubmitAnswers(answers);
+
+    const storageKey = getStorageKey(sessionId);
+    try {
+      if (storageKey) {
+        localStorage.removeItem(storageKey);
+      }
+    } catch {}
   }
 
   const allAnswered = questions.every((q) => answers[q.keyword]?.trim());
 
-  // Show submitted state after answers are submitted
+  // Show submitted state if answered from conversation or just submitted
-  if (isSubmitted) {
+  if (isAnswered || isSubmitted) {
     return (
       <div
         className={cn(

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";
+        (response.message as string) || response.error || "An error occurred";
-      return `Error: ${errorMsg}`;
+      return stripInternalReasoning(String(errorMsg));
 
     case "no_results":
       const suggestions = (response.suggestions as string[]) || [];