Merge branch 'develop_data_process_tool' of https://github.com/ModelEngine-Group/nexent into develop_multi_agent

# Conflicts:
#	sdk/nexent/core/utils/prompt_template_utils.py
#	sdk/nexent/core/utils/tools_common_message.py
#	test/backend/agents/test_create_agent_info.py
#	test/backend/services/test_tool_configuration_service.py
#	test/common/__init__.py
#	test/common/env_test_utils.py
#	test/sdk/core/utils/test_prompt_template_utils.py

Author: Zhi-a

sdk/nexent/core/tools/analyze_text_file_tool.py

@@ -37,16 +37,16 @@ class AnalyzeTextFileTool(Tool):
     inputs = {
         "file_url_list": {
             "type": "array",
-            "description": "List of file URLs (S3, HTTP, or HTTPS). Supports s3://bucket/key, /bucket/key, http://, and https:// URLs. Can also accept a single file URL which will be treated as a list with one element."
+            "description": "List of file URLs (S3, HTTP, or HTTPS). Supports s3://bucket/key, /bucket/key, http://, and https:// URLs."
         },
         "query": {
             "type": "string",
             "description": "User's question to guide the analysis"
         }
     }
-    output_type = "string"
-    category = ToolCategory.FILE.value
-    tool_sign = ToolSign.FILE_OPERATION.value
+    output_type = "array"
+    category = ToolCategory.MULTIMODAL.value
+    tool_sign = ToolSign.MULTIMODAL_OPERATION.value
 
     def __init__(
         self,
@@ -76,30 +76,29 @@ def __init__(
         self.data_process_service_url = data_process_service_url
         self.mm = LoadSaveObjectManager(storage_client=self.storage_client)
 
-        self.running_prompt_zh = "正在分析文本文件..."
-        self.running_prompt_en = "Analyzing text file..."
+        self.running_prompt_zh = "正在分析文件..."
+        self.running_prompt_en = "Analyzing file..."
         # Dynamically apply the load_object decorator to forward method
         self.forward = self.mm.load_object(input_names=["file_url_list"])(self._forward_impl)
 
     def _forward_impl(
         self,
-        file_url_list: Union[bytes, List[bytes]],
+        file_url_list: List[bytes],
         query: str,
-    ) -> Union[str, List[str]]:
+    ) -> List[str]:
         """
         Analyze text file content using a large language model.
 
         Note: This method is wrapped by load_object decorator which downloads
         the image from S3 URL, HTTP URL, or HTTPS URL and passes bytes to this method.
 
         Args:
-            file_url_list: File bytes or a sequence of file bytes (converted from URLs by the decorator).
-                          The load_object decorator converts URLs to bytes before calling this method.
+            file_url_list: List of file bytes converted from URLs by the decorator.
+                           The load_object decorator converts URLs to bytes before calling this method.
             query: User's question to guide the analysis
 
         Returns:
-            Union[str, List[str]]: Single analysis string for one file or a list
-            of analysis strings that align with the order of the provided files.
+            List[str]: One analysis string per file that aligns with the order
         """
         # Send tool run message
         if self.observer:
@@ -109,19 +108,15 @@ def _forward_impl(
             self.observer.add_message("", ProcessType.CARD, json.dumps(card_content, ensure_ascii=False))
 
         if file_url_list is None:
-            raise ValueError("file_url_list must contain at least one file")
+            raise ValueError("file_url_list cannot be None")
 
-        if isinstance(file_url_list, (list, tuple)):
-            file_inputs: List[bytes] = list(file_url_list)
-        elif isinstance(file_url_list, bytes):
-            file_inputs = [file_url_list]
-        else:
-            raise ValueError("file_url_list must be bytes or a list/tuple of bytes")
+        if not isinstance(file_url_list, list):
+            raise ValueError("file_url_list must be a list of bytes")
 
         try:
             analysis_results: List[str] = []
 
-            for index, single_file in enumerate(file_inputs, start=1):
+            for index, single_file in enumerate(file_url_list, start=1):
                 logger.info(f"Extracting text content from file #{index}, query: {query}")
                 filename = f"file_{index}.txt"
 
@@ -143,8 +138,6 @@ def _forward_impl(
                     logger.error(f"Failed to analyze file #{index}: {analysis_error}")
                     analysis_results.append(str(analysis_error))
 
-            if len(analysis_results) == 1:
-                return analysis_results[0]
             return analysis_results
 
         except Exception as e:

sdk/nexent/core/utils/prompt_template_utils.py

@@ -4,14 +4,13 @@
 
 import yaml
 
-
-logger = logging.getLogger("prompt_template_utils")
-
 LANGUAGE = {
     "ZH": "zh",
     "EN": "en"
 }
 
+logger = logging.getLogger("prompt_template_utils")
+
 # Define template path mapping
 template_paths = {
     'analyze_image': {
@@ -27,14 +26,12 @@
 def get_prompt_template(template_type: str, language: str = LANGUAGE["ZH"], **kwargs) -> Dict[str, Any]:
     """
     Get prompt template
-
     Args:
         template_type: Template type, supports the following values:
             - 'analyze_image': Analyze image template
             - 'analyze_file': Analyze file template (for text files)
         language: Language code ('zh' or 'en')
         **kwargs: Additional parameters, for agent type need to pass is_manager parameter
-
     Returns:
         dict: Loaded prompt template
     """
@@ -55,4 +52,4 @@ def get_prompt_template(template_type: str, language: str = LANGUAGE["ZH"], **kw
 
     # Read and return template content
     with open(absolute_template_path, 'r', encoding='utf-8') as f:
-        return yaml.safe_load(f)
+        return yaml.safe_load(f)

sdk/nexent/core/utils/tools_common_message.py

@@ -11,7 +11,7 @@ class ToolSign(Enum):
     TAVILY_SEARCH = "d"  # Tavily search tool identifier
     FILE_OPERATION = "f"      # File operation tool identifier
     TERMINAL_OPERATION = "t"  # Terminal operation tool identifier
-    MULTIMODAL_OPERATION = "m" # Multimodal operation tool identifier
+    MULTIMODAL_OPERATION = "m"  # Multimodal operation tool identifier
 
 
 # Tool sign mapping for backward compatibility

test/backend/agents/test_create_agent_info.py

@@ -1,8 +1,22 @@
 import pytest
 import sys
 import types
+import importlib.util
+from pathlib import Path
 from unittest.mock import AsyncMock, MagicMock, patch, Mock, PropertyMock
 
+TEST_ROOT = Path(__file__).resolve().parents[2]
+PROJECT_ROOT = TEST_ROOT.parent
+
+# Ensure project backend package is found before test/backend
+for _path in (str(PROJECT_ROOT), str(TEST_ROOT)):
+    if _path not in sys.path:
+        sys.path.insert(0, _path)
+from test.common.env_test_utils import bootstrap_env
+
+env_state = bootstrap_env()
+consts_const = env_state["mock_const"]
+
 from test.common.env_test_utils import bootstrap_env
 
 env_state = bootstrap_env()
@@ -17,6 +31,31 @@ def _create_stub_module(name: str, **attrs):
     return module
 
 
+# Configure required constants via shared bootstrap env
+consts_const.MINIO_ENDPOINT = "http://localhost:9000"
+consts_const.MINIO_ACCESS_KEY = "test_access_key"
+consts_const.MINIO_SECRET_KEY = "test_secret_key"
+consts_const.MINIO_REGION = "us-east-1"
+consts_const.MINIO_DEFAULT_BUCKET = "test-bucket"
+consts_const.POSTGRES_HOST = "localhost"
+consts_const.POSTGRES_USER = "test_user"
+consts_const.NEXENT_POSTGRES_PASSWORD = "test_password"
+consts_const.POSTGRES_DB = "test_db"
+consts_const.POSTGRES_PORT = 5432
+consts_const.DEFAULT_TENANT_ID = "default_tenant"
+consts_const.LOCAL_MCP_SERVER = "http://localhost:5011"
+consts_const.MODEL_CONFIG_MAPPING = {"llm": "llm_config"}
+consts_const.LANGUAGE = {"ZH": "zh"}
+consts_const.DATA_PROCESS_SERVICE = "https://example.com/data-process"
+# Utilities ---------------------------------------------------------------
+def _create_stub_module(name: str, **attrs):
+    """Return a lightweight module stub with the provided attributes."""
+    module = types.ModuleType(name)
+    for attr_name, attr_value in attrs.items():
+        setattr(module, attr_name, attr_value)
+    return module
+
+
 # Configure required constants via shared bootstrap env
 consts_const.MINIO_ENDPOINT = "http://localhost:9000"
 consts_const.MINIO_ACCESS_KEY = "test_access_key"
@@ -46,6 +85,7 @@ def _create_stub_module(name: str, **attrs):
 # if the testing environment does not have it available.
 boto3_mock = MagicMock()
 sys.modules['boto3'] = boto3_mock
+sys.modules['dotenv'] = MagicMock(load_dotenv=MagicMock())
 
 # Mock the entire client module
 client_mock = MagicMock()
@@ -92,6 +132,14 @@ def _create_stub_module(name: str, **attrs):
 sys.modules['services.image_service'] = _create_stub_module(
     "services.image_service", get_vlm_model=MagicMock(return_value="stub_vlm")
 )
+sys.modules['services.file_management_service'] = _create_stub_module(
+    "services.file_management_service",
+    get_llm_model=MagicMock(return_value="stub_llm_model"),
+)
+sys.modules['services.tool_configuration_service'] = _create_stub_module(
+    "services.tool_configuration_service",
+    initialize_tools_on_startup=AsyncMock(),
+)
 # Build top-level nexent module to avoid importing the real package
 nexent_module = _create_stub_module(
     "nexent",
@@ -127,7 +175,31 @@ def _create_stub_module(name: str, **attrs):
 sys.modules['smolagents'] = smolagents_module
 sys.modules['smolagents.tools'] = smolagents_tools_module
 
-# Now import the module under test
+# Ensure real backend.agents.create_agent_info is available and uses our stubs
+backend_pkg = sys.modules.get("backend")
+if backend_pkg is None:
+    backend_pkg = types.ModuleType("backend")
+    backend_pkg.__path__ = [str((TEST_ROOT.parent) / "backend")]
+    sys.modules["backend"] = backend_pkg
+
+agents_pkg = sys.modules.get("backend.agents")
+if agents_pkg is None:
+    agents_pkg = types.ModuleType("backend.agents")
+    agents_pkg.__path__ = [str((TEST_ROOT.parent) / "backend" / "agents")]
+    sys.modules["backend.agents"] = agents_pkg
+    setattr(backend_pkg, "agents", agents_pkg)
+
+create_agent_info_path = (TEST_ROOT.parent / "backend" / "agents" / "create_agent_info.py")
+spec = importlib.util.spec_from_file_location(
+    "backend.agents.create_agent_info", create_agent_info_path
+)
+create_agent_info_module = importlib.util.module_from_spec(spec)
+sys.modules["backend.agents.create_agent_info"] = create_agent_info_module
+assert spec.loader is not None
+spec.loader.exec_module(create_agent_info_module)
+setattr(agents_pkg, "create_agent_info", create_agent_info_module)
+
+# Now import the symbols under test
 from backend.agents.create_agent_info import (
     discover_langchain_tools,
     create_tool_config_list,
@@ -324,6 +396,43 @@ async def test_create_tool_config_list_with_knowledge_base_tool(self):
             last_call = mock_tool_config.call_args_list[-1]
             assert last_call[1]['class_name'] == "KnowledgeBaseSearchTool"
 
+    @pytest.mark.asyncio
+    async def test_create_tool_config_list_with_analyze_text_file_tool(self):
+        """Ensure AnalyzeTextFileTool receives text-specific metadata."""
+        mock_tool_instance = MagicMock()
+        mock_tool_instance.class_name = "AnalyzeTextFileTool"
+        mock_tool_config.return_value = mock_tool_instance
+
+        with patch('backend.agents.create_agent_info.discover_langchain_tools', return_value=[]), \
+                patch('backend.agents.create_agent_info.search_tools_for_sub_agent') as mock_search_tools, \
+                patch('backend.agents.create_agent_info.get_llm_model') as mock_get_llm_model, \
+                patch('backend.agents.create_agent_info.minio_client', new_callable=MagicMock) as mock_minio_client:
+
+            mock_search_tools.return_value = [
+                {
+                    "class_name": "AnalyzeTextFileTool",
+                    "name": "analyze_text_file",
+                    "description": "Analyze text file tool",
+                    "inputs": "string",
+                    "output_type": "array",
+                    "params": [{"name": "prompt", "default": "describe"}],
+                    "source": "local",
+                    "usage": None
+                }
+            ]
+            mock_get_llm_model.return_value = "mock_llm_model"
+
+            result = await create_tool_config_list("agent_1", "tenant_1", "user_1")
+
+            assert len(result) == 1
+            assert result[0] is mock_tool_instance
+            mock_get_llm_model.assert_called_once_with(tenant_id="tenant_1")
+            assert mock_tool_instance.metadata == {
+                "llm_model": "mock_llm_model",
+                "storage_client": mock_minio_client,
+                "data_process_service_url": consts_const.DATA_PROCESS_SERVICE,
+            }
+
     @pytest.mark.asyncio
     async def test_create_tool_config_list_with_analyze_image_tool(self):
         """Ensure AnalyzeImageTool receives VLM model metadata."""