agentscope-runtime 0.1.5b2__py3-none-any.whl → 0.1.6__py3-none-any.whl

agentscope_runtime/engine/helpers/helper.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import logging
 
 from agentscope_runtime.engine import Runner
 from agentscope_runtime.engine.schemas.agent_schemas import (
@@ -13,22 +14,28 @@ from agentscope_runtime.engine.services.environment_manager import (
     create_environment_manager,
 )
 
+logger = logging.getLogger(__name__)
+
 
 async def simple_call_agent(query, runner, user_id=None, session_id=None):
-    request = AgentRequest(
-        input=[
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": query,
-                    },
-                ],
-            },
-        ],
-        session_id=session_id,
-    )
+    if isinstance(query, str):
+        request = AgentRequest(
+            input=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": query,
+                        },
+                    ],
+                },
+            ],
+            session_id=session_id,
+        )
+    else:
+        request = query
+
     all_result = ""
     async for message in runner.stream_query(
         user_id=user_id,
@@ -58,6 +65,23 @@ async def simple_call_agent_direct(agent, query):
 
 
 async def simple_call_agent_tool(agent, query):
+    if isinstance(query, str):
+        request = AgentRequest(
+            input=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": query,
+                        },
+                    ],
+                },
+            ],
+        )
+    else:
+        request = query
+
     all_result = ""
     async with create_context_manager() as context_manager:
         async with create_environment_manager() as environment_manager:
@@ -67,20 +91,6 @@ async def simple_call_agent_tool(agent, query):
                 environment_manager=environment_manager,
             )
 
-            request = AgentRequest(
-                input=[
-                    {
-                        "role": "user",
-                        "content": [
-                            {
-                                "type": "text",
-                                "text": query,
-                            },
-                        ],
-                    },
-                ],
-            )
-
             async for message in runner.stream_query(
                 request=request,
             ):
@@ -94,12 +104,7 @@ async def simple_call_agent_tool(agent, query):
 
 
 async def simple_call_agent_tool_auto_lifecycle(agent, query):
-    all_result = ""
-    async with Runner(
-        agent=agent,
-        context_manager=create_context_manager(),
-        environment_manager=create_environment_manager(),
-    ) as runner:
+    if isinstance(query, str):
         request = AgentRequest(
             input=[
                 {
@@ -113,7 +118,15 @@ async def simple_call_agent_tool_auto_lifecycle(agent, query):
                 },
             ],
         )
+    else:
+        request = query
 
+    all_result = ""
+    async with Runner(
+        agent=agent,
+        context_manager=create_context_manager(),
+        environment_manager=create_environment_manager(),
+    ) as runner:
         async for message in runner.stream_query(
             request=request,
         ):
@@ -127,13 +140,7 @@ async def simple_call_agent_tool_auto_lifecycle(agent, query):
 
 
 async def simple_call_agent_tool_wo_env(agent, query):
-    all_result = ""
-    async with create_context_manager() as context_manager:
-        runner = Runner(
-            agent=agent,
-            context_manager=context_manager,
-        )
-
+    if isinstance(query, str):
         request = AgentRequest(
             input=[
                 {
@@ -147,6 +154,15 @@ async def simple_call_agent_tool_wo_env(agent, query):
                 },
             ],
         )
+    else:
+        request = query
+
+    all_result = ""
+    async with create_context_manager() as context_manager:
+        runner = Runner(
+            agent=agent,
+            context_manager=context_manager,
+        )
 
         async for message in runner.stream_query(
             request=request,
@@ -157,4 +173,7 @@ async def simple_call_agent_tool_wo_env(agent, query):
                 and RunStatus.Completed == message.status
             ):
                 all_result = message.content[0].text
+
+            logger.debug(message.model_dump())
+
     return all_result

agentscope_runtime/engine/runner.py

@@ -1,26 +1,23 @@
 # -*- coding: utf-8 -*-
 import uuid
+from typing import Optional, List, AsyncGenerator, Any
 from contextlib import AsyncExitStack
-from typing import Optional, List, AsyncGenerator, Any, Union, Dict
 
 from openai.types.chat import ChatCompletion
 
-from agentscope_runtime.engine.deployers.utils.service_utils import (
-    ServicesConfig,
-)
+from .deployers.adapter.protocol_adapter import ProtocolAdapter
 from .agents import Agent
+from .schemas.context import Context
 from .deployers import (
     DeployManager,
     LocalDeployManager,
 )
-from .deployers.adapter.protocol_adapter import ProtocolAdapter
 from .schemas.agent_schemas import (
     Event,
     AgentRequest,
     RunStatus,
     AgentResponse,
 )
-from .schemas.context import Context
 from .services.context_manager import ContextManager
 from .services.environment_manager import EnvironmentManager
 from .tracing import TraceType
@@ -80,57 +77,37 @@ class Runner:
         endpoint_path: str = "/process",
         stream: bool = True,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
-        requirements: Optional[Union[str, List[str]]] = None,
-        extra_packages: Optional[List[str]] = None,
-        base_image: str = "python:3.9-slim",
-        environment: Optional[Dict[str, str]] = None,
-        runtime_config: Optional[Dict] = None,
-        services_config: Optional[Union[ServicesConfig, dict]] = None,
-        **kwargs,
     ):
         """
         Deploys the agent as a service.
 
         Args:
+            protocol_adapters: protocol adapters
             deploy_manager: Deployment manager to handle service deployment
             endpoint_path: API endpoint path for the processing function
             stream: If start a streaming service
-            protocol_adapters: protocol adapters
-            requirements: PyPI dependencies
-            extra_packages: User code directory/file path
-            base_image: Docker base image (for containerized deployment)
-            environment: Environment variables dict
-            runtime_config: Runtime configuration dict
-            services_config: Services configuration dict
-            **kwargs: Additional arguments passed to deployment manager
         Returns:
             URL of the deployed service
 
         Raises:
             RuntimeError: If deployment fails
         """
+        if stream:
+            deploy_func = self.stream_query
+        else:
+            deploy_func = self.query
         deploy_result = await deploy_manager.deploy(
-            runner=self,
+            deploy_func,
             endpoint_path=endpoint_path,
-            stream=stream,
             protocol_adapters=protocol_adapters,
-            requirements=requirements,
-            extra_packages=extra_packages,
-            base_image=base_image,
-            environment=environment,
-            runtime_config=runtime_config,
-            services_config=services_config,
-            **kwargs,
         )
-
-        # TODO: add redis or other persistant method
         self._deploy_managers[deploy_manager.deploy_id] = deploy_result
         return deploy_result
 
     @trace(TraceType.AGENT_STEP)
     async def stream_query(  # pylint:disable=unused-argument
         self,
-        request: Union[AgentRequest, dict],
+        request: AgentRequest,
         user_id: Optional[str] = None,
         tools: Optional[List] = None,
         **kwargs: Any,
@@ -138,9 +115,6 @@ class Runner:
         """
         Streams the agent.
         """
-        if isinstance(request, dict):
-            request = AgentRequest(**request)
-
         response = AgentResponse()
         yield response
 
@@ -221,6 +195,7 @@ class Runner:
         """
         Streams the agent.
         """
+        # TODO: fix this @zhicheng
         return self._agent.query(message, session_id)
 
     # TODO: should be sync method?

agentscope_runtime/engine/schemas/agent_schemas.py

@@ -27,7 +27,6 @@ class MessageType:
     MCP_APPROVAL_REQUEST = "mcp_approval_request"
     MCP_TOOL_CALL = "mcp_call"
     MCP_APPROVAL_RESPONSE = "mcp_approval_response"
-    REASONING = "reasoning"
     HEARTBEAT = "heartbeat"
     ERROR = "error"
 
@@ -46,8 +45,6 @@ class ContentType:
     DATA = "data"
     IMAGE = "image"
     AUDIO = "audio"
-    FILE = "file"
-    REFUSAL = "refusal"
 
 
 class Role:
@@ -69,8 +66,6 @@ class RunStatus:
     Failed = "failed"
     Rejected = "rejected"
     Unknown = "unknown"
-    Queued = "queued"
-    Incomplete = "incomplete"
 
 
 class FunctionParameters(BaseModel):
@@ -287,63 +282,6 @@ class DataContent(Content):
     """The data content."""
 
 
-class AudioContent(Content):
-    type: Literal[ContentType.AUDIO] = ContentType.AUDIO
-    """The type of the content part."""
-
-    data: Optional[str] = None
-    """The audio data details."""
-
-    format: Optional[str] = None
-    """
-    The format of the audio data.
-    """
-
-
-class FileContent(Content):
-    type: Literal[ContentType.FILE] = ContentType.FILE
-    """The type of the content part."""
-
-    file_url: Optional[str] = None
-    """The file URL details."""
-
-    file_id: Optional[str] = None
-    """The file ID details."""
-
-    filename: Optional[str] = None
-    """The file name details."""
-
-    file_data: Optional[str] = None
-    """The file data details."""
-
-
-class RefusalContent(Content):
-    type: Literal[ContentType.REFUSAL] = ContentType.REFUSAL
-    """The type of the content part."""
-
-    refusal: Optional[str] = None
-    """The refusal content."""
-
-
-class ToolCall(BaseModel):
-    arguments: str
-    """A JSON string of the arguments to pass to the function."""
-
-    call_id: str
-    """The unique ID of the function tool call generated by the model."""
-
-    name: str
-    """The name of the function to run."""
-
-
-class ToolCallOutput(BaseModel):
-    call_id: str
-    """The unique ID of the function tool call generated by the model."""
-
-    output: str
-    """A JSON string of the output of the function tool call."""
-
-
 AgentRole: TypeAlias = Literal[
     Role.ASSISTANT,
     Role.SYSTEM,
@@ -351,15 +289,9 @@ AgentRole: TypeAlias = Literal[
     Role.TOOL,
 ]
 
+
 AgentContent = Annotated[
-    Union[
-        TextContent,
-        ImageContent,
-        DataContent,
-        AudioContent,
-        FileContent,
-        RefusalContent,
-    ],
+    Union[TextContent, ImageContent, DataContent],
     Field(discriminator="type"),
 ]
 

agentscope_runtime/engine/services/sandbox_service.py

@@ -2,27 +2,17 @@
 # pylint: disable=too-many-branches
 from typing import List
 
-try:
-    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
-except ImportError:
-    pass
-
+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
 
 
 class SandboxService(ServiceWithLifecycleManager):
     def __init__(self, base_url=None, bearer_token=None):
-        if SandboxManager is None:
-            raise ImportError(
-                "SandboxManager is not available. "
-                "Please install agentscope-runtime[sandbox]",
-            )
-
         self.manager_api = SandboxManager(
             base_url=base_url,
             bearer_token=bearer_token,
@@ -30,18 +20,20 @@ class SandboxService(ServiceWithLifecycleManager):
 
         self.base_url = base_url
         self.bearer_token = bearer_token
-        self.sandbox_type_set = set(item.value for item in SandboxType)
-
-        self.session_mapping = {}
 
     async def start(self) -> None:
         pass
 
     async def stop(self) -> None:
         # Release all environments
-        for _, env_ids in self.session_mapping.items():
-            for env_id in env_ids:
-                self.manager_api.release(env_id)
+        session_keys = self.manager_api.list_session_keys()
+
+        if session_keys:
+            for session_ctx_id in session_keys:
+                env_ids = self.manager_api.get_session_mapping(session_ctx_id)
+                if env_ids:
+                    for env_id in env_ids:
+                        self.manager_api.release(env_id)
 
         if self.base_url is None:
             # Embedded mode
@@ -57,61 +49,52 @@ class SandboxService(ServiceWithLifecycleManager):
         env_types=None,
         tools=None,
     ) -> List:
-        for tool in tools:
-            if not isinstance(tool, (SandboxTool, FunctionTool, MCPTool)):
-                raise ValueError(
-                    "tools must be instances of SandboxTool, FunctionTool, "
-                    "or MCPTool",
-                )
-
         # Create a composite key
-        composite_key = self._create_composite_key(session_id, user_id)
+        session_ctx_id = self._create_session_ctx_id(session_id, user_id)
 
-        # Check if the composite_key already has an environment
-        if composite_key in self.session_mapping:
+        env_ids = self.manager_api.get_session_mapping(session_ctx_id)
+
+        # Check if the session_ctx_id already has an environment
+        if env_ids:
             # Connect to existing environment
-            return self._connect_existing_environment(composite_key)
+            return self._connect_existing_environment(env_ids)
         else:
             # Create a new environment
             return self._create_new_environment(
-                composite_key,
+                session_ctx_id,
                 env_types,
                 tools,
             )
 
     def _create_new_environment(
         self,
-        composite_key,
+        session_ctx_id: str,
         env_types=None,
         tools=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"
 
-        server_configs = None
         if tools:
-            server_config_list = []
             tool_env_types = set()
             for tool in tools:
                 tool_env_types.add(tool.sandbox_type)
-                if isinstance(tool, MCPTool):
-                    server_config_list.append(tool.server_configs)
-
             if env_types is None:
                 env_types = []
 
-            if server_config_list:
-                server_configs = {"mcpServers": {}}
-                for server_config in server_config_list:
-                    server_configs["mcpServers"].update(
-                        server_config["mcpServers"],
-                    )
-
             env_types = set(env_types) | tool_env_types
 
-        wbs = []
+        sandboxes = []
         for env_type in env_types:
             if env_type is None:
                 continue
@@ -120,6 +103,7 @@ class SandboxService(ServiceWithLifecycleManager):
 
             box_id = self.manager_api.create_from_pool(
                 sandbox_type=box_type.value,
+                meta={"session_ctx_id": session_ctx_id},
             )
             box_cls = SandboxRegistry.get_classes_by_type(box_type)
 
@@ -135,22 +119,30 @@ class SandboxService(ServiceWithLifecycleManager):
                 # Embedded mode
                 box.manager_api = self.manager_api
 
-            if box_type == SandboxType.BASE:
-                if server_configs:
-                    box.add_mcp_servers(server_configs, overwrite=False)
-
-            # Store mapping from composite_key to env_id
-            if composite_key not in self.session_mapping:
-                self.session_mapping[composite_key] = []
-
-            self.session_mapping[composite_key].append(box_id)
-
-            wbs.append(box)
-        return wbs
-
-    def _connect_existing_environment(self, composite_key):
-        env_ids = self.session_mapping.get(composite_key)
-
+            # 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:
             info = self.manager_api.get_info(env_id)
@@ -183,16 +175,16 @@ class SandboxService(ServiceWithLifecycleManager):
         return boxes
 
     def release(self, session_id, user_id):
-        composite_key = self._create_composite_key(session_id, user_id)
+        session_ctx_id = self._create_session_ctx_id(session_id, user_id)
 
-        # Retrieve and remove env_id using composite_key
-        env_ids = self.session_mapping.pop(composite_key, [])
+        env_ids = self.manager_api.get_session_mapping(session_ctx_id)
 
-        for env_id in env_ids:
-            self.manager_api.release(env_id)
+        if env_ids:
+            for env_id in env_ids:
+                self.manager_api.release(env_id)
 
         return True
 
-    def _create_composite_key(self, session_id, user_id):
+    def _create_session_ctx_id(self, session_id, user_id):
         # Create a composite key from session_id and user_id
         return f"{session_id}_{user_id}"