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): Library v2 Agents and Presets (#9258)
Reinier van der Leerce1d63c51735
diff --git a/autogpt_platform/backend/backend/data/execution.py b/autogpt_platform/backend/backend/data/execution.pyindex 4396fcb423..eae46278d8 100644--- a/autogpt_platform/backend/backend/data/execution.py+++ b/autogpt_platform/backend/backend/data/execution.py@@ -141,6 +141,7 @@ async def create_graph_execution(graph_version: int,nodes_input: list[tuple[str, BlockInput]],user_id: str,+ preset_id: str | None = None,) -> tuple[str, list[ExecutionResult]]:"""Create a new AgentGraphExecution record.@@ -168,6 +169,7 @@ async def create_graph_execution(]},"userId": user_id,+ "agentPresetId": preset_id,},include=GRAPH_EXECUTION_INCLUDE,)diff --git a/autogpt_platform/backend/backend/data/graph.py b/autogpt_platform/backend/backend/data/graph.pyindex 3d9a107676..31bd1dee4b 100644--- a/autogpt_platform/backend/backend/data/graph.py+++ b/autogpt_platform/backend/backend/data/graph.py@@ -534,7 +534,7 @@ async def get_execution(user_id: str, execution_id: str) -> GraphExecution | Nonasync def get_graph(graph_id: str,version: int | None = None,- template: bool = False,+ template: bool = False, # note: currently not in use; TODO: remove from DB entirelyuser_id: str | None = None,for_export: bool = False,) -> GraphModel | None:diff --git a/autogpt_platform/backend/backend/executor/manager.py b/autogpt_platform/backend/backend/executor/manager.pyindex 1d965e0121..5f1b8e62c0 100644--- a/autogpt_platform/backend/backend/executor/manager.py+++ b/autogpt_platform/backend/backend/executor/manager.py@@ -803,6 +803,7 @@ class ExecutionManager(AppService):data: BlockInput,user_id: str,graph_version: Optional[int] = None,+ preset_id: str | None = None,) -> GraphExecutionEntry:graph: GraphModel | None = self.db_client.get_graph(graph_id=graph_id, user_id=user_id, version=graph_version@@ -824,9 +825,9 @@ class ExecutionManager(AppService):# Extract request input data, and assign it to the input pin.if block.block_type == BlockType.INPUT:- name = node.input_default.get("name")- if name in data.get("node_input", {}):- input_data = {"value": data["node_input"][name]}+ input_name = node.input_default.get("name")+ if input_name and input_name in data:+ input_data = {"value": data[input_name]}# Extract webhook payload, and assign it to the input pinwebhook_payload_key = f"webhook_{node.webhook_id}_payload"@@ -851,6 +852,7 @@ class ExecutionManager(AppService):graph_version=graph.version,nodes_input=nodes_input,user_id=user_id,+ preset_id=preset_id,)starting_node_execs = []diff --git a/autogpt_platform/backend/backend/server/external/routes/v1.py b/autogpt_platform/backend/backend/server/external/routes/v1.pyindex bdd4cadf6f..1eebe82381 100644--- a/autogpt_platform/backend/backend/server/external/routes/v1.py+++ b/autogpt_platform/backend/backend/server/external/routes/v1.py@@ -1,9 +1,9 @@import loggingfrom collections import defaultdict-from typing import Any, Dict, List, Optional, Sequence+from typing import Annotated, Any, Dict, List, Optional, Sequencefrom autogpt_libs.utils.cache import thread_cached-from fastapi import APIRouter, Depends, HTTPException+from fastapi import APIRouter, Body, Depends, HTTPExceptionfrom prisma.enums import AgentExecutionStatus, APIKeyPermissionfrom typing_extensions import TypedDict@@ -101,7 +101,7 @@ def execute_graph_block(def execute_graph(graph_id: str,graph_version: int,- node_input: dict[Any, Any],+ node_input: Annotated[dict[str, Any], Body(..., embed=True, default_factory=dict)],api_key: APIKey = Depends(require_permission(APIKeyPermission.EXECUTE_GRAPH)),) -> dict[str, Any]:try:@@ -113,7 +113,7 @@ def execute_graph()return {"id": graph_exec.graph_exec_id}except Exception as e:- msg = e.__str__().encode().decode("unicode_escape")+ msg = str(e).encode().decode("unicode_escape")raise HTTPException(status_code=400, detail=msg)diff --git a/autogpt_platform/backend/backend/server/model.py b/autogpt_platform/backend/backend/server/model.pyindex 9b1b2f2e98..34b0c229ed 100644--- a/autogpt_platform/backend/backend/server/model.py+++ b/autogpt_platform/backend/backend/server/model.py@@ -33,9 +33,7 @@ class ExecuteGraphResponse(pydantic.BaseModel):class CreateGraph(pydantic.BaseModel):- template_id: str | None = None- template_version: int | None = None- graph: backend.data.graph.Graph | None = None+ graph: backend.data.graph.Graphclass CreateAPIKeyRequest(pydantic.BaseModel):@@ -57,5 +55,20 @@ class UpdatePermissionsRequest(pydantic.BaseModel):permissions: List[APIKeyPermission]+class Pagination(pydantic.BaseModel):+ total_items: int = pydantic.Field(+ description="Total number of items.", examples=[42]+ )+ total_pages: int = pydantic.Field(+ description="Total number of pages.", examples=[2]+ )+ current_page: int = pydantic.Field(+ description="Current_page page number.", examples=[1]+ )+ page_size: int = pydantic.Field(+ description="Number of items per page.", examples=[25]+ )++class RequestTopUp(pydantic.BaseModel):credit_amount: intdiff --git a/autogpt_platform/backend/backend/server/rest_api.py b/autogpt_platform/backend/backend/server/rest_api.pyindex e247d2e8fd..ae756ee71f 100644--- a/autogpt_platform/backend/backend/server/rest_api.py+++ b/autogpt_platform/backend/backend/server/rest_api.py@@ -17,6 +17,8 @@ import backend.data.dbimport backend.data.graphimport backend.data.userimport backend.server.routers.v1+import backend.server.v2.library.db+import backend.server.v2.library.modelimport backend.server.v2.library.routesimport backend.server.v2.store.modelimport backend.server.v2.store.routes@@ -123,15 +125,15 @@ class AgentServer(backend.util.service.AppProcess):@staticmethodasync def test_execute_graph(graph_id: str,- node_input: dict[str, Any],user_id: str,graph_version: Optional[int] = None,+ node_input: Optional[dict[str, Any]] = None,):return backend.server.routers.v1.execute_graph(user_id=user_id,graph_id=graph_id,graph_version=graph_version,- node_input=node_input,+ node_input=node_input or {},)@staticmethod@@ -170,8 +172,64 @@ class AgentServer(backend.util.service.AppProcess):@staticmethodasync def test_delete_graph(graph_id: str, user_id: str):+ await backend.server.v2.library.db.delete_library_agent_by_graph_id(+ graph_id=graph_id, user_id=user_id+ )return await backend.server.routers.v1.delete_graph(graph_id, user_id)+ @staticmethod+ async def test_get_presets(user_id: str, page: int = 1, page_size: int = 10):+ return await backend.server.v2.library.routes.presets.get_presets(+ user_id=user_id, page=page, page_size=page_size+ )++ @staticmethod+ async def test_get_preset(preset_id: str, user_id: str):+ return await backend.server.v2.library.routes.presets.get_preset(+ preset_id=preset_id, user_id=user_id+ )++ @staticmethod+ async def test_create_preset(+ preset: backend.server.v2.library.model.CreateLibraryAgentPresetRequest,+ user_id: str,+ ):+ return await backend.server.v2.library.routes.presets.create_preset(+ preset=preset, user_id=user_id+ )++ @staticmethod+ async def test_update_preset(+ preset_id: str,+ preset: backend.server.v2.library.model.CreateLibraryAgentPresetRequest,+ user_id: str,+ ):+ return await backend.server.v2.library.routes.presets.update_preset(+ preset_id=preset_id, preset=preset, user_id=user_id+ )++ @staticmethod+ async def test_delete_preset(preset_id: str, user_id: str):+ return await backend.server.v2.library.routes.presets.delete_preset(+ preset_id=preset_id, user_id=user_id+ )++ @staticmethod+ async def test_execute_preset(+ graph_id: str,+ graph_version: int,+ preset_id: str,+ user_id: str,+ node_input: Optional[dict[str, Any]] = None,+ ):+ return await backend.server.v2.library.routes.presets.execute_preset(+ graph_id=graph_id,+ graph_version=graph_version,+ preset_id=preset_id,+ node_input=node_input or {},+ user_id=user_id,+ )+@staticmethodasync def test_create_store_listing(request: backend.server.v2.store.model.StoreSubmissionRequest, user_id: strdiff --git a/autogpt_platform/backend/backend/server/routers/v1.py b/autogpt_platform/backend/backend/server/routers/v1.pyindex dd7f72e50b..9e6c2337d6 100644--- a/autogpt_platform/backend/backend/server/routers/v1.py+++ b/autogpt_platform/backend/backend/server/routers/v1.py@@ -9,12 +9,13 @@ import stripefrom autogpt_libs.auth.middleware import auth_middlewarefrom autogpt_libs.feature_flag.client import feature_flagfrom autogpt_libs.utils.cache import thread_cached-from fastapi import APIRouter, Depends, HTTPException, Request, Response+from fastapi import APIRouter, Body, Depends, HTTPException, Request, Responsefrom typing_extensions import Optional, TypedDictimport backend.data.blockimport backend.server.integrations.routerimport backend.server.routers.analytics+import backend.server.v2.library.db as library_dbfrom backend.data import execution as execution_dbfrom backend.data import graph as graph_dbfrom backend.data.api_key import (@@ -310,11 +311,6 @@ async def get_graph(tags=["graphs"],dependencies=[Depends(auth_middleware)],)-@v1_router.get(- path="/templates/{graph_id}/versions",- tags=["templates", "graphs"],- dependencies=[Depends(auth_middleware)],-)async def get_graph_all_versions(graph_id: str, user_id: Annotated[str, Depends(get_user_id)]) -> Sequence[graph_db.GraphModel]:@@ -330,41 +326,18 @@ async def get_graph_all_versions(async def create_new_graph(create_graph: CreateGraph, user_id: Annotated[str, Depends(get_user_id)]) -> graph_db.GraphModel:- return await do_create_graph(create_graph, is_template=False, user_id=user_id)---async def do_create_graph(- create_graph: CreateGraph,- is_template: bool,- # user_id doesn't have to be annotated like on other endpoints,- # because create_graph isn't used directly as an endpoint- user_id: str,-) -> graph_db.GraphModel:- if create_graph.graph:- graph = graph_db.make_graph_model(create_graph.graph, user_id)- elif create_graph.template_id:- # Create a new graph from a template- graph = await graph_db.get_graph(- create_graph.template_id,- create_graph.template_version,- template=True,- user_id=user_id,- )- if not graph:- raise HTTPException(- 400, detail=f"Template #{create_graph.template_id} not found"- )- graph.version = 1- else:- raise HTTPException(- status_code=400, detail="Either graph or template_id must be provided."- )-- graph.is_template = is_template- graph.is_active = not is_template+ graph = graph_db.make_graph_model(create_graph.graph, user_id)graph.reassign_ids(user_id=user_id, reassign_graph_id=True)graph = await graph_db.create_graph(graph, user_id=user_id)++ # Create a library agent for the new graph+ await library_db.create_library_agent(+ graph.id,+ graph.version,+ user_id,+ )+graph = await on_graph_activate(graph,get_credentials=lambda id: integration_creds_manager.get(user_id, id),@@ -391,11 +364,6 @@ async def delete_graph(@v1_router.put(path="/graphs/{graph_id}", tags=["graphs"], dependencies=[Depends(auth_middleware)])-@v1_router.put(- path="/templates/{graph_id}",- tags=["templates", "graphs"],- dependencies=[Depends(auth_middleware)],-)async def update_graph(graph_id: str,graph: graph_db.Graph,@@ -427,6 +395,10 @@ async def update_graph(new_graph_version = await graph_db.create_graph(graph, user_id=user_id)if new_graph_version.is_active:+ # Keep the library agent up to date with the new active version+ await library_db.update_agent_version_in_library(+ user_id, graph.id, graph.version+ )def get_credentials(credentials_id: str) -> "Credentials | None":return integration_creds_manager.get(user_id, credentials_id)@@ -483,6 +455,12 @@ async def set_graph_active_version(version=new_active_version,user_id=user_id,)++ # Keep the library agent up to date with the new active version+ await library_db.update_agent_version_in_library(+ user_id, new_active_graph.id, new_active_graph.version+ )+if current_active_graph and current_active_graph.version != new_active_version:# Handle deactivation of the previously active versionawait on_graph_deactivate(@@ -498,7 +476,7 @@ async def set_graph_active_version()def execute_graph(graph_id: str,- node_input: dict[Any, Any],+ node_input: Annotated[dict[str, Any], Body(..., embed=True, default_factory=dict)],user_id: Annotated[str, Depends(get_user_id)],graph_version: Optional[int] = None,) -> ExecuteGraphResponse:@@ -508,7 +486,7 @@ def execute_graph()return ExecuteGraphResponse(graph_exec_id=graph_exec.graph_exec_id)except Exception as e:- msg = e.__str__().encode().decode("unicode_escape")+ msg = str(e).encode().decode("unicode_escape")raise HTTPException(status_code=400, detail=msg)@@ -559,47 +537,6 @@ async def get_graph_run_node_execution_results(return await execution_db.get_execution_results(graph_exec_id)-########################################################-##################### Templates ########################-########################################################---@v1_router.get(- path="/templates",- tags=["graphs", "templates"],- dependencies=[Depends(auth_middleware)],-)-async def get_templates(- user_id: Annotated[str, Depends(get_user_id)]-) -> Sequence[graph_db.GraphModel]:- return await graph_db.get_graphs(filter_by="template", user_id=user_id)---@v1_router.get(- path="/templates/{graph_id}",- tags=["templates", "graphs"],- dependencies=[Depends(auth_middleware)],-)-async def get_template(- graph_id: str, version: int | None = None-) -> graph_db.GraphModel:- graph = await graph_db.get_graph(graph_id, version, template=True)- if not graph:- raise HTTPException(status_code=404, detail=f"Template #{graph_id} not found.")- return graph---@v1_router.post(- path="/templates",- tags=["templates", "graphs"],- dependencies=[Depends(auth_middleware)],-)-async def create_new_template(- create_graph: CreateGraph, user_id: Annotated[str, Depends(get_user_id)]-) -> graph_db.GraphModel:- return await do_create_graph(create_graph, is_template=True, user_id=user_id)--############################################################################# Schedules ################################################################################diff --git a/autogpt_platform/backend/backend/server/v2/library/db.py b/autogpt_platform/backend/backend/server/v2/library/db.pyindex 8d142ef40c..da106a9081 100644--- a/autogpt_platform/backend/backend/server/v2/library/db.py+++ b/autogpt_platform/backend/backend/server/v2/library/db.py@@ -1,103 +1,166 @@import logging-from typing import Listimport prisma.errors+import prisma.fieldsimport prisma.modelsimport prisma.types-import backend.data.graph-import backend.data.includes-import backend.server.v2.library.model-import backend.server.v2.store.exceptions+import backend.server.model+import backend.server.v2.library.model as library_model+import backend.server.v2.store.exceptions as store_exceptionslogger = logging.getLogger(__name__)async def get_library_agents(- user_id: str,-) -> List[backend.server.v2.library.model.LibraryAgent]:- """- Returns all agents (AgentGraph) that belong to the user and all agents in their library (UserAgent table)- """- logger.debug(f"Getting library agents for user {user_id}")+ user_id: str, search_query: str | None = None+) -> list[library_model.LibraryAgent]:+ logger.debug(+ f"Fetching library agents for user_id={user_id} search_query={search_query}"+ )- try:- # Get agents created by user with nodes and links- user_created = await prisma.models.AgentGraph.prisma().find_many(- where=prisma.types.AgentGraphWhereInput(userId=user_id, isActive=True),- include=backend.data.includes.AGENT_GRAPH_INCLUDE,- )+ if search_query and len(search_query.strip()) > 100:+ logger.warning(f"Search query too long: {search_query}")+ raise store_exceptions.DatabaseError("Search query is too long.")- # Get agents in user's library with nodes and links- library_agents = await prisma.models.UserAgent.prisma().find_many(- where=prisma.types.UserAgentWhereInput(- userId=user_id, isDeleted=False, isArchived=False- ),+ where_clause: prisma.types.LibraryAgentWhereInput = {+ "userId": user_id,+ "isDeleted": False,+ "isArchived": False,+ }++ if search_query:+ where_clause["OR"] = [+ {+ "Agent": {+ "is": {"name": {"contains": search_query, "mode": "insensitive"}}+ }+ },+ {+ "Agent": {+ "is": {+ "description": {"contains": search_query, "mode": "insensitive"}+ }+ }+ },+ ]++ try:+ library_agents = await prisma.models.LibraryAgent.prisma().find_many(+ where=where_clause,include={"Agent": {"include": {- "AgentNodes": {- "include": {- "Input": True,- "Output": True,- "Webhook": True,- "AgentBlock": True,- }- }+ "AgentNodes": {"include": {"Input": True, "Output": True}}}}},+ order=[{"updatedAt": "desc"}],)+ logger.debug(f"Retrieved {len(library_agents)} agents for user_id={user_id}.")+ return [library_model.LibraryAgent.from_db(agent) for agent in library_agents]+ except prisma.errors.PrismaError as e:+ logger.error(f"Database error fetching library agents: {e}")+ raise store_exceptions.DatabaseError("Unable to fetch library agents.")- # Convert to Graph models first- graphs = []-- # Add user created agents- for agent in user_created:- try:- graphs.append(backend.data.graph.GraphModel.from_db(agent))- except Exception as e:- logger.error(f"Error processing user created agent {agent.id}: {e}")- continue-- # Add library agents- for agent in library_agents:- if agent.Agent:- try:- graphs.append(backend.data.graph.GraphModel.from_db(agent.Agent))- except Exception as e:- logger.error(f"Error processing library agent {agent.agentId}: {e}")- continue-- # Convert Graph models to LibraryAgent models- result = []- for graph in graphs:- result.append(- backend.server.v2.library.model.LibraryAgent(- id=graph.id,- version=graph.version,- is_active=graph.is_active,- name=graph.name,- description=graph.description,- isCreatedByUser=any(a.id == graph.id for a in user_created),- input_schema=graph.input_schema,- output_schema=graph.output_schema,- )- )- logger.debug(f"Found {len(result)} library agents")- return result+async def create_library_agent(+ agent_id: str, agent_version: int, user_id: str+) -> prisma.models.LibraryAgent:+ """+ Adds an agent to the user's library (LibraryAgent table)+ """+ try:+ return await prisma.models.LibraryAgent.prisma().create(+ data={+ "userId": user_id,+ "agentId": agent_id,+ "agentVersion": agent_version,+ "isCreatedByUser": False,+ "useGraphIsActiveVersion": True,+ }+ )except prisma.errors.PrismaError as e:- logger.error(f"Database error getting library agents: {str(e)}")- raise backend.server.v2.store.exceptions.DatabaseError(- "Failed to fetch library agents"+ logger.error(f"Database error creating agent to library: {str(e)}")+ raise store_exceptions.DatabaseError("Failed to create agent to library") from e+++async def update_agent_version_in_library(+ user_id: str, agent_id: str, agent_version: int+) -> None:+ """+ Updates the agent version in the library+ """+ try:+ library_agent = await prisma.models.LibraryAgent.prisma().find_first_or_raise(+ where={+ "userId": user_id,+ "agentId": agent_id,+ "useGraphIsActiveVersion": True,+ },+ )+ await prisma.models.LibraryAgent.prisma().update(+ where={"id": library_agent.id},+ data={+ "Agent": {+ "connect": {+ "graphVersionId": {"id": agent_id, "version": agent_version}+ },+ },+ },+ )+ except prisma.errors.PrismaError as e:+ logger.error(f"Database error updating agent version in library: {str(e)}")+ raise store_exceptions.DatabaseError(+ "Failed to update agent version in library") from e-async def add_agent_to_library(store_listing_version_id: str, user_id: str) -> None:+async def update_library_agent(+ library_agent_id: str,+ user_id: str,+ auto_update_version: bool = False,+ is_favorite: bool = False,+ is_archived: bool = False,+ is_deleted: bool = False,+) -> None:+ """+ Updates the library agent with the given fields"""- Finds the agent from the store listing version and adds it to the user's library (UserAgent table)+ try:+ await prisma.models.LibraryAgent.prisma().update_many(+ where={"id": library_agent_id, "userId": user_id},+ data={+ "useGraphIsActiveVersion": auto_update_version,+ "isFavorite": is_favorite,+ "isArchived": is_archived,+ "isDeleted": is_deleted,+ },+ )+ except prisma.errors.PrismaError as e:+ logger.error(f"Database error updating library agent: {str(e)}")+ raise store_exceptions.DatabaseError("Failed to update library agent") from e+++async def delete_library_agent_by_graph_id(graph_id: str, user_id: str) -> None:+ """+ Deletes a library agent for the given user+ """+ try:+ await prisma.models.LibraryAgent.prisma().delete_many(+ where={"agentId": graph_id, "userId": user_id}+ )+ except prisma.errors.PrismaError as e:+ logger.error(f"Database error deleting library agent: {str(e)}")+ raise store_exceptions.DatabaseError("Failed to delete library agent") from e+++async def add_store_agent_to_library(+ store_listing_version_id: str, user_id: str+) -> None:+ """+ Finds the agent from the store listing version and adds it to the user's library (LibraryAgent table)if they don't already have it"""logger.debug(@@ -116,7 +179,7 @@ async def add_agent_to_library(store_listing_version_id: str, user_id: str) -> Nlogger.warning(f"Store listing version not found: {store_listing_version_id}")- raise backend.server.v2.store.exceptions.AgentNotFoundError(+ raise store_exceptions.AgentNotFoundError(f"Store listing version {store_listing_version_id} not found")@@ -126,12 +189,10 @@ async def add_agent_to_library(store_listing_version_id: str, user_id: str) -> Nlogger.warning(f"User {user_id} cannot add their own agent to their library")- raise backend.server.v2.store.exceptions.DatabaseError(- "Cannot add own agent to library"- )+ raise store_exceptions.DatabaseError("Cannot add own agent to library")# Check if user already has this agent- existing_user_agent = await prisma.models.UserAgent.prisma().find_first(+ existing_user_agent = await prisma.models.LibraryAgent.prisma().find_first(where={"userId": user_id,"agentId": agent.id,@@ -145,21 +206,134 @@ async def add_agent_to_library(store_listing_version_id: str, user_id: str) -> N)return- # Create UserAgent entry- await prisma.models.UserAgent.prisma().create(- data=prisma.types.UserAgentCreateInput(- userId=user_id,- agentId=agent.id,- agentVersion=agent.version,- isCreatedByUser=False,- )+ # Create LibraryAgent entry+ await prisma.models.LibraryAgent.prisma().create(+ data={+ "userId": user_id,+ "agentId": agent.id,+ "agentVersion": agent.version,+ "isCreatedByUser": False,+ })logger.debug(f"Added agent {agent.id} to library for user {user_id}")- except backend.server.v2.store.exceptions.AgentNotFoundError:+ except store_exceptions.AgentNotFoundError:raiseexcept prisma.errors.PrismaError as e:logger.error(f"Database error adding agent to library: {str(e)}")- raise backend.server.v2.store.exceptions.DatabaseError(- "Failed to add agent to library"- ) from e+ raise store_exceptions.DatabaseError("Failed to add agent to library") from e+++##############################################+########### Presets DB Functions #############+##############################################+++async def get_presets(+ user_id: str, page: int, page_size: int+) -> library_model.LibraryAgentPresetResponse:+ try:+ presets = await prisma.models.AgentPreset.prisma().find_many(+ where={"userId": user_id},+ skip=page * page_size,+ take=page_size,+ )++ total_items = await prisma.models.AgentPreset.prisma().count(+ where={"userId": user_id},+ )+ total_pages = (total_items + page_size - 1) // page_size++ presets = [+ library_model.LibraryAgentPreset.from_db(preset) for preset in presets+ ]++ return library_model.LibraryAgentPresetResponse(+ presets=presets,+ pagination=backend.server.model.Pagination(+ total_items=total_items,+ total_pages=total_pages,+ current_page=page,+ page_size=page_size,+ ),+ )++ except prisma.errors.PrismaError as e:+ logger.error(f"Database error getting presets: {str(e)}")+ raise store_exceptions.DatabaseError("Failed to fetch presets") from e+++async def get_preset(+ user_id: str, preset_id: str+) -> library_model.LibraryAgentPreset | None:+ try:+ preset = await prisma.models.AgentPreset.prisma().find_unique(+ where={"id": preset_id}, include={"InputPresets": True}+ )+ if not preset or preset.userId != user_id:+ return None+ return library_model.LibraryAgentPreset.from_db(preset)+ except prisma.errors.PrismaError as e:+ logger.error(f"Database error getting preset: {str(e)}")+ raise store_exceptions.DatabaseError("Failed to fetch preset") from e+++async def upsert_preset(+ user_id: str,+ preset: library_model.CreateLibraryAgentPresetRequest,+ preset_id: str | None = None,+) -> library_model.LibraryAgentPreset:+ try:+ if preset_id:+ # Update existing preset+ new_preset = await prisma.models.AgentPreset.prisma().update(+ where={"id": preset_id},+ data={+ "name": preset.name,+ "description": preset.description,+ "isActive": preset.is_active,+ "InputPresets": {+ "create": [+ {"name": name, "data": prisma.fields.Json(data)}+ for name, data in preset.inputs.items()+ ]+ },+ },+ include={"InputPresets": True},+ )+ if not new_preset:+ raise ValueError(f"AgentPreset #{preset_id} not found")+ else:+ # Create new preset+ new_preset = await prisma.models.AgentPreset.prisma().create(+ data={+ "userId": user_id,+ "name": preset.name,+ "description": preset.description,+ "agentId": preset.agent_id,+ "agentVersion": preset.agent_version,+ "isActive": preset.is_active,+ "InputPresets": {+ "create": [+ {"name": name, "data": prisma.fields.Json(data)}+ for name, data in preset.inputs.items()+ ]+ },+ },+ include={"InputPresets": True},+ )+ return library_model.LibraryAgentPreset.from_db(new_preset)+ except prisma.errors.PrismaError as e:+ logger.error(f"Database error creating preset: {str(e)}")+ raise store_exceptions.DatabaseError("Failed to create preset") from e+++async def delete_preset(user_id: str, preset_id: str) -> None:+ try:+ await prisma.models.AgentPreset.prisma().update_many(+ where={"id": preset_id, "userId": user_id},+ data={"isDeleted": True},+ )+ except prisma.errors.PrismaError as e:+ logger.error(f"Database error deleting preset: {str(e)}")+ raise store_exceptions.DatabaseError("Failed to delete preset") from ediff --git a/autogpt_platform/backend/backend/server/v2/library/db_test.py b/autogpt_platform/backend/backend/server/v2/library/db_test.pyindex e06d4bfa9a..17e3bdb4ef 100644--- a/autogpt_platform/backend/backend/server/v2/library/db_test.py+++ b/autogpt_platform/backend/backend/server/v2/library/db_test.py@@ -37,7 +37,7 @@ async def test_get_library_agents(mocker):]mock_library_agents = [- prisma.models.UserAgent(+ prisma.models.LibraryAgent(id="ua1",userId="test-user",agentId="agent2",@@ -48,6 +48,7 @@ async def test_get_library_agents(mocker):createdAt=datetime.now(),updatedAt=datetime.now(),isFavorite=False,+ useGraphIsActiveVersion=True,Agent=prisma.models.AgentGraph(id="agent2",version=1,@@ -67,8 +68,8 @@ async def test_get_library_agents(mocker):return_value=mock_user_created)- mock_user_agent = mocker.patch("prisma.models.UserAgent.prisma")- mock_user_agent.return_value.find_many = mocker.AsyncMock(+ mock_library_agent = mocker.patch("prisma.models.LibraryAgent.prisma")+ mock_library_agent.return_value.find_many = mocker.AsyncMock(return_value=mock_library_agents)@@ -76,40 +77,16 @@ async def test_get_library_agents(mocker):result = await db.get_library_agents("test-user")# Verify results- assert len(result) == 2- assert result[0].id == "agent1"- assert result[0].name == "Test Agent 1"- assert result[0].description == "Test Description 1"- assert result[0].isCreatedByUser is True- assert result[1].id == "agent2"- assert result[1].name == "Test Agent 2"- assert result[1].description == "Test Description 2"- assert result[1].isCreatedByUser is False-- # Verify mocks called correctly- mock_agent_graph.return_value.find_many.assert_called_once_with(- where=prisma.types.AgentGraphWhereInput(userId="test-user", isActive=True),- include=backend.data.includes.AGENT_GRAPH_INCLUDE,- )- mock_user_agent.return_value.find_many.assert_called_once_with(- where=prisma.types.UserAgentWhereInput(- userId="test-user", isDeleted=False, isArchived=False- ),- include={- "Agent": {- "include": {- "AgentNodes": {- "include": {- "Input": True,- "Output": True,- "Webhook": True,- "AgentBlock": True,- }- }- }- }- },- )+ assert len(result) == 1+ assert result[0].id == "ua1"+ assert result[0].name == "Test Agent 2"+ assert result[0].description == "Test Description 2"+ assert result[0].is_created_by_user is False+ assert result[0].is_latest_version is True+ assert result[0].is_favorite is False+ assert result[0].agent_id == "agent2"+ assert result[0].agent_version == 1+ assert result[0].preset_id is None@pytest.mark.asyncio@@ -152,26 +129,26 @@ async def test_add_agent_to_library(mocker):return_value=mock_store_listing)- mock_user_agent = mocker.patch("prisma.models.UserAgent.prisma")- mock_user_agent.return_value.find_first = mocker.AsyncMock(return_value=None)- mock_user_agent.return_value.create = mocker.AsyncMock()+ mock_library_agent = mocker.patch("prisma.models.LibraryAgent.prisma")+ mock_library_agent.return_value.find_first = mocker.AsyncMock(return_value=None)+ mock_library_agent.return_value.create = mocker.AsyncMock()# Call function- await db.add_agent_to_library("version123", "test-user")+ await db.add_store_agent_to_library("version123", "test-user")# Verify mocks called correctlymock_store_listing_version.return_value.find_unique.assert_called_once_with(where={"id": "version123"}, include={"Agent": True})- mock_user_agent.return_value.find_first.assert_called_once_with(+ mock_library_agent.return_value.find_first.assert_called_once_with(where={"userId": "test-user","agentId": "agent1","agentVersion": 1,})- mock_user_agent.return_value.create.assert_called_once_with(- data=prisma.types.UserAgentCreateInput(+ mock_library_agent.return_value.create.assert_called_once_with(+ data=prisma.types.LibraryAgentCreateInput(userId="test-user", agentId="agent1", agentVersion=1, isCreatedByUser=False))@@ -189,7 +166,7 @@ async def test_add_agent_to_library_not_found(mocker):# Call function and verify exceptionwith pytest.raises(backend.server.v2.store.exceptions.AgentNotFoundError):- await db.add_agent_to_library("version123", "test-user")+ await db.add_store_agent_to_library("version123", "test-user")# Verify mock called correctlymock_store_listing_version.return_value.find_unique.assert_called_once_with(diff --git a/autogpt_platform/backend/backend/server/v2/library/model.py b/autogpt_platform/backend/backend/server/v2/library/model.pyindex 88a81f6d77..fc2c6c6757 100644--- a/autogpt_platform/backend/backend/server/v2/library/model.py+++ b/autogpt_platform/backend/backend/server/v2/library/model.py@@ -1,16 +1,111 @@-import typing+import datetime+from typing import Any+import prisma.modelsimport pydantic+import backend.data.block as block_model+import backend.data.graph as graph_model+import backend.server.model as server_model+class LibraryAgent(pydantic.BaseModel):id: str # Changed from agent_id to match GraphMeta- version: int # Changed from agent_version to match GraphMeta- is_active: bool # Added to match GraphMeta++ agent_id: str+ agent_version: int # Changed from agent_version to match GraphMeta++ preset_id: str | None++ updated_at: datetime.datetime+name: strdescription: str- isCreatedByUser: bool# Made input_schema and output_schema match GraphMeta's type- input_schema: dict[str, typing.Any] # Should be BlockIOObjectSubSchema in frontend- output_schema: dict[str, typing.Any] # Should be BlockIOObjectSubSchema in frontend+ input_schema: dict[str, Any] # Should be BlockIOObjectSubSchema in frontend+ output_schema: dict[str, Any] # Should be BlockIOObjectSubSchema in frontend++ is_favorite: bool+ is_created_by_user: bool++ is_latest_version: bool++ @staticmethod+ def from_db(agent: prisma.models.LibraryAgent):+ if not agent.Agent:+ raise ValueError("AgentGraph is required")++ graph = graph_model.GraphModel.from_db(agent.Agent)++ agent_updated_at = agent.Agent.updatedAt+ lib_agent_updated_at = agent.updatedAt++ # Take the latest updated_at timestamp either when the graph was updated or the library agent was updated+ updated_at = (+ max(agent_updated_at, lib_agent_updated_at)+ if agent_updated_at+ else lib_agent_updated_at+ )++ return LibraryAgent(+ id=agent.id,+ agent_id=agent.agentId,+ agent_version=agent.agentVersion,+ updated_at=updated_at,+ name=graph.name,+ description=graph.description,+ input_schema=graph.input_schema,+ output_schema=graph.output_schema,+ is_favorite=agent.isFavorite,+ is_created_by_user=agent.isCreatedByUser,+ is_latest_version=graph.is_active,+ preset_id=agent.AgentPreset.id if agent.AgentPreset else None,+ )+++class LibraryAgentPreset(pydantic.BaseModel):+ id: str+ updated_at: datetime.datetime++ agent_id: str+ agent_version: int++ name: str+ description: str++ is_active: bool++ inputs: block_model.BlockInput++ @staticmethod+ def from_db(preset: prisma.models.AgentPreset):+ input_data: block_model.BlockInput = {}++ for preset_input in preset.InputPresets or []:+ input_data[preset_input.name] = preset_input.data++ return LibraryAgentPreset(+ id=preset.id,+ updated_at=preset.updatedAt,+ agent_id=preset.agentId,+ agent_version=preset.agentVersion,+ name=preset.name,+ description=preset.description,+ is_active=preset.isActive,+ inputs=input_data,+ )+++class LibraryAgentPresetResponse(pydantic.BaseModel):+ presets: list[LibraryAgentPreset]+ pagination: server_model.Pagination+++class CreateLibraryAgentPresetRequest(pydantic.BaseModel):+ name: str+ description: str+ inputs: block_model.BlockInput+ agent_id: str+ agent_version: int+ is_active: booldiff --git a/autogpt_platform/backend/backend/server/v2/library/model_test.py b/autogpt_platform/backend/backend/server/v2/library/model_test.pyindex 81aa8fe07b..0eb700a7b3 100644--- a/autogpt_platform/backend/backend/server/v2/library/model_test.py+++ b/autogpt_platform/backend/backend/server/v2/library/model_test.py@@ -1,23 +1,36 @@+import datetime++import prisma.fields+import prisma.models++import backend.data.block+import backend.server.modelimport backend.server.v2.library.modeldef test_library_agent():agent = backend.server.v2.library.model.LibraryAgent(id="test-agent-123",- version=1,- is_active=True,+ agent_id="agent-123",+ agent_version=1,+ preset_id=None,+ updated_at=datetime.datetime.now(),name="Test Agent",description="Test description",- isCreatedByUser=False,input_schema={"type": "object", "properties": {}},output_schema={"type": "object", "properties": {}},+ is_favorite=False,+ is_created_by_user=False,+ is_latest_version=True,)assert agent.id == "test-agent-123"- assert agent.version == 1- assert agent.is_active is True+ assert agent.agent_id == "agent-123"+ assert agent.agent_version == 1assert agent.name == "Test Agent"assert agent.description == "Test description"- assert agent.isCreatedByUser is False+ assert agent.is_favorite is False+ assert agent.is_created_by_user is False+ assert agent.is_latest_version is Trueassert agent.input_schema == {"type": "object", "properties": {}}assert agent.output_schema == {"type": "object", "properties": {}}@@ -25,19 +38,140 @@ def test_library_agent():def test_library_agent_with_user_created():agent = backend.server.v2.library.model.LibraryAgent(id="user-agent-456",- version=2,- is_active=True,+ agent_id="agent-456",+ agent_version=2,+ preset_id=None,+ updated_at=datetime.datetime.now(),name="User Created Agent",description="An agent created by the user",- isCreatedByUser=True,input_schema={"type": "object", "properties": {}},output_schema={"type": "object", "properties": {}},+ is_favorite=False,+ is_created_by_user=True,+ is_latest_version=True,)assert agent.id == "user-agent-456"- assert agent.version == 2- assert agent.is_active is True+ assert agent.agent_id == "agent-456"+ assert agent.agent_version == 2assert agent.name == "User Created Agent"assert agent.description == "An agent created by the user"- assert agent.isCreatedByUser is True+ assert agent.is_favorite is False+ assert agent.is_created_by_user is True+ assert agent.is_latest_version is Trueassert agent.input_schema == {"type": "object", "properties": {}}assert agent.output_schema == {"type": "object", "properties": {}}+++def test_library_agent_preset():+ preset = backend.server.v2.library.model.LibraryAgentPreset(+ id="preset-123",+ name="Test Preset",+ description="Test preset description",+ agent_id="test-agent-123",+ agent_version=1,+ is_active=True,+ inputs={+ "dictionary": {"key1": "Hello", "key2": "World"},+ "selected_value": "key2",+ },+ updated_at=datetime.datetime.now(),+ )+ assert preset.id == "preset-123"+ assert preset.name == "Test Preset"+ assert preset.description == "Test preset description"+ assert preset.agent_id == "test-agent-123"+ assert preset.agent_version == 1+ assert preset.is_active is True+ assert preset.inputs == {+ "dictionary": {"key1": "Hello", "key2": "World"},+ "selected_value": "key2",+ }+++def test_library_agent_preset_response():+ preset = backend.server.v2.library.model.LibraryAgentPreset(+ id="preset-123",+ name="Test Preset",+ description="Test preset description",+ agent_id="test-agent-123",+ agent_version=1,+ is_active=True,+ inputs={+ "dictionary": {"key1": "Hello", "key2": "World"},+ "selected_value": "key2",+ },+ updated_at=datetime.datetime.now(),+ )++ pagination = backend.server.model.Pagination(+ total_items=1, total_pages=1, current_page=1, page_size=10+ )++ response = backend.server.v2.library.model.LibraryAgentPresetResponse(+ presets=[preset], pagination=pagination+ )++ assert len(response.presets) == 1+ assert response.presets[0].id == "preset-123"+ assert response.pagination.total_items == 1+ assert response.pagination.total_pages == 1+ assert response.pagination.current_page == 1+ assert response.pagination.page_size == 10+++def test_create_library_agent_preset_request():+ request = backend.server.v2.library.model.CreateLibraryAgentPresetRequest(+ name="New Preset",+ description="New preset description",+ agent_id="agent-123",+ agent_version=1,+ is_active=True,+ inputs={+ "dictionary": {"key1": "Hello", "key2": "World"},+ "selected_value": "key2",+ },+ )++ assert request.name == "New Preset"+ assert request.description == "New preset description"+ assert request.agent_id == "agent-123"+ assert request.agent_version == 1+ assert request.is_active is True+ assert request.inputs == {+ "dictionary": {"key1": "Hello", "key2": "World"},+ "selected_value": "key2",+ }+++def test_library_agent_from_db():+ # Create mock DB agent+ db_agent = prisma.models.AgentPreset(+ id="test-agent-123",+ createdAt=datetime.datetime.now(),+ updatedAt=datetime.datetime.now(),+ agentId="agent-123",+ agentVersion=1,+ name="Test Agent",+ description="Test agent description",+ isActive=True,+ userId="test-user-123",+ isDeleted=False,+ InputPresets=[+ prisma.models.AgentNodeExecutionInputOutput(+ id="input-123",+ time=datetime.datetime.now(),+ name="input1",+ data=prisma.fields.Json({"type": "string", "value": "test value"}),+ )+ ],+ )++ # Convert to LibraryAgentPreset+ agent = backend.server.v2.library.model.LibraryAgentPreset.from_db(db_agent)++ assert agent.id == "test-agent-123"+ assert agent.agent_version == 1+ assert agent.is_active is True+ assert agent.name == "Test Agent"+ assert agent.description == "Test agent description"+ assert agent.inputs == {"input1": {"type": "string", "value": "test value"}}diff --git a/autogpt_platform/backend/backend/server/v2/library/routes.py b/autogpt_platform/backend/backend/server/v2/library/routes.pydeleted file mode 100644index 3ee8680254..0000000000--- a/autogpt_platform/backend/backend/server/v2/library/routes.py+++ /dev/null@@ -1,123 +0,0 @@-import logging-import typing--import autogpt_libs.auth.depends-import autogpt_libs.auth.middleware-import fastapi-import prisma--import backend.data.graph-import backend.integrations.creds_manager-import backend.integrations.webhooks.graph_lifecycle_hooks-import backend.server.v2.library.db-import backend.server.v2.library.model--logger = logging.getLogger(__name__)--router = fastapi.APIRouter()-integration_creds_manager = (- backend.integrations.creds_manager.IntegrationCredentialsManager()-)--- "/agents",- tags=["library", "private"],- dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],-)-async def get_library_agents(- user_id: typing.Annotated[- str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)- ]-) -> typing.Sequence[backend.server.v2.library.model.LibraryAgent]:- """- Get all agents in the user's library, including both created and saved agents.- """- try:- agents = await backend.server.v2.library.db.get_library_agents(user_id)- return agents- except Exception:- logger.exception("Exception occurred whilst getting library agents")- raise fastapi.HTTPException(- status_code=500, detail="Failed to get library agents"- )--- "/agents/{store_listing_version_id}",- tags=["library", "private"],- dependencies=[fastapi.Depends(autogpt_libs.auth.middleware.auth_middleware)],- status_code=201,-)-async def add_agent_to_library(- store_listing_version_id: str,- user_id: typing.Annotated[- str, fastapi.Depends(autogpt_libs.auth.depends.get_user_id)- ],-) -> fastapi.Response:- """- Add an agent from the store to the user's library.-- Args:- store_listing_version_id (str): ID of the store listing version to add- user_id (str): ID of the authenticated user-- Returns:- fastapi.Response: 201 status code on success-- Raises:- HTTPException: If there is an error adding the agent to the library- """- try:- # Get the graph from the store listing- store_listing_version = (- await prisma.models.StoreListingVersion.prisma().find_unique(- where={"id": store_listing_version_id}, include={"Agent": True}- )- )-- if not store_listing_version or not store_listing_version.Agent:- raise fastapi.HTTPException(- status_code=404,- detail=f"Store listing version {store_listing_version_id} not found",- )-- agent = store_listing_version.Agent-- if agent.userId == user_id:- raise fastapi.HTTPException(- status_code=400, detail="Cannot add own agent to library"- )-- # Create a new graph from the template- graph = await backend.data.graph.get_graph(- agent.id, agent.version, user_id=user_id- )-- if not graph:- raise fastapi.HTTPException(- status_code=404, detail=f"Agent {agent.id} not found"- )-- # Create a deep copy with new IDs- graph.version = 1- graph.is_template = False- graph.is_active = True- graph.reassign_ids(user_id=user_id, reassign_graph_id=True)-- # Save the new graph- graph = await backend.data.graph.create_graph(graph, user_id=user_id)- graph = (- await backend.integrations.webhooks.graph_lifecycle_hooks.on_graph_activate(- graph,- get_credentials=lambda id: integration_creds_manager.get(user_id, id),- )- )-- return fastapi.Response(status_code=201)-- except Exception:- logger.exception("Exception occurred whilst adding agent to library")- raise fastapi.HTTPException(- status_code=500, detail="Failed to add agent to library"- )diff --git a/autogpt_platform/backend/backend/server/v2/library/routes/__init__.py b/autogpt_platform/backend/backend/server/v2/library/routes/__init__.pynew file mode 100644index 0000000000..f62cbe7ff2--- /dev/null+++ b/autogpt_platform/backend/backend/server/v2/library/routes/__init__.py@@ -0,0 +1,9 @@+import fastapi++from .agents import router as agents_router+from .presets import router as presets_router++router = fastapi.APIRouter()++router.include_router(presets_router)+router.include_router(agents_router)diff --git a/autogpt_platform/backend/backend/server/v2/library/routes/agents.py b/autogpt_platform/backend/backend/server/v2/library/routes/agents.pynew file mode 100644index 0000000000..ba3523c552--- /dev/null+++ b/autogpt_platform/backend/backend/server/v2/library/routes/agents.py@@ -0,0 +1,138 @@+import logging+from typing import Annotated, Sequence++import autogpt_libs.auth as autogpt_auth_lib+import fastapi++import backend.server.v2.library.db as library_db+import backend.server.v2.library.model as library_model+import backend.server.v2.store.exceptions as store_exceptions++logger = logging.getLogger(__name__)++router = fastapi.APIRouter()+++ "/agents",+ tags=["library", "private"],+ dependencies=[fastapi.Depends(autogpt_auth_lib.auth_middleware)],+)+async def get_library_agents(+ user_id: Annotated[str, fastapi.Depends(autogpt_auth_lib.depends.get_user_id)]+) -> Sequence[library_model.LibraryAgent]:+ """+ Get all agents in the user's library, including both created and saved agents.+ """+ try:+ agents = await library_db.get_library_agents(user_id)+ return agents+ except Exception as e:+ logger.exception(f"Exception occurred whilst getting library agents: {e}")+ raise fastapi.HTTPException(+ status_code=500, detail="Failed to get library agents"+ )+++ "/agents/{store_listing_version_id}",+ tags=["library", "private"],+ dependencies=[fastapi.Depends(autogpt_auth_lib.auth_middleware)],+ status_code=201,+)+async def add_agent_to_library(+ store_listing_version_id: str,+ user_id: Annotated[str, fastapi.Depends(autogpt_auth_lib.depends.get_user_id)],+) -> fastapi.Response:+ """+ Add an agent from the store to the user's library.++ Args:+ store_listing_version_id (str): ID of the store listing version to add+ user_id (str): ID of the authenticated user++ Returns:+ fastapi.Response: 201 status code on success++ Raises:+ HTTPException: If there is an error adding the agent to the library+ """+ try:+ # Use the database function to add the agent to the library+ await library_db.add_store_agent_to_library(store_listing_version_id, user_id)+ return fastapi.Response(status_code=201)++ except store_exceptions.AgentNotFoundError:+ raise fastapi.HTTPException(+ status_code=404,+ detail=f"Store listing version {store_listing_version_id} not found",+ )+ except store_exceptions.DatabaseError as e:+ logger.exception(f"Database error occurred whilst adding agent to library: {e}")+ raise fastapi.HTTPException(+ status_code=500, detail="Failed to add agent to library"+ )+ except Exception as e:+ logger.exception(+ f"Unexpected exception occurred whilst adding agent to library: {e}"+ )+ raise fastapi.HTTPException(+ status_code=500, detail="Failed to add agent to library"+ )+++ "/agents/{library_agent_id}",+ tags=["library", "private"],+ dependencies=[fastapi.Depends(autogpt_auth_lib.auth_middleware)],+ status_code=204,+)+async def update_library_agent(+ library_agent_id: str,+ user_id: Annotated[str, fastapi.Depends(autogpt_auth_lib.depends.get_user_id)],+ auto_update_version: bool = False,+ is_favorite: bool = False,+ is_archived: bool = False,+ is_deleted: bool = False,+) -> fastapi.Response:+ """+ Update the library agent with the given fields.++ Args:+ library_agent_id (str): ID of the library agent to update+ user_id (str): ID of the authenticated user+ auto_update_version (bool): Whether to auto-update the agent version+ is_favorite (bool): Whether the agent is marked as favorite+ is_archived (bool): Whether the agent is archived+ is_deleted (bool): Whether the agent is deleted++ Returns:+ fastapi.Response: 204 status code on success++ Raises:+ HTTPException: If there is an error updating the library agent+ """+ try:+ # Use the database function to update the library agent+ await library_db.update_library_agent(+ library_agent_id,+ user_id,+ auto_update_version,+ is_favorite,+ is_archived,+ is_deleted,+ )+ return fastapi.Response(status_code=204)++ except store_exceptions.DatabaseError as e:+ logger.exception(f"Database error occurred whilst updating library agent: {e}")+ raise fastapi.HTTPException(+ status_code=500, detail="Failed to update library agent"+ )+ except Exception as e:+ logger.exception(+ f"Unexpected exception occurred whilst updating library agent: {e}"+ )+ raise fastapi.HTTPException(+ status_code=500, detail="Failed to update library agent"+ )diff --git a/autogpt_platform/backend/backend/server/v2/library/routes/presets.py b/autogpt_platform/backend/backend/server/v2/library/routes/presets.pynew file mode 100644index 0000000000..ff02a394bb--- /dev/null+++ b/autogpt_platform/backend/backend/server/v2/library/routes/presets.py@@ -0,0 +1,130 @@+import logging+from typing import Annotated, Any++import autogpt_libs.auth as autogpt_auth_lib+import autogpt_libs.utils.cache+import fastapi++import backend.executor+import backend.server.v2.library.db as library_db+import backend.server.v2.library.model as library_model+import backend.util.service++logger = logging.getLogger(__name__)++router = fastapi.APIRouter()+++@autogpt_libs.utils.cache.thread_cached+def execution_manager_client() -> backend.executor.ExecutionManager:+ return backend.util.service.get_service_client(backend.executor.ExecutionManager)++[email protected]("/presets")+async def get_presets(+ user_id: Annotated[str, fastapi.Depends(autogpt_auth_lib.depends.get_user_id)],+ page: int = 1,+ page_size: int = 10,+) -> library_model.LibraryAgentPresetResponse:+ try:+ presets = await library_db.get_presets(user_id, page, page_size)+ return presets+ except Exception as e:+ logger.exception(f"Exception occurred whilst getting presets: {e}")+ raise fastapi.HTTPException(status_code=500, detail="Failed to get presets")++[email protected]("/presets/{preset_id}")+async def get_preset(+ preset_id: str,+ user_id: Annotated[str, fastapi.Depends(autogpt_auth_lib.depends.get_user_id)],+) -> library_model.LibraryAgentPreset:+ try:+ preset = await library_db.get_preset(user_id, preset_id)+ if not preset:+ raise fastapi.HTTPException(+ status_code=404,+ detail=f"Preset {preset_id} not found",+ )+ return preset+ except Exception as e:+ logger.exception(f"Exception occurred whilst getting preset: {e}")+ raise fastapi.HTTPException(status_code=500, detail="Failed to get preset")++[email protected]("/presets")+async def create_preset(+ preset: library_model.CreateLibraryAgentPresetRequest,+ user_id: Annotated[str, fastapi.Depends(autogpt_auth_lib.depends.get_user_id)],+) -> library_model.LibraryAgentPreset:+ try:+ return await library_db.upsert_preset(user_id, preset)+ except Exception as e:+ logger.exception(f"Exception occurred whilst creating preset: {e}")+ raise fastapi.HTTPException(status_code=500, detail="Failed to create preset")++[email protected]("/presets/{preset_id}")+async def update_preset(+ preset_id: str,+ preset: library_model.CreateLibraryAgentPresetRequest,+ user_id: Annotated[str, fastapi.Depends(autogpt_auth_lib.depends.get_user_id)],+) -> library_model.LibraryAgentPreset:+ try:+ return await library_db.upsert_preset(user_id, preset, preset_id)+ except Exception as e:+ logger.exception(f"Exception occurred whilst updating preset: {e}")+ raise fastapi.HTTPException(status_code=500, detail="Failed to update preset")++[email protected]("/presets/{preset_id}")+async def delete_preset(+ preset_id: str,+ user_id: Annotated[str, fastapi.Depends(autogpt_auth_lib.depends.get_user_id)],+):+ try:+ await library_db.delete_preset(user_id, preset_id)+ return fastapi.Response(status_code=204)+ except Exception as e:+ logger.exception(f"Exception occurred whilst deleting preset: {e}")+ raise fastapi.HTTPException(status_code=500, detail="Failed to delete preset")+++ path="/presets/{preset_id}/execute",+ tags=["presets"],+ dependencies=[fastapi.Depends(autogpt_auth_lib.auth_middleware)],+)+async def execute_preset(+ graph_id: str,+ graph_version: int,+ preset_id: str,+ node_input: Annotated[+ dict[str, Any], fastapi.Body(..., embed=True, default_factory=dict)+ ],+ user_id: Annotated[str, fastapi.Depends(autogpt_auth_lib.depends.get_user_id)],+) -> dict[str, Any]: # FIXME: add proper return type+ try:+ preset = await library_db.get_preset(user_id, preset_id)+ if not preset:+ raise fastapi.HTTPException(status_code=404, detail="Preset not found")++ logger.debug(f"Preset inputs: {preset.inputs}")++ # Merge input overrides with preset inputs+ merged_node_input = preset.inputs | node_input++ execution = execution_manager_client().add_execution(+ graph_id=graph_id,+ graph_version=graph_version,+ data=merged_node_input,+ user_id=user_id,+ preset_id=preset_id,+ )++ logger.debug(f"Execution added: {execution} with input: {merged_node_input}")++ return {"id": execution.graph_exec_id}+ except Exception as e:+ msg = str(e).encode().decode("unicode_escape")+ raise fastapi.HTTPException(status_code=400, detail=msg)diff --git a/autogpt_platform/backend/backend/server/v2/library/routes_test.py b/autogpt_platform/backend/backend/server/v2/library/routes_test.pyindex d793ce13b6..55efe586b4 100644--- a/autogpt_platform/backend/backend/server/v2/library/routes_test.py+++ b/autogpt_platform/backend/backend/server/v2/library/routes_test.py@@ -1,16 +1,16 @@-import autogpt_libs.auth.depends-import autogpt_libs.auth.middleware+import datetime++import autogpt_libs.auth as autogpt_auth_libimport fastapiimport fastapi.testclientimport pytestimport pytest_mock-import backend.server.v2.library.db-import backend.server.v2.library.model-import backend.server.v2.library.routes+import backend.server.v2.library.model as library_model+from backend.server.v2.library.routes import router as library_routerapp = fastapi.FastAPI()-app.include_router(backend.server.v2.library.routes.router)+app.include_router(library_router)client = fastapi.testclient.TestClient(app)@@ -25,31 +25,37 @@ def override_get_user_id():return "test-user-id"-app.dependency_overrides[autogpt_libs.auth.middleware.auth_middleware] = (- override_auth_middleware-)-app.dependency_overrides[autogpt_libs.auth.depends.get_user_id] = override_get_user_id+app.dependency_overrides[autogpt_auth_lib.auth_middleware] = override_auth_middleware+app.dependency_overrides[autogpt_auth_lib.depends.get_user_id] = override_get_user_iddef test_get_library_agents_success(mocker: pytest_mock.MockFixture):mocked_value = [- backend.server.v2.library.model.LibraryAgent(+ library_model.LibraryAgent(id="test-agent-1",- version=1,- is_active=True,+ agent_id="test-agent-1",+ agent_version=1,+ preset_id="preset-1",+ updated_at=datetime.datetime(2023, 1, 1, 0, 0, 0),+ is_favorite=False,+ is_created_by_user=True,+ is_latest_version=True,name="Test Agent 1",description="Test Description 1",- isCreatedByUser=True,input_schema={"type": "object", "properties": {}},output_schema={"type": "object", "properties": {}},),- backend.server.v2.library.model.LibraryAgent(+ library_model.LibraryAgent(id="test-agent-2",- version=1,- is_active=True,+ agent_id="test-agent-2",+ agent_version=1,+ preset_id="preset-2",+ updated_at=datetime.datetime(2023, 1, 1, 0, 0, 0),+ is_favorite=False,+ is_created_by_user=False,+ is_latest_version=True,name="Test Agent 2",description="Test Description 2",- isCreatedByUser=False,input_schema={"type": "object", "properties": {}},output_schema={"type": "object", "properties": {}},),@@ -61,14 +67,13 @@ def test_get_library_agents_success(mocker: pytest_mock.MockFixture):assert response.status_code == 200data = [- backend.server.v2.library.model.LibraryAgent.model_validate(agent)- for agent in response.json()+ library_model.LibraryAgent.model_validate(agent) for agent in response.json()]assert len(data) == 2- assert data[0].id == "test-agent-1"- assert data[0].isCreatedByUser is True- assert data[1].id == "test-agent-2"- assert data[1].isCreatedByUser is False+ assert data[0].agent_id == "test-agent-1"+ assert data[0].is_created_by_user is True+ assert data[1].agent_id == "test-agent-2"+ assert data[1].is_created_by_user is Falsemock_db_call.assert_called_once_with("test-user-id")diff --git a/autogpt_platform/backend/backend/usecases/block_autogen.py b/autogpt_platform/backend/backend/usecases/block_autogen.pyindex 97435220da..9f046a2e02 100644--- a/autogpt_platform/backend/backend/usecases/block_autogen.py+++ b/autogpt_platform/backend/backend/usecases/block_autogen.py@@ -253,7 +253,9 @@ async def block_autogen_agent():test_graph = await create_graph(create_test_graph(), user_id=test_user.id)input_data = {"input": "Write me a block that writes a string into a file."}response = await server.agent_server.test_execute_graph(- test_graph.id, input_data, test_user.id+ graph_id=test_graph.id,+ user_id=test_user.id,+ node_input=input_data,)print(response)result = await wait_execution(diff --git a/autogpt_platform/backend/backend/usecases/reddit_marketing.py b/autogpt_platform/backend/backend/usecases/reddit_marketing.pyindex 0c7769bd1b..494b3a85ca 100644--- a/autogpt_platform/backend/backend/usecases/reddit_marketing.py+++ b/autogpt_platform/backend/backend/usecases/reddit_marketing.py@@ -157,7 +157,9 @@ async def reddit_marketing_agent():test_graph = await create_graph(create_test_graph(), user_id=test_user.id)input_data = {"subreddit": "AutoGPT"}response = await server.agent_server.test_execute_graph(- test_graph.id, input_data, test_user.id+ graph_id=test_graph.id,+ user_id=test_user.id,+ node_input=input_data,)print(response)result = await wait_execution(diff --git a/autogpt_platform/backend/backend/usecases/sample.py b/autogpt_platform/backend/backend/usecases/sample.pyindex 79819fb149..8171850a7c 100644--- a/autogpt_platform/backend/backend/usecases/sample.py+++ b/autogpt_platform/backend/backend/usecases/sample.py@@ -86,7 +86,9 @@ async def sample_agent():test_graph = await create_graph(create_test_graph(), test_user.id)input_data = {"input_1": "Hello", "input_2": "World"}response = await server.agent_server.test_execute_graph(- test_graph.id, input_data, test_user.id+ graph_id=test_graph.id,+ user_id=test_user.id,+ node_input=input_data,)print(response)result = await wait_execution(diff --git a/autogpt_platform/backend/backend/util/service.py b/autogpt_platform/backend/backend/util/service.pyindex 9b07ba88e8..ac7f437fff 100644--- a/autogpt_platform/backend/backend/util/service.py+++ b/autogpt_platform/backend/backend/util/service.py@@ -62,7 +62,7 @@ def expose(func: C) -> C:try:return func(*args, **kwargs)except Exception as e:- msg = f"Error in {func.__name__}: {e.__str__()}"+ msg = f"Error in {func.__name__}: {e}"if isinstance(e, ValueError):logger.warning(msg)else:@@ -80,7 +80,7 @@ def register_pydantic_serializers(func: Callable):try:pydantic_types = _pydantic_models_from_type_annotation(annotation)except Exception as e:- raise TypeError(f"Error while exposing {func.__name__}: {e.__str__()}")+ raise TypeError(f"Error while exposing {func.__name__}: {e}")for model in pydantic_types:logger.debug(diff --git a/autogpt_platform/backend/migrations/20250107095812_preset_soft_delete/migration.sql b/autogpt_platform/backend/migrations/20250107095812_preset_soft_delete/migration.sqlnew file mode 100644index 0000000000..e85cee9654--- /dev/null+++ b/autogpt_platform/backend/migrations/20250107095812_preset_soft_delete/migration.sql@@ -0,0 +1,2 @@+-- AlterTable+ALTER TABLE "AgentPreset" ADD COLUMN "isDeleted" BOOLEAN NOT NULL DEFAULT false;diff --git a/autogpt_platform/backend/migrations/20250108084101_user_agent_to_library_agent/migration.sql b/autogpt_platform/backend/migrations/20250108084101_user_agent_to_library_agent/migration.sqlnew file mode 100644index 0000000000..a822161a17--- /dev/null+++ b/autogpt_platform/backend/migrations/20250108084101_user_agent_to_library_agent/migration.sql@@ -0,0 +1,46 @@+/*+ Warnings:++ - You are about to drop the `UserAgent` table. If the table is not empty, all the data it contains will be lost.++*/+-- DropForeignKey+ALTER TABLE "UserAgent" DROP CONSTRAINT "UserAgent_agentId_agentVersion_fkey";++-- DropForeignKey+ALTER TABLE "UserAgent" DROP CONSTRAINT "UserAgent_agentPresetId_fkey";++-- DropForeignKey+ALTER TABLE "UserAgent" DROP CONSTRAINT "UserAgent_userId_fkey";++-- DropTable+DROP TABLE "UserAgent";++-- CreateTable+CREATE TABLE "LibraryAgent" (+ "id" TEXT NOT NULL,+ "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,+ "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,+ "userId" TEXT NOT NULL,+ "agentId" TEXT NOT NULL,+ "agentVersion" INTEGER NOT NULL,+ "agentPresetId" TEXT,+ "isFavorite" BOOLEAN NOT NULL DEFAULT false,+ "isCreatedByUser" BOOLEAN NOT NULL DEFAULT false,+ "isArchived" BOOLEAN NOT NULL DEFAULT false,+ "isDeleted" BOOLEAN NOT NULL DEFAULT false,++ CONSTRAINT "LibraryAgent_pkey" PRIMARY KEY ("id")+);++-- CreateIndex+CREATE INDEX "LibraryAgent_userId_idx" ON "LibraryAgent"("userId");++-- AddForeignKey+ALTER TABLE "LibraryAgent" ADD CONSTRAINT "LibraryAgent_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;++-- AddForeignKey+ALTER TABLE "LibraryAgent" ADD CONSTRAINT "LibraryAgent_agentId_agentVersion_fkey" FOREIGN KEY ("agentId", "agentVersion") REFERENCES "AgentGraph"("id", "version") ON DELETE RESTRICT ON UPDATE CASCADE;++-- AddForeignKey+ALTER TABLE "LibraryAgent" ADD CONSTRAINT "LibraryAgent_agentPresetId_fkey" FOREIGN KEY ("agentPresetId") REFERENCES "AgentPreset"("id") ON DELETE SET NULL ON UPDATE CASCADE;diff --git a/autogpt_platform/backend/migrations/20250108084305_use_graph_is_active_version/migration.sql b/autogpt_platform/backend/migrations/20250108084305_use_graph_is_active_version/migration.sqlnew file mode 100644index 0000000000..5ffca8202f--- /dev/null+++ b/autogpt_platform/backend/migrations/20250108084305_use_graph_is_active_version/migration.sql@@ -0,0 +1,2 @@+-- AlterTable+ALTER TABLE "LibraryAgent" ADD COLUMN "useGraphIsActiveVersion" BOOLEAN NOT NULL DEFAULT false;diff --git a/autogpt_platform/backend/schema.prisma b/autogpt_platform/backend/schema.prismaindex b24f770149..c91dccb3df 100644--- a/autogpt_platform/backend/schema.prisma+++ b/autogpt_platform/backend/schema.prisma@@ -41,8 +41,8 @@ model User {AnalyticsMetrics AnalyticsMetrics[]CreditTransaction CreditTransaction[]- AgentPreset AgentPreset[]- UserAgent UserAgent[]+ AgentPreset AgentPreset[]+ LibraryAgent LibraryAgent[]Profile Profile[]StoreListing StoreListing[]@@ -78,7 +78,7 @@ model AgentGraph {AgentGraphExecution AgentGraphExecution[]AgentPreset AgentPreset[]- UserAgent UserAgent[]+ LibraryAgent LibraryAgent[]StoreListing StoreListing[]StoreListingVersion StoreListingVersion?@@ -116,9 +116,11 @@ model AgentPreset {Agent AgentGraph @relation(fields: [agentId, agentVersion], references: [id, version], onDelete: Cascade)InputPresets AgentNodeExecutionInputOutput[] @relation("AgentPresetsInputData")- UserAgents UserAgent[]+ LibraryAgents LibraryAgent[]AgentExecution AgentGraphExecution[]+ isDeleted Boolean @default(false)+@@index([userId])}@@ -163,7 +165,7 @@ model UserNotificationBatch {// For the library page// It is a user controlled list of agents, that they will see in there library-model UserAgent {+model LibraryAgent {id String @id @default(uuid())createdAt DateTime @default(now())updatedAt DateTime @default(now()) @updatedAt@@ -178,6 +180,8 @@ model UserAgent {agentPresetId String?AgentPreset AgentPreset? @relation(fields: [agentPresetId], references: [id])+ useGraphIsActiveVersion Boolean @default(false)+isFavorite Boolean @default(false)isCreatedByUser Boolean @default(false)isArchived Boolean @default(false)diff --git a/autogpt_platform/backend/test/executor/test_manager.py b/autogpt_platform/backend/test/executor/test_manager.pyindex 431c9e2c4b..3e4a7cacd2 100644--- a/autogpt_platform/backend/test/executor/test_manager.py+++ b/autogpt_platform/backend/test/executor/test_manager.py@@ -5,8 +5,9 @@ import fastapi.responsesimport pytestfrom prisma.models import User+import backend.server.v2.library.modelimport backend.server.v2.store.model-from backend.blocks.basic import FindInDictionaryBlock, StoreValueBlock+from backend.blocks.basic import AgentInputBlock, FindInDictionaryBlock, StoreValueBlockfrom backend.blocks.maths import CalculatorBlock, Operationfrom backend.data import execution, graphfrom backend.server.model import CreateGraph@@ -131,7 +132,7 @@ async def test_agent_execution(server: SpinTestServer):logger.info("Starting test_agent_execution")test_user = await create_test_user()test_graph = await create_graph(server, create_test_graph(), test_user)- data = {"node_input": {"input_1": "Hello", "input_2": "World"}}+ data = {"input_1": "Hello", "input_2": "World"}graph_exec_id = await execute_graph(server.agent_server,test_graph,@@ -295,6 +296,192 @@ async def test_static_input_link_on_graph(server: SpinTestServer):logger.info("Completed test_static_input_link_on_graph")[email protected](scope="session")+async def test_execute_preset(server: SpinTestServer):+ """+ Test executing a preset.++ This test ensures that:+ 1. A preset can be successfully executed+ 2. The execution results are correct++ Args:+ server (SpinTestServer): The test server instance.+ """+ # Create test graph and user+ nodes = [+ graph.Node( # 0+ block_id=AgentInputBlock().id,+ input_default={"name": "dictionary"},+ ),+ graph.Node( # 1+ block_id=AgentInputBlock().id,+ input_default={"name": "selected_value"},+ ),+ graph.Node( # 2+ block_id=StoreValueBlock().id,+ input_default={"input": {"key1": "Hi", "key2": "Everyone"}},+ ),+ graph.Node( # 3+ block_id=FindInDictionaryBlock().id,+ input_default={"key": "", "input": {}},+ ),+ ]+ links = [+ graph.Link(+ source_id=nodes[0].id,+ sink_id=nodes[2].id,+ source_name="result",+ sink_name="input",+ ),+ graph.Link(+ source_id=nodes[1].id,+ sink_id=nodes[3].id,+ source_name="result",+ sink_name="key",+ ),+ graph.Link(+ source_id=nodes[2].id,+ sink_id=nodes[3].id,+ source_name="output",+ sink_name="input",+ ),+ ]+ test_graph = graph.Graph(+ name="TestGraph",+ description="Test graph",+ nodes=nodes,+ links=links,+ )+ test_user = await create_test_user()+ test_graph = await create_graph(server, test_graph, test_user)++ # Create preset with initial values+ preset = backend.server.v2.library.model.CreateLibraryAgentPresetRequest(+ name="Test Preset With Clash",+ description="Test preset with clashing input values",+ agent_id=test_graph.id,+ agent_version=test_graph.version,+ inputs={+ "dictionary": {"key1": "Hello", "key2": "World"},+ "selected_value": "key2",+ },+ is_active=True,+ )+ created_preset = await server.agent_server.test_create_preset(preset, test_user.id)++ # Execute preset with overriding values+ result = await server.agent_server.test_execute_preset(+ graph_id=test_graph.id,+ graph_version=test_graph.version,+ preset_id=created_preset.id,+ user_id=test_user.id,+ )++ # Verify execution+ assert result is not None+ graph_exec_id = result["id"]++ # Wait for execution to complete+ executions = await wait_execution(test_user.id, test_graph.id, graph_exec_id)+ assert len(executions) == 4++ # FindInDictionaryBlock should wait for the input pin to be provided,+ # Hence executing extraction of "key" from {"key1": "value1", "key2": "value2"}+ assert executions[3].status == execution.ExecutionStatus.COMPLETED+ assert executions[3].output_data == {"output": ["World"]}++[email protected](scope="session")+async def test_execute_preset_with_clash(server: SpinTestServer):+ """+ Test executing a preset with clashing input data.+ """+ # Create test graph and user+ nodes = [+ graph.Node( # 0+ block_id=AgentInputBlock().id,+ input_default={"name": "dictionary"},+ ),+ graph.Node( # 1+ block_id=AgentInputBlock().id,+ input_default={"name": "selected_value"},+ ),+ graph.Node( # 2+ block_id=StoreValueBlock().id,+ input_default={"input": {"key1": "Hi", "key2": "Everyone"}},+ ),+ graph.Node( # 3+ block_id=FindInDictionaryBlock().id,+ input_default={"key": "", "input": {}},+ ),+ ]+ links = [+ graph.Link(+ source_id=nodes[0].id,+ sink_id=nodes[2].id,+ source_name="result",+ sink_name="input",+ ),+ graph.Link(+ source_id=nodes[1].id,+ sink_id=nodes[3].id,+ source_name="result",+ sink_name="key",+ ),+ graph.Link(+ source_id=nodes[2].id,+ sink_id=nodes[3].id,+ source_name="output",+ sink_name="input",+ ),+ ]+ test_graph = graph.Graph(+ name="TestGraph",+ description="Test graph",+ nodes=nodes,+ links=links,+ )+ test_user = await create_test_user()+ test_graph = await create_graph(server, test_graph, test_user)++ # Create preset with initial values+ preset = backend.server.v2.library.model.CreateLibraryAgentPresetRequest(+ name="Test Preset With Clash",+ description="Test preset with clashing input values",+ agent_id=test_graph.id,+ agent_version=test_graph.version,+ inputs={+ "dictionary": {"key1": "Hello", "key2": "World"},+ "selected_value": "key2",+ },+ is_active=True,+ )+ created_preset = await server.agent_server.test_create_preset(preset, test_user.id)++ # Execute preset with overriding values+ result = await server.agent_server.test_execute_preset(+ graph_id=test_graph.id,+ graph_version=test_graph.version,+ preset_id=created_preset.id,+ node_input={"selected_value": "key1"},+ user_id=test_user.id,+ )++ # Verify execution+ assert result is not None+ graph_exec_id = result["id"]++ # Wait for execution to complete+ executions = await wait_execution(test_user.id, test_graph.id, graph_exec_id)+ assert len(executions) == 4++ # FindInDictionaryBlock should wait for the input pin to be provided,+ # Hence executing extraction of "key" from {"key1": "value1", "key2": "value2"}+ assert executions[3].status == execution.ExecutionStatus.COMPLETED+ assert executions[3].output_data == {"output": ["Hello"]}++@pytest.mark.asyncio(scope="session")async def test_store_listing_graph(server: SpinTestServer):logger.info("Starting test_agent_execution")@@ -344,7 +531,7 @@ async def test_store_listing_graph(server: SpinTestServer):)alt_test_user = admin_user- data = {"node_input": {"input_1": "Hello", "input_2": "World"}}+ data = {"input_1": "Hello", "input_2": "World"}graph_exec_id = await execute_graph(server.agent_server,test_graph,diff --git a/autogpt_platform/backend/test/test_data_creator.py b/autogpt_platform/backend/test/test_data_creator.pyindex 45596b7d90..0dc42fd335 100644--- a/autogpt_platform/backend/test/test_data_creator.py+++ b/autogpt_platform/backend/test/test_data_creator.py@@ -140,10 +140,10 @@ async def main():print(f"Inserting {NUM_USERS * MAX_AGENTS_PER_USER} user agents")for user in users:num_agents = random.randint(MIN_AGENTS_PER_USER, MAX_AGENTS_PER_USER)- for _ in range(num_agents): # Create 1 UserAgent per user+ for _ in range(num_agents): # Create 1 LibraryAgent per usergraph = random.choice(agent_graphs)preset = random.choice(agent_presets)- user_agent = await db.useragent.create(+ user_agent = await db.libraryagent.create(data={"userId": user.id,"agentId": graph.id,diff --git a/autogpt_platform/frontend/src/lib/autogpt-server-api/client.ts b/autogpt_platform/frontend/src/lib/autogpt-server-api/client.tsindex bd13e5a6cc..981ad04cb7 100644--- a/autogpt_platform/frontend/src/lib/autogpt-server-api/client.ts+++ b/autogpt_platform/frontend/src/lib/autogpt-server-api/client.ts@@ -160,10 +160,8 @@ export default class BackendAPI {return this._get(`/graphs/${id}/versions`);}- createGraph(graphCreateBody: GraphCreatable): Promise<Graph>;-- createGraph(graphID: GraphCreatable | string): Promise<Graph> {- let requestBody = { graph: graphID } as GraphCreateRequestBody;+ createGraph(graph: GraphCreatable): Promise<Graph> {+ let requestBody = { graph } as GraphCreateRequestBody;return this._request("POST", "/graphs", requestBody);}