agentscope-runtime 0.1.0__py3-none-any.whl

agentscope_runtime/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+from .version import __version__
+
+__all__ = ["__version__"]

agentscope_runtime/engine/__init__.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+from .services import (
+    Service,
+    SandboxService,
+    MemoryService,
+    SessionHistoryService,
+)
+from .deployers import DeployManager, LocalDeployManager
+from .runner import Runner

agentscope_runtime/engine/agents/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+from .base_agent import Agent

agentscope_runtime/engine/agents/agentscope_agent/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+from .agent import AgentScopeAgent
+
+__all__ = [
+    "AgentScopeAgent",
+]

agentscope_runtime/engine/agents/agentscope_agent/agent.py

@@ -0,0 +1,342 @@
+# -*- coding: utf-8 -*-
+# pylint:disable=too-many-nested-blocks, too-many-branches, too-many-statements
+import json
+import threading
+import uuid
+from functools import partial
+from typing import Optional, Type
+
+from agentscope.agent import ReActAgent
+from agentscope.formatter import (
+    FormatterBase,
+    DashScopeChatFormatter,
+    OpenAIChatFormatter,
+    AnthropicChatFormatter,
+    OllamaChatFormatter,
+    GeminiChatFormatter,
+)
+from agentscope.model import (
+    ChatModelBase,
+    DashScopeChatModel,
+    OpenAIChatModel,
+    AnthropicChatModel,
+    OllamaChatModel,
+    GeminiChatModel,
+)
+from agentscope.memory import InMemoryMemory
+from agentscope.message import Msg
+from agentscope import setup_logger
+from agentscope.tool import (
+    Toolkit,
+    ToolResponse,
+)
+from agentscope.tool._toolkit import RegisteredToolFunction
+
+from .hooks import (
+    pre_speak_msg_buffer_hook,
+    get_msg_instances,
+    clear_msg_instances,
+    run_async_in_thread,
+)
+from ...agents import Agent
+from ...schemas.agent_schemas import (
+    Message,
+    TextContent,
+    DataContent,
+    FunctionCall,
+    FunctionCallOutput,
+    MessageType,
+    RunStatus,
+)
+from ...schemas.context import Context
+
+# Disable logging from agentscope
+setup_logger(level="CRITICAL")
+
+
+class AgentScopeContextAdapter:
+    def __init__(self, context: Context, attr: dict):
+        self.context = context
+        self.attr = attr
+
+        # Adapted attribute
+        self.toolkit = None
+        self.model = None
+        self.memory = None
+        self.new_message = None
+
+    async def initialize(self):
+        self.model, self.formatter = await self.adapt_model()
+        self.memory = await self.adapt_memory()
+        self.new_message = await self.adapt_new_message()
+        self.toolkit = await self.adapt_tools()
+
+    async def adapt_memory(self):
+        memory = self.attr["agent_config"].get("memory", InMemoryMemory())
+        messages = []
+
+        # Build context
+        for msg in self.context.session.messages[:-1]:  # Exclude the last one
+            messages.append(AgentScopeContextAdapter.converter(msg))
+
+        memory.load_state_dict({"content": messages})
+
+        return memory
+
+    @staticmethod
+    def converter(message: Message):
+        if message.role not in ["user", "system", "assistant"]:
+            role_label = "user"
+        else:
+            role_label = message.role
+
+        return {
+            "name": message.role,
+            "role": role_label,
+            "content": message.content[0].text if message.content else "",
+        }
+
+    async def adapt_new_message(self):
+        last_message = self.context.session.messages[-1]
+        return Msg(**AgentScopeContextAdapter.converter(last_message))
+
+    async def adapt_model(self):
+        model = self.attr["model"]
+        formatter = self.attr["agent_config"].get("formatter")
+        if formatter and isinstance(formatter, FormatterBase):
+            return model, formatter
+
+        if isinstance(model, OpenAIChatModel):
+            formatter = OpenAIChatFormatter()
+        elif isinstance(model, DashScopeChatModel):
+            formatter = DashScopeChatFormatter()
+        elif isinstance(model, AnthropicChatModel):
+            formatter = AnthropicChatFormatter()
+        elif isinstance(model, OllamaChatModel):
+            formatter = OllamaChatFormatter()
+        elif isinstance(model, GeminiChatModel):
+            formatter = GeminiChatFormatter()
+
+        return model, formatter
+
+    async def adapt_tools(self):
+        def func_wrapper(func, **kwargs):
+            func_res = func(**kwargs)
+            return ToolResponse(
+                content=func_res["content"],
+            )
+
+        toolkit = self.attr["agent_config"].get("toolkit", Toolkit())
+        tools = self.attr["tools"]
+
+        # in case, tools is None and tools == []
+        if not tools:
+            return toolkit
+
+        if self.context.activate_tools:
+            # Only add activated tool
+            activated_tools = self.context.activate_tools
+        else:
+            # Lazy import
+            from ....sandbox.tools.utils import setup_tools
+
+            activated_tools = setup_tools(
+                tools=self.attr["tools"],
+                environment_manager=self.context.environment_manager,
+                session_id=self.context.session.id,
+                user_id=self.context.session.user_id,
+                include_schemas=False,
+            )
+
+        for tool in activated_tools:
+            function = RegisteredToolFunction(
+                name=tool.name,
+                source="mcp_server",
+                mcp_name=tool.tool_type,
+                original_func=partial(
+                    func_wrapper,
+                    tool,
+                ),
+                json_schema=tool.schema,
+                group="basic",
+            )
+            toolkit.tools[tool.name] = function
+
+        return toolkit
+
+
+class AgentScopeAgent(Agent):
+    def __init__(
+        self,
+        name: str,
+        model: ChatModelBase,
+        tools=None,
+        agent_config=None,
+        agent_builder: Optional[Type[ReActAgent]] = ReActAgent,
+    ):
+        super().__init__(name=name, agent_config=agent_config)
+        assert isinstance(
+            model,
+            ChatModelBase,
+        ), "model must be a subclass of ChatModelBase in AgentScope"
+
+        # Set default agent_builder
+        if agent_builder is None:
+            agent_builder = ReActAgent
+
+        assert issubclass(
+            agent_builder,
+            ReActAgent,
+        ), "agent_builder must be a subclass of AgentBase in AgentScope"
+
+        # Replace name if not exists
+        self.agent_config["name"] = self.agent_config.get("name") or name
+
+        self._attr = {
+            "model": model,
+            "tools": tools,
+            "agent_config": self.agent_config,
+            "agent_builder": agent_builder,
+        }
+        self._agent = None
+        self.tools = tools
+
+    def copy(self) -> "AgentScopeAgent":
+        return AgentScopeAgent(**self._attr)
+
+    def build(self, as_context):
+        self._agent = self._attr["agent_builder"](
+            **self._attr["agent_config"],
+            model=as_context.model,
+            formatter=as_context.formatter,
+            memory=as_context.memory,
+            toolkit=as_context.toolkit,
+        )
+
+        self._agent.register_instance_hook(
+            "pre_print",
+            "pre_speak_msg_buffer_hook",
+            pre_speak_msg_buffer_hook,
+        )
+
+        return self._agent
+
+    async def run(self, context):
+        as_context = AgentScopeContextAdapter(context=context, attr=self._attr)
+        await as_context.initialize()
+
+        # We should always build a new agent since the state is manage outside
+        # the agent
+        self._agent = self.build(as_context)
+
+        # Make the output a generator
+        thread_id = "pipeline" + str(uuid.uuid4())
+        try:
+            # Run the main function in a separate thread
+            thread = threading.Thread(
+                target=run_async_in_thread,
+                args=(self._agent.reply(msg=as_context.new_message),),
+                name=thread_id,
+            )
+            clear_msg_instances(thread_id=thread_id)
+            thread.start()
+
+            # Yield new Msg instances as they are logged
+            last_content = ""
+
+            for msg, msg_len in get_msg_instances(thread_id=thread_id):
+                if msg:
+                    content = msg.content
+
+                    if isinstance(content, str):
+                        last_content = content
+                    else:
+                        for element in content:
+                            if isinstance(element, str):
+                                content = TextContent(text=element)
+                                message = Message(
+                                    type=MessageType.MESSAGE,
+                                    role="assistant",
+                                    content=[content],
+                                    status=RunStatus.Completed,
+                                )
+                                yield message
+                            elif isinstance(element, dict):
+                                if element.get("type") == "text":
+                                    content = TextContent(
+                                        text=element.get("text"),
+                                    )
+                                    message = Message(
+                                        type=MessageType.MESSAGE,
+                                        role="assistant",
+                                        status=RunStatus.Completed,
+                                        content=[content],
+                                    )
+                                    yield message
+                                elif element.get("type") == "tool_use":
+                                    json_str = json.dumps(element.get("input"))
+                                    data = DataContent(
+                                        data=FunctionCall(
+                                            call_id=element.get("id"),
+                                            name=element.get("name"),
+                                            arguments=json_str,
+                                        ).model_dump(),
+                                    )
+                                    message = Message(
+                                        type=MessageType.PLUGIN_CALL,
+                                        role="assistant",
+                                        status=RunStatus.Completed,
+                                        content=[data],
+                                    )
+                                    yield message
+                                elif element.get("type") == "tool_result":
+                                    data = DataContent(
+                                        data=FunctionCallOutput(
+                                            call_id=element.get("id"),
+                                            output=str(element.get("output")),
+                                        ).model_dump(),
+                                    )
+                                    message = Message(
+                                        type=MessageType.PLUGIN_CALL_OUTPUT,
+                                        role="assistant",
+                                        status=RunStatus.Completed,
+                                        content=[data],
+                                    )
+                                    yield message
+                                else:
+                                    message = Message(
+                                        type=MessageType.MESSAGE,
+                                        role="assistant",
+                                        status=RunStatus.Completed,
+                                        content=[
+                                            TextContent(text=f"{element}"),
+                                        ],
+                                    )
+                                    yield message
+
+                # Break if the thread is dead and no more messages are expected
+                if not thread.is_alive() and msg_len == 0:
+                    break
+
+            if last_content:
+                content = TextContent(text=last_content)
+                message = Message(
+                    type=MessageType.MESSAGE,
+                    role="assistant",
+                    content=[content],
+                    status=RunStatus.Completed,
+                )
+                yield message
+
+            # Wait for the function to finish
+            thread.join()
+        finally:
+            pass
+
+    async def run_async(
+        self,
+        context,
+        **kwargs,
+    ):
+        async for event in self.run(context):
+            yield event

agentscope_runtime/engine/agents/agentscope_agent/hooks.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+""" Hooks for stream output """
+# pylint: disable=unused-argument,too-many-nested-blocks
+import asyncio
+import time
+import threading
+import logging
+
+from collections import defaultdict
+from typing import Union, Optional, Generator, Any
+
+from agentscope.agent import AgentBase
+from agentscope.message import Msg
+
+_MSG_INSTANCE = defaultdict(list)
+_LOCKS = defaultdict(threading.Lock)
+TIMEOUT = 30
+
+
+def run_async_in_thread(coro):
+    """
+    Run an async coroutine in a thread-safe manner.
+    """
+    try:
+        return asyncio.run(coro)
+    except RuntimeError as e:
+        if "cannot be called from a running event loop" in str(e):
+            # If we're somehow in a context with an existing event loop,
+            # fall back to the manual approach with better error handling.
+            return _run_with_manual_loop(coro)
+        else:
+            logging.error(f"Runtime error in async thread: {e}")
+            return None
+    except Exception as e:
+        logging.error(f"Error in async thread: {e}")
+        return None
+
+
+def _run_with_manual_loop(coro):
+    """Fallback method using manual event loop management.
+
+    This is only used when asyncio.run cannot be used due to
+    an existing event loop in the current context.
+    """
+    loop = None
+    try:
+        loop = asyncio.new_event_loop()
+        return loop.run_until_complete(coro)
+    finally:
+        if loop:
+            try:
+                # Cancel all remaining tasks with better error handling
+                pending_tasks = asyncio.all_tasks(loop)
+                if pending_tasks:
+                    for task in pending_tasks:
+                        if not task.done():
+                            task.cancel()
+                    # Wait for cancellation to complete
+                    try:
+                        loop.run_until_complete(
+                            asyncio.gather(
+                                *pending_tasks,
+                                return_exceptions=True,
+                            ),
+                        )
+                    except Exception:
+                        pass  # Ignore exceptions during cleanup
+            except Exception as e:
+                logging.error(f"Error during task cleanup: {e}")
+            finally:
+                try:
+                    loop.close()
+                except Exception as e:
+                    logging.error(f"Error closing event loop: {e}")
+
+
+def pre_speak_msg_buffer_hook(
+    self: AgentBase,
+    kwargs: dict[str, Any],
+) -> Union[Msg, None]:
+    """Hook for pre speak msg buffer"""
+    msg = kwargs["msg"]
+    thread_id = threading.current_thread().name
+    if thread_id.startswith("pipeline"):
+        with _LOCKS[thread_id]:
+            _MSG_INSTANCE[thread_id].append(msg)
+    return kwargs
+
+
+def clear_msg_instances(thread_id: Optional[str] = None) -> None:
+    """
+    Clears all message instances for a specific thread ID.
+    This function removes all message instances associated with a given
+    thread ID (`thread_id`). It ensures thread safety through the use of a
+    threading lock when accessing the shared message instance list. This
+    prevents race conditions in concurrent environments.
+    Args:
+        thread_id (optional): The thread ID for which to clear message
+        instances. If `None`, the function will do nothing.
+    Notes:
+        - It assumes the existence of a global `_LOCKS` for synchronization and
+        a dictionary `_MSG_INSTANCE` where each thread ID maps to a list of
+        message instances.
+    """
+    if not thread_id:
+        return
+
+    with _LOCKS[thread_id]:
+        _MSG_INSTANCE[thread_id].clear()
+
+
+def get_msg_instances(thread_id: Optional[str] = None) -> Generator:
+    """
+    A generator function that yields message instances for a specific thread ID
+    This function is designed to continuously monitor and yield new message
+    instances associated with a given thread ID (`thread_id`). It ensures
+    thread safety through the use of a threading lock when accessing the shared
+    message instance list. This prevents race conditions in concurrent
+    environments.
+    Args:
+        thread_id (optional): The thread ID for which to monitor and yield
+        message instances. If `None`, the function will yield `None` and
+        terminate.
+    Yields:
+        The next available message instance for the specified thread ID. If no
+        message is available, it will wait and check periodically.
+    Notes:
+        - The function uses a small delay (`time.sleep(0.1)`) to prevent busy
+        waiting. This ensures efficient CPU usage while waiting for new
+        messages.
+        - It assumes the existence of a global `_LOCK` for synchronization and
+        a dictionary `_MSG_INSTANCE` where each thread ID maps to a list of
+        message instances.
+    Example:
+        for msg in get_msg_instances(thread_id=123):
+            process_message(msg)
+    """
+    cnt = 0
+
+    if not thread_id:
+        yield
+        return
+
+    while True:
+        with _LOCKS[thread_id]:
+            if _MSG_INSTANCE[thread_id]:
+                cnt = 0
+                yield _MSG_INSTANCE[thread_id].pop(0), len(
+                    _MSG_INSTANCE[thread_id],
+                )
+            else:
+                cnt += 0.1
+                if cnt > TIMEOUT:
+                    raise TimeoutError
+                yield None, None
+        time.sleep(0.1)  # Avoid busy waiting