agentscope-runtime 1.0.4__py3-none-any.whl → 1.0.4a1__py3-none-any.whl

agentscope_runtime/adapters/ms_agent_framework/message.py

@@ -1,205 +0,0 @@
-# -*- 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)}",
-        )

agentscope_runtime/adapters/ms_agent_framework/stream.py

@@ -1,418 +0,0 @@
-# -*- coding: utf-8 -*-
-# pylint: disable=too-many-branches,too-many-statements
-import copy
-import json
-
-from typing import AsyncIterator, Union, List
-
-from agent_framework import (
-    AgentRunResponseUpdate,
-    TextContent as MSTextContent,
-    DataContent as MSDataContent,
-    TextReasoningContent,
-    UriContent,
-    FunctionCallContent,
-    FunctionResultContent,
-    ErrorContent,
-    UsageContent,
-)
-
-from ..utils import _update_obj_attrs
-from ...engine.schemas.exception import AgentRuntimeErrorException
-from ...engine.schemas.agent_schemas import (
-    Message,
-    TextContent,
-    Content,
-    DataContent,
-    FunctionCall,
-    FunctionCallOutput,
-    MessageType,
-    ImageContent,
-    AudioContent,
-    FileContent,
-)
-
-
-async def adapt_ms_agent_framework_message_stream(
-    source_stream: AsyncIterator[AgentRunResponseUpdate],
-) -> AsyncIterator[Union[Message, Content]]:
-    # Initialize variables to avoid uncaught errors
-    msg_id = None
-    usage = None
-    tool_start = False
-    message = None
-    reasoning_message = None
-    plugin_call_message = None
-    call_id = None
-    text_delta_content = None
-    data_delta_content = None
-    index = None
-
-    # Run agent
-    async for msg in source_stream:
-        # deepcopy required to avoid modifying the original message object
-        # which may be used elsewhere in the streaming pipeline
-        msg = copy.deepcopy(msg)
-
-        assert isinstance(
-            msg,
-            AgentRunResponseUpdate,
-        ), f"Expected AgentRunResponseUpdate, got {type(msg)}"
-
-        # If a new message, create new Message
-        if msg.message_id != msg_id:
-            # If a new message, yield previous content
-            if text_delta_content is not None:
-                yield text_delta_content.completed()
-                text_delta_content = None
-
-            if data_delta_content is not None:
-                yield data_delta_content.completed()
-                data_delta_content = None
-
-            if message is not None:
-                message = _update_obj_attrs(
-                    message,
-                    usage=usage,
-                )
-
-                yield message.completed()
-                message = None
-
-            if reasoning_message is not None:
-                reasoning_message = _update_obj_attrs(
-                    reasoning_message,
-                    usage=usage,
-                )
-
-                yield reasoning_message.completed()
-                reasoning_message = None
-
-            if plugin_call_message is not None:
-                plugin_call_message = _update_obj_attrs(
-                    plugin_call_message,
-                    usage=usage,
-                )
-
-                yield plugin_call_message.completed()
-                plugin_call_message = None
-
-            index = None
-
-            # Note: Tool use content only happens in the last of messages
-            tool_start = False
-
-            # Cache msg id
-            msg_id = msg.message_id
-
-        new_blocks = []
-        new_tool_blocks = []
-        if isinstance(msg.contents, List):
-            for block in msg.contents:
-                if block.type != "function_call":
-                    new_blocks.append(block)
-                else:
-                    new_tool_blocks.append(block)
-            if new_tool_blocks:
-                if tool_start:
-                    msg.contents = new_tool_blocks
-                else:
-                    msg.contents = new_blocks
-                    tool_start = True
-
-            else:
-                msg.contents = new_blocks
-
-        if not msg.contents:
-            continue
-
-        # msg content
-        content = msg.contents
-
-        for element in content:
-            if isinstance(element, UsageContent):
-                # TODO: consider keeping the same format with as
-                usage = element.details.to_dict()
-
-            elif isinstance(element, MSTextContent):  # Text
-                text = element.text
-                if text:
-                    if message is None:
-                        message = Message(
-                            role="assistant",
-                            type=MessageType.MESSAGE,
-                        )
-
-                        index = None
-                        message = _update_obj_attrs(
-                            message,
-                            usage=usage,
-                        )
-                        yield message.in_progress()
-
-                    text_delta_content = TextContent(
-                        delta=True,
-                        index=index,
-                        text=text,
-                    )
-                    text_delta_content = message.add_delta_content(
-                        new_content=text_delta_content,
-                    )
-                    index = text_delta_content.index
-
-                    # Only yield valid text
-                    if text_delta_content.text:
-                        yield text_delta_content
-
-                    if tool_start:
-                        text_delta_content = message.content[index]
-                        if text_delta_content.text:
-                            yield text_delta_content.completed()
-                            text_delta_content = None
-
-                        message = _update_obj_attrs(
-                            message,
-                            usage=usage,
-                        )
-                        yield message.completed()
-                        message = None
-                        index = None
-
-            elif isinstance(element, TextReasoningContent):  # Thinking
-                reasoning = element.text
-                if reasoning:
-                    if reasoning_message is None:
-                        index = None
-                        reasoning_message = Message(
-                            role="assistant",
-                            type=MessageType.REASONING,
-                        )
-
-                        reasoning_message = _update_obj_attrs(
-                            reasoning_message,
-                            usage=usage,
-                        )
-                        yield reasoning_message.in_progress()
-
-                    text_delta_content = TextContent(
-                        delta=True,
-                        index=index,
-                        text=reasoning,
-                    )
-                    text_delta_content = reasoning_message.add_delta_content(
-                        new_content=text_delta_content,
-                    )
-                    index = text_delta_content.index
-
-                    # Only yield valid text
-                    if text_delta_content.text:
-                        yield text_delta_content
-
-                    if tool_start:
-                        text_delta_content = reasoning_message.content[index]
-                        if text_delta_content.text:
-                            yield text_delta_content.completed()
-                            text_delta_content = None
-
-                        reasoning_message = _update_obj_attrs(
-                            reasoning_message,
-                            usage=usage,
-                        )
-                        yield reasoning_message.completed()
-                        reasoning_message = None
-                        index = None
-
-            elif isinstance(element, FunctionCallContent):  # Tool use
-                msg_type = MessageType.PLUGIN_CALL
-                fc_cls = FunctionCall
-                fc_kwargs = {}
-
-                if element.call_id is not None:  # New tool call
-                    index = None
-                    call_id = element.call_id
-                    plugin_call_message = Message(
-                        type=msg_type,
-                        role="assistant",
-                    )
-                    plugin_call_message = _update_obj_attrs(
-                        plugin_call_message,
-                        usage=usage,
-                    )
-                    yield plugin_call_message.in_progress()
-                else:
-                    # The last plugin_call_message is completed
-                    if data_delta_content is not None:
-                        yield data_delta_content.completed()
-                        data_delta_content = None
-                    if plugin_call_message is not None:
-                        plugin_call_message = _update_obj_attrs(
-                            plugin_call_message,
-                            usage=usage,
-                        )
-                        yield plugin_call_message.completed()
-                        plugin_call_message = None
-                        index = None
-
-                data_delta_content = DataContent(
-                    index=index,
-                    data=fc_cls(
-                        call_id=call_id,
-                        name=element.name,
-                        arguments=element.arguments,
-                        **fc_kwargs,
-                    ).model_dump(),
-                    delta=True,
-                    msg_id=plugin_call_message.id,
-                )
-                yield data_delta_content.in_progress()
-
-                plugin_call_message = _update_obj_attrs(
-                    plugin_call_message,
-                    usage=usage,
-                )
-                yield plugin_call_message.in_progress()
-
-            elif isinstance(element, FunctionResultContent):  # Tool result
-                try:
-                    json_str = json.dumps(
-                        element.result,
-                        ensure_ascii=False,
-                    )
-                except Exception:
-                    json_str = str(element.result)
-
-                data_delta_content = DataContent(
-                    index=None,
-                    data=FunctionCallOutput(
-                        call_id=element.call_id,
-                        output=json_str,
-                    ).model_dump(),
-                )
-                plugin_output_message = Message(
-                    type=MessageType.PLUGIN_CALL_OUTPUT,
-                    role="tool",
-                    content=[data_delta_content],
-                )
-                plugin_output_message = _update_obj_attrs(
-                    plugin_output_message,
-                    usage=usage,
-                )
-                yield plugin_output_message.completed()
-                message = None
-                reasoning_message = None
-
-                index = None
-
-            elif isinstance(element, MSDataContent):
-                delta_content = DataContent(
-                    delta=True,
-                    index=index,
-                    data=element.uri,
-                    type=element.type,
-                )
-                delta_content = message.add_delta_content(
-                    new_content=delta_content,
-                )
-                index = delta_content.index
-                yield delta_content
-
-            elif isinstance(element, UriContent):
-                kwargs = {}
-
-                if "image" in element.type:
-                    cnt_cls = ImageContent
-                    kwargs.update(
-                        {
-                            "type": element.type,
-                            "image_url": element.uri,
-                        },
-                    )
-                elif "audio" in element.type:
-                    cnt_cls = AudioContent
-                    kwargs.update(
-                        {
-                            "type": element.type,
-                            "data": element.uri,
-                            "format": element.media_type,
-                        },
-                    )
-                elif "video" in element.type:
-                    # TODO: support video type
-                    cnt_cls = ImageContent
-                    kwargs.update(
-                        {
-                            "type": element.media_type,
-                            "image_url": element.uri,
-                        },
-                    )
-                else:
-                    cnt_cls = FileContent
-                    kwargs.update(
-                        {
-                            "type": element.type,
-                            "file_url": element.uri,
-                        },
-                    )
-
-                delta_content = cnt_cls(
-                    delta=False,
-                    index=index,
-                    **kwargs,
-                )
-                delta_content = message.add_delta_content(
-                    new_content=delta_content,
-                )
-                index = delta_content.index
-                yield delta_content
-
-            elif isinstance(element, ErrorContent):
-                raise AgentRuntimeErrorException(
-                    code=element.error_code,
-                    message=element.message,
-                    details=element.details,
-                )
-
-            else:
-                raise ValueError(f"Unknown element type: {type(element)}")
-
-    if (
-        text_delta_content is not None
-        and text_delta_content.status == "in_progress"
-    ):
-        yield text_delta_content.completed()
-
-    if (
-        data_delta_content is not None
-        and data_delta_content.status == "in_progress"
-    ):
-        yield data_delta_content.completed()
-
-    if message is not None and message.status == "in_progress":
-        message = _update_obj_attrs(
-            message,
-            usage=usage,
-        )
-
-        yield message.completed()
-
-    if (
-        reasoning_message is not None
-        and reasoning_message.status == "in_progress"
-    ):
-        reasoning_message = _update_obj_attrs(
-            reasoning_message,
-            usage=usage,
-        )
-
-        yield reasoning_message.completed()
-
-    if (
-        plugin_call_message is not None
-        and plugin_call_message.status == "in_progress"
-    ):
-        plugin_call_message = _update_obj_attrs(
-            plugin_call_message,
-            usage=usage,
-        )
-
-        yield plugin_call_message.completed()

agentscope_runtime/adapters/utils.py

@@ -1,6 +0,0 @@
-# -*- coding: utf-8 -*-
-def _update_obj_attrs(obj, **attrs):
-    for key, value in attrs.items():
-        if hasattr(obj, key):
-            setattr(obj, key, value)
-    return obj