agentscope-runtime 0.1.0__py3-none-any.whl

agentscope_runtime/engine/tracing/tracing_metric.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+class TraceType(str):
+    """Callback manager event types.
+
+    Attributes:
+        LLM: Logs for the template and response of LLM calls.
+        TOOL：Logs for the tool name and its arguments and
+            the output of tool calls
+        AGENT_STEP: Logs for the agent loop start and end?
+    """
+
+    # Officially supported event types
+    LLM = "llm"
+    TOOL = "tool"
+    AGENT_STEP = "agent_step"
+    SEARCH = "search"
+    IMAGE_GENERATION = "image_generation"
+    RAG = "rag"
+    INTENTION = "intention"
+    PLUGIN_CENTER = "plugin_center"
+
+    def __init__(self, value: str):
+        """Initialize a TraceType with a string value.
+
+        Args:
+            value (str): The string value for the trace type.
+
+        Raises:
+            ValueError: If value is not a string.
+        """
+        if not isinstance(value, str):
+            raise ValueError(
+                f"TraceType value must be a string, got {type(value)}",
+            )
+        self._value_ = value
+
+    def __str__(self) -> str:
+        """Return the string representation of the trace type.
+
+        Returns:
+            str: The trace type value.
+        """
+        return self._value_
+
+    def __repr__(self) -> str:
+        """Return the detailed string representation of the trace type.
+
+        Returns:
+            str: The trace type representation in the format TraceType(value).
+        """
+        return f"TraceType({self._value_})"
+
+    @classmethod
+    def add_type(cls, name: str, value: str) -> None:
+        """Add a new trace type to the class.
+
+        Args:
+            name (str): The name of the new trace type attribute.
+            value (str): The string value for the new trace type.
+
+        Raises:
+            ValueError: If name or value are not strings, or if the name
+            already exists.
+        """
+        if not isinstance(name, str) or not isinstance(value, str):
+            raise ValueError("Name and value must be strings")
+        if hasattr(cls, name):
+            raise ValueError(f"TraceType {name} already exists")
+        setattr(cls, name, cls(value))

agentscope_runtime/engine/tracing/wrapper.py

@@ -0,0 +1,321 @@
+# -*- coding: utf-8 -*-
+# pylint:disable=too-many-statements,typevar-name-incorrect-variance
+import inspect
+from functools import wraps
+from typing import (
+    Any,
+    AsyncGenerator,
+    Dict,
+    Iterable,
+    Optional,
+    Union,
+)
+from typing import AsyncIterable, AsyncIterator, Tuple, TypeVar
+
+from pydantic import BaseModel
+from openai.types.chat import ChatCompletionChunk
+
+from .base import Tracer, TraceType
+from .local_logging_handler import LocalLogHandler
+
+T = TypeVar("T", covariant=True)
+
+
+async def aenumerate(
+    asequence: AsyncIterable[T],
+    start: int = 0,
+) -> AsyncIterator[Tuple[int, T]]:
+    """Asynchronously enumerate an async iterator from a given start value.
+
+    Args:
+        asequence (AsyncIterable[T]): The async iterable to enumerate.
+        start (int): The starting value for enumeration. Defaults to 0.
+
+    Yields:
+        Tuple[int, T]: A tuple containing the index and the item from the
+        async iterable.
+    """
+    n = start
+    async for elem in asequence:
+        yield n, elem
+        n += 1
+
+
+def trace(
+    trace_type: Union[TraceType, str],
+    tracer: Optional[Tracer] = Tracer(
+        handlers=[LocalLogHandler(enable_console=True)],
+    ),
+) -> Any:
+    """Decorator for tracing function execution.
+
+    Args:
+        trace_type (Union[TraceType, str]): The type of trace event.
+        tracer (Optional[Tracer]): The tracer instance to use. Defaults to
+            a new Tracer with LocalLogHandler.
+
+    Returns:
+        Any: The decorated function with tracing capabilities.
+    """
+    if isinstance(trace_type, str):
+        trace_type = TraceType(trace_type)
+
+    def task_wrapper(func: Any) -> Any:
+        """Wrapper function that applies tracing to the target function.
+
+        Args:
+            func (Any): The function to be traced.
+
+        Returns:
+            Any: The wrapped function with appropriate tracing logic.
+        """
+
+        async def async_exec(*args: Any, **kwargs: Any) -> Any:
+            """Execute async function with tracing.
+
+            Args:
+                *args (Any): Positional arguments for the function.
+                **kwargs (Any): Keyword arguments for the function.
+
+            Returns:
+                Any: The result of the traced function.
+            """
+            start_payload = _get_start_payload(args, kwargs)
+            with tracer.event(
+                trace_type,
+                payload=start_payload,
+                **kwargs,
+            ) as event:
+                kwargs = kwargs if kwargs is not None else {}
+                kwargs["trace_event"] = event
+                result = await func(*args, **kwargs)
+                event.on_end(payload=_obj_to_dict(result))
+                return result
+
+        def sync_exec(*args: Any, **kwargs: Any) -> Any:
+            """Execute sync function with tracing.
+
+            Args:
+                *args (Any): Positional arguments for the function.
+                **kwargs (Any): Keyword arguments for the function.
+
+            Returns:
+                Any: The result of the traced function.
+            """
+            start_payload = _get_start_payload(args, kwargs)
+            with tracer.event(
+                trace_type,
+                payload=start_payload,
+                **kwargs,
+            ) as event:
+                kwargs = kwargs if kwargs is not None else {}
+                kwargs["trace_event"] = event
+                result = func(*args, **kwargs)
+                event.on_end(payload=_obj_to_dict(result))
+                return result
+
+        @wraps(func)
+        async def async_iter_task(
+            *args: Any,
+            **kwargs: Any,
+        ) -> AsyncGenerator[T, None]:
+            """Execute async generator function with tracing.
+
+            Args:
+                *args (Any): Positional arguments for the function.
+                **kwargs (Any): Keyword arguments for the function.
+
+            Yields:
+                T: Items from the traced async generator.
+            """
+            start_payload = _get_start_payload(args, kwargs)
+            with tracer.event(
+                trace_type,
+                payload=start_payload,
+                **kwargs,
+            ) as event:
+                kwargs = kwargs if kwargs is not None else {}
+                kwargs["trace_event"] = event
+                cumulated = []
+
+                async def iter_entry() -> AsyncGenerator[T, None]:
+                    """Internal async generator for processing items.
+
+                    Yields:
+                        T: Items from the original generator with tracing.
+                    """
+                    try:
+                        async for i, resp in aenumerate(
+                            func(*args, **kwargs),
+                        ):  # type: ignore
+                            if i == 0:
+                                event.on_log(
+                                    "",
+                                    **{
+                                        "step_suffix": "first_resp",
+                                        "payload": resp.model_dump(),
+                                    },
+                                )
+                            # todo: support more components
+                            if isinstance(resp, ChatCompletionChunk):
+                                if len(resp.choices) > 0:
+                                    cumulated.append(resp)
+                                    if (
+                                        resp.choices[0].finish_reason
+                                        is not None
+                                    ):
+                                        if (
+                                            resp.choices[0].finish_reason
+                                            == "stop"
+                                        ):
+                                            step_suffix = "last_resp"
+                                        else:
+                                            step_suffix = resp.choices[
+                                                0
+                                            ].finish_reason
+                                        event.on_log(
+                                            "",
+                                            **{
+                                                "step_suffix": step_suffix,
+                                                "payload": resp.model_dump(),
+                                            },
+                                        )
+                                elif resp.usage:
+                                    cumulated.append(resp)
+
+                            yield resp
+                    except Exception as e:
+                        raise e
+
+                try:
+                    async for resp in iter_entry():
+                        yield resp
+
+                except Exception as e:
+                    raise e
+
+        @wraps(func)
+        def iter_task(*args: Any, **kwargs: Any) -> Iterable[T]:
+            """Execute generator function with tracing.
+
+            Args:
+                *args (Any): Positional arguments for the function.
+                **kwargs (Any): Keyword arguments for the function.
+
+            Yields:
+                T: Items from the traced generator.
+            """
+            start_payload = _get_start_payload(args, kwargs)
+            with tracer.event(
+                trace_type,
+                payload=start_payload,
+                **kwargs,
+            ) as event:
+                cumulated = []
+                try:
+                    kwargs = kwargs if kwargs is not None else {}
+                    kwargs["trace_event"] = event
+                    for i, resp in enumerate(func(*args, **kwargs)):
+                        if i == 0:
+                            event.on_log(
+                                "",
+                                **{
+                                    "step_suffix": "first_resp",
+                                    "payload": resp.model_dump(),
+                                },
+                            )
+                        # todo: support more components
+                        if len(resp.choices) > 0:
+                            cumulated.append(resp)
+                            if resp.choices[0].finish_reason is not None:
+                                if resp.choices[0].finish_reason == "stop":
+                                    step_suffix = "last_resp"
+                                else:
+                                    step_suffix = resp.choices[0].finish_reason
+                                event.on_log(
+                                    "",
+                                    **{
+                                        "step_suffix": step_suffix,
+                                        "payload": resp.model_dump(),
+                                    },
+                                )
+                        elif resp.usage:
+                            cumulated.append(resp)
+
+                        yield resp
+                except Exception as e:
+                    raise e
+
+        if inspect.isasyncgenfunction(func):
+            return async_iter_task
+        elif inspect.isgeneratorfunction(func):
+            return iter_task
+        elif inspect.iscoroutinefunction(func):
+            return async_exec
+        else:
+            return sync_exec
+
+    return task_wrapper
+
+
+def _get_start_payload(args: Any, kwargs: Any) -> Dict:
+    """Extract and format the start payload from function arguments.
+
+    Args:
+        args (Any): Positional arguments from the function call.
+        kwargs (Any): Keyword arguments from the function call.
+
+    Returns:
+        Dict: The formatted start payload for tracing.
+    """
+    dict_args = {}
+    if isinstance(args, tuple) and len(args) > 1:
+        dict_args = _obj_to_dict(args[1:])
+
+    dict_kwargs = _obj_to_dict(kwargs)
+    dict_kwargs = {
+        key: value
+        for key, value in dict_kwargs.items()
+        if not key.startswith("trace_")
+    }
+
+    merged = {}
+    if dict_args:
+        if isinstance(dict_args, list):
+            for item in dict_args:
+                if isinstance(item, dict):
+                    merged.update(item)
+        elif isinstance(dict_args, dict):
+            merged.update(dict_args)
+
+    if dict_kwargs:
+        merged.update(dict_kwargs)
+
+    return merged
+
+
+def _obj_to_dict(obj: Any) -> Any:
+    """Convert an object to a dictionary representation for tracing.
+
+    Args:
+        obj (Any): The object to convert.
+
+    Returns:
+        Any: The dictionary representation of the object, or the object
+            itself if it's a primitive type.
+    """
+    if isinstance(obj, (str, int, float, bool, type(None))):
+        return obj
+    elif isinstance(obj, dict):
+        return {k: _obj_to_dict(v) for k, v in obj.items()}  # obj
+    elif isinstance(obj, (list, set, tuple)):
+        return [_obj_to_dict(item) for item in obj]
+    elif isinstance(obj, BaseModel):
+        return obj.model_dump()
+    else:
+        result = None
+        try:
+            result = str(obj)
+        except Exception as e:
+            print(f"{obj} str method failed with error: {e}")
+        return result

agentscope_runtime/sandbox/__init__.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+from .custom import *
+from .box.base.base_sandbox import BaseSandbox
+from .box.browser.browser_sandbox import BrowserSandbox
+from .box.filesystem.filesystem_sandbox import FilesystemSandbox
+from .box.training_box.training_box import TrainingSandbox
+
+
+__all__ = [
+    "BaseSandbox",
+    "BrowserSandbox",
+    "FilesystemSandbox",
+    "TrainingSandbox",
+]

agentscope_runtime/sandbox/box/base/base_sandbox.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
+
+
+@SandboxRegistry.register(
+    f"agentscope/runtime-sandbox-base:{IMAGE_TAG}",
+    sandbox_type=SandboxType.BASE,
+    security_level="medium",
+    timeout=30,
+    description="Base Sandbox",
+)
+class BaseSandbox(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.BASE,
+        )
+
+    def run_ipython_cell(self, code: str):
+        return self.call_tool("run_ipython_cell", {"code": code})
+
+    def run_shell_command(self, command: str):
+        return self.call_tool("run_shell_command", {"command": command})

agentscope_runtime/sandbox/box/browser/browser_sandbox.py

@@ -0,0 +1,176 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=too-many-public-methods
+from typing import Optional
+
+from ...constant import IMAGE_TAG
+from ...registry import SandboxRegistry
+from ...enums import SandboxType
+from ...box.sandbox import Sandbox
+
+
+@SandboxRegistry.register(
+    f"agentscope/runtime-sandbox-browser:{IMAGE_TAG}",
+    sandbox_type=SandboxType.BROWSER,
+    security_level="medium",
+    timeout=60,
+    description="Browser sandbox",
+)
+class BrowserSandbox(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.BROWSER,
+        )
+
+    def browser_close(self):
+        return self.call_tool("browser_close", {})
+
+    def browser_resize(self, width: int, height: int):
+        return self.call_tool(
+            "browser_resize",
+            {"width": width, "height": height},
+        )
+
+    def browser_console_messages(self):
+        return self.call_tool("browser_console_messages", {})
+
+    def browser_handle_dialog(self, accept: bool, prompt_text: str = ""):
+        return self.call_tool(
+            "browser_handle_dialog",
+            {"accept": accept, "promptText": prompt_text},
+        )
+
+    def browser_file_upload(self, paths: list):
+        return self.call_tool("browser_file_upload", {"paths": paths})
+
+    def browser_press_key(self, key: str):
+        return self.call_tool("browser_press_key", {"key": key})
+
+    def browser_navigate(self, url: str):
+        return self.call_tool("browser_navigate", {"url": url})
+
+    def browser_navigate_back(self):
+        return self.call_tool("browser_navigate_back", {})
+
+    def browser_navigate_forward(self):
+        return self.call_tool("browser_navigate_forward", {})
+
+    def browser_network_requests(self):
+        return self.call_tool("browser_network_requests", {})
+
+    def browser_pdf_save(self, filename: str = ""):
+        return self.call_tool("browser_pdf_save", {"filename": filename})
+
+    def browser_take_screenshot(
+        self,
+        raw: bool = False,
+        filename: str = "",
+        element: str = "",
+        ref: str = "",
+    ):
+        return self.call_tool(
+            "browser_take_screenshot",
+            {
+                "raw": raw,
+                "filename": filename,
+                "element": element,
+                "ref": ref,
+            },
+        )
+
+    def browser_snapshot(self):
+        return self.call_tool("browser_snapshot", {})
+
+    def browser_click(self, element: str, ref: str):
+        return self.call_tool(
+            "browser_click",
+            {"element": element, "ref": ref},
+        )
+
+    def browser_drag(
+        self,
+        start_element: str,
+        start_ref: str,
+        end_element: str,
+        end_ref: str,
+    ):
+        return self.call_tool(
+            "browser_drag",
+            {
+                "startElement": start_element,
+                "startRef": start_ref,
+                "endElement": end_element,
+                "endRef": end_ref,
+            },
+        )
+
+    def browser_hover(self, element: str, ref: str):
+        return self.call_tool(
+            "browser_hover",
+            {"element": element, "ref": ref},
+        )
+
+    def browser_type(
+        self,
+        element: str,
+        ref: str,
+        text: str,
+        submit: bool = False,
+        slowly: bool = False,
+    ):
+        return self.call_tool(
+            "browser_type",
+            {
+                "element": element,
+                "ref": ref,
+                "text": text,
+                "submit": submit,
+                "slowly": slowly,
+            },
+        )
+
+    def browser_select_option(self, element: str, ref: str, values: list):
+        return self.call_tool(
+            "browser_select_option",
+            {
+                "element": element,
+                "ref": ref,
+                "values": values,
+            },
+        )
+
+    def browser_tab_list(self):
+        return self.call_tool("browser_tab_list", {})
+
+    def browser_tab_new(self, url: str = ""):
+        return self.call_tool("browser_tab_new", {"url": url})
+
+    def browser_tab_select(self, index: int):
+        return self.call_tool("browser_tab_select", {"index": index})
+
+    def browser_tab_close(self, index: int = None):
+        return self.call_tool("browser_tab_close", {"index": index})
+
+    def browser_wait_for(
+        self,
+        time: float = None,
+        text: str = None,
+        text_gone: str = None,
+    ):
+        return self.call_tool(
+            "browser_wait_for",
+            {
+                "time": time,
+                "text": text,
+                "textGone": text_gone,
+            },
+        )

agentscope_runtime/sandbox/box/dummy/dummy_sandbox.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+from typing import Optional
+
+from ...registry import SandboxRegistry
+from ...enums import SandboxType
+from ...box.sandbox import Sandbox
+
+
+@SandboxRegistry.register(
+    "",
+    sandbox_type=SandboxType.DUMMY,
+    security_level="low",
+    timeout=30,
+    description="Dummy Sandbox",
+)
+class DummySandbox(Sandbox):
+    def __init__(
+        self,
+        sandbox_id: Optional[str] = None,
+        timeout: int = 3000,
+        base_url: Optional[str] = None,
+        bearer_token: Optional[str] = None,
+        sandbox_type: SandboxType = SandboxType.DUMMY,
+    ):
+        self._sandbox_id = sandbox_id
+        self.sandbox_type = sandbox_type