agentscope-runtime 1.0.0b2__py3-none-any.whl → 1.0.2__py3-none-any.whl

agentscope_runtime/adapters/langgraph/message.py

@@ -0,0 +1,257 @@
+# -*- coding: utf-8 -*-
+# pylint:disable=too-many-branches,too-many-statements,too-many-return-statements
+"""Message conversion between LangGraph and AgentScope runtime."""
+import json
+
+from collections import OrderedDict
+from typing import Union, List
+
+from langchain_core.messages import (
+    AIMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+    BaseMessage,
+)
+
+from ...engine.schemas.agent_schemas import (
+    Message,
+    FunctionCall,
+    MessageType,
+)
+from ...engine.helpers.agent_api_builder import ResponseBuilder
+
+
+def langgraph_msg_to_message(
+    messages: Union[BaseMessage, List[BaseMessage]],
+) -> List[Message]:
+    """
+    Convert LangGraph BaseMessage(s) into one or more runtime Message objects
+
+    Args:
+        messages: LangGraph message(s) from streaming.
+
+    Returns:
+        List[Message]: One or more constructed runtime Message objects.
+    """
+    if isinstance(messages, BaseMessage):
+        msgs = [messages]
+    elif isinstance(messages, list):
+        msgs = messages
+    else:
+        raise TypeError(
+            f"Expected BaseMessage or list[BaseMessage], got {type(messages)}",
+        )
+
+    results: List[Message] = []
+
+    for msg in msgs:
+        # Map LangGraph roles to runtime roles
+        if isinstance(msg, HumanMessage):
+            role = "user"
+        elif isinstance(msg, AIMessage):
+            role = "assistant"
+        elif isinstance(msg, SystemMessage):
+            role = "system"
+        elif isinstance(msg, ToolMessage):
+            role = "tool"
+        else:
+            role = "assistant"  # default fallback
+
+        # Handle tool calls in AIMessage
+        if isinstance(msg, AIMessage) and msg.tool_calls:
+            # Convert each tool call to a PLUGIN_CALL message
+            for tool_call in msg.tool_calls:
+                rb = ResponseBuilder()
+                mb = rb.create_message_builder(
+                    role=role,
+                    message_type=MessageType.PLUGIN_CALL,
+                )
+                # Add metadata
+                mb.message.metadata = {
+                    "original_id": getattr(msg, "id", None),
+                    "name": getattr(msg, "name", None),
+                    "metadata": getattr(msg, "additional_kwargs", {}),
+                }
+                cb = mb.create_content_builder(content_type="data")
+
+                call_data = FunctionCall(
+                    call_id=tool_call.get("id", ""),
+                    name=tool_call.get("name", ""),
+                    arguments=json.dumps(tool_call.get("args", {})),
+                ).model_dump()
+                cb.set_data(call_data)
+                cb.complete()
+                mb.complete()
+                results.append(mb.get_message_data())
+
+            # If there's content in addition to tool calls,
+            # create a separate message
+            if msg.content:
+                rb = ResponseBuilder()
+                mb = rb.create_message_builder(
+                    role=role,
+                    message_type=MessageType.MESSAGE,
+                )
+                mb.message.metadata = {
+                    "original_id": getattr(msg, "id", None),
+                    "name": getattr(msg, "name", None),
+                    "metadata": getattr(msg, "additional_kwargs", {}),
+                }
+                cb = mb.create_content_builder(content_type="text")
+                cb.set_text(str(msg.content))
+                cb.complete()
+                mb.complete()
+                results.append(mb.get_message_data())
+        else:
+            # Regular message conversion
+            rb = ResponseBuilder()
+            mb = rb.create_message_builder(
+                role=role,
+                message_type=MessageType.MESSAGE,
+            )
+            # Add metadata
+            mb.message.metadata = {
+                "original_id": getattr(msg, "id", None),
+                "name": getattr(msg, "name", None),
+                "metadata": getattr(msg, "additional_kwargs", {}),
+            }
+            cb = mb.create_content_builder(content_type="text")
+            cb.set_text(str(msg.content) if msg.content else "")
+            cb.complete()
+            mb.complete()
+            results.append(mb.get_message_data())
+
+    return results
+
+
+def message_to_langgraph_msg(
+    messages: Union[Message, List[Message]],
+) -> Union[BaseMessage, List[BaseMessage]]:
+    """
+    Convert AgentScope runtime Message(s) to LangGraph BaseMessage(s).
+
+    Args:
+        messages: A single AgentScope runtime Message or list of Messages.
+
+    Returns:
+        A single BaseMessage object or a list of BaseMessage objects.
+    """
+
+    def _convert_one(message: Message) -> BaseMessage:
+        # Map runtime roles to LangGraph roles
+        role_map = {
+            "user": HumanMessage,
+            "assistant": AIMessage,
+            "system": SystemMessage,
+            "tool": ToolMessage,
+        }
+
+        message_cls = role_map.get(
+            message.role,
+            AIMessage,
+        )  # default to AIMessage
+
+        # Handle different message types
+        if message.type in (
+            MessageType.PLUGIN_CALL,
+            MessageType.FUNCTION_CALL,
+        ):
+            # Convert PLUGIN_CALL, FUNCTION_CALL to AIMessage with tool_calls
+            if message.content and hasattr(message.content[0], "data"):
+                try:
+                    func_call_data = message.content[0].data
+                    tool_calls = [
+                        {
+                            "name": func_call_data.get("name", ""),
+                            "args": json.loads(
+                                func_call_data.get("arguments", "{}"),
+                            ),
+                            "id": func_call_data.get("call_id", ""),
+                        },
+                    ]
+                    return AIMessage(content="", tool_calls=tool_calls)
+                except (json.JSONDecodeError, KeyError):
+                    return message_cls(content=str(message.content))
+            else:
+                return message_cls(content="")
+
+        elif message.type in (
+            MessageType.PLUGIN_CALL_OUTPUT,
+            MessageType.FUNCTION_CALL_OUTPUT,
+        ):
+            # Convert PLUGIN_CALL_OUTPUT, FUNCTION_CALL_OUTPUT to ToolMessage
+            if message.content and hasattr(message.content[0], "data"):
+                try:
+                    func_output_data = message.content[0].data
+                    tool_call_id = func_output_data.get("call_id", "")
+                    content = func_output_data.get("output", "")
+                    # Try to parse JSON output
+                    try:
+                        content = json.loads(content)
+                    except json.JSONDecodeError:
+                        pass
+                    return ToolMessage(
+                        content=content,
+                        tool_call_id=tool_call_id,
+                    )
+                except KeyError:
+                    return message_cls(content=str(message.content))
+            else:
+                return message_cls(content="")
+
+        else:
+            # Regular message conversion
+            content = ""
+            if message.content:
+                # Concatenate all content parts
+                content_parts = []
+                for cnt in message.content:
+                    if hasattr(cnt, "text"):
+                        content_parts.append(cnt.text)
+                    elif hasattr(cnt, "data"):
+                        content_parts.append(str(cnt.data))
+                content = (
+                    "".join(content_parts)
+                    if content_parts
+                    else str(message.content)
+                )
+
+            # For ToolMessage, we need tool_call_id
+            if message_cls == ToolMessage:
+                tool_call_id = ""
+                if hasattr(message, "metadata") and isinstance(
+                    message.metadata,
+                    dict,
+                ):
+                    tool_call_id = message.metadata.get("tool_call_id", "")
+                return ToolMessage(content=content, tool_call_id=tool_call_id)
+
+            return message_cls(content=content)
+
+    # 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 for messages that should be combined
+        grouped = OrderedDict()
+        for msg, orig_msg in zip(messages, converted_list):
+            metadata = getattr(msg, "metadata", {})
+            if metadata:
+                orig_id = metadata.get("original_id", getattr(msg, "id", None))
+            else:
+                orig_id = getattr(msg, "id", None)
+
+            if orig_id and orig_id not in grouped:
+                grouped[orig_id] = orig_msg
+            # For now, we won't combine messages as LangGraph messages
+            # are typically separate,
+            # But we keep the structure in case we need it later
+
+        return list(grouped.values()) if grouped else converted_list
+    else:
+        raise TypeError(
+            f"Expected Message or list[Message], got {type(messages)}",
+        )

agentscope_runtime/adapters/langgraph/stream.py

@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=too-many-branches,too-many-statements
+# pylint: disable=simplifiable-if-expression
+"""Streaming adapter for LangGraph messages."""
+import json
+from functools import reduce
+
+from typing import AsyncIterator, Tuple
+
+from langchain_core.messages import (
+    BaseMessage,
+    AIMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+
+from ...engine.schemas.agent_schemas import (
+    Message,
+    TextContent,
+    DataContent,
+    FunctionCall,
+    FunctionCallOutput,
+    MessageType,
+)
+
+
+async def adapt_langgraph_message_stream(
+    source_stream: AsyncIterator[Tuple[BaseMessage, bool]],
+) -> AsyncIterator[Message]:
+    """
+    Optimized version of the stream adapter for LangGraph messages.
+    Reduces code duplication and improves clarity.
+    """
+    # Track message IDs to detect new messages
+    msg_id = None
+    index = None
+
+    # Track tool usage
+    tool_started = False
+    tool_call_chunk_msgs = []
+
+    async for msg, last in source_stream:
+        # Determine message role
+        if isinstance(msg, HumanMessage):
+            role = "user"
+            content = msg.content if hasattr(msg, "content") else None
+            if msg_id != getattr(msg, "id"):
+                message = Message(type=MessageType.MESSAGE, role=role)
+                yield message.in_progress()
+                msg_id = getattr(msg, "id")
+            if content:
+                text_delta_content = TextContent(
+                    delta=True,
+                    index=None,
+                    text=content,
+                )
+                text_delta_content = message.add_delta_content(
+                    new_content=text_delta_content,
+                )
+                yield text_delta_content
+                yield message.completed()
+        elif isinstance(msg, AIMessage):
+            role = "assistant"
+            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,
+                        )
+                        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,
+                        )
+
+                        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()
+
+                    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
+            if msg_id != getattr(msg, "id"):
+                message = Message(type=MessageType.MESSAGE, role=role)
+                yield message.in_progress()
+                msg_id = getattr(msg, "id")
+            if content:
+                text_delta_content = TextContent(
+                    delta=True,
+                    index=None,
+                    text=content,
+                )
+                text_delta_content = message.add_delta_content(
+                    new_content=text_delta_content,
+                )
+                yield text_delta_content
+        elif isinstance(msg, ToolMessage):
+            role = "tool"
+            content = msg.content if hasattr(msg, "content") else None
+            if msg_id != getattr(msg, "id"):
+                message = Message(type=MessageType.MESSAGE, role=role)
+                yield message.in_progress()
+                msg_id = getattr(msg, "id")
+            plugin_output_message = Message(
+                type=MessageType.PLUGIN_CALL_OUTPUT,
+                role="tool",
+            )
+            # 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),
+            )
+
+            data_content = DataContent(
+                index=None,
+                data=function_output_data.model_dump(),
+            )
+            plugin_output_message.content = [data_content]
+            yield plugin_output_message.completed()
+        else:
+            role = "assistant"
+            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()
+
+            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()

agentscope_runtime/cli/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+"""AgentScope Runtime CLI - Unified command-line interface for agent
+lifecycle management."""
+
+from agentscope_runtime.cli.cli import cli
+
+__all__ = ["cli"]

agentscope_runtime/cli/cli.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+"""AgentScope Runtime CLI - Main entry point."""
+# pylint: disable=no-value-for-parameter
+
+import os
+
+import click
+
+# Import command groups (to be registered below)
+from agentscope_runtime.cli.commands import (
+    chat,
+    run,
+    web,
+    deploy,
+    list_cmd,
+    status,
+    stop,
+    invoke,
+    sandbox,
+)
+from agentscope_runtime.version import __version__
+
+# Set default environment variable for trace console output
+# This must be set BEFORE importing any runtime modules
+# Individual commands can override this for verbose mode
+if "TRACE_ENABLE_LOG" not in os.environ:
+    os.environ.setdefault("TRACE_ENABLE_LOG", "false")
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="agentscope")
+@click.pass_context
+def cli(ctx):
+    """
+    AgentScope Runtime - Unified CLI for agent lifecycle management.
+
+    Manage your agent development, deployment, and runtime operations
+    from a single command.
+
+    """
+    # Ensure context object exists
+    ctx.ensure_object(dict)
+
+
+# Register commands
+cli.add_command(chat.chat)
+cli.add_command(run.run)
+cli.add_command(web.web)
+cli.add_command(deploy.deploy)
+cli.add_command(list_cmd.list_deployments)
+cli.add_command(status.status)
+cli.add_command(stop.stop)
+cli.add_command(invoke.invoke)
+cli.add_command(sandbox.sandbox)
+
+
+def main():
+    """Entry point for console script."""
+    cli(obj={})
+
+
+if __name__ == "__main__":
+    main()

agentscope_runtime/cli/commands/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+"""CLI command implementations."""