agentscope-runtime 1.0.4a1__py3-none-any.whl → 1.0.5__py3-none-any.whl

agentscope_runtime/engine/services/memory/redis_memory_service.py

@@ -30,25 +30,24 @@ class RedisMemoryService(MemoryService):
         Initialize RedisMemoryService.
 
         Args:
-            redis_url: Redis connection URL
-            redis_client: Optional pre-configured Redis client
-            socket_timeout: Socket timeout in seconds (default: 5.0)
+            redis_url: Redis connection URL.
+            redis_client: Optional pre-configured Redis client.
+            socket_timeout: Socket timeout in seconds (default: 5.0).
             socket_connect_timeout: Socket connect timeout in seconds
-             (default: 5.0)
+                (default: 5.0).
             max_connections: Maximum number of connections in the pool
-             (default: None)
-            retry_on_timeout: Whether to retry on timeout (default: True)
-            ttl_seconds: Time-to-live in seconds for memory data.
-            If None, data never expires (default: 3600, i.e., 1 hour)
+                (default: None).
+            retry_on_timeout: Whether to retry on timeout (default: True).
+            ttl_seconds: Time-to-live in seconds for memory data. If None,
+                data never expires (default: 3600, i.e., 1 hour).
             max_messages_per_session: Maximum number of messages stored per
-             session_id field within a user's Redis memory hash.
-             If None, no limit (default: None)
-            health_check_interval: Interval in seconds for health checks
-             on idle connections (default: 30.0).
-                Connections idle longer than this will be checked before reuse.
-                Set to 0 to disable.
-            socket_keepalive: Enable TCP keepalive to prevent
-            silent disconnections (default: True)
+                session_id field within a user's Redis memory hash. If None,
+                no limit (default: None).
+            health_check_interval: Interval in seconds for health checks on
+                idle connections (default: 30.0). Connections idle longer
+                than this will be checked before reuse. Set to 0 to disable.
+            socket_keepalive: Enable TCP keepalive to prevent silent
+                disconnections (default: True).
         """
         self._redis_url = redis_url
         self._redis = redis_client

agentscope_runtime/engine/services/session_history/__init__.py

@@ -1,6 +1,13 @@
 # -*- coding: utf-8 -*-
 from typing import TYPE_CHECKING
 from ....common.utils.lazy_loader import install_lazy_loader
+from ....common.utils.deprecation import deprecated_module
+
+deprecated_module(
+    module_name=__name__,
+    removed_in="v1.1",
+    alternative="agentscope.memory",
+)
 
 if TYPE_CHECKING:
     from .session_history_service import (

agentscope_runtime/engine/tracing/local_logging_handler.py

@@ -7,7 +7,7 @@ from datetime import datetime
 from logging.handlers import RotatingFileHandler
 from typing import Any, Dict, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 from . import TracingUtil
 from .base import TracerHandler
@@ -39,8 +39,7 @@ class LogContext(BaseModel):
     ds_service_id: str = ""
     ds_service_name: str = ""
 
-    class Config:
-        extra = "ignore"  # ignore additional key
+    model_config = ConfigDict(extra="allow")
 
 
 class JsonFormatter(logging.Formatter):

agentscope_runtime/engine/tracing/wrapper.py

@@ -26,7 +26,11 @@ from typing import (
 from pydantic import BaseModel
 from opentelemetry.propagate import extract
 from opentelemetry.context import attach
-from opentelemetry.trace import StatusCode, NoOpTracerProvider
+from opentelemetry.trace import (
+    ProxyTracerProvider,
+    StatusCode,
+    NoOpTracerProvider,
+)
 from opentelemetry import trace as ot_trace
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
     OTLPSpanExporter as OTLPSpanGrpcExporter,
@@ -917,12 +921,22 @@ def _get_ot_tracer() -> ot_trace.Tracer:
         ot_trace.Tracer: The OpenTelemetry tracer instance.
     """
 
-    def _get_ot_tracer_inner() -> ot_trace.Tracer:
+    def _has_existing_trace_provider() -> bool:
+        from opentelemetry.trace import _TRACER_PROVIDER
+
         existing_provider = ot_trace.get_tracer_provider()
+        if isinstance(existing_provider, NoOpTracerProvider):
+            return False
+        elif isinstance(existing_provider, ProxyTracerProvider):
+            # ProxyTracerProvider will use the _TRACER_PROVIDER as real tracer
+            # provider to get the tracer
+            return bool(_TRACER_PROVIDER)
 
-        if not isinstance(existing_provider, NoOpTracerProvider):
-            return ot_trace.get_tracer("agentscope_runtime")
+        return True
 
+    def _get_ot_tracer_inner() -> ot_trace.Tracer:
+        if _has_existing_trace_provider():
+            return ot_trace.get_tracer("agentscope_runtime")
         resource = Resource(
             attributes={
                 SERVICE_NAME: _get_service_name(),

agentscope_runtime/sandbox/__init__.py

@@ -3,22 +3,30 @@
 # This ensures SandboxRegistry.register() runs at import time.
 # Without this, lazy loading delays module import and types may not be
 # registered.
-from .box.base.base_sandbox import BaseSandbox
-from .box.browser.browser_sandbox import BrowserSandbox
-from .box.filesystem.filesystem_sandbox import FilesystemSandbox
-from .box.gui.gui_sandbox import GuiSandbox
+from .box.base.base_sandbox import BaseSandbox, BaseSandboxAsync
+from .box.browser.browser_sandbox import BrowserSandbox, BrowserSandboxAsync
+from .box.filesystem.filesystem_sandbox import (
+    FilesystemSandbox,
+    FilesystemSandboxAsync,
+)
+from .box.gui.gui_sandbox import GuiSandbox, GuiSandboxAsync
+from .box.mobile.mobile_sandbox import MobileSandbox, MobileSandboxAsync
 from .box.training_box.training_box import TrainingSandbox
 from .box.cloud.cloud_sandbox import CloudSandbox
-from .box.mobile.mobile_sandbox import MobileSandbox
 from .box.agentbay.agentbay_sandbox import AgentbaySandbox
 
 __all__ = [
     "BaseSandbox",
+    "BaseSandboxAsync",
     "BrowserSandbox",
+    "BrowserSandboxAsync",
     "FilesystemSandbox",
+    "FilesystemSandboxAsync",
     "GuiSandbox",
+    "GuiSandboxAsync",
+    "MobileSandbox",
+    "MobileSandboxAsync",
     "TrainingSandbox",
     "CloudSandbox",
-    "MobileSandbox",
     "AgentbaySandbox",
 ]

agentscope_runtime/sandbox/box/base/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
-from .base_sandbox import BaseSandbox
+from .base_sandbox import BaseSandbox, BaseSandboxAsync
 
-__all__ = ["BaseSandbox"]
+__all__ = ["BaseSandbox", "BaseSandboxAsync"]

agentscope_runtime/sandbox/box/base/base_sandbox.py

@@ -4,7 +4,7 @@ from typing import Optional
 from ...utils import build_image_uri
 from ...registry import SandboxRegistry
 from ...enums import SandboxType
-from ...box.sandbox import Sandbox
+from ...box.sandbox import Sandbox, SandboxAsync
 from ...constant import TIMEOUT
 
 
@@ -49,3 +49,53 @@ class BaseSandbox(Sandbox):
             command (str): Shell command to execute.
         """
         return self.call_tool("run_shell_command", {"command": command})
+
+
+@SandboxRegistry.register(
+    build_image_uri("runtime-sandbox-base"),
+    sandbox_type=SandboxType.BASE_ASYNC,
+    security_level="medium",
+    timeout=TIMEOUT,
+    description="Base Sandbox (Async)",
+)
+class BaseSandboxAsync(SandboxAsync):
+    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.BASE_ASYNC,
+    ):
+        super().__init__(
+            sandbox_id,
+            timeout,
+            base_url,
+            bearer_token,
+            sandbox_type,
+        )
+
+    async def run_ipython_cell(self, code: str):
+        """
+        Run an IPython cell asynchronously.
+
+        Args:
+            code (str): IPython code to execute.
+        Returns:
+            Any: Response from sandbox execution
+        """
+        return await self.call_tool_async("run_ipython_cell", {"code": code})
+
+    async def run_shell_command(self, command: str):
+        """
+        Run a shell command asynchronously.
+
+        Args:
+            command (str): Shell command to execute.
+        Returns:
+            Any: Response from sandbox execution
+        """
+        return await self.call_tool_async(
+            "run_shell_command",
+            {"command": command},
+        )

agentscope_runtime/sandbox/box/browser/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
-from .browser_sandbox import BrowserSandbox
+from .browser_sandbox import BrowserSandbox, BrowserSandboxAsync
 
-__all__ = ["BrowserSandbox"]
+__all__ = ["BrowserSandbox", "BrowserSandboxAsync"]

agentscope_runtime/sandbox/box/browser/browser_sandbox.py

@@ -6,8 +6,8 @@ from urllib.parse import urlparse, urlunparse
 from ...utils import build_image_uri
 from ...registry import SandboxRegistry
 from ...enums import SandboxType
-from ...box.base import BaseSandbox
-from ...box.gui import GUIMixin
+from ...box.base import BaseSandbox, BaseSandboxAsync
+from ...box.gui import GUIMixin, AsyncGUIMixin
 from ...constant import TIMEOUT
 
 
@@ -299,3 +299,199 @@ class BrowserSandbox(GUIMixin, BaseSandbox):
                 "textGone": text_gone,
             },
         )
+
+
+@SandboxRegistry.register(
+    build_image_uri("runtime-sandbox-browser"),
+    sandbox_type=SandboxType.BROWSER_ASYNC,
+    security_level="medium",
+    timeout=TIMEOUT,
+    description="Browser sandbox (Async)",
+)
+class BrowserSandboxAsync(GUIMixin, AsyncGUIMixin, BaseSandboxAsync):
+    def __init__(  # pylint: disable=useless-parent-delegation
+        self,
+        sandbox_id: Optional[str] = None,
+        timeout: int = 3000,
+        base_url: Optional[str] = None,
+        bearer_token: Optional[str] = None,
+        sandbox_type: SandboxType = SandboxType.BROWSER_ASYNC,
+    ):
+        super().__init__(
+            sandbox_id,
+            timeout,
+            base_url,
+            bearer_token,
+            sandbox_type,
+        )
+
+    async def browser_close(self):
+        """Close the current browser page."""
+        return await self.call_tool_async("browser_close", {})
+
+    async def browser_resize(self, width: int, height: int):
+        """Resize the browser window."""
+        return await self.call_tool_async(
+            "browser_resize",
+            {"width": width, "height": height},
+        )
+
+    async def browser_console_messages(self):
+        """Return all console messages from the browser."""
+        return await self.call_tool_async("browser_console_messages", {})
+
+    async def browser_handle_dialog(self, accept: bool, prompt_text: str = ""):
+        """Handle a dialog popup."""
+        return await self.call_tool_async(
+            "browser_handle_dialog",
+            {"accept": accept, "promptText": prompt_text},
+        )
+
+    async def browser_file_upload(self, paths: list):
+        """Upload one or multiple files."""
+        return await self.call_tool_async(
+            "browser_file_upload",
+            {"paths": paths},
+        )
+
+    async def browser_press_key(self, key: str):
+        """Press a key in the browser."""
+        return await self.call_tool_async("browser_press_key", {"key": key})
+
+    async def browser_navigate(self, url: str):
+        """Navigate to a URL."""
+        return await self.call_tool_async("browser_navigate", {"url": url})
+
+    async def browser_navigate_back(self):
+        """Go back in browser history."""
+        return await self.call_tool_async("browser_navigate_back", {})
+
+    async def browser_navigate_forward(self):
+        """Go forward in browser history."""
+        return await self.call_tool_async("browser_navigate_forward", {})
+
+    async def browser_network_requests(self):
+        """Return network requests."""
+        return await self.call_tool_async("browser_network_requests", {})
+
+    async def browser_pdf_save(self, filename: str = ""):
+        """Save page as a PDF."""
+        return await self.call_tool_async(
+            "browser_pdf_save",
+            {"filename": filename},
+        )
+
+    async def browser_take_screenshot(
+        self,
+        raw=False,
+        filename="",
+        element="",
+        ref="",
+    ):
+        """Take a screenshot."""
+        return await self.call_tool_async(
+            "browser_take_screenshot",
+            {"raw": raw, "filename": filename, "element": element, "ref": ref},
+        )
+
+    async def browser_snapshot(self):
+        """Accessibility snapshot."""
+        return await self.call_tool_async("browser_snapshot", {})
+
+    async def browser_click(self, element: str, ref: str):
+        """Click an element."""
+        return await self.call_tool_async(
+            "browser_click",
+            {"element": element, "ref": ref},
+        )
+
+    async def browser_drag(
+        self,
+        start_element: str,
+        start_ref: str,
+        end_element: str,
+        end_ref: str,
+    ):
+        """Drag and drop."""
+        return await self.call_tool_async(
+            "browser_drag",
+            {
+                "startElement": start_element,
+                "startRef": start_ref,
+                "endElement": end_element,
+                "endRef": end_ref,
+            },
+        )
+
+    async def browser_hover(self, element: str, ref: str):
+        """Hover over an element."""
+        return await self.call_tool_async(
+            "browser_hover",
+            {"element": element, "ref": ref},
+        )
+
+    async def browser_type(
+        self,
+        element: str,
+        ref: str,
+        text: str,
+        submit=False,
+        slowly=False,
+    ):
+        """Type text into an element."""
+        return await self.call_tool_async(
+            "browser_type",
+            {
+                "element": element,
+                "ref": ref,
+                "text": text,
+                "submit": submit,
+                "slowly": slowly,
+            },
+        )
+
+    async def browser_select_option(
+        self,
+        element: str,
+        ref: str,
+        values: list,
+    ):
+        """Select options in a dropdown."""
+        return await self.call_tool_async(
+            "browser_select_option",
+            {"element": element, "ref": ref, "values": values},
+        )
+
+    async def browser_tab_list(self):
+        """List all tabs."""
+        return await self.call_tool_async("browser_tab_list", {})
+
+    async def browser_tab_new(self, url: str = ""):
+        """Open a new tab."""
+        return await self.call_tool_async("browser_tab_new", {"url": url})
+
+    async def browser_tab_select(self, index: int):
+        """Select tab by index."""
+        return await self.call_tool_async(
+            "browser_tab_select",
+            {"index": index},
+        )
+
+    async def browser_tab_close(self, index: int = None):
+        """Close a tab."""
+        return await self.call_tool_async(
+            "browser_tab_close",
+            {"index": index},
+        )
+
+    async def browser_wait_for(
+        self,
+        time: float = None,
+        text: str = None,
+        text_gone: str = None,
+    ):
+        """Wait for text or time."""
+        return await self.call_tool_async(
+            "browser_wait_for",
+            {"time": time, "text": text, "textGone": text_gone},
+        )

agentscope_runtime/sandbox/box/filesystem/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
-from .filesystem_sandbox import FilesystemSandbox
+from .filesystem_sandbox import FilesystemSandbox, FilesystemSandboxAsync
 
-__all__ = ["FilesystemSandbox"]
+__all__ = ["FilesystemSandbox", "FilesystemSandboxAsync"]

agentscope_runtime/sandbox/box/filesystem/filesystem_sandbox.py

@@ -5,8 +5,8 @@ from typing import Optional
 from ...utils import build_image_uri
 from ...registry import SandboxRegistry
 from ...enums import SandboxType
-from ...box.base import BaseSandbox
-from ...box.gui import GUIMixin
+from ...box.base import BaseSandbox, BaseSandboxAsync
+from ...box.gui import GUIMixin, AsyncGUIMixin
 from ...constant import TIMEOUT
 
 
@@ -154,3 +154,100 @@ class FilesystemSandbox(GUIMixin, BaseSandbox):
         Returns the list of directories that this serveris allowed to access.
         """
         return self.call_tool("list_allowed_directories", {})
+
+
+@SandboxRegistry.register(
+    build_image_uri("runtime-sandbox-filesystem"),
+    sandbox_type=SandboxType.FILESYSTEM_ASYNC,
+    security_level="medium",
+    timeout=TIMEOUT,
+    description="Filesystem sandbox (Async)",
+)
+class FilesystemSandboxAsync(GUIMixin, AsyncGUIMixin, BaseSandboxAsync):
+    def __init__(  # pylint: disable=useless-parent-delegation
+        self,
+        sandbox_id: Optional[str] = None,
+        timeout: int = 3000,
+        base_url: Optional[str] = None,
+        bearer_token: Optional[str] = None,
+        sandbox_type: SandboxType = SandboxType.FILESYSTEM_ASYNC,
+    ):
+        super().__init__(
+            sandbox_id,
+            timeout,
+            base_url,
+            bearer_token,
+            sandbox_type,
+        )
+
+    async def read_file(self, path: str):
+        """Read the complete contents of a file."""
+        return await self.call_tool_async("read_file", {"path": path})
+
+    async def read_multiple_files(self, paths: list):
+        """Read the contents of multiple files simultaneously."""
+        return await self.call_tool_async(
+            "read_multiple_files",
+            {"paths": paths},
+        )
+
+    async def write_file(self, path: str, content: str):
+        """Create or overwrite a file with new content."""
+        return await self.call_tool_async(
+            "write_file",
+            {"path": path, "content": content},
+        )
+
+    async def edit_file(self, path: str, edits: list, dry_run: bool = False):
+        """Make line-based edits to a text file."""
+        return await self.call_tool_async(
+            "edit_file",
+            {
+                "path": path,
+                "edits": edits,
+                "dryRun": dry_run,
+            },
+        )
+
+    async def create_directory(self, path: str):
+        """Create a new directory or ensure it exists."""
+        return await self.call_tool_async("create_directory", {"path": path})
+
+    async def list_directory(self, path: str):
+        """Get a detailed listing of all files and directories."""
+        return await self.call_tool_async("list_directory", {"path": path})
+
+    async def directory_tree(self, path: str):
+        """Get a recursive tree view of files and directories as JSON."""
+        return await self.call_tool_async("directory_tree", {"path": path})
+
+    async def move_file(self, source: str, destination: str):
+        """Move or rename files and directories."""
+        return await self.call_tool_async(
+            "move_file",
+            {"source": source, "destination": destination},
+        )
+
+    async def search_files(
+        self,
+        path: str,
+        pattern: str,
+        exclude_patterns: list = [],
+    ):
+        """Recursively search for files and directories matching a pattern."""
+        return await self.call_tool_async(
+            "search_files",
+            {
+                "path": path,
+                "pattern": pattern,
+                "excludePatterns": exclude_patterns,
+            },
+        )
+
+    async def get_file_info(self, path: str):
+        """Retrieve metadata about a file or directory."""
+        return await self.call_tool_async("get_file_info", {"path": path})
+
+    async def list_allowed_directories(self):
+        """Returns directories this server can access."""
+        return await self.call_tool_async("list_allowed_directories", {})

agentscope_runtime/sandbox/box/gui/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
-from .gui_sandbox import GuiSandbox, GUIMixin
+from .gui_sandbox import GuiSandbox, GuiSandboxAsync, GUIMixin, AsyncGUIMixin
 
-__all__ = ["GuiSandbox", "GUIMixin"]
+__all__ = ["GuiSandbox", "GuiSandboxAsync", "GUIMixin", "AsyncGUIMixin"]