agentscope-runtime 1.0.5.post1__py3-none-any.whl → 1.1.0b3__py3-none-any.whl

agentscope_runtime/__init__.py

@@ -1,4 +1,7 @@
 # -*- coding: utf-8 -*-
 from .version import __version__
+from .common.utils.logging import setup_logger
+
+setup_logger()
 
 __all__ = ["__version__"]

agentscope_runtime/adapters/agentscope/message.py

@@ -4,8 +4,9 @@
 import json
 
 from collections import OrderedDict
-from typing import Union, List
+from typing import Union, List, Callable, Optional, Dict, Literal
 from urllib.parse import urlparse
+from typing_extensions import TypedDict, Required
 
 from mcp.types import CallToolResult
 from agentscope.message import (
@@ -24,317 +25,45 @@ from agentscope.mcp._client_base import MCPClientBase
 
 from ...engine.schemas.agent_schemas import (
     Message,
-    FunctionCall,
-    FunctionCallOutput,
     MessageType,
 )
-from ...engine.helpers.agent_api_builder import ResponseBuilder
 
 
-def matches_typed_dict_structure(obj, typed_dict_cls):
-    if not isinstance(obj, dict):
-        return False
-    expected_keys = set(typed_dict_cls.__annotations__.keys())
-    return expected_keys == set(obj.keys())
+# TODO: support in core framework
+class FileBlock(TypedDict, total=False):
+    """The file block"""
 
+    type: Required[Literal["file"]]
+    """The type of the block"""
 
-def agentscope_msg_to_message(
-    messages: Union[Msg, List[Msg]],
-) -> List[Message]:
-    """
-    Convert AgentScope Msg(s) into one or more runtime Message objects
+    source: Required[Base64Source | URLSource]
+    """The src of the file"""
 
-    Args:
-        messages: AgentScope message(s) from streaming.
+    filename: Optional[str]
+    """Optional filename hint (e.g. `report.pdf`)"""
 
-    Returns:
-        List[Message]: One or more constructed runtime Message objects.
-    """
-    if isinstance(messages, Msg):
-        msgs = [messages]
-    elif isinstance(messages, list):
-        msgs = messages
-    else:
-        raise TypeError(f"Expected Msg or list[Msg], got {type(messages)}")
-
-    results: List[Message] = []
-
-    for msg in msgs:
-        role = msg.role or "assistant"
-
-        if isinstance(msg.content, str):
-            # Only text
-            rb = ResponseBuilder()
-            mb = rb.create_message_builder(
-                role=role,
-                message_type=MessageType.MESSAGE,
-            )
-            # add meta field to store old id and name
-            mb.message.metadata = {
-                "original_id": msg.id,
-                "original_name": msg.name,
-                "metadata": msg.metadata,
-            }
-            cb = mb.create_content_builder(content_type="text")
-            cb.set_text(msg.content)
-            cb.complete()
-            mb.complete()
-            results.append(mb.get_message_data())
-            continue
-
-        # msg.content is a list of blocks
-        # We group blocks by high-level message type
-        current_mb = None
-        current_type = None
-
-        for block in msg.content:
-            if isinstance(block, dict):
-                btype = block.get("type", "text")
-            else:
-                continue
-
-            if btype == "text":
-                # Create/continue MESSAGE type
-                if current_type != MessageType.MESSAGE:
-                    if current_mb:
-                        current_mb.complete()
-                        results.append(current_mb.get_message_data())
-                    rb = ResponseBuilder()
-                    current_mb = rb.create_message_builder(
-                        role=role,
-                        message_type=MessageType.MESSAGE,
-                    )
-                    # add meta field to store old id and name
-                    current_mb.message.metadata = {
-                        "original_id": msg.id,
-                        "original_name": msg.name,
-                        "metadata": msg.metadata,
-                    }
-                    current_type = MessageType.MESSAGE
-                cb = current_mb.create_content_builder(content_type="text")
-                cb.set_text(block.get("text", ""))
-                cb.complete()
-
-            elif btype == "thinking":
-                # Create/continue REASONING type
-                if current_type != MessageType.REASONING:
-                    if current_mb:
-                        current_mb.complete()
-                        results.append(current_mb.get_message_data())
-                    rb = ResponseBuilder()
-                    current_mb = rb.create_message_builder(
-                        role=role,
-                        message_type=MessageType.REASONING,
-                    )
-                    # add meta field to store old id and name
-                    current_mb.message.metadata = {
-                        "original_id": msg.id,
-                        "original_name": msg.name,
-                        "metadata": msg.metadata,
-                    }
-                    current_type = MessageType.REASONING
-                cb = current_mb.create_content_builder(content_type="text")
-                cb.set_text(block.get("thinking", ""))
-                cb.complete()
-
-            elif btype == "tool_use":
-                # Always start a new PLUGIN_CALL message
-                if current_mb:
-                    current_mb.complete()
-                    results.append(current_mb.get_message_data())
-                rb = ResponseBuilder()
-                current_mb = rb.create_message_builder(
-                    role=role,
-                    message_type=MessageType.PLUGIN_CALL,
-                )
-                # add meta field to store old id and name
-                current_mb.message.metadata = {
-                    "original_id": msg.id,
-                    "original_name": msg.name,
-                    "metadata": msg.metadata,
-                }
-                current_type = MessageType.PLUGIN_CALL
-                cb = current_mb.create_content_builder(content_type="data")
-
-                if isinstance(block.get("input"), (dict, list)):
-                    arguments = json.dumps(block.get("input"))
-                else:
-                    arguments = block.get("input")
-
-                call_data = FunctionCall(
-                    call_id=block.get("id"),
-                    name=block.get("name"),
-                    arguments=arguments,
-                ).model_dump()
-                cb.set_data(call_data)
-                cb.complete()
-
-            elif btype == "tool_result":
-                # Always start a new PLUGIN_CALL_OUTPUT message
-                if current_mb:
-                    current_mb.complete()
-                    results.append(current_mb.get_message_data())
-                rb = ResponseBuilder()
-                current_mb = rb.create_message_builder(
-                    role=role,
-                    message_type=MessageType.PLUGIN_CALL_OUTPUT,
-                )
-                # add meta field to store old id and name
-                current_mb.message.metadata = {
-                    "original_id": msg.id,
-                    "original_name": msg.name,
-                    "metadata": msg.metadata,
-                }
-                current_type = MessageType.PLUGIN_CALL_OUTPUT
-                cb = current_mb.create_content_builder(content_type="data")
-
-                if isinstance(block.get("output"), (dict, list)):
-                    output = json.dumps(block.get("output"))
-                else:
-                    output = block.get("output")
-
-                output_data = FunctionCallOutput(
-                    call_id=block.get("id"),
-                    name=block.get("name"),
-                    output=output,
-                ).model_dump(exclude_none=True)
-                cb.set_data(output_data)
-                cb.complete()
-
-            elif btype == "image":
-                # Create/continue MESSAGE type with image
-                if current_type != MessageType.MESSAGE:
-                    if current_mb:
-                        current_mb.complete()
-                        results.append(current_mb.get_message_data())
-                    rb = ResponseBuilder()
-                    current_mb = rb.create_message_builder(
-                        role=role,
-                        message_type=MessageType.MESSAGE,
-                    )
-                    # add meta field to store old id and name
-                    current_mb.message.metadata = {
-                        "original_id": msg.id,
-                        "original_name": msg.name,
-                        "metadata": msg.metadata,
-                    }
-                    current_type = MessageType.MESSAGE
-                cb = current_mb.create_content_builder(content_type="image")
-
-                if (
-                    isinstance(block.get("source"), dict)
-                    and block.get("source", {}).get("type") == "url"
-                ):
-                    cb.set_image_url(block.get("source", {}).get("url"))
-
-                elif (
-                    isinstance(block.get("source"), dict)
-                    and block.get("source").get(
-                        "type",
-                    )
-                    == "base64"
-                ):
-                    media_type = block.get("source", {}).get(
-                        "media_type",
-                        "image/jpeg",
-                    )
-                    base64_data = block.get("source", {}).get("data", "")
-                    url = f"data:{media_type};base64,{base64_data}"
-                    cb.set_image_url(url)
-
-                cb.complete()
-
-            elif btype == "audio":
-                # Create/continue MESSAGE type with audio
-                if current_type != MessageType.MESSAGE:
-                    if current_mb:
-                        current_mb.complete()
-                        results.append(current_mb.get_message_data())
-                    rb = ResponseBuilder()
-                    current_mb = rb.create_message_builder(
-                        role=role,
-                        message_type=MessageType.MESSAGE,
-                    )
-                    # add meta field to store old id and name
-                    current_mb.message.metadata = {
-                        "original_id": msg.id,
-                        "original_name": msg.name,
-                        "metadata": msg.metadata,
-                    }
-                    current_type = MessageType.MESSAGE
-                cb = current_mb.create_content_builder(content_type="audio")
-                # URLSource runtime check (dict with type == "url")
-                if (
-                    isinstance(block.get("source"), dict)
-                    and block.get("source", {}).get(
-                        "type",
-                    )
-                    == "url"
-                ):
-                    url = block.get("source", {}).get("url")
-                    cb.content.data = url
-                    try:
-                        cb.content.format = urlparse(url).path.split(".")[-1]
-                    except (AttributeError, IndexError, ValueError):
-                        cb.content.format = None
-
-                # Base64Source runtime check (dict with type == "base64")
-                elif (
-                    isinstance(block.get("source"), dict)
-                    and block.get("source").get(
-                        "type",
-                    )
-                    == "base64"
-                ):
-                    media_type = block.get("source", {}).get(
-                        "media_type",
-                    )
-                    base64_data = block.get("source", {}).get("data", "")
-                    url = f"data:{media_type};base64,{base64_data}"
-
-                    cb.content.data = url
-                    cb.content.format = media_type
-
-                cb.complete()
 
-            else:
-                # Fallback to MESSAGE type
-                if current_type != MessageType.MESSAGE:
-                    if current_mb:
-                        current_mb.complete()
-                        results.append(current_mb.get_message_data())
-                    rb = ResponseBuilder()
-                    current_mb = rb.create_message_builder(
-                        role=role,
-                        message_type=MessageType.MESSAGE,
-                    )
-                    # add meta field to store old id and name
-                    current_mb.message.metadata = {
-                        "original_id": msg.id,
-                        "original_name": msg.name,
-                        "metadata": msg.metadata,
-                    }
-                    current_type = MessageType.MESSAGE
-                cb = current_mb.create_content_builder(content_type="text")
-                cb.set_text(str(block))
-                cb.complete()
-
-        # finalize last open message builder
-        if current_mb:
-            current_mb.complete()
-            results.append(current_mb.get_message_data())
-
-    return results
+def matches_typed_dict_structure(obj, typed_dict_cls):
+    if not isinstance(obj, dict):
+        return False
+    expected_keys = set(typed_dict_cls.__annotations__.keys())
+    return expected_keys == set(obj.keys())
 
 
 def message_to_agentscope_msg(
     messages: Union[Message, List[Message]],
+    type_converters: Optional[Dict[str, Callable]] = None,
 ) -> Union[Msg, List[Msg]]:
     """
     Convert AgentScope runtime Message(s) to AgentScope Msg(s).
 
     Args:
         messages: A single AgentScope runtime Message or list of Messages.
+        type_converters: Optional mapping from ``message.type`` to a callable
+            ``converter(message)``. When provided and the current
+            ``message.type`` exists in the mapping, the corresponding converter
+            will be used and the built-in conversion logic will be skipped for
+            that message.
 
     Returns:
         A single Msg object or a list of Msg objects.
@@ -351,6 +80,10 @@ def message_to_agentscope_msg(
         return default
 
     def _convert_one(message: Message) -> Msg:
+        # Used for custom conversion
+        if type_converters and message.type in type_converters:
+            return type_converters[message.type](message)
+
         # Normalize role
         if message.role == "tool":
             role_label = "system"  # AgentScope not support tool as role
@@ -474,8 +207,8 @@ def message_to_agentscope_msg(
                 "image": (ImageBlock, "image_url"),
                 "audio": (AudioBlock, "data"),
                 "data": (TextBlock, "data"),
-                # "video": (VideoBlock, "video_url", True),
-                # TODO: support video
+                "video": (VideoBlock, "video_url"),
+                "file": (FileBlock, "file_url"),
             }
 
             msg_content = []
@@ -547,6 +280,63 @@ def message_to_agentscope_msg(
                             msg_content.append(
                                 block_cls(type=cnt_type, source=base64_source),
                             )
+                elif cnt_type == "video":
+                    if (
+                        value
+                        and isinstance(value, str)
+                        and value.startswith("data:")
+                    ):
+                        mediatype_part = value.split(";")[0].replace(
+                            "data:",
+                            "",
+                        )
+                        base64_data = value.split(",")[1]
+                        base64_source = Base64Source(
+                            type="base64",
+                            media_type=mediatype_part,
+                            data=base64_data,
+                        )
+                        msg_content.append(
+                            block_cls(type=cnt_type, source=base64_source),
+                        )
+                    else:
+                        url_source = URLSource(type="url", url=value)
+                        msg_content.append(
+                            block_cls(type=cnt_type, source=url_source),
+                        )
+                elif cnt_type == "file":
+                    filename = cnt.filename
+                    if (
+                        value
+                        and isinstance(value, str)
+                        and value.startswith("data:")
+                    ):
+                        mediatype_part = value.split(";")[0].replace(
+                            "data:",
+                            "",
+                        )
+                        base64_data = value.split(",")[1]
+                        base64_source = Base64Source(
+                            type="base64",
+                            media_type=mediatype_part,
+                            data=base64_data,
+                        )
+                        msg_content.append(
+                            block_cls(
+                                type=cnt_type,
+                                source=base64_source,
+                                filename=filename,
+                            ),
+                        )
+                    else:
+                        url_source = URLSource(type="url", url=value)
+                        msg_content.append(
+                            block_cls(
+                                type=cnt_type,
+                                source=url_source,
+                                filename=filename,
+                            ),
+                        )
                 else:
                     # text & data
                     if isinstance(value, str):

agentscope_runtime/adapters/agentscope/stream.py

@@ -1,9 +1,10 @@
 # -*- coding: utf-8 -*-
 # pylint: disable=too-many-nested-blocks,too-many-branches,too-many-statements
 import copy
+import inspect
 import json
 
-from typing import AsyncIterator, Tuple, List, Union
+from typing import AsyncIterator, Tuple, List, Union, Optional, Callable, Dict
 from urllib.parse import urlparse
 
 from agentscope import setup_logger
@@ -16,7 +17,9 @@ from ...engine.schemas.agent_schemas import (
     TextContent,
     ImageContent,
     AudioContent,
+    VideoContent,
     DataContent,
+    FileContent,
     McpCall,
     McpCallOutput,
     FunctionCall,
@@ -29,6 +32,8 @@ setup_logger("ERROR")
 
 async def adapt_agentscope_message_stream(
     source_stream: AsyncIterator[Tuple[Msg, bool]],
+    type_converters: Optional[Dict[str, Callable]] = None,
+    **kwargs,  # pylint:disable=unused-argument
 ) -> AsyncIterator[Union[Message, Content]]:
     # Initialize variables to avoid uncaught errors
     msg_id = None
@@ -136,6 +141,44 @@ async def adapt_agentscope_message_stream(
                     index = text_delta_content.index
                     yield text_delta_content
                 elif isinstance(element, dict):
+                    # Used for custom conversion
+                    if (
+                        type_converters
+                        and element.get("type") in type_converters
+                    ):
+                        blk_type = element.get("type")
+                        if not isinstance(blk_type, str):
+                            continue
+                        fn = type_converters[blk_type]
+                        # Send  message, element, last, tool_start, metadata
+                        # and usage
+                        out = fn(
+                            element,
+                            message,
+                            last,
+                            tool_start,
+                            metadata,
+                            usage,
+                        )
+                        # Case 1: async generator / async iterator
+                        if hasattr(out, "__aiter__"):
+                            async for ev in out:
+                                yield ev
+                            continue
+
+                        # Case 2: sync generator / iterator
+                        if inspect.isgenerator(out):
+                            for ev in out:
+                                yield ev
+                            continue
+
+                        # Only generator styles are supported
+                        raise TypeError(
+                            f"type_converters['{blk_type}'] must return a "
+                            f"generator/iterator or an async generator/async "
+                            f"iterator, got: {type(out)}",
+                        )
+
                     if element.get("type") == "text":  # Text
                         text = element.get(
                             "text",
@@ -446,7 +489,12 @@ async def adapt_agentscope_message_stream(
                                 == "url"
                             ):
                                 kwargs.update(
-                                    {"image_url": element.get("source")},
+                                    {
+                                        "image_url": element.get(
+                                            "source",
+                                            {},
+                                        ).get("url"),
+                                    },
                                 )
 
                             elif (
@@ -471,7 +519,7 @@ async def adapt_agentscope_message_stream(
                                 index=index,
                                 **kwargs,
                             )
-                        elif element.get("text") == "audio":
+                        elif element.get("type") == "audio":
                             kwargs = {}
                             if (
                                 isinstance(element.get("source"), dict)
@@ -515,6 +563,88 @@ async def adapt_agentscope_message_stream(
                                 index=index,
                                 **kwargs,
                             )
+                        elif element.get("type") == "video":
+                            kwargs = {}
+                            if (
+                                isinstance(element.get("source"), dict)
+                                and element.get("source", {}).get(
+                                    "type",
+                                )
+                                == "url"
+                            ):
+                                kwargs.update(
+                                    {
+                                        "video_url": element.get(
+                                            "source",
+                                            {},
+                                        ).get("url"),
+                                    },
+                                )
+
+                            elif (
+                                isinstance(element.get("source"), dict)
+                                and element.get("source").get(
+                                    "type",
+                                )
+                                == "base64"
+                            ):
+                                media_type = element.get("source", {}).get(
+                                    "media_type",
+                                    "video/mp4",
+                                )
+                                base64_data = element.get("source", {}).get(
+                                    "data",
+                                    "",
+                                )
+                                url = f"data:{media_type};base64,{base64_data}"
+                                kwargs.update({"video_url": url})
+                            delta_content = VideoContent(
+                                delta=True,
+                                index=index,
+                                **kwargs,
+                            )
+                        elif element.get("type") == "file":
+                            kwargs = {
+                                "filename": element.get("filename"),
+                            }
+                            if (
+                                isinstance(element.get("source"), dict)
+                                and element.get("source", {}).get(
+                                    "type",
+                                )
+                                == "url"
+                            ):
+                                kwargs.update(
+                                    {
+                                        "file_url": element.get(
+                                            "source",
+                                            {},
+                                        ).get("url"),
+                                    },
+                                )
+
+                            elif (
+                                isinstance(element.get("source"), dict)
+                                and element.get("source").get(
+                                    "type",
+                                )
+                                == "base64"
+                            ):
+                                media_type = element.get("source", {}).get(
+                                    "media_type",
+                                    "application/octet-stream",
+                                )
+                                base64_data = element.get("source", {}).get(
+                                    "data",
+                                    "",
+                                )
+                                url = f"data:{media_type};base64,{base64_data}"
+                                kwargs.update({"file_url": url})
+                            delta_content = FileContent(
+                                delta=True,
+                                index=index,
+                                **kwargs,
+                            )
                         else:
                             delta_content = TextContent(
                                 delta=True,

agentscope_runtime/adapters/agno/message.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-from typing import Union, List
+from typing import Union, List, Callable, Optional, Dict
 
 from agentscope.formatter import OpenAIChatFormatter
 
@@ -9,18 +9,27 @@ from ..agentscope.message import message_to_agentscope_msg
 
 async def message_to_agno_message(
     messages: Union[Message, List[Message]],
+    type_converters: Optional[Dict[str, Callable]] = None,
 ) -> Union[dict, List[dict]]:
     """
     Convert AgentScope runtime Message(s) to Agno Message(s).
 
     Args:
         messages: A single AgentScope runtime Message or list of Messages.
+        type_converters: Optional mapping from ``message.type`` to a callable
+            ``converter(message)``. When provided and the current
+            ``message.type`` exists in the mapping, the corresponding converter
+            will be used and the built-in conversion logic will be skipped for
+            that message.
 
     Returns:
         A single AgnoMessage object or a list of AgnoMessage objects.
     """
 
-    as_msgs = message_to_agentscope_msg(messages)
+    as_msgs = message_to_agentscope_msg(
+        messages,
+        type_converters=type_converters,
+    )
     raw_list = isinstance(as_msgs, list)
     as_msgs = as_msgs if raw_list else [as_msgs]
 

agentscope_runtime/adapters/agno/stream.py

@@ -31,6 +31,7 @@ from ...engine.helpers.agent_api_builder import ResponseBuilder
 
 async def adapt_agno_message_stream(
     source_stream: AsyncIterator[BaseAgentRunEvent],
+    **kwargs,  # pylint:disable=unused-argument
 ) -> AsyncIterator[Union[Message, Content]]:
     rb = ResponseBuilder()
     mb = None

agentscope_runtime/adapters/langgraph/__init__.py

@@ -2,11 +2,9 @@
 """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
+from .message import message_to_langgraph_msg
 
 __all__ = [
-    "langgraph_msg_to_message",
     "message_to_langgraph_msg",
 ]