swarms 7.8.8__py3-none-any.whl → 7.9.0__py3-none-any.whl

swarms/tools/mcp_client_call.py

@@ -505,3 +505,511 @@ async def execute_tool_call_simple(
         *args,
         **kwargs,
     )
+
+
+def _create_server_tool_mapping(
+    urls: List[str],
+    connections: List[MCPConnection] = None,
+    format: str = "openai",
+) -> Dict[str, Dict[str, Any]]:
+    """
+    Create a mapping of function names to server information for all MCP servers.
+
+    Args:
+        urls: List of server URLs
+        connections: Optional list of MCPConnection objects
+        format: Format to fetch tools in
+
+    Returns:
+        Dict mapping function names to server info (url, connection, tool)
+    """
+    server_tool_mapping = {}
+
+    for i, url in enumerate(urls):
+        connection = (
+            connections[i]
+            if connections and i < len(connections)
+            else None
+        )
+
+        try:
+            # Get tools for this server
+            tools = get_mcp_tools_sync(
+                server_path=url,
+                connection=connection,
+                format=format,
+            )
+
+            # Create mapping for each tool
+            for tool in tools:
+                if isinstance(tool, dict) and "function" in tool:
+                    function_name = tool["function"]["name"]
+                    server_tool_mapping[function_name] = {
+                        "url": url,
+                        "connection": connection,
+                        "tool": tool,
+                        "server_index": i,
+                    }
+                elif hasattr(tool, "name"):
+                    # Handle MCPTool objects
+                    server_tool_mapping[tool.name] = {
+                        "url": url,
+                        "connection": connection,
+                        "tool": tool,
+                        "server_index": i,
+                    }
+
+        except Exception as e:
+            logger.warning(
+                f"Failed to fetch tools from server {url}: {str(e)}"
+            )
+            continue
+
+    return server_tool_mapping
+
+
+async def _create_server_tool_mapping_async(
+    urls: List[str],
+    connections: List[MCPConnection] = None,
+    format: str = "openai",
+) -> Dict[str, Dict[str, Any]]:
+    """
+    Async version: Create a mapping of function names to server information for all MCP servers.
+
+    Args:
+        urls: List of server URLs
+        connections: Optional list of MCPConnection objects
+        format: Format to fetch tools in
+
+    Returns:
+        Dict mapping function names to server info (url, connection, tool)
+    """
+    server_tool_mapping = {}
+
+    for i, url in enumerate(urls):
+        connection = (
+            connections[i]
+            if connections and i < len(connections)
+            else None
+        )
+
+        try:
+            # Get tools for this server using async function
+            tools = await aget_mcp_tools(
+                server_path=url,
+                connection=connection,
+                format=format,
+            )
+
+            # Create mapping for each tool
+            for tool in tools:
+                if isinstance(tool, dict) and "function" in tool:
+                    function_name = tool["function"]["name"]
+                    server_tool_mapping[function_name] = {
+                        "url": url,
+                        "connection": connection,
+                        "tool": tool,
+                        "server_index": i,
+                    }
+                elif hasattr(tool, "name"):
+                    # Handle MCPTool objects
+                    server_tool_mapping[tool.name] = {
+                        "url": url,
+                        "connection": connection,
+                        "tool": tool,
+                        "server_index": i,
+                    }
+
+        except Exception as e:
+            logger.warning(
+                f"Failed to fetch tools from server {url}: {str(e)}"
+            )
+            continue
+
+    return server_tool_mapping
+
+
+async def _execute_tool_on_server(
+    tool_call: Dict[str, Any],
+    server_info: Dict[str, Any],
+    output_type: Literal["json", "dict", "str", "formatted"] = "str",
+) -> Dict[str, Any]:
+    """
+    Execute a single tool call on a specific server.
+
+    Args:
+        tool_call: The tool call to execute
+        server_info: Server information from the mapping
+        output_type: Output format type
+
+    Returns:
+        Execution result with server metadata
+    """
+    try:
+        result = await _execute_tool_call_simple(
+            response=tool_call,
+            server_path=server_info["url"],
+            connection=server_info["connection"],
+            output_type=output_type,
+        )
+
+        return {
+            "server_url": server_info["url"],
+            "server_index": server_info["server_index"],
+            "function_name": tool_call.get("function", {}).get(
+                "name", "unknown"
+            ),
+            "result": result,
+            "status": "success",
+        }
+
+    except Exception as e:
+        logger.error(
+            f"Failed to execute tool on server {server_info['url']}: {str(e)}"
+        )
+        return {
+            "server_url": server_info["url"],
+            "server_index": server_info["server_index"],
+            "function_name": tool_call.get("function", {}).get(
+                "name", "unknown"
+            ),
+            "result": None,
+            "error": str(e),
+            "status": "error",
+        }
+
+
+async def execute_multiple_tools_on_multiple_mcp_servers(
+    responses: List[Dict[str, Any]],
+    urls: List[str],
+    connections: List[MCPConnection] = None,
+    output_type: Literal["json", "dict", "str", "formatted"] = "str",
+    max_concurrent: Optional[int] = None,
+    *args,
+    **kwargs,
+) -> List[Dict[str, Any]]:
+    """
+    Execute multiple tool calls across multiple MCP servers.
+
+    This function creates a mapping of function names to servers, then for each response
+    that contains tool calls, it finds the appropriate server for each function and
+    executes the calls concurrently.
+
+    Args:
+        responses: List of responses containing tool calls (OpenAI format)
+        urls: List of MCP server URLs
+        connections: Optional list of MCPConnection objects corresponding to each URL
+        output_type: Output format type for results
+        max_concurrent: Maximum number of concurrent executions (default: len(responses))
+
+    Returns:
+        List of execution results with server metadata
+
+    Example:
+        # Example responses format:
+        responses = [
+            {
+                "function": {
+                    "name": "search_web",
+                    "arguments": {"query": "python programming"}
+                }
+            },
+            {
+                "function": {
+                    "name": "search_database",
+                    "arguments": {"table": "users", "id": 123}
+                }
+            }
+        ]
+
+        urls = ["http://server1:8000", "http://server2:8000"]
+
+        results = await execute_multiple_tools_on_multiple_mcp_servers(
+            responses=responses,
+            urls=urls
+        )
+    """
+    if not responses:
+        logger.warning("No responses provided for execution")
+        return []
+
+    if not urls:
+        raise MCPValidationError("No server URLs provided")
+
+    # Create mapping of function names to servers using async version
+    logger.info(f"Creating tool mapping for {len(urls)} servers")
+    server_tool_mapping = await _create_server_tool_mapping_async(
+        urls=urls, connections=connections, format="openai"
+    )
+
+    if not server_tool_mapping:
+        raise MCPExecutionError(
+            "No tools found on any of the provided servers"
+        )
+
+    logger.info(
+        f"Found {len(server_tool_mapping)} unique functions across all servers"
+    )
+
+    # Extract all tool calls from responses
+    all_tool_calls = []
+    logger.info(
+        f"Processing {len(responses)} responses for tool call extraction"
+    )
+
+    # Check if responses are individual characters that need to be reconstructed
+    if len(responses) > 10 and all(
+        isinstance(r, str) and len(r) == 1 for r in responses
+    ):
+        logger.info(
+            "Detected character-by-character response, reconstructing JSON string"
+        )
+        try:
+            reconstructed_response = "".join(responses)
+            logger.info(
+                f"Reconstructed response length: {len(reconstructed_response)}"
+            )
+            logger.debug(
+                f"Reconstructed response: {reconstructed_response}"
+            )
+
+            # Try to parse the reconstructed response to validate it
+            try:
+                json.loads(reconstructed_response)
+                logger.info(
+                    "Successfully validated reconstructed JSON response"
+                )
+            except json.JSONDecodeError as e:
+                logger.warning(
+                    f"Reconstructed response is not valid JSON: {str(e)}"
+                )
+                logger.debug(
+                    f"First 100 chars: {reconstructed_response[:100]}"
+                )
+                logger.debug(
+                    f"Last 100 chars: {reconstructed_response[-100:]}"
+                )
+
+            responses = [reconstructed_response]
+        except Exception as e:
+            logger.warning(
+                f"Failed to reconstruct response from characters: {str(e)}"
+            )
+
+    for i, response in enumerate(responses):
+        logger.debug(
+            f"Processing response {i}: {type(response)} - {response}"
+        )
+
+        # Handle JSON string responses
+        if isinstance(response, str):
+            try:
+                response = json.loads(response)
+                logger.debug(
+                    f"Parsed JSON string response {i}: {response}"
+                )
+            except json.JSONDecodeError:
+                logger.warning(
+                    f"Failed to parse JSON response at index {i}: {response}"
+                )
+                continue
+
+        if isinstance(response, dict):
+            # Single tool call
+            if "function" in response:
+                logger.debug(
+                    f"Found single tool call in response {i}: {response['function']}"
+                )
+                # Parse arguments if they're a JSON string
+                if isinstance(
+                    response["function"].get("arguments"), str
+                ):
+                    try:
+                        response["function"]["arguments"] = (
+                            json.loads(
+                                response["function"]["arguments"]
+                            )
+                        )
+                        logger.debug(
+                            f"Parsed function arguments: {response['function']['arguments']}"
+                        )
+                    except json.JSONDecodeError:
+                        logger.warning(
+                            f"Failed to parse function arguments: {response['function']['arguments']}"
+                        )
+
+                all_tool_calls.append((i, response))
+            # Multiple tool calls
+            elif "tool_calls" in response:
+                logger.debug(
+                    f"Found multiple tool calls in response {i}: {len(response['tool_calls'])} calls"
+                )
+                for tool_call in response["tool_calls"]:
+                    # Parse arguments if they're a JSON string
+                    if isinstance(
+                        tool_call.get("function", {}).get(
+                            "arguments"
+                        ),
+                        str,
+                    ):
+                        try:
+                            tool_call["function"]["arguments"] = (
+                                json.loads(
+                                    tool_call["function"]["arguments"]
+                                )
+                            )
+                            logger.debug(
+                                f"Parsed tool call arguments: {tool_call['function']['arguments']}"
+                            )
+                        except json.JSONDecodeError:
+                            logger.warning(
+                                f"Failed to parse tool call arguments: {tool_call['function']['arguments']}"
+                            )
+
+                    all_tool_calls.append((i, tool_call))
+            # Direct tool call
+            elif "name" in response and "arguments" in response:
+                logger.debug(
+                    f"Found direct tool call in response {i}: {response}"
+                )
+                # Parse arguments if they're a JSON string
+                if isinstance(response.get("arguments"), str):
+                    try:
+                        response["arguments"] = json.loads(
+                            response["arguments"]
+                        )
+                        logger.debug(
+                            f"Parsed direct tool call arguments: {response['arguments']}"
+                        )
+                    except json.JSONDecodeError:
+                        logger.warning(
+                            f"Failed to parse direct tool call arguments: {response['arguments']}"
+                        )
+
+                all_tool_calls.append((i, {"function": response}))
+            else:
+                logger.debug(
+                    f"Response {i} is a dict but doesn't match expected tool call formats: {list(response.keys())}"
+                )
+        else:
+            logger.warning(
+                f"Unsupported response type at index {i}: {type(response)}"
+            )
+            continue
+
+    if not all_tool_calls:
+        logger.warning("No tool calls found in responses")
+        return []
+
+    logger.info(f"Found {len(all_tool_calls)} tool calls to execute")
+
+    # Execute tool calls concurrently
+    max_concurrent = max_concurrent or len(all_tool_calls)
+    semaphore = asyncio.Semaphore(max_concurrent)
+
+    async def execute_with_semaphore(tool_call_info):
+        async with semaphore:
+            response_index, tool_call = tool_call_info
+            function_name = tool_call.get("function", {}).get(
+                "name", "unknown"
+            )
+
+            if function_name not in server_tool_mapping:
+                logger.warning(
+                    f"Function '{function_name}' not found on any server"
+                )
+                return {
+                    "response_index": response_index,
+                    "function_name": function_name,
+                    "result": None,
+                    "error": f"Function '{function_name}' not available on any server",
+                    "status": "not_found",
+                }
+
+            server_info = server_tool_mapping[function_name]
+            result = await _execute_tool_on_server(
+                tool_call=tool_call,
+                server_info=server_info,
+                output_type=output_type,
+            )
+            result["response_index"] = response_index
+            return result
+
+    # Execute all tool calls concurrently
+    tasks = [
+        execute_with_semaphore(tool_call_info)
+        for tool_call_info in all_tool_calls
+    ]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    # Process results and handle exceptions
+    processed_results = []
+    for i, result in enumerate(results):
+        if isinstance(result, Exception):
+            logger.error(
+                f"Task {i} failed with exception: {str(result)}"
+            )
+            processed_results.append(
+                {
+                    "response_index": (
+                        all_tool_calls[i][0]
+                        if i < len(all_tool_calls)
+                        else -1
+                    ),
+                    "function_name": "unknown",
+                    "result": None,
+                    "error": str(result),
+                    "status": "exception",
+                }
+            )
+        else:
+            processed_results.append(result)
+
+    logger.info(
+        f"Completed execution of {len(processed_results)} tool calls"
+    )
+    return processed_results
+
+
+def execute_multiple_tools_on_multiple_mcp_servers_sync(
+    responses: List[Dict[str, Any]],
+    urls: List[str],
+    connections: List[MCPConnection] = None,
+    output_type: Literal["json", "dict", "str", "formatted"] = "str",
+    max_concurrent: Optional[int] = None,
+    *args,
+    **kwargs,
+) -> List[Dict[str, Any]]:
+    """
+    Synchronous version of execute_multiple_tools_on_multiple_mcp_servers.
+
+    Args:
+        responses: List of responses containing tool calls (OpenAI format)
+        urls: List of MCP server URLs
+        connections: Optional list of MCPConnection objects corresponding to each URL
+        output_type: Output format type for results
+        max_concurrent: Maximum number of concurrent executions
+
+    Returns:
+        List of execution results with server metadata
+    """
+    with get_or_create_event_loop() as loop:
+        try:
+            return loop.run_until_complete(
+                execute_multiple_tools_on_multiple_mcp_servers(
+                    responses=responses,
+                    urls=urls,
+                    connections=connections,
+                    output_type=output_type,
+                    max_concurrent=max_concurrent,
+                    *args,
+                    **kwargs,
+                )
+            )
+        except Exception as e:
+            logger.error(
+                f"Error in execute_multiple_tools_on_multiple_mcp_servers_sync: {str(e)}"
+            )
+            raise MCPExecutionError(
+                f"Failed to execute multiple tools sync: {str(e)}"
+            )

swarms/tools/py_func_to_openai_func_str.py

@@ -492,7 +492,6 @@ def convert_multiple_functions_to_openai_function_schema(
     # ]
     # Use 40% of cpu cores
     max_workers = int(os.cpu_count() * 0.8)
-    print(f"max_workers: {max_workers}")
 
     with concurrent.futures.ThreadPoolExecutor(
         max_workers=max_workers

swarms/utils/auto_download_check_packages.py

@@ -8,9 +8,10 @@ import subprocess
 import sys
 from typing import Literal, Optional, Union
 from swarms.utils.loguru_logger import initialize_logger
-import pkg_resources
 
 
+from importlib.metadata import distribution, PackageNotFoundError
+
 logger = initialize_logger("autocheckpackages")
 
 
@@ -39,13 +40,13 @@ def check_and_install_package(
         # Check if package exists
         if package_manager == "pip":
             try:
-                pkg_resources.get_distribution(package_name)
+                distribution(package_name)
                 if not upgrade:
                     logger.info(
                         f"Package {package_name} is already installed"
                     )
                     return True
-            except pkg_resources.DistributionNotFound:
+            except PackageNotFoundError:
                 pass
 
             # Construct installation command