Upload 9 files

aworld/tools/README.md

@@ -0,0 +1,79 @@
+# Environments
+
+Virtual environments for execution of various tools.
+
+Running on the local, we assume that the virtual environment completes startup when the python application starts.
+
+![Environment Architecture](../../readme_assets/framework_environment.png)
+
+# Be tool
+
+You also can convert locally defined functions into tools for use in a task.
+
+NOTE: The function must have a return value, preferably a string, as observed content.
+
+```python
+from pydantic import Field
+
+from aworld.core.tool.func_to_tool import be_tool
+
+
+@be_tool(tool_name='example', tool_desc="example description")
+def example_1() -> str:
+    return "example_1"
+
+
+@be_tool(tool_name='example')
+def example_2(param: str) -> str:
+    return f"example_2{param}"
+
+
+@be_tool(tool_name='example', name="example_3_alias_name", desc="example_3 description")
+def example_3(param_1: str = "param",
+              param_2: str = Field(default="", description="param2 description")) -> str:
+    return f"example_3{param_1}{param_2}"
+```
+
+The name of the tool is `example`, now, you can use these functions as tools in the framework.
+
+# Write tool
+
+Detailed steps for building a tool:
+
+1. Register action of your tool to action factory, and inherit `ExecutableAction`
+2. Optional implement the `act` or `async_act` method
+3. Register your tool to tool factory, and inherit `Tool` or `AsyncTool`
+4. Write the `step` method to execute the abilities in the tool and generate observation, update finished Status.
+
+```python
+from typing import List, Tuple, Dict, Any
+
+from aworld.core.common import ActionModel, Observation
+from aworld.core.tool.action import ExecutableAction
+from aworld.core.tool.base import ActionFactory, ToolFactory, AgentInput
+from aworld.tools.template_tool import TemplateTool
+
+from examples.tools.tool_action import GymAction
+
+
+@ToolFactory.register(name="openai_gym", desc="gym classic control game", supported_action=GymAction)
+class OpenAIGym(TemplateTool):
+    def step(self, action: List[ActionModel], **kwargs) -> Tuple[AgentInput, float, bool, bool, Dict[str, Any]]:
+        ...
+        state, reward, terminal, truncate, info = self.env.step(action)
+        ...
+        return (Observation(content=state),
+                reward,
+                terminal,
+                truncate,
+                info)
+
+
+@ActionFactory.register(name=GymAction.PLAY.value.name,
+                        desc=GymAction.PLAY.value.desc,
+                        tool_name="openai_gym")
+class Play(ExecutableAction):
+    """There is only one Action, it can be implemented in the tool, registration is required here."""
+```
+
+You can view the example [code](gym_tool/openai_gym.py) to learn more.

aworld/tools/__init__.py

@@ -0,0 +1,12 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+
+from aworld.core.tool.base import Tool, AsyncTool
+from aworld.core.tool.action import ExecutableAction
+from aworld.utils.common import scan_packages
+
+scan_packages("aworld.tools", [Tool, AsyncTool, ExecutableAction])
+
+from aworld.tools.function_tools import FunctionTools, get_function_tools, list_function_tools
+from aworld.tools.function_tools_adapter import FunctionToolsMCPAdapter, get_function_tools_mcp_adapter
+from aworld.tools.function_tools_executor import FunctionToolsExecutor

aworld/tools/async_template_tool.py

@@ -0,0 +1,75 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+import json
+from typing import List, Tuple, Dict, Any
+
+from aworld.core.tool.base import AsyncTool
+from aworld.core.common import Observation, ActionModel, Config
+from aworld.logs.util import logger
+from aworld.tools.utils import build_observation
+
+
+class TemplateTool(AsyncTool):
+    def __init__(self, conf: Config, **kwargs) -> None:
+        super(TemplateTool, self).__init__(conf, **kwargs)
+
+    async def reset(self, *, seed: int | None = None, options: Dict[str, str] | None = None) -> Tuple[
+        Observation, dict[str, Any]]:
+        # from options obtain user query
+        return build_observation(observer=self.name(),
+                                 ability='',
+                                 content=options.get("query", None) if options else None), {}
+
+    async def do_step(self,
+                      action: List[ActionModel],
+                      **kwargs) -> Tuple[Observation, float, bool, bool, Dict[str, Any]]:
+        reward = 0
+        fail_error = ""
+        action_result = None
+
+        invalid_acts: List[int] = []
+        for i, act in enumerate(action):
+            if act.tool_name != self.name():
+                logger.warning(f"tool {act.tool_name} is not a {self.name()} tool!")
+                invalid_acts.append(i)
+
+        if invalid_acts:
+            for i in invalid_acts:
+                action[i] = None
+
+        resp = ""
+        try:
+            action_result, resp = await self.action_executor.async_execute_action(action, **kwargs)
+            reward = 1
+        except Exception as e:
+            fail_error = str(e)
+
+        terminated = kwargs.get("terminated", False)
+        for res in action_result:
+            if res.is_done:
+                terminated = res.is_done
+                self._finished = True
+
+        info = {"exception": fail_error}
+        info.update(kwargs)
+        if resp:
+            resp = json.dumps(resp)
+        else:
+            resp = action_result[0].content
+
+        observation = build_observation(observer=self.name(),
+                                        action_result=action_result,
+                                        ability=action[-1].action_name,
+                                        content=resp)
+        return (observation,
+                reward,
+                terminated,
+                kwargs.get("truncated", False),
+                info)
+
+    async def close(self) -> None:
+        pass
+
+    async def finished(self) -> bool:
+        # one time
+        return True

aworld/tools/function_tools.py

@@ -0,0 +1,586 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+
+import inspect
+import json
+import logging
+import traceback
+from typing import Any, Dict, List, Optional, Union, get_type_hints
+
+from mcp.types import TextContent, ImageContent, CallToolResult
+from mcp import Tool as MCPTool
+from pydantic import Field, create_model
+from pydantic.fields import FieldInfo  # Import FieldInfo type
+
+from aworld.core.common import ActionResult
+from aworld.logs.util import logger
+
+# Global function tools server registry
+_FUNCTION_TOOLS_REGISTRY = {}
+
+def _register_function_tools(function_tools):
+    """Register function tools server to global registry"""
+    _FUNCTION_TOOLS_REGISTRY[function_tools.name] = function_tools
+    logger.info(f"Registered FunctionTools server: {function_tools.name}")
+
+def get_function_tools(name):
+    """Get specified function tools server"""
+    return _FUNCTION_TOOLS_REGISTRY.get(name)
+
+def list_function_tools():
+    """List all registered function tools servers"""
+    return list(_FUNCTION_TOOLS_REGISTRY.keys())
+
+
+class FunctionTools:
+    """Function tools server, providing tool registration and calling mechanism similar to MCP
+    
+    Example:
+        ```python
+        # Create function tools server
+        function = FunctionTools("my-server", description="My function tools server")
+        
+        # Define tool function
+        @function.tool(description="Example search function")
+        def search(query: str, limit: int = 10) -> str:
+            # Actual search logic
+            results = [f"Result {i} for {query}" for i in range(limit)]
+            return json.dumps(results)
+            
+        # Using Field decorator
+        @function.tool(description="Example search function")
+        def search(
+            query: str = Field(description="Search query"),
+            limit: int = Field(10, description="Max results")
+        ) -> str:
+            # Actual search logic
+            results = [f"Result {i} for {query}" for i in range(limit)]
+            return json.dumps(results)
+        ```
+    """
+    
+    def __new__(cls, name: str, description: Optional[str] = None, version: str = "1.0"):
+        """Implement singleton pattern, return existing instance if one with same name exists
+        
+        Args:
+            name: Server name
+            description: Server description
+            version: Server version
+        """
+        # Check if instance with same name already exists
+        if name in _FUNCTION_TOOLS_REGISTRY:
+            logger.info(f"Returning existing FunctionTools instance: {name}")
+            return _FUNCTION_TOOLS_REGISTRY[name]
+        
+        # Create new instance
+        instance = super().__new__(cls)
+        return instance
+    
+    def __init__(self, name: str, description: Optional[str] = None, version: str = "1.0"):
+        """Initialize function tools server
+        
+        Args:
+            name: Server name
+            description: Server description
+            version: Server version
+        """
+        # Skip if already initialized
+        if hasattr(self, 'name') and self.name == name:
+            return
+            
+        self.name = name
+        self.description = description or f"Function tools server: {name}"
+        self.version = version
+        self.tools = {}
+        
+        # Register server to global registry
+        _register_function_tools(self)
+    
+    def tool(self, description: Optional[str] = None, parameters: Optional[Dict[str, Any]] = None):
+        """Tool function decorator
+        
+        Args:
+            description: Tool description
+            parameters: Additional parameter information to supplement auto-generated parameter schema
+            
+        Returns:
+            Decorator function
+        """
+        def decorator(func):
+            # Get function metadata
+            tool_name = func.__name__
+            tool_desc = description or f"Tool function: {tool_name}"
+            
+            # Auto-generate parameter schema from function signature
+            param_schema = self._generate_param_schema(func, parameters)
+            
+            # Register tool
+            self._register_tool(tool_name, func, tool_desc, param_schema)
+            
+            # Return original function, maintaining its callable nature
+            return func
+        return decorator
+    
+    def _register_tool(self, name: str, func, description: str, param_schema: Dict[str, Any]):
+        """Register tool to server"""
+        self.tools[name] = {
+            "function": func,
+            "description": description,
+            "parameters": param_schema,
+            "is_async": inspect.iscoroutinefunction(func)
+        }
+        logger.info(f"Registered tool '{name}' to server '{self.name}'")
+    
+    def _generate_param_schema(self, func, additional_params: Optional[Dict[str, Any]] = None):
+        """Generate parameter schema from function signature, maintaining MCP sample format"""
+        # Get function signature and type annotations
+        sig = inspect.signature(func)
+        type_hints = get_type_hints(func)
+        
+        properties = {}
+        required = []
+        
+        # Process each parameter
+        for name, param in sig.parameters.items():
+            # Skip self parameter
+            if name == 'self':
+                continue
+                
+            param_type = type_hints.get(name, inspect.Parameter.empty)
+            has_default = param.default != inspect.Parameter.empty
+            
+            # Build parameter properties
+            param_info = self._type_to_schema(param_type)
+            
+            # Add title field - space-separated capitalized words
+            param_info["title"] = " ".join(word.capitalize() for word in name.split("_"))
+            
+            # Handle Field decorator
+            if has_default and isinstance(param.default, FieldInfo):
+                field_info = param.default
+                
+                # Add description
+                if field_info.description:
+                    param_info["description"] = field_info.description
+                
+                # Only add default field when Field has actual default value
+                if field_info.default is not None and field_info.default is not ...:
+                    # Simple check to ensure it's not PydanticUndefined
+                    if not str(field_info.default).endswith("PydanticUndefined"):
+                        param_info["default"] = field_info.default
+                    else:
+                        # No actual default value, add to required
+                        required.append(name)
+                else:
+                    # No default value, add to required
+                    required.append(name)
+            # Handle regular default values
+            elif has_default and param.default is not None:
+                param_info["default"] = param.default
+            else:
+                # Parameters without default values are required
+                required.append(name)
+            
+            # Add description (if provided in additional_params)
+            if additional_params and name in additional_params:
+                param_info.update(additional_params[name])
+            
+            properties[name] = param_info
+        
+        # Special handling: ensure query_list is in required list
+        if "query_list" in properties and "query_list" not in required:
+            required.append("query_list")
+        
+        # Create schema consistent with MCP sample
+        schema = {
+            "properties": properties,
+            "type": "object",
+            "required": required,
+            "title": func.__name__ + "Arguments"
+        }
+        
+        return schema
+    
+    def _type_to_schema(self, type_hint):
+        """Convert Python type to JSON Schema type"""
+        import typing
+        
+        # Basic type mapping
+        if type_hint == str:
+            return {"type": "string"}
+        elif type_hint == int:
+            return {"type": "integer"}
+        elif type_hint == float:
+            return {"type": "number"}
+        elif type_hint == bool:
+            return {"type": "boolean"}
+        elif type_hint == list or getattr(type_hint, "__origin__", None) == list:
+            item_type = getattr(type_hint, "__args__", [None])[0]
+            return {
+                "type": "array",
+                "items": self._type_to_schema(item_type)
+            }
+        elif type_hint == dict or getattr(type_hint, "__origin__", None) == dict:
+            return {"type": "object"}
+        else:
+            # Default to string type
+            return {"type": "string"}
+    
+    def list_tools(self) -> List[MCPTool]:
+        """List all tools and their descriptions
+        
+        Returns:
+            List of MCPTool objects
+        """
+        mcp_tools = []
+        for name, info in self.tools.items():
+            # Create MCPTool object, consistent with MCP sample format
+            mcp_tool = MCPTool(
+                name=name,
+                description=info["description"],
+                inputSchema=info["parameters"]
+                # Don't set annotations field
+            )
+            mcp_tools.append(mcp_tool)
+        
+        return mcp_tools
+    
+    async def call_tool_async(self, tool_name: str, arguments: Optional[Dict[str, Any]] = None):
+        """Asynchronously call the specified tool function
+        
+        Args:
+            tool_name: Tool name
+            arguments: Tool arguments
+            
+        Returns:
+            Tool call result
+            
+        Raises:
+            ValueError: When tool doesn't exist
+            Exception: Exceptions during tool execution
+        """
+        if tool_name not in self.tools:
+            raise ValueError(f"Tool '{tool_name}' not found in server '{self.name}'")
+        
+        tool_info = self.tools[tool_name]
+        func = tool_info["function"]
+        is_async = tool_info["is_async"]
+        arguments = arguments or {}
+        
+        # Filter parameters, only keep parameters defined in the function
+        filtered_args = self._filter_arguments(func, arguments)
+        
+        try:
+            # Call based on function type
+            if is_async:
+                # Async call
+                result = await func(**filtered_args)
+            else:
+                # Sync call
+                import asyncio
+                # Use run_in_executor to run sync function, avoid blocking
+                loop = asyncio.get_event_loop()
+                result = await loop.run_in_executor(None, lambda: func(**filtered_args))
+                
+            return self._format_result(result)
+        except Exception as e:
+            logger.error(f"Error calling tool '{tool_name}': {str(e)}")
+            logger.debug(traceback.format_exc())
+            # Return error message
+            return CallToolResult(
+                content=[TextContent(type="text", text=f"Error: {str(e)}")]
+            )
+    
+    def call_tool(self, tool_name: str, arguments: Optional[Dict[str, Any]] = None):
+        """Synchronously call the specified tool function
+        
+        For async tools, it will run in the event loop.
+        
+        Args:
+            tool_name: Tool name
+            arguments: Tool arguments
+            
+        Returns:
+            Tool call result
+            
+        Raises:
+            ValueError: When tool doesn't exist
+            Exception: Exceptions during tool execution
+        """
+        if tool_name not in self.tools:
+            raise ValueError(f"Tool '{tool_name}' not found in server '{self.name}'")
+        
+        tool_info = self.tools[tool_name]
+        func = tool_info["function"]
+        is_async = tool_info["is_async"]
+        arguments = arguments or {}
+        
+        # Filter parameters, only keep parameters defined in the function
+        filtered_args = self._filter_arguments(func, arguments)
+        
+        try:
+            # Call based on function type
+            if is_async:
+                # Async functions need to run in event loop
+                import asyncio
+                
+                # Safer way to handle async calls
+                try:
+                    # Check if already in event loop
+                    running_loop = asyncio._get_running_loop()
+                    if running_loop is not None:
+                        # Already in event loop, use nest_asyncio to solve nesting issues
+                        try:
+                            import nest_asyncio
+                            nest_asyncio.apply()
+                            logger.debug(f"Applied nest_asyncio for {tool_name}")
+                        except ImportError:
+                            logger.warning("nest_asyncio not available, using alternative approach")
+                            # If nest_asyncio not available, use alternative method
+                            # Create new thread to run async function
+                            import threading
+                            import queue
+                            
+                            result_queue = queue.Queue()
+                            
+                            def run_async_in_thread():
+                                try:
+                                    # Create new event loop
+                                    new_loop = asyncio.new_event_loop()
+                                    asyncio.set_event_loop(new_loop)
+                                    # Run async function
+                                    result = new_loop.run_until_complete(func(**filtered_args))
+                                    # Put in queue
+                                    result_queue.put(("result", result))
+                                except Exception as e:
+                                    # Put in queue
+                                    result_queue.put(("error", e))
+                                finally:
+                                    new_loop.close()
+                            
+                            # Start thread
+                            thread = threading.Thread(target=run_async_in_thread)
+                            thread.start()
+                            thread.join(timeout=60)  # Wait up to 60 seconds
+                            
+                            if thread.is_alive():
+                                raise TimeoutError(f"Timeout waiting for {tool_name} to complete")
+                            
+                            # Get result
+                            result_type, result_value = result_queue.get()
+                            if result_type == "error":
+                                raise result_value
+                            result = result_value
+                            return self._format_result(result)
+                    
+                    # Get or create event loop
+                    try:
+                        loop = asyncio.get_event_loop()
+                    except RuntimeError:
+                        loop = asyncio.new_event_loop()
+                        asyncio.set_event_loop(loop)
+                    
+                    # Run async function
+                    result = loop.run_until_complete(func(**filtered_args))
+                    
+                except RuntimeError as e:
+                    if "This event loop is already running" in str(e):
+                        # If event loop already running, use thread method
+                        logger.warning(f"Event loop already running, using thread approach for {tool_name}")
+                        import threading
+                        import queue
+                        
+                        result_queue = queue.Queue()
+                        
+                        def run_async_in_thread():
+                            try:
+                                # Create new event loop
+                                new_loop = asyncio.new_event_loop()
+                                asyncio.set_event_loop(new_loop)
+                                # Run async function
+                                result = new_loop.run_until_complete(func(**filtered_args))
+                                # Put in queue
+                                result_queue.put(("result", result))
+                            except Exception as e:
+                                # Put in queue
+                                result_queue.put(("error", e))
+                            finally:
+                                new_loop.close()
+                        
+                        # Start thread
+                        thread = threading.Thread(target=run_async_in_thread)
+                        thread.start()
+                        thread.join(timeout=60)  # Wait up to 60 seconds
+                        
+                        if thread.is_alive():
+                            raise TimeoutError(f"Timeout waiting for {tool_name} to complete")
+                        
+                        # Get result
+                        result_type, result_value = result_queue.get()
+                        if result_type == "error":
+                            raise result_value
+                        result = result_value
+                    else:
+                        # Other RuntimeError
+                        raise
+            else:
+                # Sync call
+                result = func(**filtered_args)
+                
+            return self._format_result(result)
+        except Exception as e:
+            logger.error(f"Error calling tool '{tool_name}': {str(e)}")
+            logger.debug(traceback.format_exc())
+            # Return error message
+            return CallToolResult(
+                content=[TextContent(type="text", text=f"Error: {str(e)}")]
+            )
+    
+    def _filter_arguments(self, func, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Filter arguments, only keep parameters defined in the function
+        
+        Args:
+            func: Function to call
+            arguments: Input argument dictionary
+            
+        Returns:
+            Filtered argument dictionary
+        """
+        # Get function signature
+        sig = inspect.signature(func)
+        param_names = set(sig.parameters.keys())
+        
+        # Filter arguments
+        filtered_args = {}
+        for name, value in arguments.items():
+            if name in param_names:
+                filtered_args[name] = value
+            else:
+                # Log filtered arguments
+                logger.debug(f"Filtered out argument '{name}' not defined in function {func.__name__}")
+        
+        return filtered_args
+    
+    def _format_result(self, result):
+        """Format function return value to MCP compatible format"""
+        # If result is already MCP type, return directly
+        if isinstance(result, CallToolResult):
+            return result
+        
+        # Create content list
+        content = []
+        
+        # Handle different result types
+        if isinstance(result, str):
+            # String result
+            content.append(TextContent(type="text", text=result))
+        elif isinstance(result, bytes):
+            # Image data
+            import base64
+            image_base64 = base64.b64encode(result).decode('utf-8')
+            content.append(ImageContent(type="image", data=image_base64))
+        elif isinstance(result, TextContent):
+            # If already TextContent, use directly
+            content.append(result)
+        elif isinstance(result, dict):
+            if result.get("type") in ["text", "image"]:
+                # Dictionary already in content format
+                if result["type"] == "text":
+                    # Ensure text field is plain text, without type= format issues
+                    text_content = result.get("text", "")
+                    # If text field looks like serialized content, try to extract actual text
+                    if isinstance(text_content, str) and text_content.startswith("type="):
+                        # Try to extract actual text content
+                        import re
+                        match = re.search(r"text=['\"](.+?)['\"]", text_content)
+                        if match:
+                            text_content = match.group(1)
+                    
+                    content.append(TextContent(type="text", text=text_content))
+                elif result["type"] == "image":
+                    content.append(ImageContent(type="image", data=result.get("data", "")))
+            elif "metadata" in result and "text" in result:
+                # Special handling for results with metadata
+                content.append(TextContent(
+                    type="text", 
+                    text=result["text"],
+                    metadata=result["metadata"]
+                ))
+            else:
+                # Other dictionary types, convert to JSON
+                try:
+                    content.append(TextContent(type="text", text=json.dumps(result, ensure_ascii=False)))
+                except:
+                    content.append(TextContent(type="text", text=str(result)))
+        else:
+            # Other types try JSON serialization
+            try:
+                content.append(TextContent(type="text", text=json.dumps(result, ensure_ascii=False)))
+            except:
+                content.append(TextContent(type="text", text=str(result)))
+        
+        return CallToolResult(content=content)
+
+
+class FunctionToolsAdapter:
+    """Adapter base class for adapting FunctionTools to MCPServer interface
+    
+    This class provides basic adaptation functionality, but needs to be inherited and extended in specific implementations.
+    """
+    
+    def __init__(self, name: str):
+        """Initialize adapter
+        
+        Args:
+            name: Function tools server name
+        """
+        self._function_tools = get_function_tools(name)
+        if not self._function_tools:
+            raise ValueError(f"FunctionTools '{name}' not found")
+        self._name = name
+    
+    @property
+    def name(self) -> str:
+        """Server name"""
+        return self._name
+    
+    async def list_tools(self) -> List[MCPTool]:
+        """List all tools and their descriptions"""
+        return self._function_tools.list_tools()
+    
+    async def call_tool(self, tool_name: str, arguments: Optional[Dict[str, Any]] = None):
+        """Asynchronously call the specified tool function"""
+        return await self._function_tools.call_tool_async(tool_name, arguments)
+    
+    def to_action_result(self, result) -> ActionResult:
+        """Convert call result to ActionResult
+        
+        This method is used to convert MCP call results to AWorld framework's ActionResult objects.
+        
+        Args:
+            result: MCP call result
+            
+        Returns:
+            ActionResult object
+        """
+        action_result = ActionResult(
+            content="",
+            keep=True
+        )
+        
+        if result and result.content:
+            if len(result.content) > 0:
+                if isinstance(result.content[0], TextContent):
+                    action_result = ActionResult(
+                        content=result.content[0].text,
+                        keep=True,
+                        metadata=getattr(result.content[0], "metadata", {})
+                    )
+                elif isinstance(result.content[0], ImageContent):
+                    action_result = ActionResult(
+                        content=f"data:image/jpeg;base64,{result.content[0].data}",
+                        keep=True,
+                        metadata=getattr(result.content[0], "metadata", {})
+                    )
+        
+        return action_result 

aworld/tools/function_tools_adapter.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+
+import asyncio
+from typing import Any, Dict, List, Optional
+
+from mcp.types import CallToolResult, Tool as MCPTool
+
+from aworld.core.common import ActionResult
+from aworld.logs.util import logger
+from aworld.mcp_client.server import MCPServer
+from aworld.tools.function_tools import get_function_tools, FunctionToolsAdapter as BaseAdapter
+
+
+class FunctionToolsMCPAdapter(MCPServer):
+    """Adapter for FunctionTools to MCPServer interface
+    
+    This adapter allows FunctionTools to be used like a standard MCPServer,
+    supporting list_tools and call_tool methods.
+    """
+    
+    def __init__(self, name: str):
+        """Initialize the adapter
+        
+        Args:
+            name: Function tool server name
+        """
+        self._adapter = BaseAdapter(name)
+        self._name = self._adapter.name
+        self._connected = False
+    
+    @property
+    def name(self) -> str:
+        """Server name"""
+        return self._name
+    
+    async def connect(self):
+        """Connect to the server
+        
+        For FunctionTools, this is a no-op since no actual connection is needed.
+        """
+        self._connected = True
+    
+    async def cleanup(self):
+        """Clean up server resources
+        
+        For FunctionTools, this is a no-op since there are no resources to clean up.
+        """
+        self._connected = False
+    
+    async def list_tools(self) -> List[MCPTool]:
+        """List all tools and their descriptions
+        
+        Returns:
+            List of tools
+        """
+        if not self._connected:
+            await self.connect()
+        
+        # Directly return the tool list from FunctionTools, which now returns MCPTool objects
+        return await self._adapter.list_tools()
+    
+    async def call_tool(self, tool_name: str, arguments: Optional[Dict[str, Any]] = None) -> CallToolResult:
+        """Call the specified tool function
+        
+        Args:
+            tool_name: Tool name
+            arguments: Tool parameters
+            
+        Returns:
+            Tool call result
+        """
+        if not self._connected:
+            await self.connect()
+        
+        # Use async method to call the tool
+        return await self._adapter.call_tool(tool_name, arguments)
+
+
+def get_function_tools_mcp_adapter(name: str) -> FunctionToolsMCPAdapter:
+    """Get MCP adapter for FunctionTools
+    
+    Args:
+        name: Function tool server name
+        
+    Returns:
+        MCPServer adapter
+        
+    Raises:
+        ValueError: When the function tool server with the specified name does not exist
+    """
+    function_tools = get_function_tools(name)
+    if not function_tools:
+        raise ValueError(f"FunctionTools '{name}' not found")
+    
+    return FunctionToolsMCPAdapter(name) 

aworld/tools/function_tools_executor.py

@@ -0,0 +1,145 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+
+import asyncio
+import inspect
+from typing import Any, Dict, List, Tuple, Union
+
+from aworld.core.common import ActionModel, ActionResult
+from aworld.core.tool.base import ToolActionExecutor, Tool, AsyncTool
+from aworld.logs.util import logger
+from aworld.tools.function_tools import get_function_tools
+
+
+class FunctionToolsExecutor(ToolActionExecutor):
+    """Function Tools Executor
+    
+    This executor is used to execute tools defined by FunctionTools in the AWorld framework.
+    """
+    
+    def __init__(self, tool: Union[Tool, AsyncTool] = None):
+        """Initialize the executor
+        
+        Args:
+            tool: Tool instance
+        """
+        super().__init__(tool)
+        self.function_tools_cache = {}
+    
+    def execute_action(self, actions: List[ActionModel], **kwargs) -> Tuple[List[ActionResult], Any]:
+        """Synchronously execute tool actions
+        
+        Args:
+            actions: List of actions
+            **kwargs: Additional parameters
+            
+        Returns:
+            List of execution results and additional information
+        """
+        # For synchronous execution, we use asyncio to run the async method
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(self.async_execute_action(actions, **kwargs))
+    
+    async def async_execute_action(self, actions: List[ActionModel], **kwargs) -> Tuple[List[ActionResult], Any]:
+        """Asynchronously execute tool actions
+        
+        Args:
+            actions: List of actions
+            **kwargs: Additional parameters
+            
+        Returns:
+            List of execution results and additional information
+        """
+        results = []
+        
+        for action in actions:
+            # Parse action name, format: server_name.tool_name
+            if "." not in action.name:
+                logger.warning(f"Invalid action name format: {action.name}, expected: server_name.tool_name")
+                results.append(ActionResult(
+                    content=f"Error: Invalid action name format: {action.name}",
+                    keep=False
+                ))
+                continue
+            
+            server_name, tool_name = action.name.split(".", 1)
+            
+            # Get function tools server
+            function_tools = self.function_tools_cache.get(server_name)
+            if not function_tools:
+                function_tools = get_function_tools(server_name)
+                if not function_tools:
+                    logger.warning(f"FunctionTools server not found: {server_name}")
+                    results.append(ActionResult(
+                        content=f"Error: FunctionTools server not found: {server_name}",
+                        keep=False
+                    ))
+                    continue
+                self.function_tools_cache[server_name] = function_tools
+            
+            # Check if the tool exists
+            if tool_name not in function_tools.tools:
+                logger.warning(f"Tool not found: {tool_name} in server {server_name}")
+                results.append(ActionResult(
+                    content=f"Error: Tool not found: {tool_name}",
+                    keep=False
+                ))
+                continue
+            
+            # Get tool function
+            tool_info = function_tools.tools[tool_name]
+            func = tool_info["function"]
+            
+            try:
+                # Parse arguments
+                arguments = action.arguments or {}
+                
+                # Check if the function is asynchronous
+                is_async = inspect.iscoroutinefunction(func)
+                
+                # Call the function
+                if is_async:
+                    # Asynchronous call
+                    result = await func(**arguments)
+                else:
+                    # Synchronous call
+                    result = func(**arguments)
+                
+                # Process the result
+                mcp_result = function_tools._format_result(result)
+                action_result = ActionResult(
+                    content="",
+                    keep=True
+                )
+                
+                # Extract content from MCP result
+                if mcp_result and mcp_result.content:
+                    if len(mcp_result.content) > 0:
+                        from mcp.types import TextContent, ImageContent
+                        
+                        if isinstance(mcp_result.content[0], TextContent):
+                            action_result = ActionResult(
+                                content=mcp_result.content[0].text,
+                                keep=True,
+                                metadata=getattr(mcp_result.content[0], "metadata", {})
+                            )
+                        elif isinstance(mcp_result.content[0], ImageContent):
+                            action_result = ActionResult(
+                                content=f"data:image/jpeg;base64,{mcp_result.content[0].data}",
+                                keep=True,
+                                metadata=getattr(mcp_result.content[0], "metadata", {})
+                            )
+                
+                results.append(action_result)
+                
+            except Exception as e:
+                logger.error(f"Error executing tool {tool_name}: {str(e)}")
+                import traceback
+                logger.debug(traceback.format_exc())
+                
+                results.append(ActionResult(
+                    content=f"Error: {str(e)}",
+                    keep=False
+                ))
+        
+        return results, None 

aworld/tools/template_tool.py

@@ -0,0 +1,75 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+import json
+from typing import List, Tuple, Dict, Any
+
+from aworld.core.tool.base import Tool
+from aworld.core.common import Observation, ActionModel, Config
+from aworld.logs.util import logger
+from aworld.tools.utils import build_observation
+
+
+class TemplateTool(Tool):
+    def __init__(self, conf: Config, **kwargs) -> None:
+        super(TemplateTool, self).__init__(conf, **kwargs)
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, str] | None = None) -> Tuple[
+        Observation, dict[str, Any]]:
+        # from options obtain user query
+        return build_observation(observer=self.name(),
+                                 ability='',
+                                 content=options.get("query", None) if options else None), {}
+
+    def do_step(self,
+                action: List[ActionModel],
+                **kwargs) -> Tuple[Observation, float, bool, bool, Dict[str, Any]]:
+        reward = 0
+        fail_error = ""
+        action_result = None
+
+        invalid_acts: List[int] = []
+        for i, act in enumerate(action):
+            if act.tool_name != self.name():
+                logger.warning(f"tool {act.tool_name} is not a {self.name()} tool!")
+                invalid_acts.append(i)
+
+        if invalid_acts:
+            for i in invalid_acts:
+                action[i] = None
+
+        resp = ""
+        try:
+            action_result, resp = self.action_executor.execute_action(action, **kwargs)
+            reward = 1
+        except Exception as e:
+            fail_error = str(e)
+
+        terminated = kwargs.get("terminated", False)
+        for res in action_result:
+            if res.is_done:
+                terminated = res.is_done
+                self._finished = True
+
+        info = {"exception": fail_error}
+        info.update(kwargs)
+        if resp:
+            resp = json.dumps(resp)
+        else:
+            resp = action_result[0].content
+
+        observation = build_observation(observer=self.name(),
+                                        action_result=action_result,
+                                        ability=action[-1].action_name,
+                                        content=resp)
+        return (observation,
+                reward,
+                terminated,
+                kwargs.get("truncated", False),
+                info)
+
+    def close(self) -> None:
+        pass
+
+    def finished(self) -> bool:
+        # one time
+        return True

aworld/tools/tool_action.py

@@ -0,0 +1,16 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+
+from aworld.core.common import ToolActionInfo, ParamInfo
+from aworld.core.tool.action import ToolAction
+
+
+class HumanExecuteAction(ToolAction):
+    """Definition of Human execute supported action."""
+    HUMAN_CONFIRM = ToolActionInfo(
+        name="human_confirm",
+        input_params={"confirm_content": ParamInfo(name="confirm_content",
+                                                 type="str",
+                                                 required=True,
+                                                 desc="Content for user confirmation")},
+        desc="The main purpose of this tool is to pass given content to the user for confirmation.")

aworld/tools/utils.py

@@ -0,0 +1,27 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.
+from typing import Any, List
+
+from aworld.core.common import ActionResult, Observation
+
+DEFAULT_VIRTUAL_ENV_ID = "env_0"
+
+
+def build_observation(observer: str,
+                      ability: str,
+                      container_id: str = None,
+                      content: Any = None,
+                      dom_tree: Any = None,
+                      action_result: List[ActionResult] = [],
+                      image: str = '',
+                      images: List[str] = [],
+                      **kwargs):
+    return Observation(container_id=container_id if container_id else DEFAULT_VIRTUAL_ENV_ID,
+                       observer=observer,
+                       ability=ability,
+                       content=content,
+                       action_result=action_result,
+                       dom_tree=dom_tree,
+                       image=image,
+                       images=images,
+                       info=kwargs)