agentscope-runtime 1.0.0b2__py3-none-any.whl → 1.0.2__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":
@@ -362,24 +374,49 @@ def message_to_agentscope_msg(
 
         if message.type in (
             MessageType.PLUGIN_CALL,
+            MessageType.MCP_TOOL_CALL,
             MessageType.FUNCTION_CALL,
         ):
-            # convert PLUGIN_CALL, FUNCTION_CALL to ToolUseBlock
+            # convert 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 (
             MessageType.PLUGIN_CALL_OUTPUT,
+            MessageType.MCP_TOOL_CALL_OUTPUT,
             MessageType.FUNCTION_CALL_OUTPUT,
         ):
-            # convert PLUGIN_CALL_OUTPUT, FUNCTION_CALL_OUTPUT to
-            # ToolResultBlock
-            blk = json.loads(message.content[0].data["output"])
+            # convert CALL_OUTPUT to ToolResultBlock
+            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 +426,32 @@ 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 MCP content list to blocks
+                        call_tool_result = {
+                            "content": blk,
+                            "structuredContent": None,
+                            "isError": False,
+                        }
+                        blk = MCPClientBase._convert_mcp_content_to_as_blocks(
+                            CallToolResult.model_validate(
+                                call_tool_result,
+                            ).content,
+                        )
+                    except Exception:
+                        blk = raw_output
             elif isinstance(blk, dict):
                 if not is_valid_block(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
             else:
-                blk = message.content[0].data["output"]
+                blk = raw_output
 
             result["content"] = [
                 ToolResultBlock(
@@ -416,6 +473,7 @@ def message_to_agentscope_msg(
                 "text": (TextBlock, "text"),
                 "image": (ImageBlock, "image_url"),
                 "audio": (AudioBlock, "data"),
+                "data": (TextBlock, "data"),
                 # "video": (VideoBlock, "video_url", True),
                 # TODO: support video
             }
@@ -490,7 +548,17 @@ def message_to_agentscope_msg(
                                 block_cls(type=cnt_type, source=base64_source),
                             )
                 else:
-                    msg_content.append(block_cls(type=cnt_type, text=value))
+                    # text & data
+                    if isinstance(value, str):
+                        msg_content.append(
+                            TextBlock(type="text", text=value),
+                        )
+                    else:
+                        try:
+                            json_str = json.dumps(value, ensure_ascii=False)
+                        except Exception:
+                            json_str = str(value)
+                        msg_content.append(TextBlock(text=json_str))
 
             result["content"] = msg_content
         _msg = Msg(**result)

agentscope_runtime/adapters/agentscope/stream.py

@@ -3,22 +3,28 @@
 import copy
 import json
 
-from typing import AsyncIterator, Tuple, List
+from typing import AsyncIterator, Tuple, List, Union
 from urllib.parse import urlparse
 
+from agentscope import setup_logger
 from agentscope.message import Msg
 
 from ...engine.schemas.agent_schemas import (
     Message,
+    Content,
     TextContent,
     ImageContent,
     AudioContent,
     DataContent,
+    McpCall,
+    McpCallOutput,
     FunctionCall,
     FunctionCallOutput,
     MessageType,
 )
 
+setup_logger("ERROR")
+
 
 def _update_obj_attrs(obj, **attrs):
     for key, value in attrs.items():
@@ -29,7 +35,7 @@ def _update_obj_attrs(obj, **attrs):
 
 async def adapt_agentscope_message_stream(
     source_stream: AsyncIterator[Tuple[Msg, bool]],
-) -> AsyncIterator[Message]:
+) -> AsyncIterator[Union[Message, Content]]:
     # Initialize variables to avoid uncaught errors
     msg_id = None
     last_content = ""
@@ -46,6 +52,7 @@ async def adapt_agentscope_message_stream(
     should_start_message = True
     should_start_reasoning_message = True
     tool_use_messages_dict = {}
+    tool_result_messages_dict = {}
     index = None
 
     # Run agent
@@ -78,8 +85,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,132 +256,181 @@ async def adapt_agentscope_message_stream(
                     elif element.get("type") == "tool_use":  # Tool use
                         call_id = element.get("id")
 
-                        if last:
-                            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=MessageType.PLUGIN_CALL,
-                                    role="assistant",
-                                )
-
-                                data_delta_content = DataContent(
-                                    index=index,
-                                    data=FunctionCall(
-                                        call_id=element.get("id"),
-                                        name=element.get("name"),
-                                        arguments="",
-                                    ).model_dump(),
-                                    delta=True,
-                                )
+                        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 = {}
 
-                                plugin_call_message = _update_obj_attrs(
-                                    plugin_call_message,
-                                    metadata=metadata,
-                                    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
+                        plugin_call_message = tool_use_messages_dict.get(
+                            call_id,
+                        )
 
-                            json_str = json.dumps(element.get("input"))
+                        if plugin_call_message is None:
+                            # Create a new message
+                            plugin_call_message = Message(
+                                type=msg_type,
+                                role="assistant",
+                            )
                             data_delta_content = DataContent(
-                                index=index,
-                                data=FunctionCall(
-                                    call_id=element.get("id"),
+                                index=0,
+                                data=fc_cls(
+                                    call_id=element["id"],
                                     name=element.get("name"),
-                                    arguments=json_str,
+                                    arguments="",
+                                    **fc_kwargs,
                                 ).model_dump(),
-                                delta=True,
-                            )
-                            data_delta_content = (
-                                plugin_call_message.add_delta_content(
-                                    new_content=data_delta_content,
-                                )
+                                delta=False,
                             )
-                            yield data_delta_content.completed()
                             plugin_call_message = _update_obj_attrs(
                                 plugin_call_message,
                                 metadata=metadata,
                                 usage=usage,
                             )
+                            yield plugin_call_message.in_progress()
+                            data_delta_content.msg_id = plugin_call_message.id
+                            yield data_delta_content.in_progress()
+                            tool_use_messages_dict[
+                                call_id
+                            ] = plugin_call_message
+
+                        # Update arguments
+                        json_str = json.dumps(
+                            element.get("input"),
+                            ensure_ascii=False,
+                        )
+                        data_delta_content = DataContent(
+                            index=None if last else 0,
+                            data=fc_cls(
+                                call_id=element["id"],
+                                name=element.get("name"),
+                                arguments=json_str,
+                                **fc_kwargs,
+                            ).model_dump(),
+                            delta=False,
+                        )
+
+                        plugin_call_message = _update_obj_attrs(
+                            plugin_call_message,
+                            metadata=metadata,
+                            usage=usage,
+                        )
+
+                        if last:
+                            plugin_call_message.add_content(
+                                new_content=data_delta_content,
+                            )
+                            yield data_delta_content.completed()
                             yield plugin_call_message.completed()
-                            index = None
                         else:
-                            if call_id in tool_use_messages_dict:
-                                pass
-                            else:
-                                # Build a new tool call message
-                                plugin_call_message = Message(
-                                    type=MessageType.PLUGIN_CALL,
-                                    role="assistant",
-                                )
+                            data_delta_content.msg_id = plugin_call_message.id
+                            yield data_delta_content.in_progress()
 
-                                data_delta_content = DataContent(
-                                    index=index,
-                                    data=FunctionCall(
-                                        call_id=element.get("id"),
-                                        name=element.get("name"),
-                                        arguments="",
-                                    ).model_dump(),
-                                    delta=True,
-                                )
+                    elif element.get("type") == "tool_result":  # Tool result
+                        call_id = element.get("id")
 
-                                plugin_call_message = _update_obj_attrs(
-                                    plugin_call_message,
-                                    metadata=metadata,
-                                    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
+                        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
 
-                                tool_use_messages_dict[
-                                    call_id
-                                ] = plugin_call_message
+                        if plugin_call_message:
+                            if (
+                                plugin_call_message.type
+                                == MessageType.MCP_TOOL_CALL
+                            ):
+                                msg_type = MessageType.MCP_TOOL_CALL_OUTPUT
+                                fc_cls = McpCallOutput
 
-                    elif element.get("type") == "tool_result":  # Tool result
-                        json_str = json.dumps(
-                            element.get("output"),
-                            ensure_ascii=False,
+                        plugin_output_message = tool_result_messages_dict.get(
+                            call_id,
                         )
+
+                        if plugin_output_message is None:
+                            # Create a new message
+                            plugin_output_message = Message(
+                                type=msg_type,
+                                role="tool",
+                            )
+                            data_delta_content = DataContent(
+                                index=0,
+                                data=fc_cls(
+                                    call_id=element.get("id"),
+                                    name=element.get("name"),
+                                    output="",
+                                ).model_dump(),
+                                delta=False,
+                            )
+                            plugin_output_message = _update_obj_attrs(
+                                plugin_output_message,
+                                metadata=metadata,
+                                usage=usage,
+                            )
+                            yield plugin_output_message.in_progress()
+                            data_delta_content.msg_id = (
+                                plugin_output_message.id
+                            )
+                            yield data_delta_content.in_progress()
+                            tool_result_messages_dict[
+                                call_id
+                            ] = plugin_output_message
+
+                        # Update output
+                        try:
+                            json_str = json.dumps(
+                                element.get("output"),
+                                ensure_ascii=False,
+                            )
+                        except Exception:
+                            # For non-JSON outputs, we just use the string
+                            # representation
+                            json_str = str(element.get("output"))
+
                         data_delta_content = DataContent(
-                            index=index,
-                            data=FunctionCallOutput(
+                            index=None if last else 0,
+                            data=fc_cls(
                                 call_id=element.get("id"),
                                 name=element.get("name"),
                                 output=json_str,
                             ).model_dump(),
+                            delta=False,
                         )
-                        plugin_output_message = Message(
-                            type=MessageType.PLUGIN_CALL_OUTPUT,
-                            role="tool",
-                            content=[data_delta_content],
-                        )
+
                         plugin_output_message = _update_obj_attrs(
                             plugin_output_message,
                             metadata=metadata,
                             usage=usage,
                         )
-                        yield plugin_output_message.completed()
-                        message = Message(
-                            type=MessageType.MESSAGE,
-                            role="assistant",
-                        )
-                        should_start_message = True
-                        index = None
+
+                        if last:
+                            plugin_output_message.add_content(
+                                new_content=data_delta_content,
+                            )
+                            yield data_delta_content.completed()
+                            yield plugin_output_message.completed()
+
+                            message = Message(
+                                type=MessageType.MESSAGE,
+                                role="assistant",
+                            )
+                            should_start_message = True
+                            index = None
+
+                        else:
+                            data_delta_content.msg_id = (
+                                plugin_output_message.id
+                            )
+                            yield data_delta_content.in_progress()
+
                     else:
                         # TODO: handle image/audio/video block
                         if should_start_message:

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/adapters/agno/message.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+from typing import Union, List
+
+from agentscope.formatter import OpenAIChatFormatter
+
+from ...engine.schemas.agent_schemas import Message
+from ..agentscope.message import message_to_agentscope_msg
+
+
+async def message_to_agno_message(
+    messages: Union[Message, List[Message]],
+) -> Union[dict, List[dict]]:
+    """
+    Convert AgentScope runtime Message(s) to Agno Message(s).
+
+    Args:
+        messages: A single AgentScope runtime Message or list of Messages.
+
+    Returns:
+        A single AgnoMessage object or a list of AgnoMessage objects.
+    """
+
+    as_msgs = message_to_agentscope_msg(messages)
+    raw_list = isinstance(as_msgs, list)
+    as_msgs = as_msgs if raw_list else [as_msgs]
+
+    formatter = OpenAIChatFormatter()
+    agno_message = await formatter.format(as_msgs)
+
+    return agno_message if raw_list else agno_message[0]

agentscope_runtime/adapters/agno/stream.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+# pylint:disable=too-many-branches,too-many-statements
+import json
+
+from typing import AsyncIterator, Union
+
+from agno.run.agent import (
+    BaseAgentRunEvent,
+    RunContentEvent,
+    RunCompletedEvent,
+    RunContentCompletedEvent,
+    RunStartedEvent,
+    # ReasoningStartedEvent,  # Not support now
+    # ReasoningStepEvent,
+    # ReasoningCompletedEvent,
+    ToolCallStartedEvent,
+    ToolCallCompletedEvent,
+)
+
+
+from ...engine.schemas.agent_schemas import (
+    Message,
+    Content,
+    DataContent,
+    FunctionCall,
+    FunctionCallOutput,
+    MessageType,
+)
+from ...engine.helpers.agent_api_builder import ResponseBuilder
+
+
+async def adapt_agno_message_stream(
+    source_stream: AsyncIterator[BaseAgentRunEvent],
+) -> AsyncIterator[Union[Message, Content]]:
+    rb = ResponseBuilder()
+    mb = None
+    cb = None
+    mb_type = None
+
+    should_start_new_message = True
+
+    async for event in source_stream:
+        if isinstance(event, RunStartedEvent):
+            should_start_new_message = True
+        elif isinstance(event, RunCompletedEvent):
+            # Placeholder
+            return
+        elif isinstance(event, RunContentEvent):
+            if event.reasoning_content:
+                message_type = MessageType.REASONING
+                content = event.reasoning_content
+            else:
+                message_type = MessageType.MESSAGE
+                content = event.content
+
+            if message_type != mb_type:
+                # Complete previous message
+                should_start_new_message = True
+                mb_type = message_type
+                if cb is not None:
+                    yield cb.complete()
+                if mb is not None:
+                    yield mb.complete()
+
+            if should_start_new_message:
+                should_start_new_message = False
+                mb = rb.create_message_builder(
+                    message_type=message_type,
+                    role="assistant",
+                )
+                yield mb.get_message_data()
+
+                cb = mb.create_content_builder(
+                    content_type="text",
+                )
+            yield cb.add_text_delta(content)
+        elif isinstance(event, RunContentCompletedEvent):
+            yield cb.complete()
+            yield mb.complete()
+            mb = None
+            cb = None
+            should_start_new_message = True
+        elif isinstance(event, ToolCallStartedEvent):
+            json_str = json.dumps(event.tool.tool_args, ensure_ascii=False)
+            data = DataContent(
+                data=FunctionCall(
+                    call_id=event.tool.tool_call_id,
+                    name=event.tool.tool_name,
+                    arguments=json_str,
+                ).model_dump(),
+            )
+            # Not support streaming tool call
+            message = Message(
+                type=MessageType.PLUGIN_CALL,
+                role="assistant",
+                content=[data],
+            )
+            # No stream tool call
+            yield message.completed()
+
+            should_start_new_message = True
+        elif isinstance(event, ToolCallCompletedEvent):
+            try:
+                json_str = json.dumps(event.tool.result, ensure_ascii=False)
+            except Exception:
+                json_str = str(event.tool.result)
+
+            data = DataContent(
+                data=FunctionCallOutput(
+                    name=event.tool.tool_name,
+                    call_id=event.tool.tool_call_id,
+                    output=json_str,
+                ).model_dump(),
+            )
+            message = Message(
+                type=MessageType.PLUGIN_CALL_OUTPUT,
+                role="tool",
+                content=[data],
+            )
+            yield message.completed()
+
+            should_start_new_message = True

agentscope_runtime/adapters/langgraph/__init__.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+"""LangGraph adapter for AgentScope runtime."""
+
+# todo Message(reasoning) Adapter
+# todo Memory Adapter
+# todo Sandbox Tools Adapter
+from .message import langgraph_msg_to_message, message_to_langgraph_msg
+
+__all__ = [
+    "langgraph_msg_to_message",
+    "message_to_langgraph_msg",
+]