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

agentscope_runtime/adapters/agentscope/message.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# pylint:disable=too-many-branches,too-many-statements
+# pylint:disable=too-many-branches,too-many-statements,protected-access
 # TODO: support file block
 import json
 
@@ -7,6 +7,7 @@ from collections import OrderedDict
 from typing import Union, List
 from urllib.parse import urlparse
 
+from mcp.types import CallToolResult
 from agentscope.message import (
     Msg,
     ToolUseBlock,
@@ -19,6 +20,7 @@ from agentscope.message import (
     URLSource,
     Base64Source,
 )
+from agentscope.mcp._client_base import MCPClientBase
 
 from ...engine.schemas.agent_schemas import (
     Message,
@@ -338,6 +340,16 @@ def message_to_agentscope_msg(
         A single Msg object or a list of Msg objects.
     """
 
+    def _try_loads(v, default, keep_original=False):
+        if isinstance(v, (dict, list)):
+            return v
+        if isinstance(v, str) and v.strip():
+            try:
+                return json.loads(v)
+            except Exception:
+                return v if keep_original else default
+        return default
+
     def _convert_one(message: Message) -> Msg:
         # Normalize role
         if message.role == "tool":
@@ -365,12 +377,23 @@ def message_to_agentscope_msg(
             MessageType.FUNCTION_CALL,
         ):
             # convert PLUGIN_CALL, FUNCTION_CALL to ToolUseBlock
+            tool_args = None
+            for cnt in reversed(message.content):
+                if hasattr(cnt, "data"):
+                    v = cnt.data.get("arguments")
+                    if isinstance(v, (dict, list)) or (
+                        isinstance(v, str) and v.strip()
+                    ):
+                        tool_args = _try_loads(v, {}, keep_original=False)
+                        break
+            if tool_args is None:
+                tool_args = {}
             result["content"] = [
                 ToolUseBlock(
                     type="tool_use",
                     id=message.content[0].data["call_id"],
                     name=message.content[0].data.get("name"),
-                    input=json.loads(message.content[0].data["arguments"]),
+                    input=tool_args,
                 ),
             ]
         elif message.type in (
@@ -379,7 +402,20 @@ def message_to_agentscope_msg(
         ):
             # convert PLUGIN_CALL_OUTPUT, FUNCTION_CALL_OUTPUT to
             # ToolResultBlock
-            blk = json.loads(message.content[0].data["output"])
+            out = None
+            raw_output = ""
+            for cnt in reversed(message.content):
+                if hasattr(cnt, "data"):
+                    v = cnt.data.get("output")
+                    if isinstance(v, (dict, list)) or (
+                        isinstance(v, str) and v.strip()
+                    ):
+                        raw_output = v
+                        out = _try_loads(v, "", keep_original=True)
+                        break
+            if out is None:
+                out = ""
+            blk = out
 
             def is_valid_block(obj):
                 return any(
@@ -389,12 +425,19 @@ def message_to_agentscope_msg(
 
             if isinstance(blk, list):
                 if not all(is_valid_block(item) for item in blk):
-                    blk = message.content[0].data["output"]
+                    try:
+                        # Try to convert to MCP CallToolResult then to blocks
+                        blk = CallToolResult.model_validate(blk)
+                        blk = MCPClientBase._convert_mcp_content_to_as_blocks(
+                            blk.content,
+                        )
+                    except Exception:
+                        blk = raw_output
             elif isinstance(blk, dict):
                 if not is_valid_block(blk):
-                    blk = message.content[0].data["output"]
+                    blk = raw_output
             else:
-                blk = message.content[0].data["output"]
+                blk = raw_output
 
             result["content"] = [
                 ToolResultBlock(

agentscope_runtime/adapters/agentscope/stream.py

@@ -14,6 +14,8 @@ from ...engine.schemas.agent_schemas import (
     ImageContent,
     AudioContent,
     DataContent,
+    McpCall,
+    McpCallOutput,
     FunctionCall,
     FunctionCallOutput,
     MessageType,
@@ -78,8 +80,6 @@ async def adapt_agentscope_message_stream(
             # Note: Tool use content only happens in the last of messages
             tool_start = False
 
-            tool_use_messages_dict = {}
-
             # Cache msg id
             msg_id = msg.id
 
@@ -251,24 +251,65 @@ async def adapt_agentscope_message_stream(
                     elif element.get("type") == "tool_use":  # Tool use
                         call_id = element.get("id")
 
+                        if element.get("tool_type", "plugin") == "mcp":
+                            msg_type = MessageType.MCP_TOOL_CALL
+                            fc_cls = McpCall
+                            fc_kwargs = {
+                                "server_label": element.get("server_label"),
+                            }
+                        else:
+                            msg_type = MessageType.PLUGIN_CALL
+                            fc_cls = FunctionCall
+                            fc_kwargs = {}
+
                         if last:
-                            plugin_call_message = tool_use_messages_dict[
-                                call_id
-                            ]
-                            json_str = json.dumps(element.get("input"))
+                            plugin_call_message = tool_use_messages_dict.get(
+                                call_id,
+                            )
+
+                            if plugin_call_message is None:
+                                # Only one tool use message yields, we fake
+                                #  Build a new tool call message
+                                plugin_call_message = Message(
+                                    type=msg_type,
+                                    role="assistant",
+                                )
+
+                                data_delta_content = DataContent(
+                                    index=0,
+                                    data=fc_cls(
+                                        call_id=element.get("id"),
+                                        name=element.get("name"),
+                                        arguments="",
+                                        **fc_kwargs,
+                                    ).model_dump(),
+                                    delta=False,
+                                )
+
+                                plugin_call_message = _update_obj_attrs(
+                                    plugin_call_message,
+                                    metadata=metadata,
+                                    usage=usage,
+                                )
+                                yield plugin_call_message.in_progress()
+                                yield data_delta_content.in_progress()
+
+                            json_str = json.dumps(
+                                element.get("input"),
+                                ensure_ascii=False,
+                            )
                             data_delta_content = DataContent(
-                                index=index,
-                                data=FunctionCall(
+                                index=None,  # Will be set by `add_content`
+                                data=fc_cls(
                                     call_id=element.get("id"),
                                     name=element.get("name"),
                                     arguments=json_str,
+                                    **fc_kwargs,
                                 ).model_dump(),
-                                delta=True,
+                                delta=False,
                             )
-                            data_delta_content = (
-                                plugin_call_message.add_delta_content(
-                                    new_content=data_delta_content,
-                                )
+                            plugin_call_message.add_content(
+                                new_content=data_delta_content,
                             )
                             yield data_delta_content.completed()
                             plugin_call_message = _update_obj_attrs(
@@ -284,18 +325,19 @@ async def adapt_agentscope_message_stream(
                             else:
                                 # Build a new tool call message
                                 plugin_call_message = Message(
-                                    type=MessageType.PLUGIN_CALL,
+                                    type=msg_type,
                                     role="assistant",
                                 )
 
                                 data_delta_content = DataContent(
-                                    index=index,
-                                    data=FunctionCall(
+                                    index=0,
+                                    data=fc_cls(
                                         call_id=element.get("id"),
                                         name=element.get("name"),
                                         arguments="",
+                                        **fc_kwargs,
                                     ).model_dump(),
-                                    delta=True,
+                                    delta=False,
                                 )
 
                                 plugin_call_message = _update_obj_attrs(
@@ -304,32 +346,46 @@ async def adapt_agentscope_message_stream(
                                     usage=usage,
                                 )
                                 yield plugin_call_message.in_progress()
-                                data_delta_content = (
-                                    plugin_call_message.add_delta_content(
-                                        new_content=data_delta_content,
-                                    )
-                                )
-                                yield data_delta_content
+                                yield data_delta_content.in_progress()
 
                                 tool_use_messages_dict[
                                     call_id
                                 ] = plugin_call_message
 
                     elif element.get("type") == "tool_result":  # Tool result
+                        call_id = element.get("id")
+
+                        plugin_call_message = tool_use_messages_dict.get(
+                            call_id,
+                        )
+                        # Determine the output message type and class to use
+                        # for the tool result message based on the type of
+                        # the original tool call message.
+                        msg_type = MessageType.PLUGIN_CALL_OUTPUT
+                        fc_cls = FunctionCallOutput
+
+                        if plugin_call_message:
+                            if (
+                                plugin_call_message.type
+                                == MessageType.MCP_TOOL_CALL
+                            ):
+                                msg_type = MessageType.MCP_TOOL_CALL_OUTPUT
+                                fc_cls = McpCallOutput
+
                         json_str = json.dumps(
                             element.get("output"),
                             ensure_ascii=False,
                         )
                         data_delta_content = DataContent(
                             index=index,
-                            data=FunctionCallOutput(
+                            data=fc_cls(
                                 call_id=element.get("id"),
                                 name=element.get("name"),
                                 output=json_str,
                             ).model_dump(),
                         )
                         plugin_output_message = Message(
-                            type=MessageType.PLUGIN_CALL_OUTPUT,
+                            type=msg_type,
                             role="tool",
                             content=[data_delta_content],
                         )

agentscope_runtime/adapters/agentscope/tool/tool.py

@@ -9,9 +9,7 @@ from typing import (
 )
 
 from agentscope.tool import Toolkit, ToolResponse
-from agentscope.tool._registered_tool_function import (
-    RegisteredToolFunction,
-)
+from agentscope.tool._types import RegisteredToolFunction
 
 from agentscope_runtime.tools.base import Tool
 

agentscope_runtime/engine/app/agent_app.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 import logging
 import types
+import platform
 import subprocess
 import shlex
 from typing import Optional, Callable, List
@@ -203,7 +204,13 @@ class AgentApp(BaseApp):
                     "[AgentApp] Note: First WebUI launch may take extra time "
                     "as dependencies are installed.",
                 )
-                with subprocess.Popen(shlex.split(cmd)):
+
+                cmd_kwarg = {}
+                if platform.system() == "Windows":
+                    cmd_kwarg.update({"shell": True})
+                else:
+                    cmd = shlex.split(cmd)
+                with subprocess.Popen(cmd, **cmd_kwarg):
                     uvicorn.run(
                         fastapi_app,
                         host=host,

agentscope_runtime/engine/deployers/agentrun_deployer.py

@@ -1022,7 +1022,7 @@ ls -lh /output/{zip_filename}
                     artifact_type="Code",
                     cpu=self.agentrun_config.cpu,
                     memory=self.agentrun_config.memory,
-                    port=8080,
+                    port=8090,
                     code_configuration=CodeConfig(
                         command=["python3", "/code/deploy_starter/main.py"],
                         oss_bucket_name=oss_bucket_name,
@@ -1159,7 +1159,7 @@ ls -lh /output/{zip_filename}
                 artifact_type="Code",
                 cpu=self.agentrun_config.cpu,
                 memory=self.agentrun_config.memory,
-                port=8080,
+                port=8090,
                 code_configuration=CodeConfig(
                     command=["python3", "/code/deploy_starter/main.py"],
                     oss_bucket_name=oss_bucket_name,

agentscope_runtime/engine/deployers/utils/service_utils/fastapi_factory.py

@@ -693,9 +693,32 @@ class FastAPIAppFactory:
         parsing."""
         is_async_gen = inspect.isasyncgenfunction(handler)
 
+        # NOTE:
+        # -----
+        # FastAPI >= 0.123.5 uses Dependant.is_coroutine_callable, which in
+        # turn unwraps callables via inspect.unwrap() and then inspects the
+        # unwrapped target to decide whether it is a coroutine function /
+        # generator / async generator.
+        #
+        # If we decorate an async-generator handler with
+        # functools.wraps(handler), FastAPI will unwrap back to the original
+        # async-generator function and *misclassify* the endpoint as
+        # non-coroutine. It will then call our async wrapper *without awaiting
+        # it*, and later try to JSON-encode the resulting coroutine object,
+        # causing errors like:
+        # TypeError("'coroutine' object is not iterable")
+        #
+        # To avoid that, we deliberately do NOT use functools.wraps() here.
+        # Instead, we manually copy the key metadata (name, qualname, doc,
+        # module, and signature) from the original handler, but we do NOT set
+        # __wrapped__. This ensures:
+        #   * FastAPI sees the wrapper itself as the callable (an async def),
+        #     so Dependant.is_coroutine_callable is True, and it is properly
+        #     awaited.
+        #   * FastAPI still sees the correct signature for parameter parsing.
+
         if is_async_gen:
 
-            @functools.wraps(handler)
             async def wrapped_handler(*args, **kwargs):
                 async def generate():
                     try:
@@ -720,12 +743,8 @@ class FastAPIAppFactory:
                     media_type="text/event-stream",
                 )
 
-            wrapped_handler.__signature__ = inspect.signature(handler)
-            return wrapped_handler
-
         else:
 
-            @functools.wraps(handler)
             def wrapped_handler(*args, **kwargs):
                 def generate():
                     try:
@@ -748,8 +767,34 @@ class FastAPIAppFactory:
                     media_type="text/event-stream",
                 )
 
-            wrapped_handler.__signature__ = inspect.signature(handler)
-            return wrapped_handler
+        # Manually propagate essential metadata without creating a __wrapped__
+        # chain that would confuse FastAPI's unwrap logic.
+        wrapped_handler.__name__ = getattr(
+            handler,
+            "__name__",
+            wrapped_handler.__name__,
+        )
+        wrapped_handler.__qualname__ = getattr(
+            handler,
+            "__qualname__",
+            wrapped_handler.__qualname__,
+        )
+        wrapped_handler.__doc__ = getattr(
+            handler,
+            "__doc__",
+            wrapped_handler.__doc__,
+        )
+        wrapped_handler.__module__ = getattr(
+            handler,
+            "__module__",
+            wrapped_handler.__module__,
+        )
+        wrapped_handler.__signature__ = inspect.signature(handler)
+
+        # Make sure FastAPI doesn't see any stale __wrapped__ pointing back to
+        # the original async-generator; if present, remove it.
+
+        return wrapped_handler
 
     @staticmethod
     def _add_custom_endpoints(app: FastAPI):

agentscope_runtime/engine/runner.py

@@ -216,22 +216,23 @@ class Runner:
         if isinstance(request, dict):
             request = AgentRequest(**request)
 
+        # Assign session ID
+        request.session_id = request.session_id or str(uuid.uuid4())
+
+        # Assign user ID
+        request.user_id = request.user_id or request.session_id
+
         seq_gen = SequenceNumberGenerator()
 
         # Initial response
         response = AgentResponse(id=request.id)
+        response.session_id = request.session_id
         yield seq_gen.yield_with_sequence(response)
 
         # Set to in-progress status
         response.in_progress()
         yield seq_gen.yield_with_sequence(response)
 
-        # Assign session ID
-        request.session_id = request.session_id or str(uuid.uuid4())
-
-        # Assign user ID
-        request.user_id = request.session_id or request.session_id
-
         query_kwargs = {
             "request": request,
         }

agentscope_runtime/engine/schemas/agent_schemas.py

@@ -27,6 +27,7 @@ class MessageType:
     MCP_APPROVAL_REQUEST = "mcp_approval_request"
     MCP_TOOL_CALL = "mcp_call"
     MCP_APPROVAL_RESPONSE = "mcp_approval_response"
+    MCP_TOOL_CALL_OUTPUT = "mcp_call_output"
     REASONING = "reasoning"
     HEARTBEAT = "heartbeat"
     ERROR = "error"
@@ -152,22 +153,35 @@ class FunctionCallOutput(BaseModel):
 
 
 class McpCall(BaseModel):
-    id: str
+    """
+    MCP TOOL CALL MESSAGE BODY
+    """
+
+    call_id: Optional[str] = None
     """The unique ID of the tool call."""
 
-    arguments: str
+    arguments: Optional[str] = None
     """A JSON string of the arguments passed to the tool."""
 
-    name: str
+    name: Optional[str] = None
     """The name of the tool that was run."""
 
-    server_label: str
+    server_label: Optional[str] = None
     """The label of the MCP server running the tool."""
 
-    error: Optional[str] = None
-    """The error from the tool call, if any."""
 
-    output: Optional[str] = None
+class McpCallOutput(BaseModel):
+    """
+    MCP TOOL CALL OUTPUT MESSAGE BODY
+    """
+
+    call_id: str
+    """The unique ID of the tool call."""
+
+    name: Optional[str] = None
+    """The name of the tool call."""
+
+    output: str
     """The output from the tool call."""
 
 

agentscope_runtime/engine/services/agent_state/__init__.py

@@ -5,6 +5,7 @@ from ....common.utils.lazy_loader import install_lazy_loader
 if TYPE_CHECKING:
     from .state_service import StateService, InMemoryStateService
     from .redis_state_service import RedisStateService
+    from .state_service_factory import StateServiceFactory
 
 install_lazy_loader(
     globals(),
@@ -12,5 +13,6 @@ install_lazy_loader(
         "StateService": ".state_service",
         "InMemoryStateService": ".state_service",
         "RedisStateService": ".redis_state_service",
+        "StateServiceFactory": ".state_service_factory",
     },
 )

agentscope_runtime/engine/services/agent_state/state_service_factory.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+from typing import Callable, Dict
+
+from ..service_factory import ServiceFactory
+from .state_service import StateService, InMemoryStateService
+from .redis_state_service import RedisStateService
+
+
+class StateServiceFactory(ServiceFactory[StateService]):
+    """
+    Factory for StateService, supports both environment variables and kwargs
+    parameters.
+
+    Usage examples:
+        1. Start with environment variables only:
+            export STATE_BACKEND=redis
+            export STATE_REDIS_REDIS_URL="redis://localhost:6379/5"
+            service = await StateServiceFactory.create()
+
+        2. Override environment variables with arguments:
+            export STATE_BACKEND=redis
+            export STATE_REDIS_REDIS_URL="redis://localhost:6379/5"
+            service = await StateServiceFactory.create(
+                redis_url="redis://otherhost:6379/1"
+            )
+
+        3. User-defined backend:
+            from my_backend import PostgresStateService
+            StateServiceFactory.register_backend(
+                "postgres",
+                PostgresStateService,
+            )
+            export STATE_BACKEND=postgres
+            export STATE_POSTGRES_DSN="postgresql://user:pass@localhost/db"
+            service = await StateServiceFactory.create()
+    """
+
+    _registry: Dict[str, Callable[..., StateService]] = {}
+    _env_prefix = "STATE_"
+    _default_backend = "in_memory"
+
+
+StateServiceFactory.register_backend(
+    "in_memory",
+    lambda **kwargs: InMemoryStateService(),
+)
+
+StateServiceFactory.register_backend(
+    "redis",
+    lambda **kwargs: RedisStateService(
+        redis_url=kwargs.get("redis_url", "redis://localhost:6379/0"),
+        redis_client=kwargs.get("redis_client"),
+    ),
+)

agentscope_runtime/engine/services/memory/__init__.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
     from .reme_personal_memory_service import ReMePersonalMemoryService
     from .mem0_memory_service import Mem0MemoryService
     from .tablestore_memory_service import TablestoreMemoryService
+    from .memory_service_factory import MemoryServiceFactory
 
 install_lazy_loader(
     globals(),
@@ -20,5 +21,6 @@ install_lazy_loader(
         "ReMePersonalMemoryService": ".reme_personal_memory_service",
         "Mem0MemoryService": ".mem0_memory_service",
         "TablestoreMemoryService": ".tablestore_memory_service",
+        "MemoryServiceFactory": ".memory_service_factory",
     },
 )