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

agentscope_runtime/adapters/agentscope/tool/tool.py

@@ -0,0 +1,233 @@
+# -*- coding: utf-8 -*-
+import concurrent.futures
+import json
+from typing import (
+    Any,
+    Dict,
+    Optional,
+    Sequence,
+)
+
+from agentscope.tool import Toolkit, ToolResponse
+from agentscope.tool._registered_tool_function import (
+    RegisteredToolFunction,
+)
+
+from agentscope_runtime.tools.base import Tool
+
+
+def agentscope_tool_adapter(
+    tool: Tool,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+) -> RegisteredToolFunction:
+    """Convert an agentscope_runtime tool to an AgentScope tool.
+
+    This function wraps agentscope_runtime tools to make them compatible
+    with AgentScope's toolkit system.
+
+    Args:
+        tool (Tool): The agentscope_runtime tool to wrap
+        name (str, optional): Override the tool name. Defaults to
+            tool.name
+        description (str, optional): Override the tool description.
+            Defaults to tool.description
+
+    Returns:
+        RegisteredToolFunction: The AgentScope tool function
+
+    Examples:
+        Basic usage with a search tool:
+
+        .. code-block:: python
+
+            from agentscope_runtime.searches.modelstudio_search
+            import ModelstudioSearch
+            from agentscope_runtime.adapters.agentscope.tool import
+            agentscope_tool_adapter
+            from agentscope.tool import Toolkit
+
+            # Create the search tool
+            search_tool = ModelstudioSearch()
+
+            # Convert to AgentScope tool
+            search_tool = agentscope_tool_adapter(search_tool)
+
+            # Add to toolkit
+            toolkit = Toolkit()
+            toolkit.tools[search_tool.name] = search_tool
+    """
+
+    def func_wrapper(**kwargs: Any) -> ToolResponse:
+        """Wrapper function that adapts tool execution to AgentScope
+        format."""
+        import asyncio
+
+        # Validate input with tool's input type
+        if tool.input_type:
+            try:
+                validated_input = tool.input_type.model_validate(kwargs)
+            except Exception as e:
+                return ToolResponse(
+                    content=[
+                        {
+                            "type": "text",
+                            "text": f"Input validation error: {str(e)}",
+                        },
+                    ],
+                    metadata={"error": True},
+                )
+        else:
+            validated_input = kwargs
+
+        # Execute the tool
+        try:
+            if asyncio.iscoroutinefunction(tool.arun):
+                # Check if we're already in an event loop
+                try:
+
+                    def run_async() -> Any:
+                        return asyncio.run(tool.arun(validated_input))
+
+                    with concurrent.futures.ThreadPoolExecutor() as executor:
+                        future = executor.submit(run_async)
+                        result = future.result()
+                except RuntimeError:
+                    # No event loop running, safe to use asyncio.run
+                    result = asyncio.run(tool.arun(validated_input))
+            else:
+                # Run sync tool
+                result = tool.run(validated_input)
+        except Exception as e:
+            return ToolResponse(
+                content=[
+                    {
+                        "type": "text",
+                        "text": f"Tool execution error: {str(e)}",
+                    },
+                ],
+                metadata={"error": True},
+            )
+
+        # Convert result to ToolResponse format
+        try:
+            if hasattr(result, "model_dump"):
+                # Pydantic model result
+                result_dict = result.model_dump()
+                content_text = json.dumps(
+                    result_dict,
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            else:
+                # Other result types
+                content_text = str(result)
+                result_dict = result
+
+            return ToolResponse(
+                content=[
+                    {
+                        "type": "text",
+                        "text": content_text,
+                    },
+                ],
+                metadata={"tool_result": result_dict},
+            )
+        except Exception as e:
+            return ToolResponse(
+                content=[
+                    {
+                        "type": "text",
+                        "text": f"Result formatting error: {str(e)}",
+                    },
+                ],
+                metadata={"error": True},
+            )
+
+    # Use provided name/description or fall back to tool defaults
+    tool_name = name or tool.name
+    tool_description = description or tool.description
+
+    # Get the tool's function schema and convert to AgentScope format
+    function_schema = tool.function_schema.model_dump()
+
+    # Convert from OpenAI function calling format to AgentScope format
+    agentscope_schema = {
+        "type": "function",
+        "function": {
+            "name": tool_name,
+            "description": tool_description,
+            "parameters": function_schema.get("parameters", {}),
+        },
+    }
+
+    return RegisteredToolFunction(
+        name=tool_name,
+        source="function",
+        mcp_name=None,
+        original_func=func_wrapper,
+        json_schema=agentscope_schema,
+        group="basic",
+    )
+
+
+def agentscope_toolkit_adapter(
+    tools: Sequence[Tool],
+    name_overrides: Optional[Dict[str, str]] = None,
+    description_overrides: Optional[Dict[str, str]] = None,
+) -> Toolkit:
+    """Create an AgentScope toolkit from multiple agentscope_runtime tools.
+
+    This is a convenience function that creates a toolkit with multiple
+    tools converted to AgentScope tools.
+
+    Args:
+        tools: Sequence of agentscope_runtime tools to convert
+        name_overrides: Optional dict mapping tool names to override names
+        description_overrides: Optional dict mapping tool names to
+            override descriptions
+
+    Returns:
+        Toolkit: AgentScope toolkit with all tools as tools
+
+    Examples:
+        Create toolkit from multiple tools:
+
+        .. code-block:: python
+
+            from agentscope_runtime.searches.modelstudio_search
+            import ModelstudioSearch
+            from agentscope_runtime.RAGs.modelstudio_rag import
+            ModelstudioRag
+            from agentscope_runtime.adapters.agentscope.tool import
+            agentscope_tool_adapter
+            from agentscope.tool import Toolkit
+
+            # Create the search tool
+            search_tool = ModelstudioSearch()
+            rag_tool = ModelstudioRag()
+
+            # Create toolkit
+            toolkit = agentscope_toolkit_adapter([search_tool,
+            rag_tool])
+
+            # Use in agents...
+    """
+    name_overrides = name_overrides or {}
+    description_overrides = description_overrides or {}
+
+    toolkit = Toolkit()
+
+    for tool in tools:
+        name_override = name_overrides.get(tool.name)
+        description_override = description_overrides.get(tool.name)
+
+        adapted_tool = agentscope_tool_adapter(
+            tool,
+            name=name_override,
+            description=description_override,
+        )
+
+        toolkit.tools[tool.name] = adapted_tool
+
+    return toolkit

agentscope_runtime/adapters/autogen/tool/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+from .tool import AutogenToolAdapter, create_autogen_tools
+
+__all__ = [
+    "AutogenToolAdapter",
+    "create_autogen_tools",
+]

agentscope_runtime/adapters/autogen/tool/tool.py

@@ -0,0 +1,211 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=unused-argument, redefined-outer-name
+
+import json
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+)
+
+try:
+    from autogen_core import CancellationToken
+    from autogen_core.tools import BaseTool
+except ImportError as e:
+    # Create mock classes when autogen is not available
+    raise ImportError(
+        "Please install autogen-core to use this feature: "
+        "pip install autogen-core",
+    ) from e
+
+from pydantic import BaseModel
+
+from agentscope_runtime.tools.base import Tool
+
+
+class AutogenToolAdapter(BaseTool[BaseModel, Any]):
+    """Adapter class that wraps agentscope_runtime tools to make them
+    compatible with AutoGen.
+
+    This adapter allows any tool that inherits from
+    agentscope_runtime.tools.base.Tool to be used as a tool in
+    AutoGen agents
+
+    Args:
+        tool (Tool): The agentscope_runtime tool to wrap
+        name (str, optional): Override the tool name. Defaults to
+            tool.name
+        description (str, optional): Override the tool description.
+            Defaults to tool.description
+
+    Examples:
+        Basic usage with a search tool:
+
+        .. code-block:: python
+
+            from agentscope_runtime.tools.searches.modelstudio_search
+            import ModelstudioSearch
+            from agentscope_runtime.adapters.autogen.tool import
+            AutogenToolAdapter
+            from autogen_ext.models.openai import OpenAIChatCompletionClient
+            from autogen_agentchat.agents import AssistantAgent
+            from autogen_agentchat.messages import TextMessage
+            from autogen_core import CancellationToken
+
+            async def main():
+                # Create the search tool
+                search_tool = ModelstudioSearch()
+
+                # Create the autogen tool adapter
+                search_tool = AutogenToolAdapter(search_tool)
+
+                # Create an agents with the search tool
+                model = OpenAIChatCompletionClient(model="gpt-4")
+                agents = AssistantAgent(
+                    "assistant",
+                    tools=[search_tool],
+                    model_client=model,
+                )
+
+                # Use the agents
+                response = await agents.on_messages(
+                    [TextMessage(content="What's the weather in Beijing?",
+                    source="user")],
+                    CancellationToken(),
+                )
+                print(response.chat_message)
+
+            asyncio.run(main())
+    """
+
+    def __init__(
+        self,
+        tool: Tool,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> None:
+        """Initialize the tool tool adapter.
+
+        Args:
+            tool: The agentscope_runtime tool to wrap
+            name: Optional override for the tool name
+            description: Optional override for the tool description
+        """
+
+        self._tool = tool
+
+        # Use provided name/description or fall back to tool defaults
+        tool_name = name or tool.name
+        tool_description = description or tool.description
+
+        # Create input model from tool's input type
+        arg_type = tool.input_type
+        return_type = tool.return_type
+
+        super().__init__(arg_type, return_type, tool_name, tool_description)
+
+    async def run(
+        self,
+        args: BaseModel,
+        cancellation_token: CancellationToken,
+    ) -> Any:
+        """Run the tool with the provided arguments.
+
+        Args:
+            args: The arguments to pass to the tool
+            cancellation_token: Token to signal cancellation
+
+        Returns:
+            The result of the tool execution
+
+        Raises:
+            Exception: If the operation is cancelled or the tool
+            execution fails
+        """
+
+        # Run the tool
+        try:
+            result = await self._tool.arun(args)
+            # make sure return as string
+            return json.dumps(result.model_dump(), ensure_ascii=False)
+        except Exception as e:
+            # Re-raise with more context
+            raise RuntimeError(
+                f"Tool {self._tool.name} failed: {str(e)}",
+            ) from e
+
+
+def create_autogen_tools(
+    tools: Sequence[Tool],
+    name_overrides: Optional[Dict[str, str]] = None,
+    description_overrides: Optional[Dict[str, str]] = None,
+) -> List[AutogenToolAdapter]:
+    """Create a list of tool adapters for use with AutoGen agents.
+
+    This is a convenience function that creates adapters for multiple
+    tools at once, similar to how tool.py provides
+    LanggraphNode.
+
+    Args:
+        tools: Sequence of agentscope_runtime tools to wrap
+        name_overrides: Optional dict mapping tool names to override names
+        description_overrides: Optional dict mapping tool names to
+                override descriptions
+
+
+    Returns:
+        List of Tool instances ready to use with AutoGen agents
+
+    Examples:
+        Create tools from multiple tools:
+
+        .. code-block:: python
+
+            from agentscope_runtime.searches.modelstudio_search
+            import ModelstudioSearch
+            from agentscope_runtime.RAGs.modelstudio_rag import
+            ModelstudioRag
+            from agentscope_runtime.adapters.autogen.tool import
+            AutogenToolAdapter
+            from autogen_ext.models.openai import OpenAIChatCompletionClient
+            from autogen_agentchat.agents import AssistantAgent
+
+            async def main():
+                # Create tools
+                search_tool = ModelstudioSearch()
+                rag_tool = ModelstudioRag()
+
+                # Create autogen tools
+                tools = create_autogen_tools([search_tool,
+                    rag_tool])
+
+                # Create agents with all tools
+                model = OpenAIChatCompletionClient(model="gpt-4")
+                agents = AssistantAgent(
+                    "assistant",
+                    tools=tools,
+                    model_client=model,
+                )
+
+                # Use the agents...
+
+            asyncio.run(main())
+    """
+    name_overrides = name_overrides or {}
+    description_overrides = description_overrides or {}
+
+    output_tools = []
+    for tool in tools:
+        name_override = name_overrides.get(tool.name)
+        description_override = description_overrides.get(tool.name)
+
+        adapted_tool = AutogenToolAdapter(
+            tool,
+            name=name_override,
+            description=description_override,
+        )
+        output_tools.append(adapted_tool)
+
+    return output_tools

agentscope_runtime/adapters/text/stream.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+from typing import AsyncIterator
+
+from ...engine.schemas.agent_schemas import (
+    Message,
+    MessageType,
+)
+from ...engine.helpers.agent_api_builder import ResponseBuilder
+
+
+async def adapt_text_stream(
+    source_stream: AsyncIterator[str],
+) -> AsyncIterator[Message]:
+    rb = ResponseBuilder()
+    mb = rb.create_message_builder(
+        role="assistant",
+        message_type=MessageType.MESSAGE,
+    )
+    cb = mb.create_content_builder(content_type="text")
+
+    async for text_delta in source_stream:
+        delta_content = cb.add_text_delta(text_delta)
+        yield delta_content
+
+    cb.complete()
+    yield mb.complete()
+
+    rb.completed()

agentscope_runtime/common/collections/redis_mapping.py

@@ -32,7 +32,7 @@ class RedisMapping(Mapping):
     def scan(self, prefix: str = ""):
         search_pattern = f"{self._get_full_key(prefix)}*"
         cursor = 0
-        while cursor != 0:
+        while True:
             cursor, keys = self.client.scan(
                 cursor=cursor,
                 match=search_pattern,
@@ -40,3 +40,6 @@ class RedisMapping(Mapping):
             for key in keys:
                 decoded_key = key.decode("utf-8")
                 yield self._strip_prefix(decoded_key)
+
+            if cursor == 0:
+                break