agentscope-runtime 0.2.0b1__py3-none-any.whl → 1.0.0__py3-none-any.whl

agentscope_runtime/sandbox/tools/filesystem/tool.py

@@ -1,319 +0,0 @@
-# -*- coding: utf-8 -*-
-# flake8: noqa: E501
-# pylint: disable=line-too-long
-from typing import Dict
-
-from ..base.tool import RunIPythonCellTool, RunShellCommandTool
-from ..sandbox_tool import SandboxTool
-
-
-class _RunIPythonCellTool(RunIPythonCellTool):
-    """Tool for running IPython cells."""
-
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "generic"
-
-
-class _RunShellCommandTool(RunShellCommandTool):
-    """Tool for running shell commands."""
-
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "generic"
-
-
-class ReadFileTool(SandboxTool):
-    """Tool for reading the complete contents of a file."""
-
-    _name: str = "read_file"
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "filesystem"
-    _schema: Dict = {
-        "name": "read_file",
-        "description": "Read the complete contents of a file.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "path": {
-                    "type": "string",
-                    "description": "Path to the file to read",
-                },
-            },
-            "required": ["path"],
-        },
-    }
-
-
-class ReadMultipleFilesTool(SandboxTool):
-    """Tool for reading the contents of multiple files."""
-
-    _name: str = "read_multiple_files"
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "filesystem"
-    _schema: Dict = {
-        "name": "read_multiple_files",
-        "description": "Read the contents of multiple files simultaneously.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "paths": {
-                    "type": "array",
-                    "items": {
-                        "type": "string",
-                    },
-                    "description": "Paths to the files to read",
-                },
-            },
-            "required": ["paths"],
-        },
-    }
-
-
-class WriteFileTool(SandboxTool):
-    """Tool for creating or overwriting a file with new content."""
-
-    _name: str = "write_file"
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "filesystem"
-    _schema: Dict = {
-        "name": "write_file",
-        "description": "Create a new file or overwrite an existing file with new content.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "path": {
-                    "type": "string",
-                    "description": "Path to the file to write to",
-                },
-                "content": {
-                    "type": "string",
-                    "description": "Content to write into the file",
-                },
-            },
-            "required": ["path", "content"],
-        },
-    }
-
-
-class EditFileTool(SandboxTool):
-    """Tool for making line-based edits to a text file."""
-
-    _name: str = "edit_file"
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "filesystem"
-    _schema: Dict = {
-        "name": "edit_file",
-        "description": "Make line-based edits to a text file.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "path": {
-                    "type": "string",
-                    "description": "Path to the file to edit",
-                },
-                "edits": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "oldText": {
-                                "type": "string",
-                                "description": "Text to search for - must match exactly",
-                            },
-                            "newText": {
-                                "type": "string",
-                                "description": "Text to replace with",
-                            },
-                        },
-                        "required": ["oldText", "newText"],
-                        "additionalProperties": False,
-                    },
-                },
-                "dryRun": {
-                    "type": "boolean",
-                    "default": False,
-                    "description": "Preview changes using git-style diff format",
-                },
-            },
-            "required": ["path", "edits"],
-        },
-    }
-
-
-class CreateDirectoryTool(SandboxTool):
-    """Tool for creating a new directory or ensuring it exists."""
-
-    _name: str = "create_directory"
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "filesystem"
-    _schema: Dict = {
-        "name": "create_directory",
-        "description": "Create a new directory or ensure a directory exists.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "path": {
-                    "type": "string",
-                    "description": "Path to the directory to create",
-                },
-            },
-            "required": ["path"],
-        },
-    }
-
-
-class ListDirectoryTool(SandboxTool):
-    """Tool for listing all files and directories in a specified path."""
-
-    _name: str = "list_directory"
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "filesystem"
-    _schema: Dict = {
-        "name": "list_directory",
-        "description": "Get a detailed listing of all files and directories in a specified path.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "path": {
-                    "type": "string",
-                    "description": "Path to list contents",
-                },
-            },
-            "required": ["path"],
-        },
-    }
-
-
-class DirectoryTreeTool(SandboxTool):
-    """Tool for getting a recursive tree view of files and directories."""
-
-    _name: str = "directory_tree"
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "filesystem"
-    _schema: Dict = {
-        "name": "directory_tree",
-        "description": "Get a recursive tree view of files and directories as a JSON structure.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "path": {
-                    "type": "string",
-                    "description": "Path to get tree structure",
-                },
-            },
-            "required": ["path"],
-        },
-    }
-
-
-class MoveFileTool(SandboxTool):
-    """Tool for moving or renaming files and directories."""
-
-    _name: str = "move_file"
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "filesystem"
-    _schema: Dict = {
-        "name": "move_file",
-        "description": "Move or rename files and directories.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "source": {
-                    "type": "string",
-                    "description": "Source path to move from",
-                },
-                "destination": {
-                    "type": "string",
-                    "description": "Destination path to move to",
-                },
-            },
-            "required": ["source", "destination"],
-        },
-    }
-
-
-class SearchFilesTool(SandboxTool):
-    """Tool for searching files and directories matching a pattern."""
-
-    _name: str = "search_files"
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "filesystem"
-    _schema: Dict = {
-        "name": "search_files",
-        "description": "Recursively search for files and directories matching a pattern.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "path": {
-                    "type": "string",
-                    "description": "Starting path for the search",
-                },
-                "pattern": {
-                    "type": "string",
-                    "description": "Pattern to match files/directories",
-                },
-                "excludePatterns": {
-                    "type": "array",
-                    "items": {
-                        "type": "string",
-                    },
-                    "default": [],
-                    "description": "Patterns to exclude from search",
-                },
-            },
-            "required": ["path", "pattern"],
-        },
-    }
-
-
-class GetFileInfoTool(SandboxTool):
-    """Tool for retrieving metadata about a file or directory."""
-
-    _name: str = "get_file_info"
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "filesystem"
-    _schema: Dict = {
-        "name": "get_file_info",
-        "description": "Retrieve detailed metadata about a file or directory.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "path": {
-                    "type": "string",
-                    "description": "Path to the file or directory",
-                },
-            },
-            "required": ["path"],
-        },
-    }
-
-
-class ListAllowedDirectoriesTool(SandboxTool):
-    """Tool for listing allowed directories the server can access."""
-
-    _name: str = "list_allowed_directories"
-    _sandbox_type: str = "filesystem"
-    _tool_type: str = "filesystem"
-    _schema: Dict = {
-        "name": "list_allowed_directories",
-        "description": "Returns the list of directories that this server is allowed to access.",
-        "parameters": {
-            "type": "object",
-            "properties": {},
-            "required": [],
-        },
-    }
-
-
-run_shell_command = _RunShellCommandTool()
-run_ipython_cell = _RunIPythonCellTool()
-read_file = ReadFileTool()
-read_multiple_files = ReadMultipleFilesTool()
-write_file = WriteFileTool()
-edit_file = EditFileTool()
-create_directory = CreateDirectoryTool()
-list_directory = ListDirectoryTool()
-directory_tree = DirectoryTreeTool()
-move_file = MoveFileTool()
-search_files = SearchFilesTool()
-get_file_info = GetFileInfoTool()
-list_allowed_directories = ListAllowedDirectoriesTool()

agentscope_runtime/sandbox/tools/function_tool.py

@@ -1,321 +0,0 @@
-# -*- coding: utf-8 -*-
-# pylint: disable=unused-argument
-import traceback
-from typing import Optional, Any, Dict, Callable, Union
-
-import inspect
-from functools import partial
-
-from .tool import Tool
-from ..registry import SandboxType
-
-
-class FunctionTool(Tool):
-    """Function tool class for direct function calls.
-
-    This tool class is designed for calling regular Python functions directly,
-    WITHOUT running in a sandbox environment. Unlike SandboxTool which executes
-    tools within isolated sandbox environments, FunctionTool executes functions
-    in the current Python process context.
-
-    Key differences from SandboxTool:
-    - No sandbox isolation: functions run in the same process.
-    - Direct function execution with immediate access to local variables and
-        imports.
-    - No security boundaries: functions have full access to the runtime
-        environment.
-    - Suitable for trusted, lightweight operations.
-
-    Use cases:
-    - Simple computational functions.
-    - Data processing utilities.
-    - Internal helper functions.
-    - Functions that don't require sandbox isolation.
-
-    Security note:
-    Since functions run without sandbox protection, ensure that:
-    - Functions are from trusted sources.
-    - Input validation is handled appropriately.
-    - Functions don't perform dangerous operations in production.
-
-    Example:
-        def add_numbers(a: int, b: int) -> int:
-            return a + b
-
-        tool = FunctionTool(add_numbers)
-        result = tool(a=1, b=2)  # Executes directly, returns 3
-    """
-
-    def __init__(
-        self,
-        func: Callable,
-        name: Optional[str] = None,
-        schema: Optional[Dict] = None,
-        tool_type: str = "function",
-        description: Optional[str] = None,
-    ):
-        """
-        Initialize the function tool.
-        Args:
-            func: The function to call (can be a partial function)
-            name: Tool name, defaults to function name
-            schema: Tool schema, auto-generated if not provided
-            tool_type: Tool type
-            description: Tool description
-        """
-        self._func = func
-        self._name: str = name or self._extract_function_name(func)
-        self._tool_type: str = tool_type
-        self._description = description or func.__doc__ or f"Call {self._name}"
-        # Auto-generate schema if not provided
-        if schema is None:
-            self._schema = self._generate_schema_from_func(func)
-        else:
-            self._schema = {
-                "name": self._name,
-                "description": self._description,
-                **schema,
-            }
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def tool_type(self) -> str:
-        return self._tool_type
-
-    @property
-    def schema(self) -> Dict:
-        return {
-            "type": "function",
-            "function": self._schema,
-        }
-
-    @property
-    def sandbox_type(self) -> SandboxType:
-        """Function tools don't need a sandbox type"""
-        return SandboxType.DUMMY
-
-    @property
-    def sandbox(self) -> None:
-        """Function tools don't have sandbox"""
-        return None
-
-    def __call__(self, **kwargs):
-        """Call the function directly"""
-        return self.call(**kwargs)
-
-    def call(self, *, sandbox: Optional[Any] = None, **kwargs):
-        """
-        Execute the function call.
-        Args:
-            sandbox: Ignored for function tools (for interface compatibility)
-            **kwargs: Function parameters
-        """
-        # Filter kwargs to only include parameters that the function accepts
-        filtered_kwargs = self._filter_kwargs(kwargs)
-        try:
-            return {
-                "meta": None,
-                "content": [
-                    {
-                        "type": "text",
-                        "text": str(self._func(**filtered_kwargs)),
-                        "annotations": None,
-                        "description": "None",
-                    },
-                ],
-                "isError": False,
-            }
-        except Exception as e:
-            return {
-                "meta": None,
-                "content": [
-                    {
-                        "type": "text",
-                        "text": f"{e}:\n{traceback.format_exc()}",
-                        "annotations": None,
-                        "description": "None",
-                    },
-                ],
-                "isError": True,
-            }
-
-    def bind(self, *args, **kwargs):
-        """
-        Return a new instance with pre-bound parameters (similar to
-        functools.partial).
-        """
-        return self.__class__(
-            func=self._func,
-            name=self._name,
-            tool_type=self._tool_type,
-            description=self._description,
-        )
-
-    def _extract_function_name(self, func: Callable) -> str:
-        """Extract function name from function or partial"""
-        if isinstance(func, partial):
-            return getattr(func.func, "__name__", "partial_function")
-        return getattr(func, "__name__", "unknown_function")
-
-    def _filter_kwargs(self, kwargs: Dict) -> Dict:
-        """Filter kwargs to match function signature"""
-        if isinstance(self._func, partial):
-            sig = inspect.signature(self._func.func)
-            # Remove already bound parameters
-            bound_params = set(self._func.keywords.keys())
-        else:
-            sig = inspect.signature(self._func)
-            bound_params = set()
-
-        filtered = {}
-        for param_name, param in sig.parameters.items():
-            if param_name in bound_params:
-                continue
-            if param_name in kwargs:
-                filtered[param_name] = kwargs[param_name]
-            elif (
-                param.default == inspect.Parameter.empty
-                and param.kind != param.VAR_KEYWORD
-            ):
-                # Required parameter is missing
-                raise TypeError(f"Missing required parameter: {param_name}")
-
-        # If function accepts **kwargs, include remaining parameters
-        if any(p.kind == p.VAR_KEYWORD for p in sig.parameters.values()):
-            used_params = set(sig.parameters.keys()) | bound_params
-            for key, value in kwargs.items():
-                if key not in used_params:
-                    filtered[key] = value
-
-        return filtered
-
-    def _generate_schema_from_func(self, func: Callable) -> Dict:
-        """Generate schema from function signature"""
-        if isinstance(func, partial):
-            actual_func = func.func
-            bound_kwargs = func.keywords
-        else:
-            actual_func = func
-            bound_kwargs = {}
-
-        sig = inspect.signature(actual_func)
-        parameters = {}
-        required = []
-
-        for param_name, param in sig.parameters.items():
-            # Skip already bound parameters
-            if param_name in bound_kwargs:
-                continue
-
-            param_info = self._get_param_info(param)
-            parameters[param_name] = param_info
-
-            # Check if parameter is required
-            if (
-                param.default == inspect.Parameter.empty
-                and param.kind
-                not in (
-                    param.VAR_POSITIONAL,
-                    param.VAR_KEYWORD,
-                )
-            ):
-                required.append(param_name)
-
-        schema = {
-            "name": self._name,
-            "description": self._description,
-            "parameters": {
-                "type": "object",
-                "properties": parameters,
-                "required": required,
-            },
-        }
-
-        return schema
-
-    def _get_param_info(self, param: inspect.Parameter) -> Dict:
-        """Get parameter info for schema"""
-        param_info = {"type": "string"}  # default type
-
-        # Try to infer type from annotation
-        if param.annotation != inspect.Parameter.empty:
-            param_info.update(
-                self._annotation_to_schema_type(param.annotation),
-            )
-
-        # Add default value if exists
-        if param.default != inspect.Parameter.empty:
-            param_info["default"] = param.default
-
-        return param_info
-
-    def _annotation_to_schema_type(self, annotation) -> Dict:
-        """Convert Python type annotation to JSON schema type"""
-        type_mapping = {
-            int: {"type": "integer"},
-            float: {"type": "number"},
-            bool: {"type": "boolean"},
-            str: {"type": "string"},
-            list: {"type": "array"},
-            dict: {"type": "object"},
-        }
-
-        # Handle Union types (Optional)
-        if hasattr(annotation, "__origin__"):
-            if annotation.__origin__ is Union:
-                args = annotation.__args__
-                if (
-                    len(args) == 2 and type(None) in args
-                ):  # This is Optional[T]
-                    non_none_type = next(
-                        arg for arg in args if arg is not type(None)
-                    )
-                    result = self._annotation_to_schema_type(non_none_type)
-                    # Mark as optional (though this is handled in required
-                    # array)
-                    return result
-
-        return type_mapping.get(annotation, {"type": "string"})
-
-
-def create_function_tool(
-    func: Callable,
-    name: Optional[str] = None,
-    **kwargs,
-) -> FunctionTool:
-    """
-    Factory function to create a FunctionTool.
-
-    Args:func: Function or partial function
-        name: Tool name
-        **kwargs: Additional arguments for FunctionToolReturns:
-        FunctionTool instance
-    """
-    return FunctionTool(func=func, name=name, **kwargs)
-
-
-def function_tool(
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    **tool_kwargs,
-):
-    """
-    Decorator to convert a function into a FunctionTool.
-    Usage:
-        @function_tool(name="my_calculator", description="A simple calculator")
-        def add(a: int, b: int) -> int:
-            return a + b
-    """
-
-    def decorator(func):
-        return FunctionTool(
-            func=func,
-            name=name,
-            description=description,
-            **tool_kwargs,
-        )
-
-    return decorator

agentscope_runtime/sandbox/tools/gui/__init__.py

@@ -1,7 +0,0 @@
-# -*- coding: utf-8 -*-
-from .tool import computer_use
-
-
-__all__ = [
-    "computer_use",
-]