agentscope-runtime 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

agentscope_runtime/engine/agents/agentscope_agent/agent.py

@@ -1,7 +1,9 @@
 # -*- coding: utf-8 -*-
 # pylint:disable=too-many-nested-blocks, too-many-branches, too-many-statements
 # pylint:disable=line-too-long, protected-access
-
+import copy
+import os
+import logging
 import json
 import threading
 import uuid
@@ -9,7 +11,7 @@ from functools import partial
 from typing import Optional, Type
 
 from agentscope import setup_logger
-from agentscope.agent import ReActAgent
+from agentscope.agent import AgentBase, ReActAgent
 from agentscope.formatter import (
     FormatterBase,
     DashScopeChatFormatter,
@@ -40,6 +42,7 @@ from .hooks import (
     clear_msg_instances,
     run_async_in_thread,
 )
+from ..utils import build_agent
 from ...agents import Agent
 from ...schemas.agent_schemas import (
     Message,
@@ -53,6 +56,7 @@ from ...schemas.context import Context
 
 # Disable logging from agentscope
 setup_logger(level="CRITICAL")
+logger = logging.getLogger(__name__)
 
 
 class AgentScopeContextAdapter:
@@ -95,7 +99,11 @@ class AgentScopeContextAdapter:
             "name": message.role,
             "role": role_label,
         }
-        if message.type == MessageType.PLUGIN_CALL:
+        if message.type in (
+            MessageType.PLUGIN_CALL,
+            MessageType.FUNCTION_CALL,
+        ):
+            # convert PLUGIN_CALL, FUNCTION_CALL to ToolUseBlock
             result["content"] = [
                 ToolUseBlock(
                     type="tool_use",
@@ -104,7 +112,12 @@ class AgentScopeContextAdapter:
                     input=json.loads(message.content[0].data["arguments"]),
                 ),
             ]
-        elif message.type == MessageType.PLUGIN_CALL_OUTPUT:
+        elif message.type in (
+            MessageType.PLUGIN_CALL_OUTPUT,
+            MessageType.FUNCTION_CALL_OUTPUT,
+        ):
+            # convert PLUGIN_CALL_OUTPUT, FUNCTION_CALL_OUTPUT to
+            # ToolResultBlock
             result["content"] = [
                 ToolResultBlock(
                     type="tool_result",
@@ -150,6 +163,10 @@ class AgentScopeContextAdapter:
             )
 
         toolkit = self.attr["agent_config"].get("toolkit", Toolkit())
+        # Deepcopy to avoid modify the original toolkit
+        # TODO: when toolkit contains live sessions, deepcopy fails,
+        #  need further fixed in AgentScope
+        toolkit = copy.deepcopy(toolkit)
         tools = self.attr["tools"]
 
         # in case, tools is None and tools == []
@@ -195,7 +212,7 @@ class AgentScopeAgent(Agent):
         model: ChatModelBase,
         tools=None,
         agent_config=None,
-        agent_builder: Optional[Type[ReActAgent]] = ReActAgent,
+        agent_builder: Optional[Type[AgentBase]] = ReActAgent,
     ):
         super().__init__(name=name, agent_config=agent_config)
         assert isinstance(
@@ -209,7 +226,7 @@ class AgentScopeAgent(Agent):
 
         assert issubclass(
             agent_builder,
-            ReActAgent,
+            AgentBase,
         ), "agent_builder must be a subclass of AgentBase in AgentScope"
 
         # Replace name if not exists
@@ -228,14 +245,41 @@ class AgentScopeAgent(Agent):
         return AgentScopeAgent(**self._attr)
 
     def build(self, as_context):
-        self._agent = self._attr["agent_builder"](
+        params = {
             **self._attr["agent_config"],
-            model=as_context.model,
-            formatter=as_context.formatter,
-            memory=as_context.memory,
-            toolkit=as_context.toolkit,
+            **{
+                "model": as_context.model,
+                "formatter": self._attr["agent_config"].get(
+                    "formatter",
+                    as_context.formatter,
+                ),
+                "memory": as_context.memory,
+                "toolkit": as_context.toolkit,
+            },
+        }
+
+        builder_cls = self._attr["agent_builder"]
+        self._agent = build_agent(builder_cls, params)
+
+        # Read env variable (default = false)
+        console_output_env = (
+            os.getenv(
+                "AGENTSCOPE_AGENT_CONSOLE_OUTPUT",
+                "false",
+            )
+            .strip()
+            .lower()
         )
-        self._agent._disable_console_output = True
+
+        if console_output_env not in ("true", "false"):
+            raise ValueError(
+                f"Invalid value for AGENTSCOPE_AGENT_CONSOLE_OUTPUT: "
+                f"'{console_output_env}'. "
+                f"Only 'true' or 'false' is allowed.",
+            )
+
+        # If true → enable output; if false → disable output
+        self._agent._disable_console_output = console_output_env == "false"
 
         self._agent.register_instance_hook(
             "pre_print",

agentscope_runtime/engine/agents/agentscope_agent/hooks.py

@@ -6,6 +6,7 @@ import os
 import time
 import threading
 import logging
+import traceback
 
 from collections import defaultdict
 from typing import Union, Optional, Generator, Any, List
@@ -33,7 +34,7 @@ def run_async_in_thread(coro):
             logging.error(f"Runtime error in async thread: {e}")
             return None
     except Exception as e:
-        logging.error(f"Error in async thread: {e}")
+        logging.error(f"Error in async thread: {e}, {traceback.format_exc()}")
         return None
 
 

agentscope_runtime/engine/agents/agno_agent.py

@@ -12,6 +12,7 @@ from agno.run.response import (
 )
 from agno.tools.function import Function
 
+from .utils import build_agent
 from ..agents import Agent
 from ..schemas.context import Context
 from ..schemas.agent_schemas import (
@@ -64,7 +65,7 @@ class AgnoContextAdapter:
         return self.attr["model"]
 
     async def adapt_tools(self):
-        toolkit = self.attr["agent_config"].get("toolkit", [])
+        toolkit = self.attr["agent_config"].get("tools", [])
         tools = self.attr["tools"]
 
         # in case, tools is None and tools == []
@@ -138,11 +139,16 @@ class AgnoAgent(Agent):
         return AgnoAgent(**self._attr)
 
     def build(self, as_context):
-        self._agent = self._attr["agent_builder"](
+        params = {
             **self._attr["agent_config"],
-            model=as_context.model,
-            tools=as_context.toolkit,
-        )
+            **{
+                "model": as_context.model,
+                "tools": as_context.toolkit,
+            },  # Context will be added at `self._agent.arun`
+        }
+
+        builder_cls = self._attr["agent_builder"]
+        self._agent = build_agent(builder_cls, params)
 
         return self._agent
 

agentscope_runtime/engine/agents/autogen_agent.py

@@ -11,6 +11,7 @@ from autogen_agentchat.messages import (
     ModelClientStreamingChunkEvent,
 )
 
+from .utils import build_agent
 from ..agents import Agent
 from ..schemas.context import Context
 from ..schemas.agent_schemas import (
@@ -143,11 +144,16 @@ class AutogenAgent(Agent):
         return AutogenAgent(**self._attr)
 
     def build(self, as_context):
-        self._agent = self._attr["agent_builder"](
+        params = {
             **self._attr["agent_config"],
-            model_client=as_context.model,
-            tools=as_context.toolkit,
-        )
+            **{
+                "model_client": as_context.model,
+                "tools": as_context.toolkit,
+            },  # Context will be added at `self._agent.run_stream`
+        }
+
+        builder_cls = self._attr["agent_builder"]
+        self._agent = build_agent(builder_cls, params)
 
         return self._agent
 

agentscope_runtime/engine/agents/utils.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+import inspect
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def build_agent(builder_cls, params):
+    """
+    Filters out unsupported parameters based on the __init__ signature of
+    builder_cls
+    and instantiates the class.
+
+    Args:
+        builder_cls (type): The class to instantiate.
+        params (dict): Dictionary of parameters to pass to the constructor.
+
+    Returns:
+        object: An instance of builder_cls.
+    """
+    try:
+        # Get the signature of the __init__ method
+        sig = inspect.signature(builder_cls.__init__)
+        allowed_params = set(sig.parameters.keys())
+        # Remove 'self' from the list of allowed parameters
+        allowed_params.discard("self")
+    except (TypeError, ValueError):
+        # If signature cannot be inspected, allow all given params
+        allowed_params = set(params.keys())
+
+    filtered_params = {}  # Parameters that are accepted by the constructor
+    unsupported = []  # Parameters that are not accepted
+
+    # Separate supported and unsupported parameters
+    for k, v in params.items():
+        if k in allowed_params:
+            filtered_params[k] = v
+        else:
+            unsupported.append(f"{k}={v!r}")
+
+    # Log a warning if there are unsupported parameters
+    if unsupported:
+        unsupported_str = ", ".join(unsupported)
+        logger.warning(
+            f"The following parameters are not supported by "
+            f"{builder_cls.__name__} and have been ignored: "
+            f"{unsupported_str}. If you require these parameters, "
+            f"please update the `__init__` method of "
+            f"{builder_cls.__name__} to accept and handle them.",
+        )
+
+    # Instantiate the class with only supported parameters
+    return builder_cls(**filtered_params)

agentscope_runtime/engine/services/context_manager.py

@@ -151,11 +151,13 @@ async def create_context_manager(
     memory_service: MemoryService = None,
     session_history_service: SessionHistoryService = None,
     rag_service: RAGService = None,
+    context_composer_cls=ContextComposer,
 ):
     manager = ContextManager(
         memory_service=memory_service,
         session_history_service=session_history_service,
         rag_service=rag_service,
+        context_composer_cls=context_composer_cls,
     )
 
     async with manager:

agentscope_runtime/engine/services/mem0_memory_service.py

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+import os
+from typing import Optional, Dict, Any, List
+from .memory_service import MemoryService
+from ..schemas.agent_schemas import Message, MessageType, ContentType
+
+
+class Mem0MemoryService(MemoryService):
+    """
+    Memory service that uses mem0 to store and retrieve memories.
+    To get the api key, please refer to the following link:
+    https://docs.mem0.ai/platform/quickstart
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        from mem0 import AsyncMemoryClient
+
+        mem0_api_key = os.getenv("MEM0_API_KEY")
+        if mem0_api_key is None:
+            raise ValueError("MEM0_API_KEY is not set")
+        mem0_api_key = os.getenv("MEM0_API_KEY")
+
+        # get the mem0 client instance
+        self.service = AsyncMemoryClient(api_key=mem0_api_key)
+
+    @staticmethod
+    async def get_query_text(message: Message) -> str:
+        """
+        Get the query text from the message.
+        """
+        if message:
+            if message.type == MessageType.MESSAGE:
+                for content in message.content:
+                    if content.type == ContentType.TEXT:
+                        return content.text
+        return ""
+
+    @staticmethod
+    def transform_message(message: Message) -> dict:
+        content_text = None
+
+        try:
+            if hasattr(message, "content") and isinstance(
+                message.content,
+                list,
+            ):
+                if len(message.content) > 0 and hasattr(
+                    message.content[0],
+                    "text",
+                ):
+                    content_text = message.content[0].text
+        except (AttributeError, IndexError):
+            # Log error or handle appropriately
+            pass
+
+        return {
+            "role": getattr(message, "role", None),
+            "content": content_text,
+        }
+
+    async def transform_messages(self, messages: List[Message]) -> List[dict]:
+        return [self.transform_message(message) for message in messages]
+
+    async def start(self):
+        pass
+
+    async def stop(self):
+        pass
+
+    async def health(self):
+        pass
+
+    async def add_memory(
+        self,
+        user_id: str,
+        messages: list,
+        session_id: Optional[str] = None,
+    ):
+        messages = await self.transform_messages(messages)
+        return await self.service.add(
+            messages=messages,
+            user_id=user_id,
+            run_id=session_id,
+            # async_mode=True,
+        )
+
+    async def search_memory(
+        self,
+        user_id: str,
+        messages: list,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> list:
+        query = await self.get_query_text(messages[-1])
+        kwargs = {
+            "query": query,
+            "user_id": user_id,
+        }
+        if filters:
+            kwargs["filters"] = filters
+        return await self.service.search(**kwargs)
+
+    async def list_memory(
+        self,
+        user_id: str,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> list:
+        kwargs = {"user_id": user_id}
+        if filters:
+            kwargs["filters"] = filters
+        return await self.service.get_all(**kwargs)
+
+    async def delete_memory(
+        self,
+        user_id: str,
+        session_id: Optional[str] = None,
+    ) -> None:
+        if session_id:
+            return await self.service.delete_all(
+                user_id=user_id,
+                run_id=session_id,
+            )
+        else:
+            return await self.service.delete_all(user_id=user_id)

agentscope_runtime/engine/services/memory_service.py

@@ -137,7 +137,8 @@ class InMemoryMemoryService(MemoryService):
         if storage_key not in self._store[user_id]:
             self._store[user_id][storage_key] = []
 
-        self._store[user_id][storage_key].extend(messages)
+        if messages:
+            self._store[user_id][storage_key].extend(messages)
 
     async def search_memory(
         self,

agentscope_runtime/engine/services/redis_session_history_service.py

@@ -112,9 +112,10 @@ class RedisSessionHistoryService(SessionHistoryService):
             message = [message]
         norm_message = []
         for msg in message:
-            if not isinstance(msg, Message):
-                msg = Message.model_validate(msg)
-            norm_message.append(msg)
+            if msg is not None:
+                if not isinstance(msg, Message):
+                    msg = Message.model_validate(msg)
+                norm_message.append(msg)
 
         session.messages.extend(norm_message)
 

agentscope_runtime/engine/services/sandbox_service.py

@@ -2,27 +2,17 @@
 # pylint: disable=too-many-branches
 from typing import List
 
-try:
-    from ...sandbox.enums import SandboxType
-    from ...sandbox.manager import SandboxManager
-    from ...sandbox.registry import SandboxRegistry
-    from ...sandbox.tools.mcp_tool import MCPTool
-    from ...sandbox.tools.sandbox_tool import SandboxTool
-    from ...sandbox.tools.function_tool import FunctionTool
-except ImportError:
-    pass
-
+from ...sandbox.enums import SandboxType
+from ...sandbox.manager import SandboxManager
+from ...sandbox.registry import SandboxRegistry
+from ...sandbox.tools.mcp_tool import MCPTool
+from ...sandbox.tools.sandbox_tool import SandboxTool
+from ...sandbox.tools.function_tool import FunctionTool
 from ...engine.services.base import ServiceWithLifecycleManager
 
 
 class SandboxService(ServiceWithLifecycleManager):
     def __init__(self, base_url=None, bearer_token=None):
-        if SandboxManager is None:
-            raise ImportError(
-                "SandboxManager is not available. "
-                "Please install agentscope-runtime[sandbox]",
-            )
-
         self.manager_api = SandboxManager(
             base_url=base_url,
             bearer_token=bearer_token,

agentscope_runtime/engine/services/session_history_service.py

@@ -238,9 +238,10 @@ class InMemorySessionHistoryService(SessionHistoryService):
 
         norm_message = []
         for msg in message:
-            if not isinstance(msg, Message):
-                msg = Message.model_validate(msg)
-            norm_message.append(msg)
+            if msg is not None:
+                if not isinstance(msg, Message):
+                    msg = Message.model_validate(msg)
+                norm_message.append(msg)
         session.messages.extend(norm_message)
 
         # update the in memory copy