agentscope-runtime 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

agentscope_runtime/engine/agents/agentscope_agent/agent.py

@@ -85,6 +85,7 @@ class AgentScopeContextAdapter:
 
     @staticmethod
     def converter(message: Message):
+        # TODO: support more message type
         if message.role not in ["user", "system", "assistant"]:
             role_label = "user"
         else:

agentscope_runtime/engine/agents/agno_agent.py

@@ -53,6 +53,7 @@ class AgnoContextAdapter:
 
     @staticmethod
     def converter(message: Message):
+        # TODO: support more message type
         return dict(message)
 
     async def adapt_new_message(self):

agentscope_runtime/engine/agents/autogen_agent.py

@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+from typing import Optional, Type
+
+from autogen_core.models import ChatCompletionClient
+from autogen_core.tools import FunctionTool
+from autogen_agentchat.agents import AssistantAgent
+from autogen_agentchat.messages import (
+    TextMessage,
+    ToolCallExecutionEvent,
+    ToolCallRequestEvent,
+    ModelClientStreamingChunkEvent,
+)
+
+from ..agents import Agent
+from ..schemas.context import Context
+from ..schemas.agent_schemas import (
+    Message,
+    TextContent,
+    DataContent,
+    FunctionCall,
+    FunctionCallOutput,
+    MessageType,
+    RunStatus,
+)
+
+
+class AutogenContextAdapter:
+    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 = 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):
+        messages = []
+
+        # Build context
+        for msg in self.context.session.messages[:-1]:  # Exclude the last one
+            messages.append(AutogenContextAdapter.converter(msg))
+
+        return messages
+
+    @staticmethod
+    def converter(message: Message):
+        # TODO: support more message type
+        return TextMessage.load(
+            {
+                "id": message.id,
+                "source": message.role,
+                "content": message.content[0].text if message.content else "",
+            },
+        )
+
+    async def adapt_new_message(self):
+        last_message = self.context.session.messages[-1]
+
+        return AutogenContextAdapter.converter(last_message)
+
+    async def adapt_model(self):
+        return self.attr["model"]
+
+    async def adapt_tools(self):
+        toolkit = self.attr["agent_config"].get("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:
+            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:
+            func = FunctionTool(
+                func=tool.make_function(),
+                description=tool.schema["function"]["description"],
+                name=tool.name,
+            )
+            toolkit.append(func)
+
+        return toolkit
+
+
+class AutogenAgent(Agent):
+    def __init__(
+        self,
+        name: str,
+        model: ChatCompletionClient,
+        tools=None,
+        agent_config=None,
+        agent_builder: Optional[Type[AssistantAgent]] = AssistantAgent,
+    ):
+        super().__init__(name=name, agent_config=agent_config)
+
+        assert isinstance(
+            model,
+            ChatCompletionClient,
+        ), "model must be a subclass of ChatCompletionClient in autogen"
+
+        # Set default agent_builder
+        if agent_builder is None:
+            agent_builder = AssistantAgent
+
+        assert issubclass(
+            agent_builder,
+            AssistantAgent,
+        ), "agent_builder must be a subclass of AssistantAgent in autogen"
+
+        # 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) -> "AutogenAgent":
+        return AutogenAgent(**self._attr)
+
+    def build(self, as_context):
+        self._agent = self._attr["agent_builder"](
+            **self._attr["agent_config"],
+            model_client=as_context.model,
+            tools=as_context.toolkit,
+        )
+
+        return self._agent
+
+    async def run(self, context):
+        ag_context = AutogenContextAdapter(context=context, attr=self._attr)
+        await ag_context.initialize()
+
+        # We should always build a new agent since the state is manage outside
+        # the agent
+        self._agent = self.build(ag_context)
+
+        resp = self._agent.run_stream(
+            task=ag_context.memory + [ag_context.new_message],
+        )
+
+        text_message = Message(
+            type=MessageType.MESSAGE,
+            role="assistant",
+            status=RunStatus.InProgress,
+        )
+        yield text_message
+
+        text_delta_content = TextContent(delta=True)
+        is_text_delta = False
+        stream_mode = False
+        async for event in resp:
+            if getattr(event, "source", "user") == "user":
+                continue
+
+            if isinstance(event, TextMessage):
+                if stream_mode:
+                    continue
+                is_text_delta = True
+                text_delta_content.text = event.content
+                text_delta_content = text_message.add_delta_content(
+                    new_content=text_delta_content,
+                )
+                yield text_delta_content
+            elif isinstance(event, ModelClientStreamingChunkEvent):
+                stream_mode = True
+                is_text_delta = True
+                text_delta_content.text = event.content
+                text_delta_content = text_message.add_delta_content(
+                    new_content=text_delta_content,
+                )
+                yield text_delta_content
+            elif isinstance(event, ToolCallRequestEvent):
+                data = DataContent(
+                    data=FunctionCall(
+                        call_id=event.id,
+                        name=event.content[0].name,
+                        arguments=event.content[0].arguments,
+                    ).model_dump(),
+                )
+                message = Message(
+                    type=MessageType.PLUGIN_CALL,
+                    role="assistant",
+                    status=RunStatus.Completed,
+                    content=[data],
+                )
+                yield message
+            elif isinstance(event, ToolCallExecutionEvent):
+                data = DataContent(
+                    data=FunctionCallOutput(
+                        call_id=event.id,
+                        output=event.content[0].content,
+                    ).model_dump(),
+                )
+                message = Message(
+                    type=MessageType.PLUGIN_CALL_OUTPUT,
+                    role="assistant",
+                    status=RunStatus.Completed,
+                    content=[data],
+                )
+                yield message
+
+                # Add to message
+                is_text_delta = True
+                text_delta_content.text = event.content[0].content
+                text_delta_content = text_message.add_delta_content(
+                    new_content=text_delta_content,
+                )
+                yield text_delta_content
+
+        if is_text_delta:
+            yield text_message.content_completed(text_delta_content.index)
+            yield text_message.completed()
+
+    async def run_async(
+        self,
+        context,
+        **kwargs,
+    ):
+        async for event in self.run(context):
+            yield event

agentscope_runtime/engine/schemas/agent_schemas.py

@@ -210,7 +210,7 @@ class Content(Event):
     delta: Optional[bool] = False
     """Whether this content is a delta."""
 
-    msg_id: str = None
+    msg_id: Optional[str] = None
     """message unique id"""
 
 

agentscope_runtime/engine/services/memory_service.py

@@ -58,8 +58,8 @@ class MemoryService(ServiceWithLifecycleManager):
         Args:
             user_id: The user id.
             messages: The user query or the query with history messages,
-            both in the format of list of messages.  If messages is a list,
-            the search will be based on the content of the last message.
+                both in the format of list of messages.  If messages is a list,
+                the search will be based on the content of the last message.
             filters: The filters used to search memory
         """
 

agentscope_runtime/engine/services/redis_memory_service.py

@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*-
+from typing import Optional, Dict, Any
+import json
+import redis.asyncio as aioredis
+
+
+from .memory_service import MemoryService
+from ..schemas.agent_schemas import Message, MessageType
+
+
+class RedisMemoryService(MemoryService):
+    """
+    A Redis-based implementation of the memory service.
+    """
+
+    def __init__(
+        self,
+        redis_url: str = "redis://localhost:6379/0",
+        redis_client: Optional[aioredis.Redis] = None,
+    ):
+        self._redis_url = redis_url
+        self._redis = redis_client
+        self._DEFAULT_SESSION_ID = "default"
+
+    async def start(self) -> None:
+        """Starts the Redis connection."""
+        if self._redis is None:
+            self._redis = aioredis.from_url(
+                self._redis_url,
+                decode_responses=True,
+            )
+
+    async def stop(self) -> None:
+        """Closes the Redis connection."""
+        if self._redis:
+            await self._redis.close()
+            self._redis = None
+
+    async def health(self) -> bool:
+        """Checks the health of the service."""
+
+        if not self._redis:
+            return False
+        try:
+            pong = await self._redis.ping()
+            return pong is True or pong == "PONG"
+        except Exception:
+            return False
+
+    def _user_key(self, user_id):
+        # Each user is a Redis hash
+        return f"user_memory:{user_id}"
+
+    def _serialize(self, messages):
+        return json.dumps([msg.dict() for msg in messages])
+
+    def _deserialize(self, messages_json):
+        if not messages_json:
+            return []
+        return [Message.parse_obj(m) for m in json.loads(messages_json)]
+
+    async def add_memory(
+        self,
+        user_id: str,
+        messages: list,
+        session_id: Optional[str] = None,
+    ) -> None:
+        if not self._redis:
+            raise RuntimeError("Redis connection is not available")
+        key = self._user_key(user_id)
+        field = session_id if session_id else self._DEFAULT_SESSION_ID
+
+        existing_json = await self._redis.hget(key, field)
+        existing_msgs = self._deserialize(existing_json)
+        all_msgs = existing_msgs + messages
+        await self._redis.hset(key, field, self._serialize(all_msgs))
+
+    async def search_memory(
+        self,
+        user_id: str,
+        messages: list,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> list:
+        key = self._user_key(user_id)
+        if (
+            not messages
+            or not isinstance(messages, list)
+            or len(messages) == 0
+        ):
+            return []
+
+        message = messages[-1]
+        query = await self.get_query_text(message)
+        if not query:
+            return []
+
+        keywords = set(query.lower().split())
+
+        all_msgs = []
+        hash_keys = await self._redis.hkeys(key)
+        for session_id in hash_keys:
+            msgs_json = await self._redis.hget(key, session_id)
+            msgs = self._deserialize(msgs_json)
+            all_msgs.extend(msgs)
+
+        matched_messages = []
+        for msg in all_msgs:
+            candidate_content = await self.get_query_text(msg)
+            if candidate_content:
+                msg_content_lower = candidate_content.lower()
+                if any(keyword in msg_content_lower for keyword in keywords):
+                    matched_messages.append(msg)
+
+        if (
+            filters
+            and "top_k" in filters
+            and isinstance(filters["top_k"], int)
+        ):
+            return matched_messages[-filters["top_k"] :]
+
+        return matched_messages
+
+    async def get_query_text(self, message: Message) -> str:
+        if message:
+            if message.type == MessageType.MESSAGE:
+                for content in message.content:
+                    if content.type == "text":
+                        return content.text
+        return ""
+
+    async def list_memory(
+        self,
+        user_id: str,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> list:
+        key = self._user_key(user_id)
+        all_msgs = []
+        hash_keys = await self._redis.hkeys(key)
+        for session_id in sorted(hash_keys):
+            msgs_json = await self._redis.hget(key, session_id)
+            msgs = self._deserialize(msgs_json)
+            all_msgs.extend(msgs)
+
+        page_num = filters.get("page_num", 1) if filters else 1
+        page_size = filters.get("page_size", 10) if filters else 10
+
+        start_index = (page_num - 1) * page_size
+        end_index = start_index + page_size
+
+        return all_msgs[start_index:end_index]
+
+    async def delete_memory(
+        self,
+        user_id: str,
+        session_id: Optional[str] = None,
+    ) -> None:
+        key = self._user_key(user_id)
+        if session_id:
+            await self._redis.hdel(key, session_id)
+        else:
+            await self._redis.delete(key)
+
+    async def clear_all_memory(self) -> None:
+        """
+        Clears all memory data from Redis.
+        This method removes all user memory keys from the Redis database.
+        """
+        if not self._redis:
+            raise RuntimeError("Redis connection is not available")
+
+        keys = await self._redis.keys(self._user_key("*"))
+        if keys:
+            await self._redis.delete(*keys)
+
+    async def delete_user_memory(self, user_id: str) -> None:
+        """
+        Deletes all memory data for a specific user.
+
+        Args:
+            user_id (str): The ID of the user whose memory data should be
+            deleted
+        """
+        if not self._redis:
+            raise RuntimeError("Redis connection is not available")
+
+        key = self._user_key(user_id)
+        await self._redis.delete(key)

agentscope_runtime/engine/services/redis_session_history_service.py

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+import uuid
+
+from typing import Optional, Dict, Any, List, Union
+
+import redis.asyncio as aioredis
+
+from .session_history_service import SessionHistoryService, Session
+from ..schemas.agent_schemas import Message
+
+
+class RedisSessionHistoryService(SessionHistoryService):
+    def __init__(
+        self,
+        redis_url: str = "redis://localhost:6379/0",
+        redis_client: Optional[aioredis.Redis] = None,
+    ):
+        self._redis_url = redis_url
+        self._redis = redis_client
+
+    async def start(self):
+        if self._redis is None:
+            self._redis = aioredis.from_url(
+                self._redis_url,
+                decode_responses=True,
+            )
+
+    async def stop(self):
+        if self._redis:
+            await self._redis.close()
+            self._redis = None
+
+    async def health(self) -> bool:
+        try:
+            pong = await self._redis.ping()
+            return pong is True or pong == "PONG"
+        except Exception:
+            return False
+
+    def _session_key(self, user_id: str, session_id: str):
+        return f"session:{user_id}:{session_id}"
+
+    def _index_key(self, user_id: str):
+        return f"session_index:{user_id}"
+
+    def _session_to_json(self, session: Session) -> str:
+        return session.model_dump_json()
+
+    def _session_from_json(self, s: str) -> Session:
+        return Session.model_validate_json(s)
+
+    async def create_session(
+        self,
+        user_id: str,
+        session_id: Optional[str] = None,
+    ) -> Session:
+        if session_id and session_id.strip():
+            sid = session_id.strip()
+        else:
+            sid = str(uuid.uuid4())
+
+        session = Session(id=sid, user_id=user_id, messages=[])
+        key = self._session_key(user_id, sid)
+
+        await self._redis.set(key, self._session_to_json(session))
+        await self._redis.sadd(self._index_key(user_id), sid)
+        return session
+
+    async def get_session(
+        self,
+        user_id: str,
+        session_id: str,
+    ) -> Optional[Session]:
+        key = self._session_key(user_id, session_id)
+        session_json = await self._redis.get(key)
+        if session_json is None:
+            session = Session(id=session_id, user_id=user_id)
+            await self._redis.set(key, self._session_to_json(session))
+            await self._redis.sadd(self._index_key(user_id), session_id)
+            return session
+        return self._session_from_json(session_json)
+
+    async def delete_session(self, user_id: str, session_id: str):
+        key = self._session_key(user_id, session_id)
+        await self._redis.delete(key)
+        await self._redis.srem(self._index_key(user_id), session_id)
+
+    async def list_sessions(self, user_id: str) -> list[Session]:
+        idx_key = self._index_key(user_id)
+        session_ids = await self._redis.smembers(idx_key)
+        sessions = []
+        for sid in session_ids:
+            key = self._session_key(user_id, sid)
+            session_json = await self._redis.get(key)
+            if session_json:
+                session = self._session_from_json(session_json)
+                session.messages = []
+                sessions.append(session)
+        return sessions
+
+    async def append_message(
+        self,
+        session: Session,
+        message: Union[
+            "Message",
+            List["Message"],
+            Dict[str, Any],
+            List[Dict[str, Any]],
+        ],
+    ):
+        if not isinstance(message, list):
+            message = [message]
+        norm_message = []
+        for msg in message:
+            if not isinstance(msg, Message):
+                msg = Message.model_validate(msg)
+            norm_message.append(msg)
+
+        session.messages.extend(norm_message)
+
+        user_id = session.user_id
+        session_id = session.id
+        key = self._session_key(user_id, session_id)
+
+        session_json = await self._redis.get(key)
+        if session_json:
+            stored_session = self._session_from_json(session_json)
+            stored_session.messages.extend(norm_message)
+            await self._redis.set(key, self._session_to_json(stored_session))
+            await self._redis.sadd(self._index_key(user_id), session_id)
+        else:
+            print(
+                f"Warning: Session {session.id} not found in storage for "
+                f"append_message.",
+            )
+
+    async def delete_user_sessions(self, user_id: str) -> None:
+        """
+        Deletes all session history data for a specific user.
+
+        Args:
+            user_id (str): The ID of the user whose session history data should
+             be deleted
+        """
+        if not self._redis:
+            raise RuntimeError("Redis connection is not available")
+
+        index_key = self._index_key(user_id)
+        session_ids = await self._redis.smembers(index_key)
+
+        for session_id in session_ids:
+            key = self._session_key(user_id, session_id)
+            await self._redis.delete(key)
+
+        await self._redis.delete(index_key)

agentscope_runtime/sandbox/build.py

@@ -124,7 +124,7 @@ def build_image(build_type, dockerfile_path=None):
             f"{free_port}:80",
             "-e",
             f"SECRET_TOKEN={secret_token}",
-            f"{image_name}",
+            f"{image_name}dev",
         ],
         capture_output=True,
         text=True,

agentscope_runtime/sandbox/custom/custom_sandbox.py

@@ -14,7 +14,6 @@ SANDBOXTYPE = "custom_sandbox"
 @SandboxRegistry.register(
     f"agentscope/runtime-sandbox-{SANDBOXTYPE}:{IMAGE_TAG}",
     sandbox_type=SANDBOXTYPE,
-    resource_limits={"memory": "16Gi", "cpu": "4"},
     security_level="medium",
     timeout=60,
     description="my sandbox",

agentscope_runtime/sandbox/custom/example.py

@@ -12,7 +12,6 @@ SANDBOX_TYPE = "example"
 @SandboxRegistry.register(
     f"agentscope/runtime-sandbox-{SANDBOX_TYPE}:{IMAGE_TAG}",
     sandbox_type=SANDBOX_TYPE,
-    resource_limits={"memory": "16Gi", "cpu": "4"},
     security_level="medium",
     timeout=60,
     description="Example sandbox",

agentscope_runtime/sandbox/manager/container_clients/__init__.py

@@ -1,8 +1,10 @@
 # -*- coding: utf-8 -*-
 from .base_client import BaseClient
 from .docker_client import DockerClient
+from .kubernetes_client import KubernetesClient
 
 __all__ = [
     "BaseClient",
     "DockerClient",
+    "KubernetesClient",
 ]