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

agentscope_runtime/sandbox/tools/gui/tool.py

@@ -1,77 +0,0 @@
-# -*- coding: utf-8 -*-
-# flake8: noqa: E501
-# pylint: disable=line-too-long
-from typing import Dict
-
-from ..sandbox_tool import SandboxTool
-
-
-class ComputerUseTool(SandboxTool):
-    """
-    Use a mouse and keyboard to interact with a computer, and take screenshots.
-    """
-
-    _name: str = "computer"
-    _sandbox_type: str = "gui"
-    _tool_type: str = "computer_use"
-    _schema: Dict = {
-        "name": "computer",
-        "description": (
-            "Use a mouse and keyboard to interact with a computer, and take screenshots.\n"
-            "* This is an interface to a desktop GUI. You do not have access to a terminal or applications menu. You must click on desktop icons to start applications.\n"
-            "* Always prefer using keyboard shortcuts rather than clicking, where possible.\n"
-            "* If you see boxes with two letters in them, typing these letters will click that element. Use this instead of other shortcuts or clicking, where possible.\n"
-            "* Some applications may take time to start or process actions, so you may need to wait and take successive screenshots to see the results of your actions. E.g. if you click on Firefox and a window doesn't open, try taking another screenshot.\n"
-            "* Whenever you intend to move the cursor to click on an element like an icon, you should consult a screenshot to determine the coordinates of the element before moving the cursor.\n"
-            "* If you tried clicking on a program or link but it failed to load, even after waiting, try adjusting your cursor position so that the tip of the cursor visually falls on the element that you want to click.\n"
-            "* Make sure to click any buttons, links, icons, etc with the cursor tip in the center of the element. Don't click boxes on their edges unless asked."
-        ),
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "action": {
-                    "type": "string",
-                    "enum": [
-                        "key",
-                        "type",
-                        "mouse_move",
-                        "left_click",
-                        "left_click_drag",
-                        "right_click",
-                        "middle_click",
-                        "double_click",
-                        "get_screenshot",
-                        "get_cursor_position",
-                    ],
-                    "description": (
-                        "The action to perform. The available actions are:\n"
-                        "* key: Press a key or key-combination on the keyboard.\n"
-                        "* type: Type a string of text on the keyboard.\n"
-                        "* get_cursor_position: Get the current (x, y) pixel coordinate of the cursor on the screen.\n"
-                        "* mouse_move: Move the cursor to a specified (x, y) pixel coordinate on the screen.\n"
-                        "* left_click: Click the left mouse button.\n"
-                        "* left_click_drag: Click and drag the cursor to a specified (x, y) pixel coordinate on the screen.\n"
-                        "* right_click: Click the right mouse button.\n"
-                        "* middle_click: Click the middle mouse button.\n"
-                        "* double_click: Double-click the left mouse button.\n"
-                        "* get_screenshot: Take a screenshot of the screen."
-                    ),
-                },
-                "coordinate": {
-                    "type": "array",
-                    "items": {"type": "number"},
-                    "minItems": 2,
-                    "maxItems": 2,
-                    "description": "(x, y): The x (pixels from the left edge) and y (pixels from the top edge) coordinates",
-                },
-                "text": {
-                    "type": "string",
-                    "description": "Text to type or key command to execute",
-                },
-            },
-            "required": ["action"],
-        },
-    }
-
-
-computer_use = ComputerUseTool()

agentscope_runtime/sandbox/tools/mcp_tool.py

@@ -1,195 +0,0 @@
-# -*- coding: utf-8 -*-
-from typing import Optional, Any, Dict, Set, List
-
-from ..enums import SandboxType
-from ..box.sandbox import Sandbox
-from .sandbox_tool import SandboxTool
-
-
-class MCPTool(SandboxTool):
-    """MCP tool class."""
-
-    def __init__(
-        self,
-        *,
-        sandbox: Optional[Any] = None,
-        name: Optional[str] = None,
-        sandbox_type: Optional[SandboxType | str] = None,
-        tool_type: Optional[str] = None,
-        schema: Optional[Dict] = None,
-        server_configs: Optional[Dict] = None,
-    ):
-        """
-        Initialize the MCP tool with an additional MCP server configuration.
-        """
-        super().__init__(
-            sandbox=sandbox,
-            name=name,
-            sandbox_type=sandbox_type,
-            tool_type=tool_type,
-            schema=schema,
-        )
-        self._server_configs = server_configs
-
-    @property
-    def server_configs(self) -> Optional[Dict]:
-        return self._server_configs
-
-    @server_configs.setter
-    def server_configs(self, config: Dict):
-        if not isinstance(config, dict) and "mcpServers" not in config:
-            raise ValueError(
-                "MCP server configuration must be a valid dictionary.",
-            )
-        self._server_configs = config
-
-    def bind(self, sandbox: Sandbox):
-        """
-        Return a new instance bound with a specific sandbox (immutable mode).
-        """
-        if not isinstance(sandbox, Sandbox):
-            raise TypeError(
-                "The provided sandbox must be an instance of `Sandbox`.",
-            )
-
-        assert self.sandbox_type == sandbox.sandbox_type, (
-            f"Sandbox type mismatch! The tool requires a sandbox of type "
-            f"`{self.sandbox_type}`, but a sandbox of type"
-            f" `{sandbox.sandbox_type}` was provided."
-        )
-
-        return self.__class__(
-            sandbox=sandbox,
-            name=self._name,
-            sandbox_type=self._sandbox_type,
-            tool_type=self._tool_type,
-            schema=self._schema,
-            server_configs=self._server_configs,
-        )
-
-
-class MCPConfigConverter:
-    """MCP configuration management class."""
-
-    def __init__(
-        self,
-        server_configs: Dict,
-        *,
-        sandbox: Optional[Sandbox] = None,
-        whitelist: Optional[Set[str]] = None,
-        blacklist: Optional[Set[str]] = None,
-    ) -> None:
-        """
-        Initializes MCP configuration.
-
-        Args:
-            server_configs: Dictionary of MCP server configurations.
-            whitelist: Whitelist; if set, only functions in the whitelist
-                are allowed.
-            blacklist: Blacklist; functions in the blacklist will be excluded.
-        """
-        self.server_configs = server_configs
-        self.whitelist = whitelist or set()
-        self.blacklist = blacklist or set()
-        self._sandbox = sandbox
-
-        assert (
-            "mcpServers" in server_configs
-        ), "MCP server config must contain 'mcpServers'"
-
-    def bind(self, sandbox: Sandbox) -> "MCPConfigConverter":
-        """
-        Binds a sandbox and returns a new instance.
-
-        Args:
-            sandbox: The sandbox object to bind.
-
-        Returns:
-            A new configuration instance bound to the sandbox.
-        """
-        new_config = self.__class__(
-            server_configs=self.server_configs.copy(),
-            sandbox=sandbox,
-            whitelist=self.whitelist.copy(),
-            blacklist=self.blacklist.copy(),
-        )
-        return new_config
-
-    def to_builtin_tools(
-        self,
-        *,
-        sandbox: Optional[Sandbox] = None,
-        sandbox_type: Optional[SandboxType | str] = None,
-    ) -> List[MCPTool]:
-        """
-        Converts to a list of MCPTool instances.
-
-        Returns:
-            A list of bound MCPTool objects.
-        """
-        box = sandbox or self._sandbox
-        if box is None:
-            from ..registry import SandboxRegistry
-
-            if sandbox_type is None:
-                sandbox_type = SandboxType.BASE
-
-            cls_ = SandboxRegistry.get_classes_by_type(sandbox_type)
-            # Use proper context manager
-            with cls_() as tmp_box:
-                return self._process_tools(tmp_box)
-        else:
-            return self._process_tools(box)
-
-    def _process_tools(self, box: Sandbox) -> List[MCPTool]:
-        """Helper method to process tools with the given sandbox."""
-        tools_to_add = []
-        box.add_mcp_servers(
-            server_configs=self.server_configs,
-            overwrite=False,
-        )
-        for server_name in self.server_configs["mcpServers"]:
-            tools = box.list_tools(tool_type=server_name).get(server_name, {})
-            for tool_name, tool_info in tools.items():
-                if self.whitelist and tool_name not in self.whitelist:
-                    continue
-                if self.blacklist and tool_name in self.blacklist:
-                    continue
-
-                tools_to_add.append(
-                    MCPTool(
-                        sandbox=box,
-                        name=tool_name,
-                        sandbox_type=box.sandbox_type,
-                        tool_type=server_name,
-                        schema=tool_info["json_schema"]["function"],
-                        server_configs={
-                            "mcpServers": {
-                                server_name: self.server_configs["mcpServers"][
-                                    server_name
-                                ],
-                            },
-                        },
-                    ),
-                )
-
-        return tools_to_add
-
-    @classmethod
-    def from_dict(
-        cls,
-        config_dict: Dict,
-        whitelist: Optional[Set[str]] = None,
-        blacklist: Optional[Set[str]] = None,
-    ) -> "MCPConfigConverter":
-        """Creates a configuration instance from a dictionary.
-
-        Args:
-            config_dict: Configuration dictionary.
-            whitelist: Whitelist.
-            blacklist: Blacklist.
-
-        Returns:
-            An instance of McpConfig.
-        """
-        return cls(config_dict, whitelist=whitelist, blacklist=blacklist)

agentscope_runtime/sandbox/tools/sandbox_tool.py

@@ -1,104 +0,0 @@
-# -*- coding: utf-8 -*-
-from typing import Optional, Any, Dict
-
-from .tool import Tool
-from ..enums import SandboxType
-from ..box.sandbox import Sandbox
-
-
-class SandboxTool(Tool):
-    """Built-in tool class"""
-
-    _name: str = None
-    _sandbox_type: SandboxType | str = None
-    _tool_type: str = None
-    _schema: Dict = None
-
-    def __init__(
-        self,
-        *,
-        sandbox: Optional[Any] = None,
-        name: Optional[str] = None,
-        sandbox_type: Optional[SandboxType | str] = None,
-        tool_type: Optional[str] = None,
-        schema: Optional[Dict] = None,
-    ):
-        """
-        Initialize the tool.
-
-        Note: Once the sandbox is set, it does not change.
-        """
-        self._sandbox = sandbox
-        self._name = name or self.__class__._name
-        self._sandbox_type = sandbox_type or self.__class__._sandbox_type
-        self._tool_type = tool_type or self.__class__._tool_type
-        self._schema = schema or self.__class__._schema
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def sandbox_type(self) -> SandboxType:
-        return SandboxType(self._sandbox_type)
-
-    @property
-    def tool_type(self) -> str:
-        return self._tool_type
-
-    @property
-    def schema(self) -> Dict:
-        return {
-            "type": "function",
-            "function": self._schema,
-        }
-
-    @property
-    def sandbox(self):
-        return self._sandbox
-
-    def __call__(self, *, sandbox: Optional[Any] = None, **kwargs):
-        """Call the tool, allowing a temporary sandbox to be specified"""
-        return self.call(sandbox=sandbox, **kwargs)
-
-    def call(self, *, sandbox: Optional[Any] = None, **kwargs):
-        """
-        Execute the tool call.
-        Args:
-            sandbox: Temporarily used sandbox, highest priority
-            **kwargs: Tool parameters
-        """
-        # Priority: temporary sandbox > instance sandbox > None (dryrun)
-        box = sandbox or self._sandbox
-        if box is None:
-            return self._dryrun_call(**kwargs)
-        else:
-            return box.call_tool(self.name, arguments=kwargs)
-
-    def bind(self, sandbox: Sandbox):
-        """
-        Return a new instance bound with a specific sandbox (immutable mode).
-        """
-        if not isinstance(sandbox, Sandbox):
-            raise TypeError(
-                "The provided sandbox must be an instance of `Sandbox`.",
-            )
-
-        assert self.sandbox_type == sandbox.sandbox_type, (
-            f"Sandbox type mismatch! The tool requires a sandbox of type "
-            f"`{self.sandbox_type}`, but a sandbox of type"
-            f" `{sandbox.sandbox_type}` was provided."
-        )
-
-        return self.__class__(sandbox=sandbox)
-
-    def _dryrun_call(self, **kwargs):
-        """
-        Dryrun mode: temporarily create a sandbox
-        """
-        from ..registry import SandboxRegistry
-
-        cls_ = SandboxRegistry.get_classes_by_type(self.sandbox_type)
-
-        with cls_() as box:
-            return box.call_tool(self.name, arguments=kwargs)

agentscope_runtime/sandbox/tools/tool.py

@@ -1,238 +0,0 @@
-# -*- coding: utf-8 -*-
-# pylint: disable=unused-argument
-import inspect
-
-from abc import ABC, abstractmethod
-from typing import Optional, Any, Dict
-from ..enums import SandboxType
-
-
-class Tool(ABC):
-    """Abstract base class for all tools.
-
-    This abstract class defines the common interface that all tool
-    implementations must follow, including both SandboxTool and FunctionTool.
-
-    Key responsibilities:
-    - Define the standard tool interface
-    - Ensure consistent behavior across different tool types
-    - Provide common functionality where applicable
-    """
-
-    def __init__(
-        self,
-        *,
-        name: Optional[str] = None,
-        tool_type: Optional[str] = None,
-        **kwargs,
-    ):
-        """
-        Initialize the tool with basic parameters.
-
-        Args:
-            name: Tool name
-            tool_type: Tool type identifier
-            **kwargs: Additional tool-specific parameters
-        """
-        self._name = name
-        self._tool_type = tool_type
-
-    @property
-    def __name__(self) -> str:
-        return self.name
-
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """Get the tool name."""
-
-    @property
-    @abstractmethod
-    def tool_type(self) -> str:
-        """Get the tool type."""
-
-    @property
-    @abstractmethod
-    def schema(self) -> Dict:
-        """Get the tool schema in OpenAI function calling format."""
-
-    @property
-    @abstractmethod
-    def sandbox_type(self) -> SandboxType:
-        """Get the required sandbox type for this tool."""
-
-    @property
-    @abstractmethod
-    def sandbox(self) -> Optional[Any]:
-        """Get the current sandbox instance (if any)."""
-
-    def __call__(self, *, sandbox: Optional[Any] = None, **kwargs):
-        """Call the tool with optional sandbox override.
-
-        This is a convenience method that delegates to the call() method.
-
-        Args:
-            sandbox: Optional sandbox to use for this call
-            **kwargs: Tool parameters
-
-        Returns:
-            Tool execution result
-        """
-        return self.call(sandbox=sandbox, **kwargs)
-
-    @abstractmethod
-    def call(self, *, sandbox: Optional[Any] = None, **kwargs) -> Dict:
-        """Execute the tool call.
-
-        This is the core method that each tool implementation must provide.
-
-        Args:
-            sandbox: Optional sandbox to use for this call
-            **kwargs: Tool parameters
-
-        Returns:
-            Tool execution result in standardized format:
-            {
-                "meta": Optional[Dict],
-                "content": List[Dict],
-                "isError": bool
-            }
-        """
-
-    @abstractmethod
-    def bind(self, *args, **kwargs) -> "Tool":
-        """Bind parameters or context to create a new tool instance.
-
-        The specific binding behavior depends on the tool type:
-        - SandboxTool: binds to a sandbox
-        - FunctionTool: binds function parameters
-
-        Returns:
-            New tool instance with bound parameters/context
-        """
-
-    def __str__(self) -> str:
-        """String representation of the tool."""
-        return (
-            f"{self.__class__.__name__}(name='{self.name}', type="
-            f"'{self.tool_type}')"
-        )
-
-    def __repr__(self) -> str:
-        """Detailed string representation of the tool."""
-        return (
-            f"{self.__class__.__name__}("
-            f"name='{self.name}', "
-            f"tool_type='{self.tool_type}', "
-            f"sandbox_type='{self.sandbox_type}'"
-            f")"
-        )
-
-    def make_function(self):
-        """Create a function with proper type signatures from schema."""
-        tool_call = self.__call__
-        parameters = self.schema["function"]["parameters"]
-
-        # Extract properties and required parameters from the schema
-        properties = parameters.get("properties", {})
-        required = parameters.get("required", [])
-
-        # Type mapping from JSON schema types to Python types
-        type_mapping = {
-            "string": str,
-            "integer": int,
-            "number": float,
-            "boolean": bool,
-            "array": list,
-            "object": dict,
-        }
-
-        # Build parameter signature
-        sig_params = []
-        for param_name, param_info in properties.items():
-            param_type = type_mapping.get(
-                param_info.get("type", "string"),
-                str,
-            )
-
-            if param_name in required:
-                # Required parameter
-                param = inspect.Parameter(
-                    param_name,
-                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                    annotation=param_type,
-                )
-            else:
-                # Optional parameter with default None
-                param = inspect.Parameter(
-                    param_name,
-                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                    default=None,
-                    annotation=Optional[param_type],
-                )
-
-            sig_params.append(param)
-
-        # Create the function signature
-        new_signature = inspect.Signature(sig_params, return_annotation=Any)
-
-        def generated_function(*args, **kwargs):
-            """
-            Dynamically generated function wrapper for the tool schema.
-
-            This function is created at runtime to match the tool's parameter
-            signature as defined in the schema. It validates arguments and
-            forwards them to the tool's call interface.
-            """
-            # Bind arguments to signature
-            bound = new_signature.bind(*args, **kwargs)
-            bound.apply_defaults()
-
-            # Validate required parameters
-            missing_required = [
-                param_name
-                for param_name in required
-                if param_name not in bound.arguments
-                or bound.arguments[param_name] is None
-            ]
-
-            if missing_required:
-                raise TypeError(
-                    f"Missing required arguments: {set(missing_required)}",
-                )
-
-            # Filter kwargs based on defined properties and remove None
-            # values for optional params
-            filtered_kwargs = {
-                k: v
-                for k, v in bound.arguments.items()
-                if k in properties and (k in required or v is not None)
-            }
-
-            return tool_call(**filtered_kwargs)
-
-        # Set the correct signature and metadata
-        generated_function.__signature__ = new_signature
-        generated_function.__name__ = self.name
-
-        # Build docstring with parameter information
-        doc_parts = []
-        for name, info in properties.items():
-            required_str = " (required)" if name in required else " (optional)"
-            doc_parts.append(
-                f"    {name}: {info.get('type', 'string')}{required_str} -"
-                f" {info.get('description', '')}",
-            )
-
-        generated_function.__doc__ = (
-            self.schema["function"]["description"]
-            + "\n\nParameters:\n"
-            + "\n".join(doc_parts)
-        )
-
-        # Set type annotations for compatibility with typing inspection
-        annotations = {param.name: param.annotation for param in sig_params}
-        annotations["return"] = Any
-        generated_function.__annotations__ = annotations
-
-        return generated_function

agentscope_runtime/sandbox/tools/utils.py

@@ -1,68 +0,0 @@
-# -*- coding: utf-8 -*-
-def setup_tools(
-    tools,
-    environment_manager,
-    session_id,
-    user_id,
-    include_schemas=False,
-):
-    """
-    Generic function to activate tools.
-
-    Args:
-        tools: List of tools to activate.
-        environment_manager: Environment manager
-        session_id: ID of the session.
-        user_id: ID of the user.
-        include_schemas: Boolean flag to indicate if schemas should be
-            included.
-
-    Returns:
-        tuple: (activated_tools, schemas) if include_schemas=True,
-            else only activated_tools.
-    """
-    # Lazy import
-    from .tool import Tool
-    from .sandbox_tool import SandboxTool
-    from ...sandbox.box.dummy.dummy_sandbox import DummySandbox
-
-    enable_sandbox = False
-
-    # Check tool types and determine if sandbox needs to be enabled
-    for tool in tools:
-        assert isinstance(tool, Tool), f"{tool} must be an instance of Tool"
-        if isinstance(tool, SandboxTool):
-            enable_sandbox = True
-            break
-
-    # Check environment service
-    if enable_sandbox and environment_manager is None:
-        raise ValueError("environment_manager is not set")
-
-    # Connect to sandbox if required
-    if enable_sandbox:
-        sandboxes = environment_manager.connect_sandbox(
-            session_id=session_id,
-            user_id=user_id,
-            tools=tools,
-        )
-    else:
-        sandboxes = [DummySandbox()]
-
-    # Bind tools to sandbox and prepare schemas if required
-    schemas = []  # Initialize schemas list
-    activated_tools = []  # Initialize activated tools list
-
-    for tool in tools:
-        if include_schemas:
-            schemas.append(tool.schema)  # Collect tool schemas
-        for sandbox in sandboxes:
-            if sandbox.sandbox_type == tool.sandbox_type:
-                bound_tool = tool.bind(sandbox)  # Bind tool to the sandbox
-                activated_tools.append(
-                    bound_tool,
-                )  # Add to the activated tools list
-
-    if include_schemas:
-        return activated_tools, schemas
-    return activated_tools