agentscope-runtime 1.0.1__py3-none-any.whl → 1.0.2__py3-none-any.whl

agentscope_runtime/adapters/agentscope/message.py

@@ -374,9 +374,10 @@ 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"):
@@ -398,10 +399,10 @@ def message_to_agentscope_msg(
             ]
         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
+            # convert CALL_OUTPUT to ToolResultBlock
             out = None
             raw_output = ""
             for cnt in reversed(message.content):
@@ -425,6 +426,22 @@ def message_to_agentscope_msg(
 
             if isinstance(blk, list):
                 if not all(is_valid_block(item) for item in blk):
+                    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):
                     try:
                         # Try to convert to MCP CallToolResult then to blocks
                         blk = CallToolResult.model_validate(blk)
@@ -433,9 +450,6 @@ def message_to_agentscope_msg(
                         )
                     except Exception:
                         blk = raw_output
-            elif isinstance(blk, dict):
-                if not is_valid_block(blk):
-                    blk = raw_output
             else:
                 blk = raw_output
 
@@ -459,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
             }
@@ -533,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,13 +3,15 @@
 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,
@@ -21,6 +23,8 @@ from ...engine.schemas.agent_schemas import (
     MessageType,
 )
 
+setup_logger("ERROR")
+
 
 def _update_obj_attrs(obj, **attrs):
     for key, value in attrs.items():
@@ -31,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 = ""
@@ -48,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
@@ -262,95 +267,69 @@ async def adapt_agentscope_message_stream(
                             fc_cls = FunctionCall
                             fc_kwargs = {}
 
-                        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=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()
+                        plugin_call_message = tool_use_messages_dict.get(
+                            call_id,
+                        )
 
-                            json_str = json.dumps(
-                                element.get("input"),
-                                ensure_ascii=False,
+                        if plugin_call_message is None:
+                            # Create a new message
+                            plugin_call_message = Message(
+                                type=msg_type,
+                                role="assistant",
                             )
                             data_delta_content = DataContent(
-                                index=None,  # Will be set by `add_content`
+                                index=0,
                                 data=fc_cls(
-                                    call_id=element.get("id"),
+                                    call_id=element["id"],
                                     name=element.get("name"),
-                                    arguments=json_str,
+                                    arguments="",
                                     **fc_kwargs,
                                 ).model_dump(),
                                 delta=False,
                             )
-                            plugin_call_message.add_content(
-                                new_content=data_delta_content,
-                            )
-                            yield data_delta_content.completed()
                             plugin_call_message = _update_obj_attrs(
                                 plugin_call_message,
                                 metadata=metadata,
                                 usage=usage,
                             )
-                            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=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,
-                                )
+                            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,
-                                )
-                                yield plugin_call_message.in_progress()
-                                yield data_delta_content.in_progress()
+                        plugin_call_message = _update_obj_attrs(
+                            plugin_call_message,
+                            metadata=metadata,
+                            usage=usage,
+                        )
 
-                                tool_use_messages_dict[
-                                    call_id
-                                ] = plugin_call_message
+                        if last:
+                            plugin_call_message.add_content(
+                                new_content=data_delta_content,
+                            )
+                            yield data_delta_content.completed()
+                            yield plugin_call_message.completed()
+                        else:
+                            data_delta_content.msg_id = plugin_call_message.id
+                            yield data_delta_content.in_progress()
 
                     elif element.get("type") == "tool_result":  # Tool result
                         call_id = element.get("id")
@@ -372,35 +351,86 @@ async def adapt_agentscope_message_stream(
                                 msg_type = MessageType.MCP_TOOL_CALL_OUTPUT
                                 fc_cls = McpCallOutput
 
-                        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,
+                            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=msg_type,
-                            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/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",
+]