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

agentscope_runtime/adapters/langgraph/message.py

@@ -4,7 +4,7 @@
 import json
 
 from collections import OrderedDict
-from typing import Union, List
+from typing import Union, List, Callable, Optional, Dict
 
 from langchain_core.messages import (
     AIMessage,
@@ -16,129 +16,34 @@ from langchain_core.messages import (
 
 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]],
+    type_converters: Optional[Dict[str, Callable]] = None,
 ) -> Union[BaseMessage, List[BaseMessage]]:
     """
     Convert AgentScope runtime Message(s) to LangGraph BaseMessage(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 BaseMessage object or a list of BaseMessage objects.
     """
 
     def _convert_one(message: Message) -> BaseMessage:
+        # Used for custom conversion
+        if type_converters and message.type in type_converters:
+            return type_converters[message.type](message)
+
         # Map runtime roles to LangGraph roles
         role_map = {
             "user": HumanMessage,

agentscope_runtime/adapters/langgraph/stream.py

@@ -27,6 +27,7 @@ from ...engine.schemas.agent_schemas import (
 
 async def adapt_langgraph_message_stream(
     source_stream: AsyncIterator[Tuple[BaseMessage, bool]],
+    **kwargs,  # pylint:disable=unused-argument
 ) -> AsyncIterator[Message]:
     """
     Optimized version of the stream adapter for LangGraph messages.

agentscope_runtime/adapters/ms_agent_framework/message.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 # pylint: disable=too-many-branches,too-many-statements
 import json
-from typing import Union, List
+from typing import Union, List, Callable, Optional, Dict
 from collections import OrderedDict
 
 from agent_framework import (
@@ -22,6 +22,7 @@ from ...engine.schemas.agent_schemas import (
 
 def message_to_ms_agent_framework_message(
     messages: Union[Message, List[Message]],
+    type_converters: Optional[Dict[str, Callable]] = None,
 ) -> Union[ChatMessage, List[ChatMessage]]:
     """
     Convert AgentScope runtime Message(s) to Microsoft agent framework
@@ -33,6 +34,11 @@ def message_to_ms_agent_framework_message(
 
     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 Microsoft agent framework Message object or a list of
@@ -50,6 +56,10 @@ def message_to_ms_agent_framework_message(
         return default
 
     def _convert_one(message: Message) -> ChatMessage:
+        # Used for custom conversion
+        if type_converters and message.type in type_converters:
+            return type_converters[message.type](message)
+
         result = {
             "author_name": getattr(message, "name", message.role),
             "role": message.role or "assistant",

agentscope_runtime/adapters/ms_agent_framework/stream.py

@@ -35,6 +35,7 @@ from ...engine.schemas.agent_schemas import (
 
 async def adapt_ms_agent_framework_message_stream(
     source_stream: AsyncIterator[AgentRunResponseUpdate],
+    **kwargs,  # pylint:disable=unused-argument
 ) -> AsyncIterator[Union[Message, Content]]:
     # Initialize variables to avoid uncaught errors
     msg_id = None

agentscope_runtime/adapters/text/stream.py

@@ -11,6 +11,7 @@ from ...engine.helpers.agent_api_builder import ResponseBuilder
 
 async def adapt_text_stream(
     source_stream: AsyncIterator[str],
+    **kwargs,  # pylint:disable=unused-argument
 ) -> AsyncIterator[Message]:
     rb = ResponseBuilder()
     mb = rb.create_message_builder(

agentscope_runtime/common/container_clients/agentrun_client.py

@@ -1095,6 +1095,3 @@ class AgentRunClient(BaseClient):
             image_name = image
 
         return replacement_map.get(image_name.strip(), image)
-
-    def _is_browser_image(self, image: str):
-        return image.startswith("agentscope/runtime-sandbox-browser")

agentscope_runtime/common/container_clients/boxlite_client.py

@@ -159,27 +159,38 @@ class BoxliteClient(BaseClient):
             # Convert environment dict to list of tuples
             env_list = []
             if environment:
-                env_list = list(environment.items())
+                env_list = [
+                    (str(k), "" if v is None else str(v))
+                    for k, v in environment.items()
+                ]
 
             # Convert volumes to BoxLite format
             volume_list = []
             if volumes:
-                for vol in volumes:
-                    if isinstance(vol, (list, tuple)) and len(vol) >= 2:
-                        host_path = vol[0]
-                        guest_path = vol[1]
-                        read_only = len(vol) > 2 and vol[2] in (
-                            "ro",
-                            "readonly",
-                            True,
-                        )
+                if isinstance(volumes, dict):
+                    for host_path, spec in volumes.items():
+                        guest_path = spec.get("bind")
+                        mode = (spec.get("mode") or "rw").lower()
+                        read_only = mode in ("ro", "readonly")
                         volume_list.append(
-                            (
-                                host_path,
-                                guest_path,
-                                "ro" if read_only else "rw",
-                            ),
+                            (host_path, guest_path, read_only),
                         )
+                elif isinstance(volumes, (list, tuple)):
+                    for vol in volumes:
+                        if isinstance(vol, (list, tuple)) and len(vol) >= 2:
+                            host_path, guest_path = vol[0], vol[1]
+                            third = vol[2] if len(vol) > 2 else "rw"
+                            read_only = third is True or str(
+                                third,
+                            ).lower() in (
+                                "ro",
+                                "readonly",
+                                "true",
+                                "1",
+                            )
+                            volume_list.append(
+                                (host_path, guest_path, read_only),
+                            )
 
             # Convert ports to BoxLite format
             port_list = []

agentscope_runtime/common/container_clients/fc_client.py

@@ -844,14 +844,3 @@ class FCClient(BaseClient):
             image_name = image
 
         return replacement_map.get(image_name.strip(), image)
-
-    def _is_browser_image(self, image: str) -> bool:
-        """Check if the image is a browser image.
-
-        Args:
-            image (str): The image name to check.
-
-        Returns:
-            bool: True if the image is a browser image, False otherwise.
-        """
-        return image.startswith("agentscope/runtime-sandbox-browser")

agentscope_runtime/common/utils/deprecation.py

@@ -1,11 +1,14 @@
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 
+import logging
 import functools
-import warnings
+import threading
 from dataclasses import dataclass
 from typing import Callable, TypeVar
 
+logger = logging.getLogger(__name__)
+
 T = TypeVar("T", bound=object)
 
 
@@ -38,27 +41,26 @@ def format_deprecation_message(subject: str, info: DeprecationInfo) -> str:
     return " ".join(parts)
 
 
+_LOGGED_ONCE_MESSAGES: set[str] = set()
+_LOGGED_ONCE_LOCK = threading.Lock()
+
+
 def warn_deprecated(
     subject: str,
     info: DeprecationInfo,
     *,
-    category=DeprecationWarning,
     stacklevel: int = 2,
     once: bool = False,
 ) -> None:
     message = format_deprecation_message(subject, info)
 
     if once:
-        top = _toplevel_pkg()
-        with warnings.catch_warnings():
-            warnings.filterwarnings(
-                "once",
-                category=category,
-                module=rf"^{top}(\.|$)",
-            )
-            warnings.warn(message, category=category, stacklevel=stacklevel)
-    else:
-        warnings.warn(message, category=category, stacklevel=stacklevel)
+        with _LOGGED_ONCE_LOCK:
+            if message in _LOGGED_ONCE_MESSAGES:
+                return
+            _LOGGED_ONCE_MESSAGES.add(message)
+
+    logger.warning(message, stacklevel=stacklevel)
 
 
 def deprecated(
@@ -68,7 +70,6 @@ def deprecated(
     removed_in: str | None = None,
     alternative: str | None = None,
     issue: str | int | None = None,
-    category=DeprecationWarning,
     stacklevel: int = 2,
     once: bool = False,
 ) -> Callable[[T], T]:
@@ -104,7 +105,6 @@ def deprecated(
                 warn_deprecated(
                     subject,
                     info,
-                    category=category,
                     stacklevel=stacklevel,
                     once=once,
                 )
@@ -118,7 +118,6 @@ def deprecated(
             warn_deprecated(
                 subject,
                 info,
-                category=category,
                 stacklevel=stacklevel,
                 once=once,
             )
@@ -137,7 +136,6 @@ def deprecated_module(
     removed_in: str | None = None,
     alternative: str | None = None,
     issue: str | int | None = None,
-    category=DeprecationWarning,
     stacklevel: int = 2,
     once: bool = True,
 ) -> None:
@@ -158,7 +156,6 @@ def deprecated_module(
     warn_deprecated(
         f"Module `{module_name}`",
         info,
-        category=category,
         stacklevel=stacklevel,
         once=once,
     )

agentscope_runtime/common/utils/logging.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+import logging
+import os
+
+
+class ColorFormatter(logging.Formatter):
+    COLORS = {
+        logging.DEBUG: "\033[34m",
+        logging.INFO: "\033[32m",
+        logging.WARNING: "\033[33m",
+        logging.ERROR: "\033[31m",
+        logging.CRITICAL: "\033[41m\033[97m",
+    }
+    RESET = "\033[0m"
+
+    def format(self, record):
+        color = self.COLORS.get(record.levelno, "")
+        level = f"{color}{record.levelname}{self.RESET}"
+
+        full_path = record.pathname
+        cwd = os.getcwd()
+        if full_path.startswith(cwd):
+            full_path = full_path[len(cwd) + 1 :]
+
+        prefix = f"{level} {full_path}:{record.lineno}"
+        original_msg = super().format(record)
+
+        return f"{prefix} | {original_msg}"
+
+
+def setup_logger(level=logging.INFO):
+    log_format = "%(asctime)s | %(message)s"
+    datefmt = "%Y-%m-%d %H:%M:%S"
+
+    formatter = ColorFormatter(log_format, datefmt)
+    logger = logging.getLogger()
+    logger.setLevel(level)
+
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    return logger

agentscope_runtime/engine/app/agent_app.py

@@ -245,11 +245,11 @@ class AgentApp(BaseApp):
 
         try:
             logger.info(
-                "[AgentApp] Starting AgentApp with FastAPIAppFactory...",
+                "Starting AgentApp with FastAPIAppFactory...",
             )
             fastapi_app = self.get_fastapi_app(**kwargs)
 
-            logger.info(f"[AgentApp] Starting server on {host}:{port}")
+            logger.info(f"Starting server on {host}:{port}")
 
             if web_ui:
                 webui_url = f"http://{host}:{port}{self.endpoint_path}"
@@ -257,9 +257,9 @@ class AgentApp(BaseApp):
                     f"npx @agentscope-ai/chat agentscope-runtime-webui "
                     f"--url {webui_url}"
                 )
-                logger.info(f"[AgentApp] WebUI started at {webui_url}")
+                logger.info(f"WebUI started at {webui_url}")
                 logger.info(
-                    "[AgentApp] Note: First WebUI launch may take extra time "
+                    "Note: First WebUI launch may take extra time "
                     "as dependencies are installed.",
                 )
 
@@ -287,7 +287,7 @@ class AgentApp(BaseApp):
 
         except KeyboardInterrupt:
             logger.info(
-                "[AgentApp] KeyboardInterrupt received, shutting down...",
+                "KeyboardInterrupt received, shutting down...",
             )
 
     def get_fastapi_app(self, **kwargs):

agentscope_runtime/engine/app/celery_mixin.py

@@ -40,12 +40,51 @@ class CeleryMixin:
 
         self._registered_queues.add(queue)
 
+        def _coerce_result(x):
+            # Normalize Pydantic models first
+            if hasattr(x, "model_dump"):  # pydantic v2
+                x = x.model_dump()
+            elif hasattr(x, "dict"):  # pydantic v1
+                x = x.dict()
+            # Preserve simple primitives as-is
+            if isinstance(x, (str, int, float, bool)) or x is None:
+                return x
+            # Recursively coerce dictionaries
+            if isinstance(x, dict):
+                return {k: _coerce_result(v) for k, v in x.items()}
+            # Recursively coerce lists
+            if isinstance(x, list):
+                return [_coerce_result(item) for item in x]
+            # Fallback: string representation for anything else
+            return str(x)
+
+        async def _collect_async_gen(agen):
+            items = []
+            async for x in agen:
+                items.append(_coerce_result(x))
+            return items
+
+        def _collect_gen(gen):
+            return [_coerce_result(x) for x in gen]
+
         @self.celery_app.task(queue=queue)
         def wrapper(*args, **kwargs):
-            if inspect.iscoroutinefunction(func):
-                return asyncio.run(func(*args, **kwargs))
+            # 1) async generator function
+            if inspect.isasyncgenfunction(func):
+                result = func(*args, **kwargs)
+            # 2) async function
+            elif inspect.iscoroutinefunction(func):
+                result = asyncio.run(func(*args, **kwargs))
             else:
-                return func(*args, **kwargs)
+                result = func(*args, **kwargs)
+            # 3) async generator
+            if inspect.isasyncgen(result):
+                return asyncio.run(_collect_async_gen(result))
+            # 4) sync generator
+            if inspect.isgenerator(result):
+                return _collect_gen(result)
+            # 5) normal return
+            return _coerce_result(result)
 
         return wrapper
 
@@ -63,7 +102,7 @@ class CeleryMixin:
         if concurrency:
             cmd.append(f"--concurrency={concurrency}")
         if queues:
-            cmd.append(f"-Q {','.join(queues)}")
+            cmd += ["-Q", ",".join(queues)]
 
         self.celery_app.worker_main(cmd)
 

agentscope_runtime/engine/deployers/adapter/agui/__init__.py

@@ -5,4 +5,11 @@ from .agui_protocol_adapter import (
     AGUIAdaptorConfig,
 )
 
-__all__ = ["AGUIDefaultAdapter", "FlexibleRunAgentInput", "AGUIAdaptorConfig"]
+from .agui_adapter_utils import AGUIAdapterUtils
+
+__all__ = [
+    "AGUIDefaultAdapter",
+    "FlexibleRunAgentInput",
+    "AGUIAdaptorConfig",
+    "AGUIAdapterUtils",
+]

agentscope_runtime/engine/deployers/adapter/agui/agui_adapter_utils.py

@@ -216,7 +216,7 @@ class AGUI_MESSAGE_STATUS(Enum):
     COMPLETED = "COMPLETED"
 
 
-class AGUIAdapter:
+class AGUIAdapterUtils:
     """
     Utility adapter that converts between Agent API events and AG-UI events.
     """
@@ -285,6 +285,11 @@ class AGUIAdapter:
                 "session_id": self.thread_id,
                 "user_id": user_id,
                 "tools": tools,
+                # extra fields from agui_request
+                "state": agui_request.state,
+                "forwarded_props": agui_request.forwarded_props,
+                "parent_run_id": agui_request.parent_run_id,
+                "context": agui_request.context,
             },
         )
         return agent_request

agentscope_runtime/engine/deployers/adapter/agui/agui_protocol_adapter.py

@@ -14,7 +14,7 @@ from pydantic import BaseModel, Field
 from agentscope_runtime.engine.schemas.agent_schemas import AgentRequest, Event
 
 from .agui_adapter_utils import (
-    AGUIAdapter,
+    AGUIAdapterUtils,
     AGUIEvent,
     AGUIEventType,
     RunErrorEvent,
@@ -157,7 +157,7 @@ class AGUIDefaultAdapter(ProtocolAdapter):
         request: FlexibleRunAgentInput,
     ):
         assert self._execution_func is not None
-        adapter = AGUIAdapter(
+        adapter = AGUIAdapterUtils(
             thread_id=request.thread_id,
             run_id=request.run_id,
         )

agentscope_runtime/engine/deployers/utils/service_utils/fastapi_factory.py

@@ -292,6 +292,19 @@ class FastAPIAppFactory:
             def start_celery_worker():
                 try:
                     celery_mixin = app.state.celery_mixin
+
+                    for ep in app.state.custom_endpoints:
+                        if ep.get("task_type"):
+                            func = ep["handler"]
+                            queue = ep.get("queue", "celery")
+                            if not hasattr(func, "celery_task"):
+                                func.celery_task = (
+                                    celery_mixin.register_celery_task(
+                                        func,
+                                        queue,
+                                    )
+                                )
+
                     # Get registered queues or use default
                     queues = (
                         list(celery_mixin.get_registered_queues())