AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.
feat(backend): Blocks Menu redesign backend (#10128)
Krzysztof Czerwinski8a68e03eb130
diff --git a/autogpt_platform/backend/backend/blocks/agent.py b/autogpt_platform/backend/backend/blocks/agent.pyindex 2f72527bdf..ac3eedb12b 100644--- a/autogpt_platform/backend/backend/blocks/agent.py+++ b/autogpt_platform/backend/backend/blocks/agent.py@@ -25,6 +25,9 @@ class AgentExecutorBlock(Block):user_id: str = SchemaField(description="User ID")graph_id: str = SchemaField(description="Graph ID")graph_version: int = SchemaField(description="Graph Version")+ agent_name: Optional[str] = SchemaField(+ default=None, description="Name to display in the Builder UI"+ )inputs: BlockInput = SchemaField(description="Input data for the graph")input_schema: dict = SchemaField(description="Input schema for the graph")diff --git a/autogpt_platform/backend/backend/blocks/system/store_operations.py b/autogpt_platform/backend/backend/blocks/system/store_operations.pyindex bef6eb610e..6f5763bc93 100644--- a/autogpt_platform/backend/backend/blocks/system/store_operations.py+++ b/autogpt_platform/backend/backend/blocks/system/store_operations.py@@ -288,7 +288,7 @@ class SearchStoreAgentsBlock(Block):result = await get_database_manager_async_client().get_store_agents(featured=False,- creator=None,+ creators=None,sorted_by=sorted_by_map.get(sort_by, "most_popular"),search_query=query,category=category,diff --git a/autogpt_platform/backend/backend/server/rest_api.py b/autogpt_platform/backend/backend/server/rest_api.pyindex 6f0ce0b3d1..deeb85c394 100644--- a/autogpt_platform/backend/backend/server/rest_api.py+++ b/autogpt_platform/backend/backend/server/rest_api.py@@ -20,6 +20,8 @@ import backend.server.routers.postmark.postmarkimport backend.server.routers.v1import backend.server.v2.admin.credit_admin_routesimport backend.server.v2.admin.store_admin_routes+import backend.server.v2.builder+import backend.server.v2.builder.routesimport backend.server.v2.library.dbimport backend.server.v2.library.modelimport backend.server.v2.library.routes@@ -195,6 +197,9 @@ app.include_router(backend.server.routers.v1.v1_router, tags=["v1"], prefix="/apapp.include_router(backend.server.v2.store.routes.router, tags=["v2"], prefix="/api/store")+app.include_router(+ backend.server.v2.builder.routes.router, tags=["v2"], prefix="/api/builder"+)app.include_router(backend.server.v2.admin.store_admin_routes.router,tags=["v2", "admin"],diff --git a/autogpt_platform/backend/backend/server/v2/builder/db.py b/autogpt_platform/backend/backend/server/v2/builder/db.pynew file mode 100644index 0000000000..3cef265561--- /dev/null+++ b/autogpt_platform/backend/backend/server/v2/builder/db.py@@ -0,0 +1,376 @@+import functools+import logging+from datetime import datetime, timedelta, timezone++import prisma++import backend.data.block+from backend.blocks import load_all_blocks+from backend.blocks.llm import LlmModel+from backend.data.block import Block, BlockCategory, BlockSchema+from backend.data.credit import get_block_costs+from backend.integrations.providers import ProviderName+from backend.server.v2.builder.model import (+ BlockCategoryResponse,+ BlockData,+ BlockResponse,+ BlockType,+ CountResponse,+ Provider,+ ProviderResponse,+ SearchBlocksResponse,+)+from backend.util.models import Pagination++logger = logging.getLogger(__name__)+llm_models = [name.name.lower().replace("_", " ") for name in LlmModel]+_static_counts_cache: dict | None = None+_suggested_blocks: list[BlockData] | None = None+++def get_block_categories(category_blocks: int = 3) -> list[BlockCategoryResponse]:+ categories: dict[BlockCategory, BlockCategoryResponse] = {}++ for block_type in load_all_blocks().values():+ block: Block[BlockSchema, BlockSchema] = block_type()+ # Skip disabled blocks+ if block.disabled:+ continue+ # Skip blocks that don't have categories (all should have at least one)+ if not block.categories:+ continue++ # Add block to the categories+ for category in block.categories:+ if category not in categories:+ categories[category] = BlockCategoryResponse(+ name=category.name.lower(),+ total_blocks=0,+ blocks=[],+ )++ categories[category].total_blocks += 1++ # Append if the category has less than the specified number of blocks+ if len(categories[category].blocks) < category_blocks:+ categories[category].blocks.append(block.to_dict())++ # Sort categories by name+ return sorted(categories.values(), key=lambda x: x.name)+++def get_blocks(+ *,+ category: str | None = None,+ type: BlockType | None = None,+ provider: ProviderName | None = None,+ page: int = 1,+ page_size: int = 50,+) -> BlockResponse:+ """+ Get blocks based on either category, type or provider.+ Providing nothing fetches all block types.+ """+ # Only one of category, type, or provider can be specified+ if (category and type) or (category and provider) or (type and provider):+ raise ValueError("Only one of category, type, or provider can be specified")++ blocks: list[Block[BlockSchema, BlockSchema]] = []+ skip = (page - 1) * page_size+ take = page_size+ total = 0++ for block_type in load_all_blocks().values():+ block: Block[BlockSchema, BlockSchema] = block_type()+ # Skip disabled blocks+ if block.disabled:+ continue+ # Skip blocks that don't match the category+ if category and category not in {c.name.lower() for c in block.categories}:+ continue+ # Skip blocks that don't match the type+ if (+ (type == "input" and block.block_type.value != "Input")+ or (type == "output" and block.block_type.value != "Output")+ or (type == "action" and block.block_type.value in ("Input", "Output"))+ ):+ continue+ # Skip blocks that don't match the provider+ if provider:+ credentials_info = block.input_schema.get_credentials_fields_info().values()+ if not any(provider in info.provider for info in credentials_info):+ continue++ total += 1+ if skip > 0:+ skip -= 1+ continue+ if take > 0:+ take -= 1+ blocks.append(block)++ costs = get_block_costs()++ return BlockResponse(+ blocks=[{**b.to_dict(), "costs": costs.get(b.id, [])} for b in blocks],+ pagination=Pagination(+ total_items=total,+ total_pages=(total + page_size - 1) // page_size,+ current_page=page,+ page_size=page_size,+ ),+ )+++def search_blocks(+ include_blocks: bool = True,+ include_integrations: bool = True,+ query: str = "",+ page: int = 1,+ page_size: int = 50,+) -> SearchBlocksResponse:+ """+ Get blocks based on the filter and query.+ `providers` only applies for `integrations` filter.+ """+ blocks: list[Block[BlockSchema, BlockSchema]] = []+ query = query.lower()++ total = 0+ skip = (page - 1) * page_size+ take = page_size+ block_count = 0+ integration_count = 0++ for block_type in load_all_blocks().values():+ block: Block[BlockSchema, BlockSchema] = block_type()+ # Skip disabled blocks+ if block.disabled:+ continue+ # Skip blocks that don't match the query+ if (+ query not in block.name.lower()+ and query not in block.description.lower()+ and not _matches_llm_model(block.input_schema, query)+ ):+ continue+ keep = False+ credentials = list(block.input_schema.get_credentials_fields().values())+ if include_integrations and len(credentials) > 0:+ keep = True+ integration_count += 1+ if include_blocks and len(credentials) == 0:+ keep = True+ block_count += 1++ if not keep:+ continue++ total += 1+ if skip > 0:+ skip -= 1+ continue+ if take > 0:+ take -= 1+ blocks.append(block)++ costs = get_block_costs()++ return SearchBlocksResponse(+ blocks=BlockResponse(+ blocks=[{**b.to_dict(), "costs": costs.get(b.id, [])} for b in blocks],+ pagination=Pagination(+ total_items=total,+ total_pages=(total + page_size - 1) // page_size,+ current_page=page,+ page_size=page_size,+ ),+ ),+ total_block_count=block_count,+ total_integration_count=integration_count,+ )+++def get_providers(+ query: str = "",+ page: int = 1,+ page_size: int = 50,+) -> ProviderResponse:+ providers = []+ query = query.lower()++ skip = (page - 1) * page_size+ take = page_size++ all_providers = _get_all_providers()++ for provider in all_providers.values():+ if (+ query not in provider.name.value.lower()+ and query not in provider.description.lower()+ ):+ continue+ if skip > 0:+ skip -= 1+ continue+ if take > 0:+ take -= 1+ providers.append(provider)++ total = len(all_providers)++ return ProviderResponse(+ providers=providers,+ pagination=Pagination(+ total_items=total,+ total_pages=(total + page_size - 1) // page_size,+ current_page=page,+ page_size=page_size,+ ),+ )+++async def get_counts(user_id: str) -> CountResponse:+ my_agents = await prisma.models.LibraryAgent.prisma().count(+ where={+ "userId": user_id,+ "isDeleted": False,+ "isArchived": False,+ }+ )+ counts = await _get_static_counts()+ return CountResponse(+ my_agents=my_agents,+ **counts,+ )+++async def _get_static_counts():+ """+ Get counts of blocks, integrations, and marketplace agents.+ This is cached to avoid unnecessary database queries and calculations.+ Can't use functools.cache here because the function is async.+ """+ global _static_counts_cache+ if _static_counts_cache is not None:+ return _static_counts_cache++ all_blocks = 0+ input_blocks = 0+ action_blocks = 0+ output_blocks = 0+ integrations = 0++ for block_type in load_all_blocks().values():+ block: Block[BlockSchema, BlockSchema] = block_type()+ if block.disabled:+ continue++ all_blocks += 1++ if block.block_type.value == "Input":+ input_blocks += 1+ elif block.block_type.value == "Output":+ output_blocks += 1+ else:+ action_blocks += 1++ credentials = list(block.input_schema.get_credentials_fields().values())+ if len(credentials) > 0:+ integrations += 1++ marketplace_agents = await prisma.models.StoreAgent.prisma().count()++ _static_counts_cache = {+ "all_blocks": all_blocks,+ "input_blocks": input_blocks,+ "action_blocks": action_blocks,+ "output_blocks": output_blocks,+ "integrations": integrations,+ "marketplace_agents": marketplace_agents,+ }++ return _static_counts_cache+++def _matches_llm_model(schema_cls: type[BlockSchema], query: str) -> bool:+ for field in schema_cls.model_fields.values():+ if field.annotation == LlmModel:+ # Check if query matches any value in llm_models+ if any(query in name for name in llm_models):+ return True+ return False+++def _get_all_providers() -> dict[ProviderName, Provider]:+ providers: dict[ProviderName, Provider] = {}++ for block_type in load_all_blocks().values():+ block: Block[BlockSchema, BlockSchema] = block_type()+ if block.disabled:+ continue++ credentials_info = block.input_schema.get_credentials_fields_info().values()+ for info in credentials_info:+ for provider in info.provider: # provider is a ProviderName enum member+ if provider in providers:+ providers[provider].integration_count += 1+ else:+ providers[provider] = Provider(+ name=provider, description="", integration_count=1+ )+ return providers+++async def get_suggested_blocks(count: int = 5) -> list[BlockData]:+ global _suggested_blocks++ if _suggested_blocks is not None and len(_suggested_blocks) >= count:+ return _suggested_blocks[:count]++ _suggested_blocks = []+ # Sum the number of executions for each block type+ # Prisma cannot group by nested relations, so we do a raw query+ # Calculate the cutoff timestamp+ timestamp_threshold = datetime.now(timezone.utc) - timedelta(days=30)++ results = await prisma.get_client().query_raw(+ """+ SELECT+ agent_node."agentBlockId" AS block_id,+ COUNT(execution.id) AS execution_count+ FROM "AgentNodeExecution" execution+ JOIN "AgentNode" agent_node ON execution."agentNodeId" = agent_node.id+ WHERE execution."endedTime" >= $1::timestamp+ GROUP BY agent_node."agentBlockId"+ ORDER BY execution_count DESC;+ """,+ timestamp_threshold,+ )++ # Get the top blocks based on execution count+ # But ignore Input and Output blocks+ blocks: list[tuple[BlockData, int]] = []++ for block_type in load_all_blocks().values():+ block: Block[BlockSchema, BlockSchema] = block_type()+ if block.disabled or block.block_type in (+ backend.data.block.BlockType.INPUT,+ backend.data.block.BlockType.OUTPUT,+ backend.data.block.BlockType.AGENT,+ ):+ continue+ # Find the execution count for this block+ execution_count = next(+ (row["execution_count"] for row in results if row["block_id"] == block.id),+ 0,+ )+ blocks.append((block.to_dict(), execution_count))+ # Sort blocks by execution count+ blocks.sort(key=lambda x: x[1], reverse=True)++ _suggested_blocks = [block[0] for block in blocks]++ # Return the top blocks+ return _suggested_blocks[:count]diff --git a/autogpt_platform/backend/backend/server/v2/builder/model.py b/autogpt_platform/backend/backend/server/v2/builder/model.pynew file mode 100644index 0000000000..7b9fe58f0a--- /dev/null+++ b/autogpt_platform/backend/backend/server/v2/builder/model.py@@ -0,0 +1,87 @@+from typing import Any, Literal++from pydantic import BaseModel++import backend.server.v2.library.model as library_model+import backend.server.v2.store.model as store_model+from backend.integrations.providers import ProviderName+from backend.util.models import Pagination++FilterType = Literal[+ "blocks",+ "integrations",+ "marketplace_agents",+ "my_agents",+]++BlockType = Literal["all", "input", "action", "output"]++BlockData = dict[str, Any]+++# Suggestions+class SuggestionsResponse(BaseModel):+ otto_suggestions: list[str]+ recent_searches: list[str]+ providers: list[ProviderName]+ top_blocks: list[BlockData]+++# All blocks+class BlockCategoryResponse(BaseModel):+ name: str+ total_blocks: int+ blocks: list[BlockData]++ model_config = {"use_enum_values": False} # <== use enum names like "AI"+++# Input/Action/Output and see all for block categories+class BlockResponse(BaseModel):+ blocks: list[BlockData]+ pagination: Pagination+++# Providers+class Provider(BaseModel):+ name: ProviderName+ description: str+ integration_count: int+++class ProviderResponse(BaseModel):+ providers: list[Provider]+ pagination: Pagination+++# Search+class SearchRequest(BaseModel):+ search_query: str | None = None+ filter: list[FilterType] | None = None+ by_creator: list[str] | None = None+ search_id: str | None = None+ page: int | None = None+ page_size: int | None = None+++class SearchBlocksResponse(BaseModel):+ blocks: BlockResponse+ total_block_count: int+ total_integration_count: int+++class SearchResponse(BaseModel):+ items: list[BlockData | library_model.LibraryAgent | store_model.StoreAgent]+ total_items: dict[FilterType, int]+ page: int+ more_pages: bool+++class CountResponse(BaseModel):+ all_blocks: int+ input_blocks: int+ action_blocks: int+ output_blocks: int+ integrations: int+ marketplace_agents: int+ my_agents: intdiff --git a/autogpt_platform/backend/backend/server/v2/builder/routes.py b/autogpt_platform/backend/backend/server/v2/builder/routes.pynew file mode 100644index 0000000000..0e78af3d4b--- /dev/null+++ b/autogpt_platform/backend/backend/server/v2/builder/routes.py@@ -0,0 +1,239 @@+import logging+from typing import Annotated, Sequence++import fastapi+from autogpt_libs.auth.depends import auth_middleware, get_user_id++import backend.server.v2.builder.db as builder_db+import backend.server.v2.builder.model as builder_model+import backend.server.v2.library.db as library_db+import backend.server.v2.library.model as library_model+import backend.server.v2.store.db as store_db+import backend.server.v2.store.model as store_model+from backend.integrations.providers import ProviderName+from backend.util.models import Pagination++logger = logging.getLogger(__name__)++router = fastapi.APIRouter()+++# Taken from backend/server/v2/store/db.py+def sanitize_query(query: str | None) -> str | None:+ if query is None:+ return query+ query = query.strip()[:100]+ return (+ query.replace("\\", "\\\\")+ .replace("%", "\\%")+ .replace("_", "\\_")+ .replace("[", "\\[")+ .replace("]", "\\]")+ .replace("'", "\\'")+ .replace('"', '\\"')+ .replace(";", "\\;")+ .replace("--", "\\--")+ .replace("/*", "\\/*")+ .replace("*/", "\\*/")+ )+++ "/suggestions",+ summary="Get Builder suggestions",+ dependencies=[fastapi.Depends(auth_middleware)],+ response_model=builder_model.SuggestionsResponse,+)+async def get_suggestions(+ user_id: Annotated[str, fastapi.Depends(get_user_id)],+) -> builder_model.SuggestionsResponse:+ """+ Get all suggestions for the Blocks Menu.+ """+ return builder_model.SuggestionsResponse(+ otto_suggestions=[+ "What blocks do I need to get started?",+ "Help me create a list",+ "Help me feed my data to Google Maps",+ ],+ recent_searches=[+ "image generation",+ "deepfake",+ "competitor analysis",+ ],+ providers=[+ ProviderName.TWITTER,+ ProviderName.GITHUB,+ ProviderName.NOTION,+ ProviderName.GOOGLE,+ ProviderName.DISCORD,+ ProviderName.GOOGLE_MAPS,+ ],+ top_blocks=await builder_db.get_suggested_blocks(),+ )+++ "/categories",+ summary="Get Builder block categories",+ dependencies=[fastapi.Depends(auth_middleware)],+ response_model=Sequence[builder_model.BlockCategoryResponse],+)+async def get_block_categories(+ blocks_per_category: Annotated[int, fastapi.Query()] = 3,+) -> Sequence[builder_model.BlockCategoryResponse]:+ """+ Get all block categories with a specified number of blocks per category.+ """+ return builder_db.get_block_categories(blocks_per_category)+++ "/blocks",+ summary="Get Builder blocks",+ dependencies=[fastapi.Depends(auth_middleware)],+ response_model=builder_model.BlockResponse,+)+async def get_blocks(+ category: Annotated[str | None, fastapi.Query()] = None,+ type: Annotated[builder_model.BlockType | None, fastapi.Query()] = None,+ provider: Annotated[ProviderName | None, fastapi.Query()] = None,+ page: Annotated[int, fastapi.Query()] = 1,+ page_size: Annotated[int, fastapi.Query()] = 50,+) -> builder_model.BlockResponse:+ """+ Get blocks based on either category, type, or provider.+ """+ return builder_db.get_blocks(+ category=category,+ type=type,+ provider=provider,+ page=page,+ page_size=page_size,+ )+++ "/providers",+ summary="Get Builder integration providers",+ dependencies=[fastapi.Depends(auth_middleware)],+ response_model=builder_model.ProviderResponse,+)+async def get_providers(+ page: Annotated[int, fastapi.Query()] = 1,+ page_size: Annotated[int, fastapi.Query()] = 50,+) -> builder_model.ProviderResponse:+ """+ Get all integration providers with their block counts.+ """+ return builder_db.get_providers(+ page=page,+ page_size=page_size,+ )+++ "/search",+ summary="Builder search",+ tags=["store", "private"],+ dependencies=[fastapi.Depends(auth_middleware)],+ response_model=builder_model.SearchResponse,+)+async def search(+ options: builder_model.SearchRequest,+ user_id: Annotated[str, fastapi.Depends(get_user_id)],+) -> builder_model.SearchResponse:+ """+ Search for blocks (including integrations), marketplace agents, and user library agents.+ """+ # If no filters are provided, then we will return all types+ if not options.filter:+ options.filter = [+ "blocks",+ "integrations",+ "marketplace_agents",+ "my_agents",+ ]+ options.search_query = sanitize_query(options.search_query)+ options.page = options.page or 1+ options.page_size = options.page_size or 50++ # Blocks&Integrations+ blocks = builder_model.SearchBlocksResponse(+ blocks=builder_model.BlockResponse(+ blocks=[],+ pagination=Pagination.empty(),+ ),+ total_block_count=0,+ total_integration_count=0,+ )+ if "blocks" in options.filter or "integrations" in options.filter:+ blocks = builder_db.search_blocks(+ include_blocks="blocks" in options.filter,+ include_integrations="integrations" in options.filter,+ query=options.search_query or "",+ page=options.page,+ page_size=options.page_size,+ )++ # Library Agents+ my_agents = library_model.LibraryAgentResponse(+ agents=[],+ pagination=Pagination.empty(),+ )+ if "my_agents" in options.filter:+ my_agents = await library_db.list_library_agents(+ user_id=user_id,+ search_term=options.search_query,+ page=options.page,+ page_size=options.page_size,+ )++ # Marketplace Agents+ marketplace_agents = store_model.StoreAgentsResponse(+ agents=[],+ pagination=Pagination.empty(),+ )+ if "marketplace_agents" in options.filter:+ marketplace_agents = await store_db.get_store_agents(+ creators=options.by_creator,+ search_query=options.search_query,+ page=options.page,+ page_size=options.page_size,+ )++ more_pages = False+ if (+ blocks.blocks.pagination.current_page < blocks.blocks.pagination.total_pages+ or my_agents.pagination.current_page < my_agents.pagination.total_pages+ or marketplace_agents.pagination.current_page+ < marketplace_agents.pagination.total_pages+ ):+ more_pages = True++ return builder_model.SearchResponse(+ items=blocks.blocks.blocks + my_agents.agents + marketplace_agents.agents,+ total_items={+ "blocks": blocks.total_block_count,+ "integrations": blocks.total_integration_count,+ "marketplace_agents": marketplace_agents.pagination.total_items,+ "my_agents": my_agents.pagination.total_items,+ },+ page=options.page,+ more_pages=more_pages,+ )+++ "/counts",+ summary="Get Builder item counts",+ dependencies=[fastapi.Depends(auth_middleware)],+ response_model=builder_model.CountResponse,+)+async def get_counts(+ user_id: Annotated[str, fastapi.Depends(get_user_id)],+) -> builder_model.CountResponse:+ """+ Get item counts for the menu categories in the Blocks Menu.+ """+ return await builder_db.get_counts(user_id)diff --git a/autogpt_platform/backend/backend/server/v2/library/model.py b/autogpt_platform/backend/backend/server/v2/library/model.pyindex 8378f66f41..3838d9a88d 100644--- a/autogpt_platform/backend/backend/server/v2/library/model.py+++ b/autogpt_platform/backend/backend/server/v2/library/model.py@@ -51,6 +51,7 @@ class LibraryAgent(pydantic.BaseModel):description: strinput_schema: dict[str, Any] # Should be BlockIOObjectSubSchema in frontend+ output_schema: dict[str, Any]credentials_input_schema: dict[str, Any] | None = pydantic.Field(description="Input schema for credentials required by the agent",)@@ -126,6 +127,7 @@ class LibraryAgent(pydantic.BaseModel):name=graph.name,description=graph.description,input_schema=graph.input_schema,+ output_schema=graph.output_schema,credentials_input_schema=(graph.credentials_input_schema if sub_graphs is not None else None),diff --git a/autogpt_platform/backend/backend/server/v2/library/routes_test.py b/autogpt_platform/backend/backend/server/v2/library/routes_test.pyindex ba67d4d99c..2681e9dfb7 100644--- a/autogpt_platform/backend/backend/server/v2/library/routes_test.py+++ b/autogpt_platform/backend/backend/server/v2/library/routes_test.py@@ -50,6 +50,7 @@ async def test_get_library_agents_success(creator_name="Test Creator",creator_image_url="",input_schema={"type": "object", "properties": {}},+ output_schema={"type": "object", "properties": {}},credentials_input_schema={"type": "object", "properties": {}},has_external_trigger=False,status=library_model.LibraryAgentStatus.COMPLETED,@@ -68,6 +69,7 @@ async def test_get_library_agents_success(creator_name="Test Creator",creator_image_url="",input_schema={"type": "object", "properties": {}},+ output_schema={"type": "object", "properties": {}},credentials_input_schema={"type": "object", "properties": {}},has_external_trigger=False,status=library_model.LibraryAgentStatus.COMPLETED,@@ -132,6 +134,7 @@ def test_add_agent_to_library_success(mocker: pytest_mock.MockFixture):creator_name="Test Creator",creator_image_url="",input_schema={"type": "object", "properties": {}},+ output_schema={"type": "object", "properties": {}},credentials_input_schema={"type": "object", "properties": {}},has_external_trigger=False,status=library_model.LibraryAgentStatus.COMPLETED,diff --git a/autogpt_platform/backend/backend/server/v2/store/db.py b/autogpt_platform/backend/backend/server/v2/store/db.pyindex 83931d6d7d..d50bf5c909 100644--- a/autogpt_platform/backend/backend/server/v2/store/db.py+++ b/autogpt_platform/backend/backend/server/v2/store/db.py@@ -55,7 +55,7 @@ def sanitize_query(query: str | None) -> str | None:async def get_store_agents(featured: bool = False,- creator: str | None = None,+ creators: list[str] | None = None,sorted_by: str | None = None,search_query: str | None = None,category: str | None = None,@@ -66,15 +66,15 @@ async def get_store_agents(Get PUBLIC store agents from the StoreAgent view"""logger.debug(- f"Getting store agents. featured={featured}, creator={creator}, sorted_by={sorted_by}, search={search_query}, category={category}, page={page}"+ f"Getting store agents. featured={featured}, creators={creators}, sorted_by={sorted_by}, search={search_query}, category={category}, page={page}")sanitized_query = sanitize_query(search_query)where_clause = {}if featured:where_clause["featured"] = featured- if creator:- where_clause["creator_username"] = creator+ if creators:+ where_clause["creator_username"] = {"in": creators}if category:where_clause["categories"] = {"has": category}diff --git a/autogpt_platform/backend/backend/server/v2/store/routes.py b/autogpt_platform/backend/backend/server/v2/store/routes.pyindex bbe3edde40..dfe14b3ef0 100644--- a/autogpt_platform/backend/backend/server/v2/store/routes.py+++ b/autogpt_platform/backend/backend/server/v2/store/routes.py@@ -162,7 +162,7 @@ async def get_agents(try:agents = await backend.server.v2.store.db.get_store_agents(featured=featured,- creator=creator,+ creators=[creator] if creator else None,sorted_by=sorted_by,search_query=search_query,category=category,diff --git a/autogpt_platform/backend/backend/server/v2/store/routes_test.py b/autogpt_platform/backend/backend/server/v2/store/routes_test.pyindex 88bb523c5f..86eb82e534 100644--- a/autogpt_platform/backend/backend/server/v2/store/routes_test.py+++ b/autogpt_platform/backend/backend/server/v2/store/routes_test.py@@ -66,7 +66,7 @@ def test_get_agents_defaults(snapshot.assert_match(json.dumps(response.json(), indent=2), "def_agts")mock_db_call.assert_called_once_with(featured=False,- creator=None,+ creators=None,sorted_by=None,search_query=None,category=None,@@ -113,7 +113,7 @@ def test_get_agents_featured(snapshot.assert_match(json.dumps(response.json(), indent=2), "feat_agts")mock_db_call.assert_called_once_with(featured=True,- creator=None,+ creators=None,sorted_by=None,search_query=None,category=None,@@ -160,7 +160,7 @@ def test_get_agents_by_creator(snapshot.assert_match(json.dumps(response.json(), indent=2), "agts_by_creator")mock_db_call.assert_called_once_with(featured=False,- creator="specific-creator",+ creators=["specific-creator"],sorted_by=None,search_query=None,category=None,@@ -207,7 +207,7 @@ def test_get_agents_sorted(snapshot.assert_match(json.dumps(response.json(), indent=2), "agts_sorted")mock_db_call.assert_called_once_with(featured=False,- creator=None,+ creators=None,sorted_by="runs",search_query=None,category=None,@@ -254,7 +254,7 @@ def test_get_agents_search(snapshot.assert_match(json.dumps(response.json(), indent=2), "agts_search")mock_db_call.assert_called_once_with(featured=False,- creator=None,+ creators=None,sorted_by=None,search_query="specific",category=None,@@ -300,7 +300,7 @@ def test_get_agents_category(snapshot.assert_match(json.dumps(response.json(), indent=2), "agts_category")mock_db_call.assert_called_once_with(featured=False,- creator=None,+ creators=None,sorted_by=None,search_query=None,category="test-category",@@ -349,7 +349,7 @@ def test_get_agents_pagination(snapshot.assert_match(json.dumps(response.json(), indent=2), "agts_pagination")mock_db_call.assert_called_once_with(featured=False,- creator=None,+ creators=None,sorted_by=None,search_query=None,category=None,diff --git a/autogpt_platform/backend/backend/util/models.py b/autogpt_platform/backend/backend/util/models.pyindex 867de27a36..a4b21af900 100644--- a/autogpt_platform/backend/backend/util/models.py+++ b/autogpt_platform/backend/backend/util/models.py@@ -18,3 +18,12 @@ class Pagination(pydantic.BaseModel):page_size: int = pydantic.Field(description="Number of items per page.", examples=[25])++ @staticmethod+ def empty() -> "Pagination":+ return Pagination(+ total_items=0,+ total_pages=0,+ current_page=0,+ page_size=0,+ )diff --git a/autogpt_platform/backend/snapshots/lib_agts_search b/autogpt_platform/backend/snapshots/lib_agts_searchindex e0f168ddd7..f19d42896b 100644--- a/autogpt_platform/backend/snapshots/lib_agts_search+++ b/autogpt_platform/backend/snapshots/lib_agts_search@@ -15,6 +15,10 @@"type": "object","properties": {}},+ "output_schema": {+ "type": "object",+ "properties": {}+ },"credentials_input_schema": {"type": "object","properties": {}@@ -40,6 +44,10 @@"type": "object","properties": {}},+ "output_schema": {+ "type": "object",+ "properties": {}+ },"credentials_input_schema": {"type": "object","properties": {}diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.jsonindex 8cfcabf6e9..32d6184fb7 100644--- a/autogpt_platform/frontend/src/app/api/openapi.json+++ b/autogpt_platform/frontend/src/app/api/openapi.json@@ -2838,6 +2838,239 @@}}},+ "/api/builder/suggestions": {+ "get": {+ "tags": ["v2"],+ "summary": "Get Builder suggestions",+ "description": "Get all suggestions for the Blocks Menu.",+ "operationId": "getV2Get builder suggestions",+ "responses": {+ "200": {+ "description": "Successful Response",+ "content": {+ "application/json": {+ "schema": { "$ref": "#/components/schemas/SuggestionsResponse" }+ }+ }+ }+ }+ }+ },+ "/api/builder/categories": {+ "get": {+ "tags": ["v2"],+ "summary": "Get Builder block categories",+ "description": "Get all block categories with a specified number of blocks per category.",+ "operationId": "getV2Get builder block categories",+ "parameters": [+ {+ "name": "blocks_per_category",+ "in": "query",+ "required": false,+ "schema": {+ "type": "integer",+ "default": 3,+ "title": "Blocks Per Category"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "Successful Response",+ "content": {+ "application/json": {+ "schema": {+ "type": "array",+ "items": {+ "$ref": "#/components/schemas/BlockCategoryResponse"+ },+ "title": "Response Getv2Get Builder Block Categories"+ }+ }+ }+ },+ "422": {+ "description": "Validation Error",+ "content": {+ "application/json": {+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }+ }+ }+ }+ }+ }+ },+ "/api/builder/blocks": {+ "get": {+ "tags": ["v2"],+ "summary": "Get Builder blocks",+ "description": "Get blocks based on either category, type, or provider.",+ "operationId": "getV2Get builder blocks",+ "parameters": [+ {+ "name": "category",+ "in": "query",+ "required": false,+ "schema": {+ "anyOf": [{ "type": "string" }, { "type": "null" }],+ "title": "Category"+ }+ },+ {+ "name": "type",+ "in": "query",+ "required": false,+ "schema": {+ "anyOf": [+ {+ "enum": ["all", "input", "action", "output"],+ "type": "string"+ },+ { "type": "null" }+ ],+ "title": "Type"+ }+ },+ {+ "name": "provider",+ "in": "query",+ "required": false,+ "schema": {+ "anyOf": [+ {+ "type": "string",+ "description": "Provider name for integrations. Can be any string value, including custom provider names."+ },+ { "type": "null" }+ ],+ "title": "Provider"+ }+ },+ {+ "name": "page",+ "in": "query",+ "required": false,+ "schema": { "type": "integer", "default": 1, "title": "Page" }+ },+ {+ "name": "page_size",+ "in": "query",+ "required": false,+ "schema": { "type": "integer", "default": 50, "title": "Page Size" }+ }+ ],+ "responses": {+ "200": {+ "description": "Successful Response",+ "content": {+ "application/json": {+ "schema": { "$ref": "#/components/schemas/BlockResponse" }+ }+ }+ },+ "422": {+ "description": "Validation Error",+ "content": {+ "application/json": {+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }+ }+ }+ }+ }+ }+ },+ "/api/builder/providers": {+ "get": {+ "tags": ["v2"],+ "summary": "Get Builder integration providers",+ "description": "Get all integration providers with their block counts.",+ "operationId": "getV2Get builder integration providers",+ "parameters": [+ {+ "name": "page",+ "in": "query",+ "required": false,+ "schema": { "type": "integer", "default": 1, "title": "Page" }+ },+ {+ "name": "page_size",+ "in": "query",+ "required": false,+ "schema": { "type": "integer", "default": 50, "title": "Page Size" }+ }+ ],+ "responses": {+ "200": {+ "description": "Successful Response",+ "content": {+ "application/json": {+ "schema": { "$ref": "#/components/schemas/ProviderResponse" }+ }+ }+ },+ "422": {+ "description": "Validation Error",+ "content": {+ "application/json": {+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }+ }+ }+ }+ }+ }+ },+ "/api/builder/search": {+ "post": {+ "tags": ["v2", "store", "private"],+ "summary": "Builder search",+ "description": "Search for blocks (including integrations), marketplace agents, and user library agents.",+ "operationId": "postV2Builder search",+ "requestBody": {+ "content": {+ "application/json": {+ "schema": { "$ref": "#/components/schemas/SearchRequest" }+ }+ },+ "required": true+ },+ "responses": {+ "200": {+ "description": "Successful Response",+ "content": {+ "application/json": {+ "schema": { "$ref": "#/components/schemas/SearchResponse" }+ }+ }+ },+ "422": {+ "description": "Validation Error",+ "content": {+ "application/json": {+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }+ }+ }+ }+ }+ }+ },+ "/api/builder/counts": {+ "get": {+ "tags": ["v2"],+ "summary": "Get Builder item counts",+ "description": "Get item counts for the menu categories in the Blocks Menu.",+ "operationId": "getV2Get builder item counts",+ "responses": {+ "200": {+ "description": "Successful Response",+ "content": {+ "application/json": {+ "schema": { "$ref": "#/components/schemas/CountResponse" }+ }+ }+ }+ }+ }+ },"/api/store/admin/listings": {"get": {"tags": ["v2", "admin", "store", "admin"],@@ -4128,6 +4361,33 @@],"title": "BaseGraph"},+ "BlockCategoryResponse": {+ "properties": {+ "name": { "type": "string", "title": "Name" },+ "total_blocks": { "type": "integer", "title": "Total Blocks" },+ "blocks": {+ "items": { "additionalProperties": true, "type": "object" },+ "type": "array",+ "title": "Blocks"+ }+ },+ "type": "object",+ "required": ["name", "total_blocks", "blocks"],+ "title": "BlockCategoryResponse"+ },+ "BlockResponse": {+ "properties": {+ "blocks": {+ "items": { "additionalProperties": true, "type": "object" },+ "type": "array",+ "title": "Blocks"+ },+ "pagination": { "$ref": "#/components/schemas/Pagination" }+ },+ "type": "object",+ "required": ["blocks", "pagination"],+ "title": "BlockResponse"+ },"Body_postV1Callback": {"properties": {"code": {@@ -4248,6 +4508,31 @@"required": ["query", "conversation_history", "message_id"],"title": "ChatRequest"},+ "CountResponse": {+ "properties": {+ "all_blocks": { "type": "integer", "title": "All Blocks" },+ "input_blocks": { "type": "integer", "title": "Input Blocks" },+ "action_blocks": { "type": "integer", "title": "Action Blocks" },+ "output_blocks": { "type": "integer", "title": "Output Blocks" },+ "integrations": { "type": "integer", "title": "Integrations" },+ "marketplace_agents": {+ "type": "integer",+ "title": "Marketplace Agents"+ },+ "my_agents": { "type": "integer", "title": "My Agents" }+ },+ "type": "object",+ "required": [+ "all_blocks",+ "input_blocks",+ "action_blocks",+ "output_blocks",+ "integrations",+ "marketplace_agents",+ "my_agents"+ ],+ "title": "CountResponse"+ },"CreateAPIKeyRequest": {"properties": {"name": { "type": "string", "title": "Name" },@@ -4957,6 +5242,11 @@"type": "object","title": "Input Schema"},+ "output_schema": {+ "additionalProperties": true,+ "type": "object",+ "title": "Output Schema"+ },"credentials_input_schema": {"anyOf": [{ "additionalProperties": true, "type": "object" },@@ -4999,6 +5289,7 @@"name","description","input_schema",+ "output_schema","credentials_input_schema","has_external_trigger","new_output",@@ -6005,6 +6296,23 @@"required": ["name", "username", "description", "links"],"title": "ProfileDetails"},+ "Provider": {+ "properties": {+ "name": {+ "type": "string",+ "title": "Name",+ "description": "Provider name for integrations. Can be any string value, including custom provider names."+ },+ "description": { "type": "string", "title": "Description" },+ "integration_count": {+ "type": "integer",+ "title": "Integration Count"+ }+ },+ "type": "object",+ "required": ["name", "description", "integration_count"],+ "title": "Provider"+ },"ProviderConstants": {"properties": {"PROVIDER_NAMES": {@@ -6044,6 +6352,19 @@"title": "ProviderNamesResponse","description": "Response containing list of all provider names."},+ "ProviderResponse": {+ "properties": {+ "providers": {+ "items": { "$ref": "#/components/schemas/Provider" },+ "type": "array",+ "title": "Providers"+ },+ "pagination": { "$ref": "#/components/schemas/Pagination" }+ },+ "type": "object",+ "required": ["providers", "pagination"],+ "title": "ProviderResponse"+ },"RefundRequest": {"properties": {"id": { "type": "string", "title": "Id" },@@ -6130,6 +6451,86 @@"required": ["name", "cron", "inputs"],"title": "ScheduleCreationRequest"},+ "SearchRequest": {+ "properties": {+ "search_query": {+ "anyOf": [{ "type": "string" }, { "type": "null" }],+ "title": "Search Query"+ },+ "filter": {+ "anyOf": [+ {+ "items": {+ "type": "string",+ "enum": [+ "blocks",+ "integrations",+ "marketplace_agents",+ "my_agents"+ ]+ },+ "type": "array"+ },+ { "type": "null" }+ ],+ "title": "Filter"+ },+ "by_creator": {+ "anyOf": [+ { "items": { "type": "string" }, "type": "array" },+ { "type": "null" }+ ],+ "title": "By Creator"+ },+ "search_id": {+ "anyOf": [{ "type": "string" }, { "type": "null" }],+ "title": "Search Id"+ },+ "page": {+ "anyOf": [{ "type": "integer" }, { "type": "null" }],+ "title": "Page"+ },+ "page_size": {+ "anyOf": [{ "type": "integer" }, { "type": "null" }],+ "title": "Page Size"+ }+ },+ "type": "object",+ "title": "SearchRequest"+ },+ "SearchResponse": {+ "properties": {+ "items": {+ "items": {+ "anyOf": [+ { "additionalProperties": true, "type": "object" },+ { "$ref": "#/components/schemas/LibraryAgent" },+ { "$ref": "#/components/schemas/StoreAgent" }+ ]+ },+ "type": "array",+ "title": "Items"+ },+ "total_items": {+ "additionalProperties": { "type": "integer" },+ "propertyNames": {+ "enum": [+ "blocks",+ "integrations",+ "marketplace_agents",+ "my_agents"+ ]+ },+ "type": "object",+ "title": "Total Items"+ },+ "page": { "type": "integer", "title": "Page" },+ "more_pages": { "type": "boolean", "title": "More Pages" }+ },+ "type": "object",+ "required": ["items", "total_items", "page", "more_pages"],+ "title": "SearchResponse"+ },"SetGraphActiveVersion": {"properties": {"active_graph_version": {@@ -6558,6 +6959,41 @@"enum": ["DRAFT", "PENDING", "APPROVED", "REJECTED"],"title": "SubmissionStatus"},+ "SuggestionsResponse": {+ "properties": {+ "otto_suggestions": {+ "items": { "type": "string" },+ "type": "array",+ "title": "Otto Suggestions"+ },+ "recent_searches": {+ "items": { "type": "string" },+ "type": "array",+ "title": "Recent Searches"+ },+ "providers": {+ "items": {+ "type": "string",+ "description": "Provider name for integrations. Can be any string value, including custom provider names."+ },+ "type": "array",+ "title": "Providers"+ },+ "top_blocks": {+ "items": { "additionalProperties": true, "type": "object" },+ "type": "array",+ "title": "Top Blocks"+ }+ },+ "type": "object",+ "required": [+ "otto_suggestions",+ "recent_searches",+ "providers",+ "top_blocks"+ ],+ "title": "SuggestionsResponse"+ },"TimezoneResponse": {"properties": {"timezone": {diff --git a/autogpt_platform/frontend/src/hooks/useAgentGraph.tsx b/autogpt_platform/frontend/src/hooks/useAgentGraph.tsxindex d6616e5419..0f672339f2 100644--- a/autogpt_platform/frontend/src/hooks/useAgentGraph.tsx+++ b/autogpt_platform/frontend/src/hooks/useAgentGraph.tsx@@ -18,6 +18,7 @@ import {NodeCreatable,NodeExecutionResult,SpecialBlockID,+ Node,} from "@/lib/autogpt-server-api";import { useBackendAPI } from "@/lib/autogpt-server-api/context";import {@@ -155,6 +156,16 @@ export default function useAgentGraph(setAgentName(graph.name);setAgentDescription(graph.description);+ const getGraphName = (node: Node) => {+ if (node.input_default.agent_name) {+ return node.input_default.agent_name;+ }+ return (+ availableFlows.find((flow) => flow.id === node.input_default.graph_id)+ ?.name || null+ );+ };+setXYNodes((prevNodes) => {const _newNodes = graph.nodes.map((node) => {const block = availableBlocks.find(@@ -162,12 +173,8 @@ export default function useAgentGraph()!;if (!block) return null;const prevNode = prevNodes.find((n) => n.id === node.id);- const flow =- block.uiType == BlockUIType.AGENT- ? availableFlows.find(- (flow) => flow.id === node.input_default.graph_id,- )- : null;+ const graphName =+ (block.uiType == BlockUIType.AGENT && getGraphName(node)) || null;const newNode: CustomNode = {id: node.id,type: "custom",@@ -179,7 +186,7 @@ export default function useAgentGraph(isOutputOpen: false,...prevNode?.data,block_id: block.id,- blockType: flow?.name || block.name,+ blockType: graphName || block.name,blockCosts: block.costs,categories: block.categories,description: block.description,@@ -257,15 +264,16 @@ export default function useAgentGraph(const getToolFuncName = useCallback((nodeID: string) => {const sinkNode = xyNodes.find((node) => node.id === nodeID);- const sinkNodeName = sinkNode- ? sinkNode.data.block_id === SpecialBlockID.AGENT- ? sinkNode.data.hardcodedValues?.graph_id- ? availableFlows.find(- (flow) => flow.id === sinkNode.data.hardcodedValues.graph_id,- )?.name || "agentexecutorblock"- : "agentexecutorblock"- : sinkNode.data.title.split(" ")[0]- : "";+ if (!sinkNode) return "";++ const sinkNodeName =+ sinkNode.data.block_id === SpecialBlockID.AGENT+ ? sinkNode.data.hardcodedValues?.agent_name ||+ availableFlows.find(+ (flow) => flow.id === sinkNode.data.hardcodedValues.graph_id,+ )?.name ||+ "agentexecutorblock"+ : sinkNode.data.title.split(" ")[0];return sinkNodeName;},diff --git a/autogpt_platform/frontend/src/lib/autogpt-server-api/types.ts b/autogpt_platform/frontend/src/lib/autogpt-server-api/types.tsindex ec22543859..1d7f21cce0 100644--- a/autogpt_platform/frontend/src/lib/autogpt-server-api/types.ts+++ b/autogpt_platform/frontend/src/lib/autogpt-server-api/types.ts@@ -407,6 +407,7 @@ export type LibraryAgent = {name: string;description: string;input_schema: GraphIOSchema;+ output_schema: GraphIOSchema;credentials_input_schema: CredentialsInputSchema;new_output: boolean;can_access_graph: boolean;