swarms 7.7.9__py3-none-any.whl → 7.8.1__py3-none-any.whl

swarms/tools/mcp_client.py

@@ -1,246 +0,0 @@
-import asyncio
-import json
-from typing import List, Literal, Dict, Any, Union
-from fastmcp import Client
-from swarms.utils.str_to_dict import str_to_dict
-from loguru import logger
-
-
-def parse_agent_output(
-    dictionary: Union[str, Dict[Any, Any]],
-) -> tuple[str, Dict[Any, Any]]:
-    """
-    Parse agent output into tool name and parameters.
-
-    Args:
-        dictionary: Either a string or dictionary containing tool information.
-                   If string, it will be converted to a dictionary.
-                   Must contain a 'name' key for the tool name.
-
-    Returns:
-        tuple[str, Dict[Any, Any]]: A tuple containing the tool name and its parameters.
-
-    Raises:
-        ValueError: If the input is invalid or missing required 'name' key.
-    """
-    try:
-        if isinstance(dictionary, str):
-            dictionary = str_to_dict(dictionary)
-
-        elif not isinstance(dictionary, dict):
-            raise ValueError("Invalid dictionary")
-
-        # Handle regular dictionary format
-        if "name" in dictionary:
-            name = dictionary["name"]
-            # Remove the name key and use remaining key-value pairs as parameters
-            params = dict(dictionary)
-            params.pop("name")
-            return name, params
-
-        raise ValueError("Invalid function call format")
-    except Exception as e:
-        raise ValueError(f"Error parsing agent output: {str(e)}")
-
-
-async def _list_all(url: str):
-    """
-    Asynchronously list all tools available on a given MCP server.
-
-    Args:
-        url: The URL of the MCP server to query.
-
-    Returns:
-        List of available tools.
-
-    Raises:
-        ValueError: If there's an error connecting to or querying the server.
-    """
-    try:
-        async with Client(url) as client:
-            return await client.list_tools()
-    except Exception as e:
-        raise ValueError(f"Error listing tools: {str(e)}")
-
-
-def list_all(url: str, output_type: Literal["str", "json"] = "json"):
-    """
-    Synchronously list all tools available on a given MCP server.
-
-    Args:
-        url: The URL of the MCP server to query.
-
-    Returns:
-        List of dictionaries containing tool information.
-
-    Raises:
-        ValueError: If there's an error connecting to or querying the server.
-    """
-    try:
-        out = asyncio.run(_list_all(url))
-
-        outputs = []
-        for tool in out:
-            outputs.append(tool.model_dump())
-
-        if output_type == "json":
-            return json.dumps(outputs, indent=4)
-        else:
-            return outputs
-    except Exception as e:
-        raise ValueError(f"Error in list_all: {str(e)}")
-
-
-def list_tools_for_multiple_urls(
-    urls: List[str], output_type: Literal["str", "json"] = "json"
-):
-    """
-    List tools available across multiple MCP servers.
-
-    Args:
-        urls: List of MCP server URLs to query.
-        output_type: Format of the output, either "json" (string) or "str" (list).
-
-    Returns:
-        If output_type is "json": JSON string containing all tools with server URLs.
-        If output_type is "str": List of tools with server URLs.
-
-    Raises:
-        ValueError: If there's an error querying any of the servers.
-    """
-    try:
-        out = []
-        for url in urls:
-            tools = list_all(url)
-            # Add server URL to each tool's data
-            for tool in tools:
-                tool["server_url"] = url
-            out.append(tools)
-
-        if output_type == "json":
-            return json.dumps(out, indent=4)
-        else:
-            return out
-    except Exception as e:
-        raise ValueError(
-            f"Error listing tools for multiple URLs: {str(e)}"
-        )
-
-
-async def _execute_mcp_tool(
-    url: str,
-    parameters: Dict[Any, Any] = None,
-    *args,
-    **kwargs,
-) -> Dict[Any, Any]:
-    """
-    Asynchronously execute a tool on an MCP server.
-
-    Args:
-        url: The URL of the MCP server.
-        parameters: Dictionary containing tool name and parameters.
-        *args: Additional positional arguments for the Client.
-        **kwargs: Additional keyword arguments for the Client.
-
-    Returns:
-        Dictionary containing the tool execution results.
-
-    Raises:
-        ValueError: If the URL is invalid or tool execution fails.
-    """
-    try:
-
-        name, params = parse_agent_output(parameters)
-
-        outputs = []
-
-        async with Client(url, *args, **kwargs) as client:
-            out = await client.call_tool(
-                name=name,
-                arguments=params,
-            )
-
-            for output in out:
-                outputs.append(output.model_dump())
-
-        # convert outputs to string
-        return json.dumps(outputs, indent=4)
-    except Exception as e:
-        raise ValueError(f"Error executing MCP tool: {str(e)}")
-
-
-def execute_mcp_tool(
-    url: str,
-    parameters: Dict[Any, Any] = None,
-) -> Dict[Any, Any]:
-    """
-    Synchronously execute a tool on an MCP server.
-
-    Args:
-        url: The URL of the MCP server.
-        parameters: Dictionary containing tool name and parameters.
-
-    Returns:
-        Dictionary containing the tool execution results.
-
-    Raises:
-        ValueError: If tool execution fails.
-    """
-    try:
-        logger.info(f"Executing MCP tool with URL: {url}")
-        logger.debug(f"Tool parameters: {parameters}")
-
-        result = asyncio.run(
-            _execute_mcp_tool(
-                url=url,
-                parameters=parameters,
-            )
-        )
-
-        logger.info("MCP tool execution completed successfully")
-        logger.debug(f"Tool execution result: {result}")
-        return result
-    except Exception as e:
-        logger.error(f"Error in execute_mcp_tool: {str(e)}")
-        raise ValueError(f"Error in execute_mcp_tool: {str(e)}")
-
-
-def find_and_execute_tool(
-    urls: List[str], tool_name: str, parameters: Dict[Any, Any]
-) -> Dict[Any, Any]:
-    """
-    Find a tool across multiple servers and execute it with the given parameters.
-
-    Args:
-        urls: List of server URLs to search through.
-        tool_name: Name of the tool to find and execute.
-        parameters: Parameters to pass to the tool.
-
-    Returns:
-        Dict containing the tool execution results.
-
-    Raises:
-        ValueError: If tool is not found on any server or execution fails.
-    """
-    try:
-        # Search for tool across all servers
-        for url in urls:
-            try:
-                tools = list_all(url)
-                # Check if tool exists on this server
-                if any(tool["name"] == tool_name for tool in tools):
-                    # Prepare parameters in correct format
-                    tool_params = {"name": tool_name, **parameters}
-                    # Execute tool on this server
-                    return execute_mcp_tool(
-                        url=url, parameters=tool_params
-                    )
-            except Exception:
-                # Skip servers that fail and continue searching
-                continue
-
-        raise ValueError(
-            f"Tool '{tool_name}' not found on any provided servers"
-        )
-    except Exception as e:
-        raise ValueError(f"Error in find_and_execute_tool: {str(e)}")

swarms/tools/mcp_integration.py

@@ -1,340 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-
-from loguru import logger
-
-import abc
-import asyncio
-from contextlib import AbstractAsyncContextManager, AsyncExitStack
-from pathlib import Path
-from typing import Literal
-
-from anyio.streams.memory import (
-    MemoryObjectReceiveStream,
-    MemoryObjectSendStream,
-)
-from mcp import (
-    ClientSession,
-    StdioServerParameters,
-    Tool as MCPTool,
-    stdio_client,
-)
-from mcp.client.sse import sse_client
-from mcp.types import CallToolResult, JSONRPCMessage
-from typing_extensions import NotRequired, TypedDict
-
-
-class MCPServer(abc.ABC):
-    """Base class for Model Context Protocol servers."""
-
-    @abc.abstractmethod
-    async def connect(self):
-        """Connect to the server. For example, this might mean spawning a subprocess or
-        opening a network connection. The server is expected to remain connected until
-        `cleanup()` is called.
-        """
-        pass
-
-    @property
-    @abc.abstractmethod
-    def name(self) -> str:
-        """A readable name for the server."""
-        pass
-
-    @abc.abstractmethod
-    async def cleanup(self):
-        """Cleanup the server. For example, this might mean closing a subprocess or
-        closing a network connection.
-        """
-        pass
-
-    @abc.abstractmethod
-    async def list_tools(self) -> list[MCPTool]:
-        """List the tools available on the server."""
-        pass
-
-    @abc.abstractmethod
-    async def call_tool(
-        self, tool_name: str, arguments: dict[str, Any] | None
-    ) -> CallToolResult:
-        """Invoke a tool on the server."""
-        pass
-
-
-class _MCPServerWithClientSession(MCPServer, abc.ABC):
-    """Base class for MCP servers that use a `ClientSession` to communicate with the server."""
-
-    def __init__(self, cache_tools_list: bool):
-        """
-        Args:
-            cache_tools_list: Whether to cache the tools list. If `True`, the tools list will be
-            cached and only fetched from the server once. If `False`, the tools list will be
-            fetched from the server on each call to `list_tools()`. The cache can be invalidated
-            by calling `invalidate_tools_cache()`. You should set this to `True` if you know the
-            server will not change its tools list, because it can drastically improve latency
-            (by avoiding a round-trip to the server every time).
-        """
-        self.session: ClientSession | None = None
-        self.exit_stack: AsyncExitStack = AsyncExitStack()
-        self._cleanup_lock: asyncio.Lock = asyncio.Lock()
-        self.cache_tools_list = cache_tools_list
-
-        # The cache is always dirty at startup, so that we fetch tools at least once
-        self._cache_dirty = True
-        self._tools_list: list[MCPTool] | None = None
-
-    @abc.abstractmethod
-    def create_streams(
-        self,
-    ) -> AbstractAsyncContextManager[
-        tuple[
-            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
-            MemoryObjectSendStream[JSONRPCMessage],
-        ]
-    ]:
-        """Create the streams for the server."""
-        pass
-
-    async def __aenter__(self):
-        await self.connect()
-        return self
-
-    async def __aexit__(self, exc_type, exc_value, traceback):
-        await self.cleanup()
-
-    def invalidate_tools_cache(self):
-        """Invalidate the tools cache."""
-        self._cache_dirty = True
-
-    async def connect(self):
-        """Connect to the server."""
-        try:
-            transport = await self.exit_stack.enter_async_context(
-                self.create_streams()
-            )
-            read, write = transport
-            session = await self.exit_stack.enter_async_context(
-                ClientSession(read, write)
-            )
-            await session.initialize()
-            self.session = session
-        except Exception as e:
-            logger.error(f"Error initializing MCP server: {e}")
-            await self.cleanup()
-            raise
-
-    async def list_tools(self) -> list[MCPTool]:
-        """List the tools available on the server."""
-        if not self.session:
-            raise Exception(
-                "Server not initialized. Make sure you call `connect()` first."
-            )
-
-        # Return from cache if caching is enabled, we have tools, and the cache is not dirty
-        if (
-            self.cache_tools_list
-            and not self._cache_dirty
-            and self._tools_list
-        ):
-            return self._tools_list
-
-        # Reset the cache dirty to False
-        self._cache_dirty = False
-
-        # Fetch the tools from the server
-        self._tools_list = (await self.session.list_tools()).tools
-        return self._tools_list
-
-    async def call_tool(
-        self, arguments: dict[str, Any] | None
-    ) -> CallToolResult:
-        """Invoke a tool on the server."""
-        tool_name = arguments.get("tool_name") or arguments.get(
-            "name"
-        )
-
-        if not tool_name:
-            raise Exception("No tool name found in arguments")
-
-        if not self.session:
-            raise Exception(
-                "Server not initialized. Make sure you call `connect()` first."
-            )
-
-        return await self.session.call_tool(tool_name, arguments)
-
-    async def cleanup(self):
-        """Cleanup the server."""
-        async with self._cleanup_lock:
-            try:
-                await self.exit_stack.aclose()
-                self.session = None
-            except Exception as e:
-                logger.error(f"Error cleaning up server: {e}")
-
-
-class MCPServerStdioParams(TypedDict):
-    """Mirrors `mcp.client.stdio.StdioServerParameters`, but lets you pass params without another
-    import.
-    """
-
-    command: str
-    """The executable to run to start the server. For example, `python` or `node`."""
-
-    args: NotRequired[list[str]]
-    """Command line args to pass to the `command` executable. For example, `['foo.py']` or
-    `['server.js', '--port', '8080']`."""
-
-    env: NotRequired[dict[str, str]]
-    """The environment variables to set for the server. ."""
-
-    cwd: NotRequired[str | Path]
-    """The working directory to use when spawning the process."""
-
-    encoding: NotRequired[str]
-    """The text encoding used when sending/receiving messages to the server. Defaults to `utf-8`."""
-
-    encoding_error_handler: NotRequired[
-        Literal["strict", "ignore", "replace"]
-    ]
-    """The text encoding error handler. Defaults to `strict`.
-
-    See https://docs.python.org/3/library/codecs.html#codec-base-classes for
-    explanations of possible values.
-    """
-
-
-class MCPServerStdio(_MCPServerWithClientSession):
-    """MCP server implementation that uses the stdio transport. See the [spec]
-    (https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#stdio) for
-    details.
-    """
-
-    def __init__(
-        self,
-        params: MCPServerStdioParams,
-        cache_tools_list: bool = False,
-        name: str | None = None,
-    ):
-        """Create a new MCP server based on the stdio transport.
-
-        Args:
-            params: The params that configure the server. This includes the command to run to
-                start the server, the args to pass to the command, the environment variables to
-                set for the server, the working directory to use when spawning the process, and
-                the text encoding used when sending/receiving messages to the server.
-            cache_tools_list: Whether to cache the tools list. If `True`, the tools list will be
-                cached and only fetched from the server once. If `False`, the tools list will be
-                fetched from the server on each call to `list_tools()`. The cache can be
-                invalidated by calling `invalidate_tools_cache()`. You should set this to `True`
-                if you know the server will not change its tools list, because it can drastically
-                improve latency (by avoiding a round-trip to the server every time).
-            name: A readable name for the server. If not provided, we'll create one from the
-                command.
-        """
-        super().__init__(cache_tools_list)
-
-        self.params = StdioServerParameters(
-            command=params["command"],
-            args=params.get("args", []),
-            env=params.get("env"),
-            cwd=params.get("cwd"),
-            encoding=params.get("encoding", "utf-8"),
-            encoding_error_handler=params.get(
-                "encoding_error_handler", "strict"
-            ),
-        )
-
-        self._name = name or f"stdio: {self.params.command}"
-
-    def create_streams(
-        self,
-    ) -> AbstractAsyncContextManager[
-        tuple[
-            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
-            MemoryObjectSendStream[JSONRPCMessage],
-        ]
-    ]:
-        """Create the streams for the server."""
-        return stdio_client(self.params)
-
-    @property
-    def name(self) -> str:
-        """A readable name for the server."""
-        return self._name
-
-
-class MCPServerSseParams(TypedDict):
-    """Mirrors the params in`mcp.client.sse.sse_client`."""
-
-    url: str
-    """The URL of the server."""
-
-    headers: NotRequired[dict[str, str]]
-    """The headers to send to the server."""
-
-    timeout: NotRequired[float]
-    """The timeout for the HTTP request. Defaults to 5 seconds."""
-
-    sse_read_timeout: NotRequired[float]
-    """The timeout for the SSE connection, in seconds. Defaults to 5 minutes."""
-
-
-class MCPServerSse(_MCPServerWithClientSession):
-    """MCP server implementation that uses the HTTP with SSE transport. See the [spec]
-    (https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse)
-    for details.
-    """
-
-    def __init__(
-        self,
-        params: MCPServerSseParams,
-        cache_tools_list: bool = False,
-        name: str | None = None,
-    ):
-        """Create a new MCP server based on the HTTP with SSE transport.
-
-        Args:
-            params: The params that configure the server. This includes the URL of the server,
-                the headers to send to the server, the timeout for the HTTP request, and the
-                timeout for the SSE connection.
-
-            cache_tools_list: Whether to cache the tools list. If `True`, the tools list will be
-                cached and only fetched from the server once. If `False`, the tools list will be
-                fetched from the server on each call to `list_tools()`. The cache can be
-                invalidated by calling `invalidate_tools_cache()`. You should set this to `True`
-                if you know the server will not change its tools list, because it can drastically
-                improve latency (by avoiding a round-trip to the server every time).
-
-            name: A readable name for the server. If not provided, we'll create one from the
-                URL.
-        """
-        super().__init__(cache_tools_list)
-
-        self.params = params
-        self._name = name or f"sse: {self.params['url']}"
-
-    def create_streams(
-        self,
-    ) -> AbstractAsyncContextManager[
-        tuple[
-            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
-            MemoryObjectSendStream[JSONRPCMessage],
-        ]
-    ]:
-        """Create the streams for the server."""
-        return sse_client(
-            url=self.params["url"],
-            headers=self.params.get("headers", None),
-            timeout=self.params.get("timeout", 5),
-            sse_read_timeout=self.params.get(
-                "sse_read_timeout", 60 * 5
-            ),
-        )
-
-    @property
-    def name(self) -> str:
-        """A readable name for the server."""
-        return self._name