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

agentscope_runtime/engine/services/{tablestore_memory_service.py → memory/tablestore_memory_service.py}

@@ -5,25 +5,19 @@ import copy
 from enum import Enum
 from typing import Any, Dict, List, Optional
 
-try:
-    import tablestore
-    from langchain_community.embeddings import DashScopeEmbeddings
-    from langchain_core.embeddings import Embeddings
-    from tablestore import AsyncOTSClient as AsyncTablestoreClient
-    from tablestore import VectorMetricType
-    from tablestore_for_agent_memory.base.filter import Filters
-    from tablestore_for_agent_memory.knowledge.async_knowledge_store import (
-        AsyncKnowledgeStore,
-    )
-except ImportError as e:
-    raise ImportError(
-        "aliyun_tablestore is not available. "
-        "Please run pip install agentscope-runtime[aliyun_tablestore_ext]",
-    ) from e
-
-from ..schemas.agent_schemas import Message, MessageType
+import tablestore
+from langchain_community.embeddings import DashScopeEmbeddings
+from langchain_core.embeddings import Embeddings
+from tablestore import AsyncOTSClient as AsyncTablestoreClient
+from tablestore import VectorMetricType
+from tablestore_for_agent_memory.base.filter import Filters
+from tablestore_for_agent_memory.knowledge.async_knowledge_store import (
+    AsyncKnowledgeStore,
+)
+
+from ...schemas.agent_schemas import Message, MessageType
 from .memory_service import MemoryService
-from .utils.tablestore_service_utils import (
+from ..utils.tablestore_service_utils import (
     convert_messages_to_tablestore_documents,
     convert_tablestore_document_to_message,
     get_message_metadata_names,
@@ -51,7 +45,7 @@ class TablestoreMemoryService(MemoryService):
         self,
         tablestore_client: AsyncTablestoreClient,
         search_strategy: SearchStrategy = SearchStrategy.FULL_TEXT,
-        embedding_model: Optional[Embeddings] = DashScopeEmbeddings(),
+        embedding_model: Optional[Embeddings] = None,
         vector_dimension: int = 1536,
         table_name: Optional[str] = "agentscope_runtime_memory",
         search_index_schema: Optional[List[tablestore.FieldSchema]] = (
@@ -63,6 +57,9 @@ class TablestoreMemoryService(MemoryService):
         vector_metric_type: VectorMetricType = VectorMetricType.VM_COSINE,
         **kwargs: Any,
     ):
+        if embedding_model is None:
+            embedding_model = DashScopeEmbeddings()
+
         self._search_strategy = search_strategy
         self._embedding_model = (
             embedding_model  # the parameter is None, don't store vector.

agentscope_runtime/engine/services/sandbox/__init__.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+from typing import TYPE_CHECKING
+from ....common.utils.lazy_loader import install_lazy_loader
+
+if TYPE_CHECKING:
+    from .sandbox_service import SandboxService
+
+install_lazy_loader(
+    globals(),
+    {
+        "SandboxService": ".sandbox_service",
+    },
+)

agentscope_runtime/engine/services/{sandbox_service.py → sandbox/sandbox_service.py}

@@ -1,31 +1,34 @@
 # -*- coding: utf-8 -*-
-# pylint: disable=too-many-branches
-from typing import List
+# mypy: disable-error-code="list-item"
+from typing import List, Optional
 
-from ...sandbox.enums import SandboxType
-from ...sandbox.manager import SandboxManager
-from ...sandbox.registry import SandboxRegistry
-from ...sandbox.tools.mcp_tool import MCPTool
-from ...sandbox.tools.sandbox_tool import SandboxTool
-from ...sandbox.tools.function_tool import FunctionTool
-from ...engine.services.base import ServiceWithLifecycleManager
+from ....sandbox.enums import SandboxType
+from ....sandbox.manager import SandboxManager
+from ....sandbox.registry import SandboxRegistry
+from ....engine.services.base import ServiceWithLifecycleManager
 
 
 class SandboxService(ServiceWithLifecycleManager):
     def __init__(self, base_url=None, bearer_token=None):
-        self.manager_api = SandboxManager(
-            base_url=base_url,
-            bearer_token=bearer_token,
-        )
-
+        self.manager_api = None
         self.base_url = base_url
         self.bearer_token = bearer_token
+        self._health = False
 
     async def start(self) -> None:
-        pass
+        if self.manager_api is None:
+            self.manager_api = SandboxManager(
+                base_url=self.base_url,
+                bearer_token=self.bearer_token,
+            )
+        self._health = True
 
     async def stop(self) -> None:
         # Release all environments
+        if self.manager_api is None:
+            self._health = False
+            return
+
         session_keys = self.manager_api.list_session_keys()
 
         if session_keys:
@@ -39,15 +42,16 @@ class SandboxService(ServiceWithLifecycleManager):
             # Embedded mode
             self.manager_api.cleanup()
 
+        self.manager_api = None
+
     async def health(self) -> bool:
-        return True
+        return self._health
 
     def connect(
         self,
-        session_id,
-        user_id,
-        env_types=None,
-        tools=None,
+        session_id: str,
+        user_id: Optional[str] = None,
+        sandbox_types=None,
     ) -> List:
         # Create a composite key
         session_ctx_id = self._create_session_ctx_id(session_id, user_id)
@@ -62,49 +66,32 @@ class SandboxService(ServiceWithLifecycleManager):
             # Create a new environment
             return self._create_new_environment(
                 session_ctx_id,
-                env_types,
-                tools,
+                sandbox_types,
             )
 
     def _create_new_environment(
         self,
         session_ctx_id: str,
-        env_types=None,
-        tools=None,
+        sandbox_types: Optional[List[str]] = None,
     ):
-        if tools:
-            for tool in tools:
-                if not isinstance(tool, (SandboxTool, FunctionTool, MCPTool)):
-                    raise ValueError(
-                        "tools must be instances of SandboxTool, "
-                        "FunctionTool, or MCPTool",
-                    )
-
-        if env_types is None:
-            assert (
-                tools is not None
-            ), "tools must be specified when env_types is not set"
-
-        if tools:
-            tool_env_types = set()
-            for tool in tools:
-                tool_env_types.add(tool.sandbox_type)
-            if env_types is None:
-                env_types = []
-
-            env_types = set(env_types) | tool_env_types
+        if sandbox_types is None:
+            sandbox_types = [SandboxType.BASE]
 
         sandboxes = []
-        for env_type in env_types:
+        for env_type in sandbox_types:
             if env_type is None:
                 continue
 
             box_type = SandboxType(env_type)
 
-            box_id = self.manager_api.create_from_pool(
-                sandbox_type=box_type.value,
-                meta={"session_ctx_id": session_ctx_id},
-            )
+            if box_type != SandboxType.AGENTBAY:
+                box_id = self.manager_api.create_from_pool(
+                    sandbox_type=box_type.value,
+                    meta={"session_ctx_id": session_ctx_id},
+                )
+            else:
+                box_id = None
+
             box_cls = SandboxRegistry.get_classes_by_type(box_type)
 
             box = box_cls(
@@ -119,32 +106,38 @@ class SandboxService(ServiceWithLifecycleManager):
                 # Embedded mode
                 box.manager_api = self.manager_api
 
-            # Add MCP to the sandbox
-            server_config_list = []
-            if tools:
-                for tool in tools:
-                    if isinstance(tool, MCPTool) and SandboxType(
-                        tool.sandbox_type,
-                    ) == SandboxType(box_type):
-                        server_config_list.append(tool.server_configs)
-            if server_config_list:
-                server_configs = {"mcpServers": {}}
-                for server_config in server_config_list:
-                    if (
-                        server_config is not None
-                        and "mcpServers" in server_config
-                    ):
-                        server_configs["mcpServers"].update(
-                            server_config["mcpServers"],
-                        )
-                box.add_mcp_servers(server_configs, overwrite=False)
-
             sandboxes.append(box)
         return sandboxes
 
     def _connect_existing_environment(self, env_ids: List[str]):
         boxes = []
         for env_id in env_ids:
+            # Check if this is an AgentBay session ID
+            if self._is_agentbay_session_id(env_id):
+                try:
+                    from ....sandbox.box.agentbay.agentbay_sandbox import (
+                        AgentbaySandbox,
+                    )
+
+                    # Connect to existing AgentBay session
+                    sandbox = AgentbaySandbox(
+                        sandbox_id=env_id,
+                        base_url=self.base_url,
+                        bearer_token=self.bearer_token,
+                        sandbox_type=SandboxType.AGENTBAY,
+                    )
+                    boxes.append(sandbox)
+                    continue
+                except Exception as e:
+                    import logging
+
+                    logger = logging.getLogger(__name__)
+                    logger.error(
+                        f"Failed to connect to AgentBay session {env_id}: {e}",
+                    )
+                    continue
+
+            # Standard sandbox connection
             info = self.manager_api.get_info(env_id)
             version = info.get("version", "")
 
@@ -174,17 +167,39 @@ class SandboxService(ServiceWithLifecycleManager):
 
         return boxes
 
-    def release(self, session_id, user_id):
+    def _is_agentbay_session_id(self, session_id: str) -> bool:
+        """
+        Check if a session ID belongs to AgentBay.
+
+        AgentBay session IDs typically start with 'session-' prefix.
+
+        Args:
+            session_id: Session ID to check
+
+        Returns:
+            True if this appears to be an AgentBay session ID
+        """
+        return session_id.startswith("session-")
+
+    def release(self, session_id, user_id=None):
         session_ctx_id = self._create_session_ctx_id(session_id, user_id)
 
         env_ids = self.manager_api.get_session_mapping(session_ctx_id)
 
         if env_ids:
             for env_id in env_ids:
+                # Check if this is an AgentBay session
+                if self._is_agentbay_session_id(env_id):
+                    # AgentBay sessions are cleaned up automatically
+                    # when the sandbox object is destroyed
+                    continue
+                # Standard sandbox release
                 self.manager_api.release(env_id)
 
         return True
 
     def _create_session_ctx_id(self, session_id, user_id):
         # Create a composite key from session_id and user_id
+        if user_id is None:
+            return session_id
         return f"{session_id}_{user_id}"

agentscope_runtime/engine/services/session_history/__init__.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+from typing import TYPE_CHECKING
+from ....common.utils.lazy_loader import install_lazy_loader
+
+if TYPE_CHECKING:
+    from .session_history_service import (
+        SessionHistoryService,
+        InMemorySessionHistoryService,
+    )
+    from .redis_session_history_service import RedisSessionHistoryService
+    from .tablestore_session_history_service import (
+        TablestoreSessionHistoryService,
+    )
+
+install_lazy_loader(
+    globals(),
+    {
+        "SessionHistoryService": ".session_history_service",
+        "InMemorySessionHistoryService": ".session_history_service",
+        "RedisSessionHistoryService": ".redis_session_history_service",
+        "TablestoreSessionHistoryService": ".tablestore_session_history_service",  # noqa
+    },
+)

agentscope_runtime/engine/services/{redis_session_history_service.py → session_history/redis_session_history_service.py}

@@ -5,8 +5,9 @@ from typing import Optional, Dict, Any, List, Union
 
 import redis.asyncio as aioredis
 
-from .session_history_service import SessionHistoryService, Session
-from ..schemas.agent_schemas import Message
+from .session_history_service import SessionHistoryService
+from ...schemas.session import Session
+from ...schemas.agent_schemas import Message
 
 
 class RedisSessionHistoryService(SessionHistoryService):

agentscope_runtime/engine/services/{session_history_service.py → session_history/session_history_service.py}

@@ -4,28 +4,9 @@ import uuid
 from abc import abstractmethod
 from typing import List, Dict, Optional, Union, Any
 
-from pydantic import BaseModel
-
-from .base import ServiceWithLifecycleManager
-from ..schemas.agent_schemas import Message
-
-
-class Session(BaseModel):
-    """Represents a single conversation session.
-
-    A session contains the history of a conversation, including all
-    messages, and is uniquely identified by its ID.
-
-    Attributes:
-        id: The unique identifier for the session.
-        user_id: The identifier of the user who owns the session.
-        messages: A list of messages formatted for Agent response
-
-    """
-
-    id: str
-    user_id: str
-    messages: List[Union[Message, Dict[str, Any]]] = []
+from ..base import ServiceWithLifecycleManager
+from ...schemas.session import Session
+from ...schemas.agent_schemas import Message
 
 
 class SessionHistoryService(ServiceWithLifecycleManager):
@@ -42,9 +23,6 @@ class SessionHistoryService(ServiceWithLifecycleManager):
     async def stop(self) -> None:
         pass
 
-    async def health(self) -> bool:
-        return True
-
     @abstractmethod
     async def create_session(
         self,
@@ -124,13 +102,31 @@ class InMemorySessionHistoryService(SessionHistoryService):
     for development, testing, and scenarios where persistence is not required.
 
     Attributes:
-        _sessions: A dictionary holding all session objects, keyed by user ID
+        _store: A dictionary holding all session objects, keyed by user ID
             and then by session ID.
     """
 
     def __init__(self) -> None:
         """Initializes the InMemorySessionHistoryService."""
-        self._sessions: Dict[str, Dict[str, Session]] = {}
+        self._store: Optional[Dict[str, Dict[str, Session]]] = None
+        self._health = False
+
+    async def start(self) -> None:
+        """Initialize the in-memory store."""
+        if self._store is None:
+            self._store = {}
+        self._health = True
+
+    async def stop(self) -> None:
+        """Clear all in-memory data."""
+        if self._store is not None:
+            self._store.clear()
+        self._store = None
+        self._health = False
+
+    async def health(self) -> bool:
+        """Service health check: always True."""
+        return self._health
 
     async def create_session(
         self,
@@ -146,13 +142,16 @@ class InMemorySessionHistoryService(SessionHistoryService):
         Returns:
             A deep copy of the newly created Session object.
         """
+        if self._store is None:
+            raise RuntimeError("Service not started")
+
         session_id = (
             session_id.strip()
             if session_id and session_id.strip()
             else str(uuid.uuid4())
         )
         session = Session(id=session_id, user_id=user_id)
-        self._sessions.setdefault(user_id, {})[session_id] = session
+        self._store.setdefault(user_id, {})[session_id] = session
         return copy.deepcopy(session)
 
     async def get_session(
@@ -169,11 +168,13 @@ class InMemorySessionHistoryService(SessionHistoryService):
         Returns:
             A deep copy of the Session object if found, otherwise None.
         """
+        if self._store is None:
+            raise RuntimeError("Service not started")
 
-        session = self._sessions.get(user_id, {}).get(session_id)
+        session = self._store.get(user_id, {}).get(session_id)
         if not session:
             session = Session(id=session_id, user_id=user_id)
-            self._sessions.setdefault(user_id, {})[session_id] = session
+            self._store.setdefault(user_id, {})[session_id] = session
         return copy.deepcopy(session) if session else None
 
     async def delete_session(self, user_id: str, session_id: str) -> None:
@@ -185,8 +186,11 @@ class InMemorySessionHistoryService(SessionHistoryService):
             user_id: The identifier for the user.
             session_id: The identifier for the session to delete.
         """
-        if user_id in self._sessions and session_id in self._sessions[user_id]:
-            del self._sessions[user_id][session_id]
+        if self._store is None:
+            raise RuntimeError("Service not started")
+
+        if user_id in self._store and session_id in self._store[user_id]:
+            del self._store[user_id][session_id]
 
     async def list_sessions(self, user_id: str) -> list[Session]:
         """Lists all sessions for a given user.
@@ -200,7 +204,10 @@ class InMemorySessionHistoryService(SessionHistoryService):
         Returns:
             A list of Session objects belonging to the user, without history.
         """
-        user_sessions = self._sessions.get(user_id, {})
+        if self._store is None:
+            raise RuntimeError("Service not started")
+
+        user_sessions = self._store.get(user_id, {})
         # Return sessions without their potentially large history for
         # efficiency.
         sessions_without_history = []
@@ -232,6 +239,9 @@ class InMemorySessionHistoryService(SessionHistoryService):
             message: The message or list of messages to append to the
                 session's history.
         """
+        if self._store is None:
+            raise RuntimeError("Service not started")
+
         # Normalize to list
         if not isinstance(message, list):
             message = [message]
@@ -245,7 +255,7 @@ class InMemorySessionHistoryService(SessionHistoryService):
         session.messages.extend(norm_message)
 
         # update the in memory copy
-        storage_session = self._sessions.get(session.user_id, {}).get(
+        storage_session = self._store.get(session.user_id, {}).get(
             session.id,
         )
         if storage_session:

agentscope_runtime/engine/services/{tablestore_session_history_service.py → session_history/tablestore_session_history_service.py}

@@ -4,25 +4,20 @@ import asyncio
 import uuid
 from typing import Any, Dict, List, Optional, Union
 
-try:
-    import tablestore
-    from tablestore import AsyncOTSClient as AsyncTablestoreClient
-    from tablestore_for_agent_memory.base.base_memory_store import (
-        Session as TablestoreSession,
-    )
-    from tablestore_for_agent_memory.base.common import MetaType, Order
-    from tablestore_for_agent_memory.memory.async_memory_store import (
-        AsyncMemoryStore,
-    )
-except ImportError as e:
-    raise ImportError(
-        "aliyun_tablestore is not available. "
-        "Please run pip install agentscope-runtime[aliyun_tablestore_ext]",
-    ) from e
-
-from ..schemas.agent_schemas import Message
-from .session_history_service import Session, SessionHistoryService
-from .utils.tablestore_service_utils import (
+import tablestore
+from tablestore import AsyncOTSClient as AsyncTablestoreClient
+from tablestore_for_agent_memory.base.base_memory_store import (
+    Session as TablestoreSession,
+)
+from tablestore_for_agent_memory.base.common import MetaType, Order
+from tablestore_for_agent_memory.memory.async_memory_store import (
+    AsyncMemoryStore,
+)
+
+from .session_history_service import SessionHistoryService
+from ...schemas.agent_schemas import Message
+from ...schemas.session import Session
+from ..utils.tablestore_service_utils import (
     convert_message_to_tablestore_message,
     convert_tablestore_session_to_session,
     tablestore_log,

agentscope_runtime/engine/services/utils/tablestore_service_utils.py

@@ -17,8 +17,8 @@ from tablestore_for_agent_memory.base.base_memory_store import (
     Session as TablestoreSession,
 )
 
-from ...schemas.agent_schemas import ContentType, MessageType
-from ..session_history_service import Message, Session
+from ...schemas.agent_schemas import ContentType, MessageType, Message
+from ...schemas.session import Session
 
 
 def create_tablestore_client(

agentscope_runtime/engine/tracing/base.py

@@ -82,7 +82,6 @@ class TracerHandler(ABC):
         raise NotImplementedError("Subclasses must implement on_error method")
 
 
-# 新增基础的LogHandler类
 class BaseLogHandler(TracerHandler):
     """Basic log handler implementation using Python's logging module."""
 
@@ -166,14 +165,16 @@ class BaseLogHandler(TracerHandler):
 
 class Tracer:
     """
-    Tracer class for logging events
-    usage:
-    with tracer.event(TraceType.LLM, payload) as event:
-        event.log("message")
-        ""...logic here...""
-        end_payload = {xxx}
-        # optional on_end call for additional payload and kwargs
-        event.on_end(end_payload, if_success=True)
+    Tracer class for logging events.
+
+    Usage example::
+
+        with tracer.event(TraceType.LLM, payload) as event:
+            event.log("message")
+            # ...logic here...
+            end_payload = {"xxx": "value"}
+            # optional on_end call for additional payload and kwargs
+            event.on_end(end_payload, if_success=True)
     """
 
     def __init__(self, handlers: List[TracerHandler]):

agentscope_runtime/engine/tracing/message_util.py

@@ -13,7 +13,7 @@ from agentscope_runtime.engine.schemas.agent_schemas import (
     TextContent,
 )
 
-# Use OpenAI's ToolCall type instead of agentscope_bricks
+# Use OpenAI's ToolCall type instead of agentscope_runtime
 ToolCall = ChoiceDeltaToolCall
 
 

agentscope_runtime/engine/tracing/tracing_util.py

@@ -26,7 +26,10 @@ class TracingUtil:
         """Set request id"""
         _user_request_id.set(value)
         if value:
-            ctx = baggage.set_baggage("agentscope-bricks_request_id", value)
+            ctx = baggage.set_baggage(
+                "agentscope-runtime_request_id",
+                value,
+            )
             attach(ctx)
 
             TracingUtil.clear_common_attributes()
@@ -48,7 +51,9 @@ class TracingUtil:
             return request_id
 
         # Fallback to baggage for cross-thread scenarios
-        request_id = baggage.get_baggage("agentscope-bricks_request_id")
+        request_id = baggage.get_baggage(
+            "agentscope-runtime_request_id",
+        )
         if request_id:
             return request_id