swarms 7.7.2__py3-none-any.whl → 7.7.3__py3-none-any.whl

swarms/telemetry/main.py

@@ -1,4 +1,3 @@
-import threading
 import asyncio
 
 
@@ -394,9 +393,4 @@ def _log_agent_data(data_dict: dict):
 
 def log_agent_data(data_dict: dict):
     """Log agent data"""
-    process_thread = threading.Thread(
-        target=_log_agent_data,
-        args=(data_dict,),
-        daemon=True,
-    )
-    process_thread.start()
+    pass

swarms/tools/mcp_client.py

@@ -1,90 +1,246 @@
 import asyncio
-from typing import Literal, Dict, Any, Union
+import json
+from typing import List, Literal, Dict, Any, Union
 from fastmcp import Client
-from swarms.utils.any_to_str import any_to_str
 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]]:
-    if isinstance(dictionary, str):
-        dictionary = str_to_dict(dictionary)
+    """
+    Parse agent output into tool name and parameters.
 
-    elif not isinstance(dictionary, dict):
-        raise ValueError("Invalid dictionary")
+    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.
 
-    # Handle OpenAI function call format
-    if "function_call" in dictionary:
-        name = dictionary["function_call"]["name"]
-        # arguments is a JSON string, so we need to parse it
-        params = str_to_dict(dictionary["function_call"]["arguments"])
-        return name, params
+    Returns:
+        tuple[str, Dict[Any, Any]]: A tuple containing the tool name and its parameters.
 
-    # Handle OpenAI tool calls format
-    if "tool_calls" in dictionary:
-        # Get the first tool call (or you could handle multiple if needed)
-        tool_call = dictionary["tool_calls"][0]
-        name = tool_call["function"]["name"]
-        params = str_to_dict(tool_call["function"]["arguments"])
-        return name, params
+    Raises:
+        ValueError: If the input is invalid or missing required 'name' key.
+    """
+    try:
+        if isinstance(dictionary, str):
+            dictionary = str_to_dict(dictionary)
 
-    # Handle regular dictionary format
-    if "name" in dictionary:
-        name = dictionary["name"]
-        params = dictionary.get("arguments", {})
-        return name, params
+        elif not isinstance(dictionary, dict):
+            raise ValueError("Invalid dictionary")
 
-    raise ValueError("Invalid function call format")
+        # 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,
-    method: Literal["stdio", "sse"] = "sse",
     parameters: Dict[Any, Any] = None,
-    output_type: Literal["str", "dict"] = "str",
     *args,
     **kwargs,
 ) -> Dict[Any, Any]:
+    """
+    Asynchronously execute a tool on an MCP server.
 
-    if "sse" or "stdio" not in url:
-        raise ValueError("Invalid URL")
+    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.
 
-    url = f"{url}/{method}"
+    Returns:
+        Dictionary containing the tool execution results.
 
-    name, params = parse_agent_output(parameters)
+    Raises:
+        ValueError: If the URL is invalid or tool execution fails.
+    """
+    try:
+
+        name, params = parse_agent_output(parameters)
+
+        outputs = []
 
-    if output_type == "str":
-        async with Client(url, *args, **kwargs) as client:
-            out = await client.call_tool(
-                name=name,
-                arguments=params,
-            )
-            return any_to_str(out)
-    elif output_type == "dict":
         async with Client(url, *args, **kwargs) as client:
             out = await client.call_tool(
                 name=name,
                 arguments=params,
             )
-            return out
-    else:
-        raise ValueError(f"Invalid output type: {output_type}")
+
+            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,
-    tool_name: str = None,
-    method: Literal["stdio", "sse"] = "sse",
     parameters: Dict[Any, Any] = None,
-    output_type: Literal["str", "dict"] = "str",
 ) -> Dict[Any, Any]:
-    return asyncio.run(
-        _execute_mcp_tool(
-            url=url,
-            tool_name=tool_name,
-            method=method,
-            parameters=parameters,
-            output_type=output_type,
+    """
+    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,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, List
+from typing import Any
 
 
 from loguru import logger
@@ -25,8 +25,6 @@ from mcp.client.sse import sse_client
 from mcp.types import CallToolResult, JSONRPCMessage
 from typing_extensions import NotRequired, TypedDict
 
-from swarms.utils.any_to_str import any_to_str
-
 
 class MCPServer(abc.ABC):
     """Base class for Model Context Protocol servers."""
@@ -340,53 +338,3 @@ class MCPServerSse(_MCPServerWithClientSession):
     def name(self) -> str:
         """A readable name for the server."""
         return self._name
-
-
-def mcp_flow_get_tool_schema(
-    params: MCPServerSseParams,
-) -> MCPServer:
-    server = MCPServerSse(params, cache_tools_list=True)
-
-    # Connect the server
-    asyncio.run(server.connect())
-
-    # Return the server
-    output = asyncio.run(server.list_tools())
-
-    # Cleanup the server
-    asyncio.run(server.cleanup())
-
-    return output.model_dump()
-
-
-def mcp_flow(
-    params: MCPServerSseParams,
-    function_call: dict[str, Any],
-) -> MCPServer:
-    server = MCPServerSse(params, cache_tools_list=True)
-
-    # Connect the server
-    asyncio.run(server.connect())
-
-    # Return the server
-    output = asyncio.run(server.call_tool(function_call))
-
-    output = output.model_dump()
-
-    # Cleanup the server
-    asyncio.run(server.cleanup())
-
-    return any_to_str(output)
-
-
-def batch_mcp_flow(
-    params: List[MCPServerSseParams],
-    function_call: List[dict[str, Any]] = [],
-) -> MCPServer:
-    output_list = []
-
-    for param in params:
-        output = mcp_flow(param, function_call)
-        output_list.append(output)
-
-    return output_list

swarms/utils/generate_keys.py

@@ -0,0 +1,64 @@
+import secrets
+import string
+import re
+
+
+def generate_api_key(prefix: str = "sk-", length: int = 32) -> str:
+    """
+    Generate a secure API key with a custom prefix.
+
+    Args:
+        prefix (str): The prefix to add to the API key (default: "sk-")
+        length (int): The length of the random part of the key (default: 32)
+
+    Returns:
+        str: A secure API key in the format: prefix + random_string
+
+    Example:
+        >>> generate_api_key("sk-")
+        'sk-abc123...'
+    """
+    # Validate prefix
+    if not isinstance(prefix, str):
+        raise ValueError("Prefix must be a string")
+
+    # Validate length
+    if length < 8:
+        raise ValueError("Length must be at least 8 characters")
+
+    # Generate random string using alphanumeric characters
+    alphabet = string.ascii_letters + string.digits
+    random_part = "".join(
+        secrets.choice(alphabet) for _ in range(length)
+    )
+
+    # Combine prefix and random part
+    api_key = f"{prefix}{random_part}"
+
+    return api_key
+
+
+def validate_api_key(api_key: str, prefix: str = "sk-") -> bool:
+    """
+    Validate if an API key matches the expected format.
+
+    Args:
+        api_key (str): The API key to validate
+        prefix (str): The expected prefix (default: "sk-")
+
+    Returns:
+        bool: True if the API key is valid, False otherwise
+    """
+    if not isinstance(api_key, str):
+        return False
+
+    # Check if key starts with prefix
+    if not api_key.startswith(prefix):
+        return False
+
+    # Check if the rest of the key contains only alphanumeric characters
+    random_part = api_key[len(prefix) :]
+    if not re.match(r"^[a-zA-Z0-9]+$", random_part):
+        return False
+
+    return True

swarms/utils/history_output_formatter.py

@@ -19,6 +19,8 @@ HistoryOutputType = Literal[
     "str-all-except-first",
 ]
 
+output_type: HistoryOutputType
+
 
 def history_output_formatter(
     conversation: Conversation, type: HistoryOutputType = "list"