agentscope-runtime 1.0.4a1__py3-none-any.whl → 1.0.5.post1__py3-none-any.whl

agentscope_runtime/adapters/agentscope/stream.py

@@ -9,6 +9,7 @@ from urllib.parse import urlparse
 from agentscope import setup_logger
 from agentscope.message import Msg
 
+from ..utils import _update_obj_attrs
 from ...engine.schemas.agent_schemas import (
     Message,
     Content,
@@ -26,13 +27,6 @@ from ...engine.schemas.agent_schemas import (
 setup_logger("ERROR")
 
 
-def _update_obj_attrs(obj, **attrs):
-    for key, value in attrs.items():
-        if hasattr(obj, key):
-            setattr(obj, key, value)
-    return obj
-
-
 async def adapt_agentscope_message_stream(
     source_stream: AsyncIterator[Tuple[Msg, bool]],
 ) -> AsyncIterator[Union[Message, Content]]:
@@ -277,7 +271,7 @@ async def adapt_agentscope_message_stream(
                                 role="assistant",
                             )
                             data_delta_content = DataContent(
-                                index=0,
+                                index=None if last else 0,
                                 data=fc_cls(
                                     call_id=element["id"],
                                     name=element.get("name"),

agentscope_runtime/adapters/langgraph/stream.py

@@ -62,79 +62,121 @@ async def adapt_langgraph_message_stream(
                 yield message.completed()
         elif isinstance(msg, AIMessage):
             role = "assistant"
+            tool_calls = getattr(msg, "tool_calls", [])
             has_tool_call_chunk = (
-                True if getattr(msg, "tool_call_chunks") else False
+                True if getattr(msg, "tool_call_chunks", "") else False
             )
-            is_last_chunk = (
-                True if getattr(msg, "chunk_position") == "last" else False
-            )
-
-            # Extract tool calls if present
-            if tool_started:
-                if has_tool_call_chunk:
-                    tool_call_chunk_msgs.append(msg)
-                if is_last_chunk:
-                    # tool call finished
-                    tool_started = False
-                    result = reduce(lambda x, y: x + y, tool_call_chunk_msgs)
-                    tool_calls = result.tool_call_chunks
-                    for tool_call in tool_calls:
-                        call_id = tool_call.get("id", "")
-                        # Create new tool call message
-                        plugin_call_message = Message(
-                            type=MessageType.PLUGIN_CALL,
-                            role=role,
-                        )
-                        data_content = DataContent(
-                            index=index,
-                            data=FunctionCall(
-                                call_id=call_id,
-                                name=tool_call.get("name", ""),
-                                arguments=json.dumps(
-                                    tool_call.get("args", {}),
-                                    ensure_ascii=False,
-                                ),
-                            ).model_dump(),
-                            delta=True,
+            if tool_calls and not has_tool_call_chunk:
+                plugin_call_message = Message(
+                    type=MessageType.PLUGIN_CALL,
+                    role=role,
+                )
+                for tool_call in tool_calls:
+                    tool_call_args = (
+                        tool_call.get("args")
+                        if isinstance(tool_call.get("args"), str)
+                        else json.dumps(tool_call.get("args"))
+                    )
+                    data_content = DataContent(
+                        index=index,
+                        data=FunctionCall(
+                            call_id=tool_call.get("id"),
+                            name=tool_call.get("name"),
+                            arguments=tool_call_args,
+                        ).model_dump(),
+                    )
+                    plugin_call_message.add_content(
+                        data_content,
+                    )
+                    yield data_content.completed()
+                yield plugin_call_message.completed()
+            else:
+                has_tool_call_chunk = (
+                    True if getattr(msg, "tool_call_chunks", "") else False
+                )
+                is_last_chunk = (
+                    True
+                    if getattr(msg, "chunk_position", "") == "last"
+                    else False
+                )
+                # Extract tool calls if present
+                if tool_started:
+                    if has_tool_call_chunk:
+                        tool_call_chunk_msgs.append(msg)
+                    if is_last_chunk:
+                        # tool call finished
+                        tool_started = False
+                        result = reduce(
+                            lambda x, y: x + y,
+                            tool_call_chunk_msgs,
                         )
+                        tool_calls = result.tool_call_chunks
+                        for tool_call in tool_calls:
+                            call_id = tool_call.get("id", "")
+                            # Create new tool call message
+                            plugin_call_message = Message(
+                                type=MessageType.PLUGIN_CALL,
+                                role=role,
+                            )
+                            tool_call_args = (
+                                tool_call.get("args")
+                                if isinstance(tool_call.get("args"), str)
+                                else json.dumps(tool_call.get("args"))
+                            )
 
-                        data_content = plugin_call_message.add_delta_content(
-                            new_content=data_content,
-                        )
-                        yield data_content
-                        yield plugin_call_message.completed()
-            else:
-                if has_tool_call_chunk:
-                    # tool call start, collect chunks and continue
-                    tool_started = True
-                    tool_call_chunk_msgs.append(msg)
-                else:
-                    # normal message
-                    content = msg.content if hasattr(msg, "content") else None
-                    if msg_id != getattr(msg, "id"):
-                        index = None
-                        message = Message(type=MessageType.MESSAGE, role=role)
-                        msg_id = getattr(msg, "id")
-                        yield message.in_progress()
+                            data_content = DataContent(
+                                index=index,
+                                data=FunctionCall(
+                                    call_id=call_id,
+                                    name=tool_call.get("name"),
+                                    arguments=tool_call_args,
+                                ).model_dump(),
+                            )
 
-                    if content:
-                        # todo support non str content
-                        text_delta_content = TextContent(
-                            delta=True,
-                            index=index,
-                            text=content,
-                        )
-                        text_delta_content = message.add_delta_content(
-                            new_content=text_delta_content,
+                            data_content = (
+                                plugin_call_message.add_delta_content(
+                                    new_content=data_content,
+                                )
+                            )
+                            yield data_content.completed()
+                            yield plugin_call_message.completed()
+                else:
+                    if has_tool_call_chunk:
+                        # tool call start, collect chunks and continue
+                        tool_started = True
+                        tool_call_chunk_msgs.append(msg)
+                    else:
+                        # normal message
+                        content = (
+                            msg.content if hasattr(msg, "content") else None
                         )
-                        index = text_delta_content.index
-                        yield text_delta_content
-                    # Handle final completion
-                    if last:
-                        # completed_content = message.content[index]
-                        # if completed_content.text:
-                        #     yield completed_content.completed()
-                        yield message.completed()
+                        if msg_id != getattr(msg, "id"):
+                            index = None
+                            message = Message(
+                                type=MessageType.MESSAGE,
+                                role=role,
+                            )
+                            msg_id = getattr(msg, "id")
+                            yield message.in_progress()
+
+                        if content:
+                            # todo support non str content
+                            text_delta_content = TextContent(
+                                delta=True,
+                                index=index,
+                                text=content,
+                            )
+                            text_delta_content = message.add_delta_content(
+                                new_content=text_delta_content,
+                            )
+                            index = text_delta_content.index
+                            yield text_delta_content
+                        # Handle final completion
+                        if last:
+                            # completed_content = message.content[index]
+                            # if completed_content.text:
+                            #     yield completed_content.completed()
+                            yield message.completed()
         elif isinstance(msg, SystemMessage):
             role = "system"
             content = msg.content if hasattr(msg, "content") else None
@@ -163,18 +205,26 @@ async def adapt_langgraph_message_stream(
                 type=MessageType.PLUGIN_CALL_OUTPUT,
                 role="tool",
             )
+            tool_call_output = (
+                msg.content
+                if isinstance(msg.content, str)
+                else json.dumps(msg.content, ensure_ascii=False)
+            )
             # Create function call output data
             function_output_data = FunctionCallOutput(
                 call_id=msg.tool_call_id,
                 name=msg.name,
-                output=json.dumps(content, ensure_ascii=False),
+                output=tool_call_output,
             )
 
             data_content = DataContent(
-                index=None,
                 data=function_output_data.model_dump(),
+                msg_id=plugin_output_message.id,
+            )
+            yield data_content.completed()
+            plugin_output_message.add_content(
+                data_content,
             )
-            plugin_output_message.content = [data_content]
             yield plugin_output_message.completed()
         else:
             role = "assistant"

agentscope_runtime/adapters/ms_agent_framework/message.py

@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=too-many-branches,too-many-statements
+import json
+from typing import Union, List
+from collections import OrderedDict
+
+from agent_framework import (
+    ChatMessage,
+    TextContent as MSTextContent,
+    DataContent as MSDataContent,
+    TextReasoningContent,
+    UriContent,
+    FunctionCallContent,
+    FunctionResultContent,
+)
+
+from ...engine.schemas.agent_schemas import (
+    Message,
+    MessageType,
+)
+
+
+def message_to_ms_agent_framework_message(
+    messages: Union[Message, List[Message]],
+) -> Union[ChatMessage, List[ChatMessage]]:
+    """
+    Convert AgentScope runtime Message(s) to Microsoft agent framework
+    Message(s).
+
+    Reference:
+        https://learn.microsoft.com/en-us/agent-framework/user-guide/agents
+        /running-agents?pivots=programming-language-python
+
+    Args:
+        messages: A single AgentScope runtime Message or list of Messages.
+
+    Returns:
+        A single Microsoft agent framework Message object or a list of
+        Microsoft agent framework Message 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) -> ChatMessage:
+        result = {
+            "author_name": getattr(message, "name", message.role),
+            "role": message.role or "assistant",
+        }
+        _id = getattr(message, "id")
+
+        # if meta exists, prefer original id/name from meta
+        if hasattr(message, "metadata") and isinstance(message.metadata, dict):
+            if "original_id" in message.metadata:
+                _id = message.metadata["original_id"]
+            if "original_name" in message.metadata:
+                result["author_name"] = message.metadata["original_name"]
+            if "metadata" in message.metadata:
+                result["additional_properties"] = message.metadata["metadata"]
+        result["message_id"] = _id
+
+        if message.type in (
+            MessageType.PLUGIN_CALL,
+            MessageType.MCP_TOOL_CALL,
+            MessageType.FUNCTION_CALL,
+        ):
+            # 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["contents"] = [
+                FunctionCallContent(
+                    call_id=message.content[0].data["call_id"],
+                    name=message.content[0].data.get("name"),
+                    arguments=tool_args,
+                ),
+            ]
+        elif message.type in (
+            MessageType.PLUGIN_CALL_OUTPUT,
+            MessageType.MCP_TOOL_CALL_OUTPUT,
+            MessageType.FUNCTION_CALL_OUTPUT,
+        ):
+            result["role"] = "tool"
+            out = None
+            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()
+                    ):
+                        out = _try_loads(v, "", keep_original=True)
+                        break
+            if out is None:
+                out = ""
+            blk = out
+
+            result["contents"] = [
+                FunctionResultContent(
+                    call_id=message.content[0].data["call_id"],
+                    result=blk,
+                ),
+            ]
+        elif message.type in (MessageType.REASONING,):
+            result["contents"] = [
+                TextReasoningContent(
+                    text=message.content[0].text,
+                ),
+            ]
+        else:
+            type_mapping = {
+                "text": (MSTextContent, "text"),
+                "image": (UriContent, "image_url"),
+                "audio": (UriContent, "data"),
+                "data": (MSDataContent, "data"),
+                "file": (MSDataContent, "file_url"),  # Support file_url
+                # "video": (VideoBlock, "video_url", True),
+                # TODO: support video
+            }
+
+            msg_content = []
+            for cnt in message.content:
+                cnt_type = cnt.type or "text"
+
+                if cnt_type not in type_mapping:
+                    raise ValueError(f"Unsupported message type: {cnt_type}")
+
+                block_cls, attr_name = type_mapping[cnt_type]
+                value = getattr(cnt, attr_name)
+
+                if cnt_type in ("image", "audio", "file", "data"):
+                    msg_content.append(
+                        block_cls(
+                            data=value,
+                            type=cnt.type,
+                        ),
+                    )
+
+                else:
+                    # text
+                    if isinstance(value, str):
+                        msg_content.append(
+                            MSTextContent(text=value),
+                        )
+                    else:
+                        try:
+                            json_str = json.dumps(value, ensure_ascii=False)
+                        except Exception:
+                            json_str = str(value)
+                        msg_content.append(MSTextContent(text=json_str))
+
+            result["contents"] = msg_content
+        _msg = ChatMessage(**result)
+        return _msg
+
+    # Handle single or list input
+    if isinstance(messages, Message):
+        return _convert_one(messages)
+    elif isinstance(messages, list):
+        converted_list = [_convert_one(m) for m in messages]
+
+        # Group by original_id
+        grouped = OrderedDict()
+        for msg, orig_msg in zip(messages, converted_list):
+            metadata = getattr(msg, "metadata")
+            if metadata:
+                orig_id = metadata.get(
+                    "original_id",
+                    orig_msg.message_id,
+                )
+            else:
+                # In case metadata is not provided, use the original id
+                orig_id = msg.id
+
+            if orig_id not in grouped:
+                ms_msg = ChatMessage(
+                    author_name=orig_msg.author_name,
+                    role=orig_msg.role,
+                    additional_properties=orig_msg.additional_properties,
+                    contents=list(orig_msg.contents),
+                )
+                ms_msg.message_id = orig_id
+                grouped[orig_id] = ms_msg
+            else:
+                grouped[orig_id].contents.extend(orig_msg.contents)
+
+        return list(grouped.values())
+    else:
+        raise TypeError(
+            f"Expected Message or list[Message], got {type(messages)}",
+        )