✨ Add tool category feature. #1362

Author: Phinease

backend/apps/tool_config_app.py

@@ -5,7 +5,7 @@
 from fastapi import APIRouter, Header, HTTPException
 from fastapi.responses import JSONResponse
 
-from consts.exceptions import MCPConnectionError, TimeoutException, NotFoundException
+from consts.exceptions import MCPConnectionError, NotFoundException
 from consts.model import ToolInstanceInfoRequest, ToolInstanceSearchRequest, ToolValidateRequest
 from services.tool_configuration_service import (
     search_tool_info_impl,
@@ -109,8 +109,8 @@ async def validate_tool(
 ):
     """Validate specific tool based on source type"""
     try:
-        _, tenant_id = get_current_user_id(authorization)
-        result = await validate_tool_impl(request, tenant_id)
+        user_id, tenant_id = get_current_user_id(authorization)
+        result = await validate_tool_impl(request, tenant_id, user_id)
 
         return JSONResponse(
             status_code=HTTPStatus.OK,
@@ -132,5 +132,5 @@ async def validate_tool(
         logger.error(f"Failed to validate tool: {e}")
         raise HTTPException(
             status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-            detail=f"Failed to validate tool: {str(e)}"
+            detail=str(e)
         )

backend/consts/model.py

@@ -245,6 +245,7 @@ class ToolInfo(BaseModel):
     class_name: str
     usage: Optional[str]
     origin_name: Optional[str] = None
+    category: Optional[str] = None
 
 
 # used in Knowledge Summary request

backend/database/db_models.py

@@ -177,6 +177,7 @@ class ToolInfo(TableBase):
     params = Column(JSON, doc="Tool parameter information (json)")
     inputs = Column(String(2048), doc="Prompt tool inputs description")
     output_type = Column(String(100), doc="Prompt tool output description")
+    category = Column(String(100), doc="Tool category description")
     is_available = Column(
         Boolean, doc="Whether the tool can be used under the current main service")
 

backend/services/tool_configuration_service.py

@@ -2,7 +2,6 @@
 import importlib
 import inspect
 import json
-import keyword
 import logging
 from typing import Any, List, Optional, Dict
 from urllib.parse import urljoin
@@ -24,6 +23,8 @@
     search_last_tool_instance_by_tool_id
 )
 from database.user_tenant_db import get_all_tenant_ids
+from services.elasticsearch_service import get_embedding_model, elastic_core
+from services.tenant_config_service import get_selected_knowledge_list
 
 logger = logging.getLogger("tool_configuration_service")
 
@@ -102,6 +103,7 @@ def get_local_tools() -> List[ToolInfo]:
             inputs=json.dumps(getattr(tool_class, 'inputs'),
                               ensure_ascii=False),
             output_type=getattr(tool_class, 'output_type'),
+            category=getattr(tool_class, 'category'),
             class_name=tool_class.__name__,
             usage=None,
             origin_name=getattr(tool_class, 'name')
@@ -162,7 +164,8 @@ def _build_tool_info_from_langchain(obj) -> ToolInfo:
         output_type=output_type,
         class_name=tool_name,
         usage=None,
-        origin_name=tool_name
+        origin_name=tool_name,
+        category=None
     )
     return tool_info
 
@@ -298,7 +301,8 @@ async def get_tool_from_remote_mcp_server(mcp_server_name: str, remote_mcp_serve
                                      output_type="string",
                                      class_name=sanitized_tool_name,
                                      usage=mcp_server_name,
-                                     origin_name=tool.name)
+                                     origin_name=tool.name,
+                                     category=None)
                 tools_info.append(tool_info)
             return tools_info
     except Exception as e:
@@ -351,7 +355,8 @@ async def list_all_tools(tenant_id: str):
             "create_time": tool.get("create_time"),
             "usage": tool.get("usage"),
             "params": tool.get("params", []),
-            "inputs": tool.get("inputs", {})
+            "inputs": tool.get("inputs", {}),
+            "category": tool.get("category")
         }
         formatted_tools.append(formatted_tool)
 
@@ -543,7 +548,9 @@ def _get_tool_class_by_name(tool_name: str) -> Optional[type]:
 def _validate_local_tool(
     tool_name: str,
     inputs: Optional[Dict[str, Any]] = None,
-    params: Optional[Dict[str, Any]] = None
+    params: Optional[Dict[str, Any]] = None,
+    tenant_id: Optional[str] = None,
+    user_id: Optional[str] = None
 ) -> Dict[str, Any]:
     """
     Validate local tool by actually instantiating and calling it.
@@ -552,6 +559,8 @@ def _validate_local_tool(
         tool_name: Name of the tool to test
         inputs: Parameters to pass to the tool's forward method
         params: Configuration parameters for tool initialization
+        tenant_id: Tenant ID for knowledge base tools (optional)
+        user_id: User ID for knowledge base tools (optional)
 
     Returns:
         Dict[str, Any]: The actual result returned by the tool's forward method, 
@@ -567,15 +576,45 @@ def _validate_local_tool(
         if not tool_class:
             raise NotFoundException(f"Tool class not found for {tool_name}")
 
-        # Instantiate tool with provided params or default parameters
+        # Parse instantiation parameters first
         instantiation_params = params or {}
-        # Check if the tool constructor expects an observer parameter
+        # Get signature and extract default values for all parameters
         sig = inspect.signature(tool_class.__init__)
-        if 'observer' in sig.parameters and 'observer' not in instantiation_params:
-            instantiation_params['observer'] = None
-        tool_instance = tool_class(**instantiation_params)
 
-        # Call forward method with provided parameters
+        # Extract default values for all parameters not provided in instantiation_params
+        for param_name, param in sig.parameters.items():
+            if param_name == "self":
+                continue
+
+            # If parameter not provided, extract default value
+            if param_name not in instantiation_params:
+                if param.default is PydanticUndefined:
+                    continue
+                elif hasattr(param.default, 'default'):
+                    # This is a Field object, extract its default value
+                    if param.default.default is not PydanticUndefined:
+                        instantiation_params[param_name] = param.default.default
+                else:
+                    instantiation_params[param_name] = param.default
+
+        if tool_name == "knowledge_base_search":
+            if not tenant_id or not user_id:
+                raise ToolExecutionException(f"Tenant ID and User ID are required for {tool_name} validation")
+            knowledge_info_list = get_selected_knowledge_list(
+                tenant_id=tenant_id, user_id=user_id)
+            index_names = [knowledge_info.get("index_name")
+                           for knowledge_info in knowledge_info_list]
+            embedding_model = get_embedding_model(tenant_id=tenant_id)
+            params = {
+                **instantiation_params,
+                'index_names': index_names,
+                'es_core': elastic_core,
+                'embedding_model': embedding_model
+            }
+            tool_instance = tool_class(**params)
+        else:
+            tool_instance = tool_class(**instantiation_params)
+
         result = tool_instance.forward(**(inputs or {}))
         return result
     except Exception as e:
@@ -630,14 +669,16 @@ def _validate_langchain_tool(
 
 async def validate_tool_impl(
     request: ToolValidateRequest,
-    tenant_id: Optional[str] = None
+    tenant_id: Optional[str] = None,
+    user_id: Optional[str] = None
 ) -> Dict[str, Any]:
     """
     Validate a tool from various sources (MCP, local, or LangChain).
 
     Args:
         request: Tool validation request containing tool details
         tenant_id: Tenant ID for database queries (optional)
+        user_id: User ID for database queries (optional)
 
     Returns:
         Dict containing validation result - success returns tool result, failure returns error message
@@ -657,18 +698,18 @@ async def validate_tool_impl(
             else:
                 return await _validate_mcp_tool_remote(tool_name, inputs, usage, tenant_id)
         elif source == ToolSourceEnum.LOCAL.value:
-            return _validate_local_tool(tool_name, inputs, params)
+            return _validate_local_tool(tool_name, inputs, params, tenant_id, user_id)
         elif source == ToolSourceEnum.LANGCHAIN.value:
             return _validate_langchain_tool(tool_name, inputs)
         else:
             raise Exception(f"Unsupported tool source: {source}")
 
     except NotFoundException as e:
         logger.error(f"Tool not found: {e}")
-        raise NotFoundException(f"Tool not found: {str(e)}")
+        raise NotFoundException(str(e))
     except MCPConnectionError as e:
         logger.error(f"MCP connection failed: {e}")
-        raise MCPConnectionError(f"MCP connection failed: {str(e)}")
+        raise MCPConnectionError(str(e))
     except Exception as e:
         logger.error(f"Validate Tool failed: {e}")
-        raise ToolExecutionException(f"Validate Tool failed: {str(e)}")
+        raise ToolExecutionException(str(e))

docker/init.sql

@@ -237,6 +237,7 @@ CREATE TABLE IF NOT EXISTS nexent.ag_tool_info_t (
     params JSON,
     inputs VARCHAR,
     output_type VARCHAR(100),
+    category VARCHAR(100),
     is_available BOOLEAN DEFAULT FALSE,
     create_time TIMESTAMP WITHOUT TIME ZONE DEFAULT CURRENT_TIMESTAMP,
     update_time TIMESTAMP WITHOUT TIME ZONE DEFAULT CURRENT_TIMESTAMP,

docker/sql/1013_add_tool_group_to_ag_tool_info.sql

@@ -0,0 +1,8 @@
+-- Add category column to ag_tool_info_t table
+-- This field stores the tool category information (search, file, email, terminal)
+
+ALTER TABLE nexent.ag_tool_info_t 
+ADD COLUMN IF NOT EXISTS category VARCHAR(100);
+
+-- Add comment to document the purpose of this field
+COMMENT ON COLUMN nexent.ag_tool_info_t.category IS 'Tool category information';

frontend/app/[locale]/setup/agents/components/tool/ToolConfigModal.tsx

@@ -29,6 +29,7 @@ import {
   extractParameterNames,
 } from "@/services/agentConfigService";
 import log from "@/lib/logger";
+import { useModalPosition } from "@/hooks/useModalPosition";
 
 export default function ToolConfigModal({
   isOpen,
@@ -51,6 +52,8 @@ export default function ToolConfigModal({
   const [parsedInputs, setParsedInputs] = useState<Record<string, any>>({});
   const [paramValues, setParamValues] = useState<Record<string, string>>({});
   const [dynamicInputParams, setDynamicInputParams] = useState<string[]>([]);
+  const { windowWidth, mainModalTop, mainModalRight } =
+    useModalPosition(isOpen);
 
   // load tool config
   useEffect(() => {
@@ -572,8 +575,11 @@ export default function ToolConfigModal({
             className="tool-test-panel"
             style={{
               position: "fixed",
-              top: "10vh",
-              right: "5vw",
+              top: mainModalTop > 0 ? `${mainModalTop}px` : "10vh", // Align with main modal top or fallback to 10vh
+              left:
+                mainModalRight > 0
+                  ? `${mainModalRight + windowWidth * 0.05}px`
+                  : "calc(50% + 300px + 5vw)", // Position to the right of main modal with 5% viewport width gap
               width: "500px",
               height: "auto",
               maxHeight: "80vh",
@@ -759,4 +765,4 @@ export default function ToolConfigModal({
       )}
     </>
   );
-}
+}