agentscope-runtime 0.1.0__py3-none-any.whl

agentscope_runtime/sandbox/client/training_client.py

@@ -0,0 +1,265 @@
+# -*- coding: utf-8 -*-
+"""Module for the training sandbox client."""
+# -*- coding: utf-8 -*-
+# pylint: disable=unused-argument,too-many-return-statements
+import time
+import logging
+from typing import Dict, List, Optional, Any
+
+import requests
+from requests.exceptions import HTTPError, JSONDecodeError
+
+logger = logging.getLogger(__name__)
+
+
+class TrainingSandboxClient:
+    """Client for interacting with the training sandbox."""
+
+    def __init__(self, base_url: str = "http://localhost:8000"):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = 100
+        self.session = requests.Session()
+
+    def __enter__(self):
+        # Wait for the runtime api server to be healthy
+        self.wait_until_healthy()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        pass
+
+    def wait_until_healthy(self) -> None:
+        """
+        Waits until the runtime service is running for a specified timeout.
+        """
+        start_time = time.time()
+        while time.time() - start_time < self.timeout:
+            if self.check_health():
+                return
+            time.sleep(1)
+        raise TimeoutError(
+            "Runtime service did not start within the specified timeout.",
+        )
+
+    def check_health(self) -> bool:
+        """
+        Checks if the runtime service is running by verifying the health
+        endpoint.
+
+        Returns:
+            bool: True if the service is reachable, False otherwise
+        """
+        endpoint = f"{self.base_url}/healthz"
+
+        try:
+            response_api = self.session.get(endpoint)
+
+            return response_api.status_code == 200
+        except requests.RequestException:
+            return False
+
+    def _make_request(
+        self,
+        endpoint: str,
+        env_type: str = "default",
+        task_id: str = None,
+        instance_id: str = None,
+        messages: Dict[str, Any] = None,
+        params: Dict[str, Any] = None,
+    ) -> Dict:
+        """Request from fastapi"""
+        url = f"{self.base_url}/{endpoint}"
+        data = {
+            "env_type": env_type,
+            "task_id": task_id,
+            "instance_id": instance_id,
+            "messages": messages or {},
+            "params": params or {},
+        }
+        response = self.session.post(url, json=data)
+        try:
+            response.raise_for_status()
+        except HTTPError as e:
+            try:
+                detail = response.json().get("detail", "")
+            except JSONDecodeError:
+                detail = response.text
+
+            raise ValueError(
+                f"HTTP Error {e.response.status_code}: {detail}",
+            ) from e
+
+        return response.json()
+
+    def get_task_ids(
+        self,
+        env_type: str,
+        split: str = "train",
+        params: dict | None = None,
+    ) -> List[str]:
+        """Get task id list"""
+        payload = {"env_type": env_type}
+        if params:
+            payload["params"] = params
+        response = self._make_request(
+            endpoint="get_env_profile",
+            env_type=env_type,
+            params={"split": split},
+        )
+        return response["data"]
+
+    def get_env_profile(
+        self,
+        env_type: str,
+        split: str = "train",
+        params: dict | None = None,
+    ) -> List[str]:
+        """get environment profile"""
+        payload = {"env_type": env_type}
+        if params:
+            payload["params"] = params
+        response = self._make_request(
+            endpoint="get_env_profile",
+            env_type=env_type,
+            params={"split": split},
+        )
+        return response["data"]
+
+    def get_tools_info(
+        self,
+        instance_id: str,
+        messages: Dict = None,
+        params: Dict = None,
+    ) -> float:
+        """get tools information"""
+        messages = messages or {}
+        params = params or {}
+
+        response = self._make_request(
+            endpoint="get_info",
+            instance_id=instance_id,
+            messages=messages,
+            params=params,
+        )
+        return response["data"]
+
+    def create_instance(
+        self,
+        env_type: str,
+        task_id: str,
+        instance_id: str = None,
+        params: Dict = None,
+    ) -> Dict[str, str]:
+        """create instance of a task"""
+        response = self._make_request(
+            endpoint="create",
+            env_type=env_type,
+            task_id=task_id,
+            instance_id=instance_id,
+            params=params,
+        )
+        return response["data"]
+
+    def step(
+        self,
+        instance_id: str,
+        action: Dict = None,
+        params: Dict = None,
+    ) -> str:
+        """execute step transmission"""
+        action = action or {}
+        params = params or {}
+
+        response = self._make_request(
+            endpoint="step",
+            instance_id=instance_id,
+            messages=action,
+            params=params,
+        )
+        return response["data"]
+
+    def evaluate(
+        self,
+        instance_id: str,
+        messages: Dict = None,
+        params: Dict = None,
+    ) -> float:
+        """evaluate instance execution"""
+        messages = messages or {}
+        params = params or {}
+
+        response = self._make_request(
+            endpoint="evaluate",
+            instance_id=instance_id,
+            messages=messages,
+            params=params,
+        )
+        return response["data"]
+
+    def release_instance(self, instance_id: str) -> bool:
+        """release instance from memory"""
+        response = self._make_request(
+            endpoint="release",
+            instance_id=instance_id,
+        )
+        return response["success"]
+
+    # remined for future
+    def add_mcp_servers(self, server_configs, overwrite=False):
+        """add mcp for future"""
+        return None
+
+    def list_tools(self, **kwargs):
+        """list tools"""
+        if "instance_id" in kwargs:
+            # 只传get_tools_info的方法参数
+            return self.get_tools_info(
+                instance_id=kwargs.get("instance_id"),
+                messages=kwargs.get("messages", {}),
+                params=kwargs.get("params", {}),
+            )
+
+        return None
+
+    def call_tool(
+        self,
+        name: str,
+        arguments: Optional[dict[str, Any]] = None,
+    ) -> Any:
+        """release call tools"""
+        if arguments is None:
+            return None
+        if name == "create_instance":
+            return self.create_instance(
+                env_type=arguments.get("env_type", ""),
+                task_id=arguments.get("task_id", ""),
+                instance_id=arguments.get("instance_id", None),
+                params=arguments.get("params", {}),
+            )
+        if name == "release_instance":
+            return self.release_instance(instance_id=arguments["instance_id"])
+        if name == "evaluate":
+            return self.evaluate(
+                instance_id=arguments["instance_id"],
+                messages=arguments["messages"],
+                params=arguments["params"],
+            )
+
+        if name == "step":
+            return self.step(
+                instance_id=arguments["instance_id"],
+                action=arguments["action"],
+                params=arguments["params"],
+            )
+        if name in ["get_task_ids", "get_env_profile"]:
+            return self.get_env_profile(
+                env_type=arguments["env_type"],
+                split=arguments["split"],
+                params=arguments["params"],
+            )
+
+        logger.warning(
+            "missing function type of %s, please check the sandbox_client.py",
+            name,
+        )
+        return None

agentscope_runtime/sandbox/constant.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+import os
+
+IMAGE_TAG = os.getenv("RUNTIME_SANDBOX_IMAGE_TAG", "latest")
+BROWSER_SESSION_ID = "123e4567-e89b-12d3-a456-426614174000"

agentscope_runtime/sandbox/custom/__init__.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+import copy
+from os.path import dirname, basename, isfile, join
+import glob
+
+modules = glob.glob(join(dirname(__file__), "*.py"))
+__all__ = [
+    basename(f)[:-3]
+    for f in modules
+    if isfile(f) and not f.endswith("__init__.py")
+]
+
+# to ensure the sub-configs registered before set up the global config
+all_sub_configs_contrib = copy.copy(__all__)
+if "config" in all_sub_configs_contrib:
+    all_sub_configs_contrib.remove("config")

agentscope_runtime/sandbox/custom/custom_sandbox.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+import os
+
+from typing import Optional
+
+from ..constant import IMAGE_TAG
+from ..registry import SandboxRegistry
+from ..enums import SandboxType
+from ..box.sandbox import Sandbox
+
+SANDBOXTYPE = "custom_sandbox"
+
+
+@SandboxRegistry.register(
+    f"agentscope/runtime-sandbox-{SANDBOXTYPE}:{IMAGE_TAG}",
+    sandbox_type=SANDBOXTYPE,
+    resource_limits={"memory": "16Gi", "cpu": "4"},
+    security_level="medium",
+    timeout=60,
+    description="my sandbox",
+    environment={
+        "TAVILY_API_KEY": os.getenv("TAVILY_API_KEY", ""),
+        "AMAP_MAPS_API_KEY": os.getenv("AMAP_MAPS_API_KEY", ""),
+    },
+)
+class CustomSandbox(Sandbox):
+    def __init__(
+        self,
+        sandbox_id: Optional[str] = None,
+        timeout: int = 3000,
+        base_url: Optional[str] = None,
+        bearer_token: Optional[str] = None,
+    ):
+        super().__init__(
+            sandbox_id,
+            timeout,
+            base_url,
+            bearer_token,
+            SandboxType(SANDBOXTYPE),
+        )

agentscope_runtime/sandbox/custom/example.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+from typing import Optional
+
+from ..constant import IMAGE_TAG
+from ..registry import SandboxRegistry
+from ..enums import SandboxType
+from ..box.sandbox import Sandbox
+
+SANDBOX_TYPE = "example"
+
+
+@SandboxRegistry.register(
+    f"agentscope/runtime-sandbox-{SANDBOX_TYPE}:{IMAGE_TAG}",
+    sandbox_type=SANDBOX_TYPE,
+    resource_limits={"memory": "16Gi", "cpu": "4"},
+    security_level="medium",
+    timeout=60,
+    description="Example sandbox",
+)
+class ExampleSandbox(Sandbox):
+    def __init__(
+        self,
+        sandbox_id: Optional[str] = None,
+        timeout: int = 3000,
+        base_url: Optional[str] = None,
+        bearer_token: Optional[str] = None,
+    ):
+        super().__init__(
+            sandbox_id,
+            timeout,
+            base_url,
+            bearer_token,
+            SandboxType(SANDBOX_TYPE),
+        )
+        raise NotImplementedError(
+            "This sandbox is just a template and not implemented yet.",
+        )

agentscope_runtime/sandbox/enums.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+from enum import Enum, EnumMeta
+
+
+class DynamicEnumMeta(EnumMeta):
+    def __new__(
+        metacls,
+        cls,
+        bases,
+        classdict,
+        **kwds,
+    ):  # pylint: disable=bad-mcs-classmethod-argument
+        enum_class = super().__new__(metacls, cls, bases, classdict, **kwds)
+        for member in enum_class:
+            member.builtin = True
+        return enum_class
+
+
+class DynamicEnum(Enum, metaclass=DynamicEnumMeta):
+    def __init__(self, value):  # pylint: disable=unused-argument
+        self.builtin = True
+
+    @classmethod
+    def add_member(cls, name: str, value=None):
+        if name in cls.__members__:
+            raise ValueError(f"Member '{name}' already exists.")
+
+        if value is None:
+            value = name.lower()
+
+        # Add new member
+        new_member = cls._create_pseudo_member(name, value)
+        new_member.builtin = False
+        cls._member_map_[name] = new_member
+        cls._value2member_map_[value] = new_member
+        # Update ordered members
+        cls._member_names_.append(name)
+
+    @classmethod
+    def _create_pseudo_member(cls, name, value):
+        temp = object.__new__(cls)
+        temp._value_ = value
+        temp._name_ = name
+        temp.__objclass__ = cls
+        return temp
+
+    @classmethod
+    def get_builtin_members(cls):
+        return [member for member in cls if getattr(member, "builtin", False)]
+
+    @classmethod
+    def get_dynamic_members(cls):
+        return [
+            member for member in cls if not getattr(member, "builtin", False)
+        ]
+
+    def is_builtin(self):
+        return getattr(self, "builtin", False)
+
+
+class SandboxType(DynamicEnum):
+    """Sandbox type enumeration"""
+
+    DUMMY = "dummy"
+    BASE = "base"
+    BROWSER = "browser"
+    FILESYSTEM = "filesystem"
+    APPWORLD = "appworld"

agentscope_runtime/sandbox/manager/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+from .sandbox_manager import SandboxManager
+
+__all__ = ["SandboxManager"]

agentscope_runtime/sandbox/manager/collections/__init__.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+from .base_mapping import Mapping
+from .base_set import SetCollection
+from .base_queue import Queue
+from .redis_set import RedisSetCollection
+from .redis_queue import RedisQueue
+from .redis_mapping import RedisMapping
+from .in_memory_queue import InMemoryQueue
+from .in_memory_set import InMemorySetCollection
+from .in_memory_mapping import InMemoryMapping
+
+__all__ = [
+    "Mapping",
+    "SetCollection",
+    "Queue",
+    "RedisSetCollection",
+    "RedisQueue",
+    "RedisMapping",
+    "InMemoryQueue",
+    "InMemorySetCollection",
+    "InMemoryMapping",
+]

agentscope_runtime/sandbox/manager/collections/base_mapping.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+from abc import ABC, abstractmethod
+
+
+class Mapping(ABC):
+    @abstractmethod
+    def set(self, key: str, value: dict):
+        pass
+
+    @abstractmethod
+    def get(self, key: str) -> dict:
+        pass
+
+    @abstractmethod
+    def delete(self, key: str):
+        pass
+
+    @abstractmethod
+    def scan(self, prefix: str):
+        pass

agentscope_runtime/sandbox/manager/collections/base_queue.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# file: base_queue.py
+from abc import ABC, abstractmethod
+
+
+class Queue(ABC):
+    @abstractmethod
+    def enqueue(self, item: dict):
+        pass
+
+    @abstractmethod
+    def dequeue(self) -> dict:
+        pass
+
+    @abstractmethod
+    def peek(self) -> dict:
+        pass
+
+    @abstractmethod
+    def is_empty(self) -> bool:
+        pass
+
+    @abstractmethod
+    def size(self) -> int:
+        pass

agentscope_runtime/sandbox/manager/collections/base_set.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# file: base_set_collection.py
+from abc import ABC, abstractmethod
+
+
+class SetCollection(ABC):
+    @abstractmethod
+    def add(self, value: str):
+        pass
+
+    @abstractmethod
+    def remove(self, value: str):
+        pass
+
+    @abstractmethod
+    def contains(self, value: str) -> bool:
+        pass
+
+    @abstractmethod
+    def clear(self):
+        pass
+
+    @abstractmethod
+    def to_list(self) -> list:
+        pass

agentscope_runtime/sandbox/manager/collections/in_memory_mapping.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+from .base_mapping import Mapping
+
+
+class InMemoryMapping(Mapping):
+    def __init__(self):
+        self.store = {}
+
+    def set(self, key: str, value: dict):
+        self.store[key] = value
+
+    def get(self, key: str) -> dict:
+        return self.store.get(key)
+
+    def delete(self, key: str):
+        if key in self.store:
+            del self.store[key]
+
+    def scan(self, prefix: str):
+        for key in list(self.store.keys()):
+            if key.startswith(prefix):
+                yield key

agentscope_runtime/sandbox/manager/collections/in_memory_queue.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+# file: in_memory_queue.py
+from .base_queue import Queue
+
+
+class InMemoryQueue(Queue):
+    def __init__(self):
+        self.queue = []
+
+    def enqueue(self, item: dict):
+        self.queue.append(item)
+
+    def dequeue(self):
+        if self.queue:
+            return self.queue.pop(0)
+        return None
+
+    def peek(self):
+        if self.queue:
+            return self.queue[0]
+        return None
+
+    def is_empty(self) -> bool:
+        return len(self.queue) == 0
+
+    def size(self) -> int:
+        """Returns the number of items in the queue."""
+        return len(self.queue)

agentscope_runtime/sandbox/manager/collections/in_memory_set.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# file: in_memory_set_collection.py
+from .base_set import SetCollection
+
+
+class InMemorySetCollection(SetCollection):
+    def __init__(self):
+        self.set = set()
+
+    def add(self, value: str):
+        if value in self.set:
+            return False
+        else:
+            self.set.add(value)
+            return True
+
+    def remove(self, value: str):
+        self.set.discard(value)
+
+    def contains(self, value: str) -> bool:
+        return value in self.set
+
+    def clear(self):
+        self.set.clear()
+
+    def to_list(self) -> list:
+        return list(self.set)

agentscope_runtime/sandbox/manager/collections/redis_mapping.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+import json
+
+from .base_mapping import Mapping
+
+
+class RedisMapping(Mapping):
+    def __init__(self, redis_client):
+        self.client = redis_client
+
+    def set(self, key: str, value: dict):
+        self.client.set(key, json.dumps(value))
+
+    def get(self, key: str) -> dict:
+        value = self.client.get(key)
+        return json.loads(value) if value else None
+
+    def delete(self, key: str):
+        self.client.delete(key)
+
+    def scan(self, prefix: str):
+        cursor = 0
+        while cursor != 0:
+            cursor, keys = self.client.scan(cursor=cursor, match=f"{prefix}*")
+            for key in keys:
+                yield key.decode("utf-8")

agentscope_runtime/sandbox/manager/collections/redis_queue.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# file: redis_queue.py
+import json
+from .base_queue import Queue
+
+
+class RedisQueue(Queue):
+    def __init__(self, redis_client, queue_name: str):
+        self.client = redis_client
+        self.queue_name = queue_name
+
+    def enqueue(self, item: dict):
+        self.client.rpush(self.queue_name, json.dumps(item))
+
+    def dequeue(self) -> dict:
+        item = self.client.lpop(self.queue_name)
+        return json.loads(item) if item is not None else None
+
+    def peek(self) -> dict:
+        item = self.client.lindex(self.queue_name, 0)
+        return json.loads(item) if item is not None else None
+
+    def is_empty(self) -> bool:
+        return self.client.llen(self.queue_name) == 0
+
+    def size(self) -> int:
+        return self.client.llen(self.queue_name)

agentscope_runtime/sandbox/manager/collections/redis_set.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+from .base_set import SetCollection
+
+
+class RedisSetCollection(SetCollection):
+    def __init__(self, redis_client, set_name: str):
+        self.client = redis_client
+        self.set_name = set_name
+
+    def add(self, value: str):
+        return self.client.sadd(self.set_name, value) == 1
+
+    def remove(self, value: str):
+        self.client.srem(self.set_name, value)
+
+    def contains(self, value: str) -> bool:
+        return self.client.sismember(self.set_name, value)
+
+    def clear(self):
+        self.client.delete(self.set_name)
+
+    def to_list(self) -> list:
+        return list(self.client.smembers(self.set_name))