agentscope-runtime 0.1.0__py3-none-any.whl

agentscope_runtime/sandbox/box/training_box/registry.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# registry.py
+"""
+This module contains the registry for training boxes.
+"""
+
+from typing import Dict, Type
+from .base import BaseEnv
+
+
+class Registry:
+    """
+    Registry for registering and managing environment classes.
+    Stores all BaseEnv subclasses with their names.
+    """
+
+    _envs: Dict[str, Type[BaseEnv]] = {}
+
+    @classmethod
+    def register(cls, name: str):
+        """
+        Registry for registering
+        """
+
+        def _register(env_class):
+            if not hasattr(env_class, "__bases__") or not any(
+                "BaseEnv" in str(base) for base in env_class.__bases__
+            ):
+                raise TypeError(
+                    f"{env_class.__name__} must inherit from BaseEnv",
+                )
+            cls._envs[name] = env_class
+            return env_class
+
+        return _register
+
+    @classmethod
+    def get(cls, name: str) -> Type[BaseEnv]:
+        """
+        Get the Environment subclass by name.
+        """
+        if name not in cls._envs:
+            raise KeyError(
+                f"Environment '{name}' not found. "
+                f"Available: {list(cls._envs.keys())}",
+            )
+        return cls._envs[name]
+
+    @classmethod
+    def list(cls) -> list:
+        """
+        Get the environment classes registered.
+        """
+        return list(cls._envs.keys())

agentscope_runtime/sandbox/box/training_box/src/trajectory.py

@@ -0,0 +1,278 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=no-member
+"""
+Module for defining data structures and models used in trajectory tracking.
+
+This module provides classes and enums for managing messages, tool calls,
+roles, rewards, and trajectory information in an agent-based system.
+"""
+import datetime
+import json
+from typing import List, Any
+from uuid import uuid4
+from enum import Enum
+from pydantic import BaseModel, Field  # , model_validator
+
+
+class Reward(BaseModel):
+    """
+    Represents a reward with an optional value and metadata.
+
+    Attributes:
+        reward_value (float, optional): The numerical reward value.
+        metadata (dict): Additional information about the reward.
+    """
+
+    reward_value: float | None = Field(default=None)
+    metadata: dict = Field(default_factory=dict)
+
+
+class Role(str, Enum):
+    """
+    Enumeration of possible roles in the agent communication system.
+
+    Defines standard roles for system, user, tool,
+        and different types of assistants.
+    """
+
+    SYSTEM = "system"
+    USER = "user"
+    TOOL = "tool"  # environment
+    ASSISTANT = "assistant"  # policy model
+    CONTEXT_ASSISTANT = "context_assistant"  # context model
+    SUMMARY_ASSISTANT = "summary_assistant"  # summary model
+
+
+class ToolCall(BaseModel):
+    """
+    Represents a tool call with its associated metadata and properties.
+
+    Attributes:
+        index (int): The index of the tool call.
+        id (str): Unique identifier for the tool call.
+        name (str): Name of the tool being called.
+        arguments (str): Arguments for the tool call.
+        type (str): Type of the tool call.
+        result (Any, optional): Result of the tool call.
+    """
+
+    index: int = Field(default=...)
+    id: str = Field(default="")
+    name: str = Field(default="")
+    arguments: str = Field(default="")
+    type: str = Field(default="function")
+    result: Any = Field(default=None, exclude=True)
+
+    # @model_validator(mode="before")  # noqa
+    @classmethod
+    def init_tool_call(cls, data: dict):
+        """
+        Initialize tool call data, ensuring required fields are present.
+
+        Args:
+            data (dict): Input data for tool call.
+
+        Returns:
+            dict: Processed tool call data.
+        """
+        tool_type = data.get("type", "")
+        tool_type_dict = data.get(tool_type, {})
+
+        for key in ["name", "arguments"]:
+            if key not in data:
+                data[key] = tool_type_dict.get(key, "")
+        return data
+
+    @property
+    def argument_dict(self):
+        """
+        Convert arguments string to a dictionary.
+
+        Returns:
+            dict: Parsed arguments.
+        """
+        return json.loads(self.arguments)
+
+    @property
+    def simple_dict(self):
+        """
+        Create a simplified dictionary representation of the tool call.
+
+        Returns:
+            dict: Simplified tool call information.
+        """
+        return {
+            "id": self.id,
+            self.type: {"arguments": self.arguments, "name": self.name},
+            "type": self.type,
+            "index": self.index,
+            "result": self.result,
+        }
+
+
+class Message(BaseModel):
+    """
+    Represents a message in the communication system.
+
+    Attributes:
+        role (Role): The role of the message sender.
+        content (str or bytes): The message content.
+        reasoning_content (str):
+            Additional reasoning content.
+        tool_calls (List[ToolCall]):
+            List of tool calls associated with the message.
+        timestamp (str): Timestamp of message creation.
+        metadata (dict): Additional metadata for the message.
+    """
+
+    role: Role = Field(default=Role.USER)
+    content: str | bytes = Field(default="")
+    reasoning_content: str = Field(default="")
+    tool_calls: List[ToolCall] = Field(default_factory=list)
+    timestamp: str = Field(
+        default_factory=lambda: datetime.datetime.now().strftime(
+            "%Y-%m-%d %H:%M:%S.%f",
+        ),
+    )
+    metadata: dict = Field(default_factory=dict)
+
+    @property
+    def simple_dict(self) -> dict:
+        """
+        Create a simplified dictionary representation of the message.
+
+        Returns:
+            dict: Simplified message information.
+        """
+        result = {
+            "role": self.role.value,
+            "content": self.content,
+        }
+        if self.tool_calls:
+            result["tool_calls"] = [x.simple_dict for x in self.tool_calls]
+        return result
+
+
+class ActionMessage(Message):
+    """
+    Represents an action message with a predefined role of ASSISTANT.
+    """
+
+    role: Role = Field(default=Role.ASSISTANT)
+
+
+class StateMessage(Message):
+    """
+    Represents a state message with additional tool call tracking.
+
+    Attributes:
+        tool_call_id (str): Identifier for the associated tool call.
+    """
+
+    role: Role = Field(default=Role.USER)
+    tool_call_id: str = Field(default="")
+
+    @property
+    def simple_dict(self) -> dict:
+        """
+        Create a simplified dictionary representation of the state message.
+
+        Returns:
+            dict: Simplified state message information.
+        """
+        result = {
+            "role": self.role.value,
+            "content": self.content,
+            "tool_calls": [tc.simple_dict for tc in self.tool_calls],
+        }
+        if self.tool_call_id:
+            result["tool_call_id"] = self.tool_call_id
+        return result
+
+    @property
+    def simple_list(self) -> list:
+        """
+        Create a simplified list representation of the state message.
+
+        Returns:
+            list: Simplified list of state message information.
+        """
+        return [
+            {
+                "role": self.role.value,
+                "content": str(x.result),
+                "tool_call_id": x.id,
+            }
+            for x in self.tool_calls
+        ]
+
+
+class ContextMessage(Message):
+    """
+    Represents a context message with a predefined role of CONTEXT_ASSISTANT.
+    """
+
+    role: Role = Field(default=Role.CONTEXT_ASSISTANT)
+
+
+class SummaryMessage(Message):
+    """
+    Represents a summary message with a predefined role of SUMMARY_ASSISTANT.
+    """
+
+    role: Role = Field(default=Role.SUMMARY_ASSISTANT)
+
+
+class Sample(BaseModel):
+    """
+    Represents a sample with a list of messages and associated metadata.
+
+    Attributes:
+        steps (List[Message]): List of messages in the sample.
+        metadata (dict): Additional metadata for the sample.
+    """
+
+    steps: List[Message] = Field(default_factory=list)
+    metadata: dict = Field(default_factory=dict)
+
+
+class Trajectory(BaseModel):
+    """
+    Represents a trajectory of steps with associated metadata.
+
+    Attributes:
+        id (str): Unique identifier for the trajectory.
+        steps (List[Message]): List of messages/steps in the trajectory.
+        done (bool): Flag indicating if the trajectory is complete.
+        query (str): Query associated with the trajectory.
+        answer (Any): Answer to the query.
+        metadata (dict): Additional metadata for the trajectory.
+    """
+
+    id: str = Field(default_factory=lambda: uuid4().hex)
+    steps: List[Message] = Field(default_factory=list)
+    done: bool = Field(default=False)
+    query: str = Field(default="")
+    answer: Any = Field(default=None)
+    metadata: dict = Field(default_factory=dict)
+
+    def add_step(self, step: Message):
+        """
+        Add a step (message) to the trajectory.
+
+        Args:
+            step (Message): Message to be added to the trajectory.
+        """
+        self.steps.append(step)
+
+    def reset(self):
+        """
+        Reset the trajectory to its initial state.
+
+        Clears steps, resets flags, and clears metadata.
+        """
+        self.steps.clear()
+        self.done = False
+        self.query = ""
+        self.answer = ""
+        self.metadata.clear()

agentscope_runtime/sandbox/box/training_box/training_box.py

@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+"""
+Module for the Training Sandbox implementation.
+
+This module provides a sandbox environment for training tasks
+with specific configuration and tool calling methods.
+"""
+import platform
+from typing import Dict, Optional
+
+from ...registry import SandboxRegistry
+from ...enums import SandboxType
+from ...box.sandbox import Sandbox
+from ...constant import IMAGE_TAG
+
+
+def get_image_tag() -> str:
+    machine = platform.machine().lower()
+    if machine in ("arm64", "aarch64", "armv7l", "armv8"):
+        return f"{IMAGE_TAG}-arm64"
+    return IMAGE_TAG
+
+
+@SandboxRegistry.register(
+    f"agentscope/runtime-sandbox-appworld:{get_image_tag()}",
+    sandbox_type=SandboxType.APPWORLD,
+    runtime_config={"shm_size": "5.06gb"},
+    security_level="medium",
+    timeout=30,
+    description="appworld Sandbox",
+)
+class TrainingSandbox(Sandbox):
+    """
+    Training Sandbox class for managing and executing training-related tasks.
+
+    This class provides methods to create, manage, and interact with
+    training environment instances using specialized tool calls.
+    """
+
+    def __init__(
+        self,
+        sandbox_id: Optional[str] = None,
+        timeout: int = 3000,
+        base_url: Optional[str] = None,
+        bearer_token: Optional[str] = None,
+    ):
+        """
+        Initialize the Training Sandbox.
+
+        Args:
+            sandbox_id (Optional[str]): Unique identifier for the sandbox.
+            timeout (int): Maximum time allowed for sandbox operations.
+            base_url (Optional[str]): Base URL for sandbox API.
+            bearer_token (Optional[str]): Authentication token for API access.
+        """
+        super().__init__(
+            sandbox_id,
+            timeout,
+            base_url,
+            bearer_token,
+            SandboxType.APPWORLD,
+        )
+
+    def create_instance(
+        self,
+        env_type: str,
+        task_id: str,
+        instance_id: str = None,
+        params: Dict = None,
+    ):
+        """
+        Create a new instance of a training environment.
+
+        Args:
+            env_type (str): Type of environment to create.
+            task_id (str): Identifier for the specific task.
+            instance_id (str, optional): Custom instance identifier.
+            params (Dict, optional):
+                Additional parameters for instance creation.
+
+        Returns:
+            The created instance details.
+        """
+        return self.call_tool(
+            name="create_instance",
+            arguments={
+                "env_type": env_type,
+                "task_id": task_id,
+                "instance_id": instance_id,
+                "params": params,
+            },
+        )
+
+    def get_task_ids(
+        self,
+        env_type: str,
+        split: str = "train",
+        params: dict = None,
+    ):
+        """
+        Retrieve task identifiers for a specific environment.
+
+        Args:
+            env_type (str): Type of environment.
+            split (str, optional):
+                Data split to retrieve tasks from. Defaults to "train".
+            params (dict, optional): Additional filtering parameters.
+
+        Returns:
+            List of task identifiers.
+        """
+        return self.call_tool(
+            name="get_task_ids",
+            arguments={
+                "env_type": env_type,
+                "split": split,
+                "params": params,
+            },
+        )
+
+    def get_env_profile(
+        self,
+        env_type: str,
+        split: str = "train",
+        params: dict = None,
+    ):
+        """
+        Retrieve the environment profile.
+
+        Args:
+            env_type (str): Type of environment.
+            split (str, optional):
+                Data split to retrieve profile from. Defaults to "train".
+            params (dict, optional): Additional profile retrieval parameters.
+
+        Returns:
+            Environment profile details.
+        """
+        return self.call_tool(
+            name="get_env_profile",
+            arguments={
+                "env_type": env_type,
+                "split": split,
+                "params": params,
+            },
+        )
+
+    def step(
+        self,
+        instance_id: str,
+        action: Dict = None,
+        params: Dict = None,
+    ) -> str:
+        """
+        Execute a step in the training environment.
+
+        Args:
+            instance_id (str): Identifier of the environment instance.
+            action (Dict, optional): Action to be performed in the environment.
+            params (Dict, optional): Additional step parameters.
+
+        Returns:
+            str: Result of the step execution.
+        """
+        action = action or {}
+        params = params or {}
+        return self.call_tool(
+            name="step",
+            arguments={
+                "instance_id": instance_id,
+                "action": action,
+                "params": params,
+            },
+        )
+
+    def evaluate(
+        self,
+        instance_id: str,
+        messages: Dict = None,
+        params: Dict = None,
+    ):
+        """
+        Evaluate the performance of a training environment instance.
+
+        Args:
+            instance_id (str): Identifier of the environment instance.
+            messages (Dict, optional): Evaluation-related messages.
+            params (Dict, optional): Additional evaluation parameters.
+
+        Returns:
+            Evaluation results.
+        """
+        messages = messages or {}
+        params = params or {}
+        return self.call_tool(
+            name="evaluate",
+            arguments={
+                "instance_id": instance_id,
+                "messages": messages,
+                "params": params,
+            },
+        )
+
+    def release_instance(self, instance_id: str):
+        """
+        Release a training environment instance.
+
+        Args:
+            instance_id (str): Identifier of the instance to be released.
+
+        Returns:
+            Result of the instance release operation.
+        """
+        return self.call_tool(
+            name="release_instance",
+            arguments={
+                "instance_id": instance_id,
+            },
+        )