agentscope-runtime 0.1.5b2__py3-none-any.whl → 0.1.6__py3-none-any.whl

agentscope_runtime/engine/agents/agentscope_agent/agent.py

@@ -1,401 +0,0 @@
-# -*- coding: utf-8 -*-
-# pylint:disable=too-many-nested-blocks, too-many-branches, too-many-statements
-# pylint:disable=line-too-long, protected-access
-
-import json
-import threading
-import uuid
-from functools import partial
-from typing import Optional, Type
-
-from agentscope import setup_logger
-from agentscope.agent import ReActAgent
-from agentscope.formatter import (
-    FormatterBase,
-    DashScopeChatFormatter,
-    OpenAIChatFormatter,
-    AnthropicChatFormatter,
-    OllamaChatFormatter,
-    GeminiChatFormatter,
-)
-from agentscope.memory import InMemoryMemory
-from agentscope.message import Msg, ToolUseBlock, ToolResultBlock
-from agentscope.model import (
-    ChatModelBase,
-    DashScopeChatModel,
-    OpenAIChatModel,
-    AnthropicChatModel,
-    OllamaChatModel,
-    GeminiChatModel,
-)
-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,
-)
-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):
-        # TODO: support more message type
-        if message.role not in ["user", "system", "assistant"]:
-            role_label = "user"
-        else:
-            role_label = message.role
-        result = {
-            "name": message.role,
-            "role": role_label,
-        }
-        if message.type == MessageType.PLUGIN_CALL:
-            result["content"] = [
-                ToolUseBlock(
-                    type="tool_use",
-                    id=message.content[0].data["call_id"],
-                    name=message.role,
-                    input=json.loads(message.content[0].data["arguments"]),
-                ),
-            ]
-        elif message.type == MessageType.PLUGIN_CALL_OUTPUT:
-            result["content"] = [
-                ToolResultBlock(
-                    type="tool_result",
-                    id=message.content[0].data["call_id"],
-                    name=message.role,
-                    output=message.content[0].data["output"],
-                ),
-            ]
-        else:
-            result["content"] = (
-                message.content[0].text if message.content else ""
-            )
-        return result
-
-    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._disable_console_output = True
-
-        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()
-        local_truncate_memory = ""
-
-        # 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 = ""
-
-            message = Message(type=MessageType.MESSAGE, role="assistant")
-            yield message.in_progress()
-            index = None
-
-            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) and element:
-                                text_delta_content = TextContent(
-                                    delta=True,
-                                    index=index,
-                                    text=element,
-                                )
-                                text_delta_content = message.add_delta_content(
-                                    new_content=text_delta_content,
-                                )
-                                index = text_delta_content.index
-                                yield text_delta_content
-                            elif isinstance(element, dict):
-                                if element.get("type") == "text":
-                                    text = element.get(
-                                        "text",
-                                        "",
-                                    )
-                                    if text:
-                                        text_delta_content = TextContent(
-                                            delta=True,
-                                            index=index,
-                                            text=text.removeprefix(
-                                                local_truncate_memory,
-                                            ),
-                                        )
-                                        local_truncate_memory = element.get(
-                                            "text",
-                                            "",
-                                        )
-                                        text_delta_content = (
-                                            message.add_delta_content(
-                                                new_content=text_delta_content,
-                                            )
-                                        )
-                                        index = text_delta_content.index
-                                        yield text_delta_content
-                                        if hasattr(msg, "is_last"):
-                                            yield message.content_completed(
-                                                index,
-                                            )
-                                            yield message.completed()
-                                            message = Message(
-                                                type=MessageType.MESSAGE,
-                                                role="assistant",
-                                            )
-                                            index = None
-
-                                elif element.get("type") == "tool_use":
-                                    json_str = json.dumps(element.get("input"))
-                                    data_delta_content = DataContent(
-                                        index=index,
-                                        data=FunctionCall(
-                                            call_id=element.get("id"),
-                                            name=element.get("name"),
-                                            arguments=json_str,
-                                        ).model_dump(),
-                                    )
-                                    plugin_call_message = Message(
-                                        type=MessageType.PLUGIN_CALL,
-                                        role="assistant",
-                                        content=[data_delta_content],
-                                    )
-                                    yield plugin_call_message.completed()
-                                elif element.get("type") == "tool_result":
-                                    data_delta_content = DataContent(
-                                        index=index,
-                                        data=FunctionCallOutput(
-                                            call_id=element.get("id"),
-                                            output=str(element.get("output")),
-                                        ).model_dump(),
-                                    )
-                                    plugin_output_message = Message(
-                                        type=MessageType.PLUGIN_CALL_OUTPUT,
-                                        role="assistant",
-                                        content=[data_delta_content],
-                                    )
-                                    yield plugin_output_message.completed()
-                                else:
-                                    text_delta_content = TextContent(
-                                        delta=True,
-                                        index=index,
-                                        text=f"{element}",
-                                    )
-                                    text_delta_content = (
-                                        message.add_delta_content(
-                                            new_content=text_delta_content,
-                                        )
-                                    )
-                                    index = text_delta_content.index
-                                    yield text_delta_content
-
-                # 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:
-                text_delta_content = TextContent(
-                    delta=True,
-                    index=index,
-                    text=last_content,
-                )
-                text_delta_content = message.add_delta_content(
-                    new_content=text_delta_content,
-                )
-                yield text_delta_content
-                yield message.completed()
-
-            # 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

@@ -1,169 +0,0 @@
-# -*- coding: utf-8 -*-
-""" Hooks for stream output """
-# pylint: disable=unused-argument,too-many-nested-blocks
-import asyncio
-import os
-import time
-import threading
-import logging
-
-from collections import defaultdict
-from typing import Union, Optional, Generator, Any, List
-
-from agentscope.agent import AgentBase
-from agentscope.message import Msg
-
-_MSG_INSTANCE = defaultdict(list)
-_LOCKS = defaultdict(threading.Lock)
-TIMEOUT = int(os.getenv("AGENTSCOPE_AGENT_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]:
-            if kwargs.get("last", True):
-                msg.is_last = True
-                _MSG_INSTANCE[thread_id].append(msg)
-            else:
-                new_blocks = []
-                if isinstance(msg.content, List):
-                    for block in msg.content:
-                        if block.get("type", "") != "tool_use":
-                            new_blocks.append(block)
-                    msg.content = new_blocks
-                if msg.content:
-                    _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

agentscope_runtime/engine/agents/llm_agent.py

@@ -1,51 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from .base_agent import Agent
-from ..llms import BaseLLM
-from ..schemas.agent_schemas import (
-    Message,
-    TextContent,
-    convert_to_openai_messages,
-    MessageType,
-    convert_to_openai_tools,
-)
-
-
-class LLMAgent(Agent):
-    def __init__(
-        self,
-        model: BaseLLM,
-        **kwargs,
-    ):
-        super().__init__(
-            **kwargs,
-        )
-        self.model = model
-
-    async def run_async(
-        self,
-        context,
-        **kwargs,
-    ):
-        # agent request --> model request
-        openai_messages = convert_to_openai_messages(context.session.messages)
-        tools = convert_to_openai_tools(context.request.tools)
-
-        # Step 3: Create initial Message
-        message = Message(type=MessageType.MESSAGE, role="assistant")
-        yield message.in_progress()
-
-        # Step 4: LLM Content delta
-        text_delta_content = TextContent(delta=True)
-        async for chunk in self.model.chat_stream(openai_messages, tools):
-            delta = chunk.choices[0].delta
-
-            if delta.content:
-                text_delta_content.text = delta.content
-                text_delta_content = message.add_delta_content(
-                    new_content=text_delta_content,
-                )
-                yield text_delta_content
-
-        message.completed()
-        yield message