agentscope-runtime 0.2.0b1__py3-none-any.whl → 1.0.0__py3-none-any.whl

agentscope_runtime/engine/agents/autogen_agent.py

@@ -1,250 +0,0 @@
-# -*- 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 .utils import build_agent
-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.tools = tools
-
-    def copy(self) -> "AutogenAgent":
-        return AutogenAgent(**self._attr)
-
-    def build(self, as_context):
-        params = {
-            **self._attr["agent_config"],
-            **{
-                "model_client": as_context.model,
-                "tools": as_context.toolkit,
-            },  # Context will be added at `_agent.run_stream`
-        }
-
-        builder_cls = self._attr["agent_builder"]
-        _agent = build_agent(builder_cls, params)
-
-        return _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
-        _agent = self.build(ag_context)
-
-        resp = _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/agents/base_agent.py

@@ -1,29 +0,0 @@
-# -*- coding: utf-8 -*-
-from typing import AsyncGenerator
-
-from ..schemas.agent_schemas import Event
-
-
-class Agent:
-    def __init__(
-        self,
-        name: str = "",
-        description: str = "",
-        before_agent_callback=None,
-        after_agent_callback=None,
-        agent_config=None,
-        **kwargs,
-    ):
-        self.name = name
-        self.description = description
-        self.before_agent_callback = before_agent_callback or []
-        self.after_agent_callback = after_agent_callback or []
-        self.agent_config = agent_config or {}
-        self.kwargs = kwargs
-
-    async def run_async(
-        self,
-        context,
-        **kwargs,
-    ) -> AsyncGenerator[Event, None]:
-        raise NotImplementedError("Subclasses must implement this method")

agentscope_runtime/engine/agents/langgraph_agent.py

@@ -1,59 +0,0 @@
-# -*- coding: utf-8 -*-
-import json
-
-from langgraph.graph.state import CompiledStateGraph
-
-from .base_agent import Agent
-from ..schemas.agent_schemas import (
-    Message,
-    TextContent,
-)
-
-
-def _state_folder(messages):
-    if len(messages) > 0:
-        return json.loads(messages[0]["content"])
-    else:
-        return []
-
-
-def _state_unfolder(state):
-    state_jsons = json.dumps(state)
-    return state_jsons
-
-
-class LangGraphAgent(Agent):
-    def __init__(
-        self,
-        graph: CompiledStateGraph = None,
-        state_folder=_state_folder,
-        state_unfolder=_state_unfolder,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        self.state_folder = state_folder
-        self.state_unfolder = state_unfolder
-        self.graph = graph
-
-    async def run_async(
-        self,
-        context,
-        **kwargs,
-    ):
-        # fold the last m
-        list_messages = []
-        for m in context.session.messages:
-            dumped = m.model_dump()
-            dumped["content"] = dumped["content"][0]["text"]
-            list_messages.append(dumped)
-
-        _input = self.state_folder(list_messages)
-
-        output = await self.graph.ainvoke(_input)
-        content = self.state_unfolder(output)
-
-        message = Message(role="assistant")
-        text = TextContent(type="text", text=content)
-        message.add_content(text)
-        message.completed()
-        yield message

agentscope_runtime/engine/agents/utils.py

@@ -1,53 +0,0 @@
-# -*- 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)