✨ Now user can save or discard changes in agent config page

Author: Phinease

backend/apps/agent_app.py

@@ -3,7 +3,6 @@
 from typing import Optional
 
 from fastapi import APIRouter, Body, Header, HTTPException, Request
-from fastapi.responses import JSONResponse
 
 from consts.model import AgentRequest, AgentInfoRequest, AgentIDRequest, ConversationResponse, AgentImportRequest
 from services.agent_service import (
@@ -14,11 +13,9 @@
     export_agent_impl,
     import_agent_impl,
     list_all_agent_info_impl,
-    insert_related_agent_impl,
     run_agent_stream,
     stop_agent_tasks,
-    get_agent_call_relationship_impl,
-    delete_related_agent_impl
+    get_agent_call_relationship_impl
 )
 from utils.auth_utils import get_current_user_info, get_current_user_id
 
@@ -94,8 +91,8 @@ async def update_agent_info_api(request: AgentInfoRequest, authorization: Option
     Update an existing agent
     """
     try:
-        await update_agent_info_impl(request, authorization)
-        return {}
+        result = await update_agent_info_impl(request, authorization)
+        return result or {}
     except Exception as e:
         logger.error(f"Agent update error: {str(e)}")
         raise HTTPException(
@@ -158,42 +155,6 @@ async def list_all_agent_info_api(authorization: Optional[str] = Header(None), r
             status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Agent list error.")
 
 
-@router.post("/related_agent")
-async def related_agent_api(parent_agent_id: int = Body(...),
-                            child_agent_id: int = Body(...),
-                            authorization: Optional[str] = Header(None)):
-    """
-    get related agent info
-    """
-    try:
-        _, tenant_id = get_current_user_id(authorization)
-        return insert_related_agent_impl(parent_agent_id=parent_agent_id,
-                                         child_agent_id=child_agent_id,
-                                         tenant_id=tenant_id)
-    except Exception as e:
-        logger.error(f"Agent related info error: {str(e)}")
-        return JSONResponse(
-            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-            content={"message": "Failed to insert relation", "status": "error"}
-        )
-
-
-@router.post("/delete_related_agent")
-async def delete_related_agent_api(parent_agent_id: int = Body(...),
-                                   child_agent_id: int = Body(...),
-                                   authorization: Optional[str] = Header(None)):
-    """
-    delete related agent info
-    """
-    try:
-        _, tenant_id = get_current_user_id(authorization)
-        return delete_related_agent_impl(parent_agent_id, child_agent_id, tenant_id)
-    except Exception as e:
-        logger.error(f"Agent related info error: {str(e)}")
-        raise HTTPException(
-            status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Agent related info error.")
-
-
 @router.get("/call_relationship/{agent_id}")
 async def get_agent_call_relationship_api(agent_id: int, authorization: Optional[str] = Header(None)):
     """

backend/consts/model.py

@@ -202,7 +202,7 @@ class GenerateTitleRequest(BaseModel):
 
 # used in agent/search agent/update for save agent info
 class AgentInfoRequest(BaseModel):
-    agent_id: int
+    agent_id: Optional[int] = None
     name: Optional[str] = None
     display_name: Optional[str] = None
     description: Optional[str] = None
@@ -217,6 +217,8 @@ class AgentInfoRequest(BaseModel):
     enabled: Optional[bool] = None
     business_logic_model_name: Optional[str] = None
     business_logic_model_id: Optional[int] = None
+    enabled_tool_ids: Optional[List[int]] = None
+    related_agent_ids: Optional[List[int]] = None
 
 
 class AgentIDRequest(BaseModel):

backend/database/agent_db.py

@@ -1,4 +1,5 @@
 import logging
+from typing import List
 
 from database.client import get_db_session, as_dict, filter_property
 from database.db_models import AgentInfo, ToolInstance, AgentRelation
@@ -169,13 +170,68 @@ def delete_related_agent(parent_agent_id: int, child_agent_id: int, tenant_id: s
             session.query(AgentRelation).filter(AgentRelation.parent_agent_id == parent_agent_id,
                                                 AgentRelation.selected_agent_id == child_agent_id,
                                                 AgentRelation.tenant_id == tenant_id).update(
-                {ToolInstance.delete_flag: 'Y', 'updated_by': tenant_id})
+                {AgentRelation.delete_flag: 'Y', 'updated_by': tenant_id})
             return True
     except Exception as e:
         logger.error(f"Failed to delete related agent: {str(e)}")
         return False
 
 
+def update_related_agents(parent_agent_id: int, related_agent_ids: List[int], tenant_id: str, user_id: str):
+    """
+    Update related agents for a parent agent by replacing all existing relations.
+    This function handles both creation and deletion of relations in a single transaction.
+    :param parent_agent_id: ID of the parent agent
+    :param related_agent_ids: List of child agent IDs to be related
+    :param tenant_id: Tenant ID
+    :param user_id: User ID for audit trail
+    :return: None
+    """
+    with get_db_session() as session:
+        # Get current relations
+        current_relations = session.query(AgentRelation).filter(
+            AgentRelation.parent_agent_id == parent_agent_id,
+            AgentRelation.tenant_id == tenant_id,
+            AgentRelation.delete_flag != 'Y'
+        ).all()
+
+        current_related_ids = {
+            rel.selected_agent_id for rel in current_relations}
+        new_related_ids = set(
+            related_agent_ids) if related_agent_ids else set()
+
+        # Find IDs to delete (in current but not in new)
+        ids_to_delete = current_related_ids - new_related_ids
+        # Find IDs to add (in new but not in current)
+        ids_to_add = new_related_ids - current_related_ids
+
+        # Soft delete removed relations
+        if ids_to_delete:
+            session.query(AgentRelation).filter(
+                AgentRelation.parent_agent_id == parent_agent_id,
+                AgentRelation.selected_agent_id.in_(ids_to_delete),
+                AgentRelation.tenant_id == tenant_id
+            ).update(
+                {AgentRelation.delete_flag: 'Y', 'updated_by': user_id},
+                synchronize_session=False
+            )
+
+        # Add new relations
+        for child_agent_id in ids_to_add:
+            relation_info = {
+                "parent_agent_id": parent_agent_id,
+                "selected_agent_id": child_agent_id,
+                "tenant_id": tenant_id,
+                "created_by": user_id,
+                "updated_by": user_id
+            }
+            new_relation = AgentRelation(
+                **filter_property(relation_info, AgentRelation))
+            session.add(new_relation)
+
+        session.commit()
+
+
 def delete_agent_relationship(agent_id: int, tenant_id: str, user_id: str):
     with get_db_session() as session:
         session.query(AgentRelation).filter(AgentRelation.parent_agent_id == agent_id,

backend/services/agent_service.py

@@ -4,6 +4,7 @@
 import os
 import uuid
 from collections import deque
+from typing import Optional
 
 from fastapi import Header, Request
 from fastapi.responses import JSONResponse, StreamingResponse
@@ -35,7 +36,8 @@
     search_agent_id_by_agent_name,
     search_agent_info_by_agent_id,
     search_blank_sub_agent_by_main_agent_id,
-    update_agent
+    update_agent,
+    update_related_agents
 )
 from database.model_management_db import get_model_by_model_id, get_model_id_by_display_name
 from database.remote_mcp_db import check_mcp_name_exists, get_mcp_server_by_name_and_tenant
@@ -45,6 +47,7 @@
     delete_tools_by_agent_id,
     query_all_enabled_tool_instances,
     query_all_tools,
+    query_tool_instances_by_id,
     search_tools_for_sub_agent
 )
 from services.conversation_management_service import save_conversation_assistant, save_conversation_user
@@ -340,12 +343,100 @@ async def get_creating_sub_agent_info_impl(authorization: str = Header(None)):
 async def update_agent_info_impl(request: AgentInfoRequest, authorization: str = Header(None)):
     user_id, tenant_id, _ = get_current_user_info(authorization)
 
+    # If agent_id is None, create a new agent; otherwise, update existing
+    agent_id: Optional[int] = request.agent_id
     try:
-        update_agent(request.agent_id, request, tenant_id, user_id)
+        if agent_id is None:
+            # Create agent
+            created = create_agent(agent_info={
+                "name": request.name,
+                "display_name": request.display_name,
+                "description": request.description,
+                "business_description": request.business_description,
+                "model_id": request.model_id,
+                "model_name": request.model_name,
+                "business_logic_model_id": request.business_logic_model_id,
+                "business_logic_model_name": request.business_logic_model_name,
+                "max_steps": request.max_steps,
+                "provide_run_summary": request.provide_run_summary,
+                "duty_prompt": request.duty_prompt,
+                "constraint_prompt": request.constraint_prompt,
+                "few_shots_prompt": request.few_shots_prompt,
+                "enabled": request.enabled if request.enabled is not None else True
+            }, tenant_id=tenant_id, user_id=user_id)
+            agent_id = created["agent_id"]
+        else:
+            # Update agent
+            update_agent(agent_id, request, tenant_id, user_id)
     except Exception as e:
         logger.error(f"Failed to update agent info: {str(e)}")
         raise ValueError(f"Failed to update agent info: {str(e)}")
 
+    # Handle enabled tools saving when provided
+    try:
+        if request.enabled_tool_ids is not None and agent_id is not None:
+            enabled_set = set(request.enabled_tool_ids)
+            # Get all tools for current tenant
+            all_tools = query_all_tools(tenant_id=tenant_id)
+            for tool in all_tools:
+                tool_id = tool.get("tool_id")
+                if tool_id is None:
+                    continue
+                # Keep existing params if any
+                existing_instance = query_tool_instances_by_id(
+                    agent_id, tool_id, tenant_id)
+                params = (existing_instance or {}).get(
+                    "params", {}) if existing_instance else {}
+                create_or_update_tool_by_tool_info(
+                    tool_info=ToolInstanceInfoRequest(
+                        tool_id=tool_id,
+                        agent_id=agent_id,
+                        params=params,
+                        enabled=(tool_id in enabled_set)
+                    ),
+                    tenant_id=tenant_id,
+                    user_id=user_id
+                )
+    except Exception as e:
+        logger.error(f"Failed to update agent tools: {str(e)}")
+        raise ValueError(f"Failed to update agent tools: {str(e)}")
+
+    # Handle related agents saving when provided
+    try:
+        if request.related_agent_ids is not None and agent_id is not None:
+            related_agent_ids = request.related_agent_ids
+            # Check for circular dependencies using BFS
+            search_list = deque(related_agent_ids)
+            agent_id_set = set()
+
+            while len(search_list):
+                left_ele = search_list.popleft()
+                if left_ele == agent_id:
+                    raise ValueError("Circular dependency detected: Agent cannot be related to itself or create circular calls")
+                if left_ele in agent_id_set:
+                    continue
+                else:
+                    agent_id_set.add(left_ele)
+                sub_ids = query_sub_agents_id_list(
+                    main_agent_id=left_ele, tenant_id=tenant_id)
+                search_list.extend(sub_ids)
+
+            # Update related agents
+            update_related_agents(
+                parent_agent_id=agent_id,
+                related_agent_ids=related_agent_ids,
+                tenant_id=tenant_id,
+                user_id=user_id
+            )
+    except ValueError as e:
+        # Re-raise ValueError (circular dependency) as-is
+        raise
+    except Exception as e:
+        logger.error(f"Failed to update related agents: {str(e)}")
+        raise ValueError(f"Failed to update related agents: {str(e)}")
+
+    return {"agent_id": agent_id}
+
 
 async def delete_agent_impl(agent_id: int, authorization: str = Header(None)):
     user_id, tenant_id, _ = get_current_user_info(authorization)